1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2017-2022 Broadcom. All Rights Reserved. The term *
5 * “Broadcom” refers to Broadcom Inc. and/or its subsidiaries. *
6 * Copyright (C) 2004-2016 Emulex. All rights reserved. *
7 * EMULEX and SLI are trademarks of Emulex. *
9 * Portions Copyright (C) 2004-2005 Christoph Hellwig *
11 * This program is free software; you can redistribute it and/or *
12 * modify it under the terms of version 2 of the GNU General *
13 * Public License as published by the Free Software Foundation. *
14 * This program is distributed in the hope that it will be useful. *
15 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
16 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
17 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
18 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
19 * TO BE LEGALLY INVALID. See the GNU General Public License for *
20 * more details, a copy of which can be found in the file COPYING *
21 * included with this package. *
22 *******************************************************************/
24 #include <linux/ctype.h>
25 #include <linux/delay.h>
26 #include <linux/pci.h>
27 #include <linux/interrupt.h>
28 #include <linux/module.h>
29 #include <linux/aer.h>
30 #include <linux/gfp.h>
31 #include <linux/kernel.h>
33 #include <scsi/scsi.h>
34 #include <scsi/scsi_device.h>
35 #include <scsi/scsi_host.h>
36 #include <scsi/scsi_tcq.h>
37 #include <scsi/scsi_transport_fc.h>
38 #include <scsi/fc/fc_fs.h>
43 #include "lpfc_sli4.h"
45 #include "lpfc_disc.h"
47 #include "lpfc_scsi.h"
48 #include "lpfc_nvme.h"
49 #include "lpfc_logmsg.h"
50 #include "lpfc_version.h"
51 #include "lpfc_compat.h"
52 #include "lpfc_crtn.h"
53 #include "lpfc_vport.h"
54 #include "lpfc_attr.h"
56 #define LPFC_DEF_DEVLOSS_TMO 30
57 #define LPFC_MIN_DEVLOSS_TMO 1
58 #define LPFC_MAX_DEVLOSS_TMO 255
60 #define LPFC_MAX_INFO_TMP_LEN 100
61 #define LPFC_INFO_MORE_STR "\nCould be more info...\n"
63 * Write key size should be multiple of 4. If write key is changed
64 * make sure that library write key is also changed.
66 #define LPFC_REG_WRITE_KEY_SIZE 4
67 #define LPFC_REG_WRITE_KEY "EMLX"
69 const char *const trunk_errmsg[] = { /* map errcode */
70 "", /* There is no such error code at index 0*/
71 "link negotiated speed does not match existing"
72 " trunk - link was \"low\" speed",
73 "link negotiated speed does not match"
74 " existing trunk - link was \"middle\" speed",
75 "link negotiated speed does not match existing"
76 " trunk - link was \"high\" speed",
77 "Attached to non-trunking port - F_Port",
78 "Attached to non-trunking port - N_Port",
79 "FLOGI response timeout",
80 "non-FLOGI frame received",
81 "Invalid FLOGI response",
82 "Trunking initialization protocol",
83 "Trunk peer device mismatch",
87 * lpfc_jedec_to_ascii - Hex to ascii convertor according to JEDEC rules
88 * @incr: integer to convert.
89 * @hdw: ascii string holding converted integer plus a string terminator.
92 * JEDEC Joint Electron Device Engineering Council.
93 * Convert a 32 bit integer composed of 8 nibbles into an 8 byte ascii
94 * character string. The string is then terminated with a NULL in byte 9.
95 * Hex 0-9 becomes ascii '0' to '9'.
96 * Hex a-f becomes ascii '=' to 'B' capital B.
99 * Coded for 32 bit integers only.
102 lpfc_jedec_to_ascii(int incr, char hdw[])
105 for (i = 0; i < 8; i++) {
108 hdw[7 - i] = 0x30 + j;
110 hdw[7 - i] = 0x61 + j - 10;
118 lpfc_cmf_info_show(struct device *dev, struct device_attribute *attr,
121 struct Scsi_Host *shost = class_to_shost(dev);
122 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
123 struct lpfc_hba *phba = vport->phba;
124 struct lpfc_cgn_info *cp = NULL;
125 struct lpfc_cgn_stat *cgs;
129 char tmp[LPFC_MAX_INFO_TMP_LEN] = {0};
132 cp = (struct lpfc_cgn_info *)phba->cgn_i->virt;
134 scnprintf(tmp, sizeof(tmp),
135 "Congestion Mgmt Info: E2Eattr %d Ver %d "
137 phba->sli4_hba.pc_sli4_params.mi_ver,
138 cp ? cp->cgn_info_version : 0,
139 phba->sli4_hba.pc_sli4_params.cmf, phba->cmf_timer_cnt);
141 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
144 if (!phba->sli4_hba.pc_sli4_params.cmf)
147 switch (phba->cgn_init_reg_signal) {
148 case EDC_CG_SIG_WARN_ONLY:
149 scnprintf(tmp, sizeof(tmp),
150 "Register: Init: Signal:WARN ");
152 case EDC_CG_SIG_WARN_ALARM:
153 scnprintf(tmp, sizeof(tmp),
154 "Register: Init: Signal:WARN|ALARM ");
157 scnprintf(tmp, sizeof(tmp),
158 "Register: Init: Signal:NONE ");
161 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
164 switch (phba->cgn_init_reg_fpin) {
165 case LPFC_CGN_FPIN_WARN:
166 scnprintf(tmp, sizeof(tmp),
169 case LPFC_CGN_FPIN_ALARM:
170 scnprintf(tmp, sizeof(tmp),
173 case LPFC_CGN_FPIN_BOTH:
174 scnprintf(tmp, sizeof(tmp),
175 "FPIN:WARN|ALARM\n");
178 scnprintf(tmp, sizeof(tmp),
182 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
185 switch (phba->cgn_reg_signal) {
186 case EDC_CG_SIG_WARN_ONLY:
187 scnprintf(tmp, sizeof(tmp),
188 " Current: Signal:WARN ");
190 case EDC_CG_SIG_WARN_ALARM:
191 scnprintf(tmp, sizeof(tmp),
192 " Current: Signal:WARN|ALARM ");
195 scnprintf(tmp, sizeof(tmp),
196 " Current: Signal:NONE ");
199 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
202 switch (phba->cgn_reg_fpin) {
203 case LPFC_CGN_FPIN_WARN:
204 scnprintf(tmp, sizeof(tmp),
205 "FPIN:WARN ACQEcnt:%d\n", phba->cgn_acqe_cnt);
207 case LPFC_CGN_FPIN_ALARM:
208 scnprintf(tmp, sizeof(tmp),
209 "FPIN:ALARM ACQEcnt:%d\n", phba->cgn_acqe_cnt);
211 case LPFC_CGN_FPIN_BOTH:
212 scnprintf(tmp, sizeof(tmp),
213 "FPIN:WARN|ALARM ACQEcnt:%d\n", phba->cgn_acqe_cnt);
216 scnprintf(tmp, sizeof(tmp),
217 "FPIN:NONE ACQEcnt:%d\n", phba->cgn_acqe_cnt);
220 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
223 if (phba->cmf_active_mode != phba->cgn_p.cgn_param_mode) {
224 switch (phba->cmf_active_mode) {
226 scnprintf(tmp, sizeof(tmp), "Active: Mode:Off\n");
228 case LPFC_CFG_MANAGED:
229 scnprintf(tmp, sizeof(tmp), "Active: Mode:Managed\n");
231 case LPFC_CFG_MONITOR:
232 scnprintf(tmp, sizeof(tmp), "Active: Mode:Monitor\n");
235 scnprintf(tmp, sizeof(tmp), "Active: Mode:Unknown\n");
237 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
241 switch (phba->cgn_p.cgn_param_mode) {
243 scnprintf(tmp, sizeof(tmp), "Config: Mode:Off ");
245 case LPFC_CFG_MANAGED:
246 scnprintf(tmp, sizeof(tmp), "Config: Mode:Managed ");
248 case LPFC_CFG_MONITOR:
249 scnprintf(tmp, sizeof(tmp), "Config: Mode:Monitor ");
252 scnprintf(tmp, sizeof(tmp), "Config: Mode:Unknown ");
254 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
259 for_each_present_cpu(cpu) {
260 cgs = per_cpu_ptr(phba->cmf_stat, cpu);
261 total += atomic64_read(&cgs->total_bytes);
262 rcv += atomic64_read(&cgs->rcv_bytes);
265 scnprintf(tmp, sizeof(tmp),
266 "IObusy:%d Info:%d Bytes: Rcv:x%llx Total:x%llx\n",
267 atomic_read(&phba->cmf_busy),
268 phba->cmf_active_info, rcv, total);
269 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
272 scnprintf(tmp, sizeof(tmp),
273 "Port_speed:%d Link_byte_cnt:%ld "
274 "Max_byte_per_interval:%ld\n",
275 lpfc_sli_port_speed_get(phba),
276 (unsigned long)phba->cmf_link_byte_count,
277 (unsigned long)phba->cmf_max_bytes_per_interval);
278 strlcat(buf, tmp, PAGE_SIZE);
281 len = strnlen(buf, PAGE_SIZE);
283 if (unlikely(len >= (PAGE_SIZE - 1))) {
284 lpfc_printf_log(phba, KERN_INFO, LOG_CGN_MGMT,
285 "6312 Catching potential buffer "
286 "overflow > PAGE_SIZE = %lu bytes\n",
288 strscpy(buf + PAGE_SIZE - 1 - sizeof(LPFC_INFO_MORE_STR),
289 LPFC_INFO_MORE_STR, sizeof(LPFC_INFO_MORE_STR) + 1);
295 * lpfc_drvr_version_show - Return the Emulex driver string with version number
296 * @dev: class unused variable.
297 * @attr: device attribute, not used.
298 * @buf: on return contains the module description text.
300 * Returns: size of formatted string.
303 lpfc_drvr_version_show(struct device *dev, struct device_attribute *attr,
306 return scnprintf(buf, PAGE_SIZE, LPFC_MODULE_DESC "\n");
310 * lpfc_enable_fip_show - Return the fip mode of the HBA
311 * @dev: class unused variable.
312 * @attr: device attribute, not used.
313 * @buf: on return contains the module description text.
315 * Returns: size of formatted string.
318 lpfc_enable_fip_show(struct device *dev, struct device_attribute *attr,
321 struct Scsi_Host *shost = class_to_shost(dev);
322 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
323 struct lpfc_hba *phba = vport->phba;
325 if (phba->hba_flag & HBA_FIP_SUPPORT)
326 return scnprintf(buf, PAGE_SIZE, "1\n");
328 return scnprintf(buf, PAGE_SIZE, "0\n");
332 lpfc_nvme_info_show(struct device *dev, struct device_attribute *attr,
335 struct Scsi_Host *shost = class_to_shost(dev);
336 struct lpfc_vport *vport = shost_priv(shost);
337 struct lpfc_hba *phba = vport->phba;
338 struct lpfc_nvmet_tgtport *tgtp;
339 struct nvme_fc_local_port *localport;
340 struct lpfc_nvme_lport *lport;
341 struct lpfc_nvme_rport *rport;
342 struct lpfc_nodelist *ndlp;
343 struct nvme_fc_remote_port *nrport;
344 struct lpfc_fc4_ctrl_stat *cstat;
345 uint64_t data1, data2, data3;
346 uint64_t totin, totout, tot;
350 char tmp[LPFC_MAX_INFO_TMP_LEN] = {0};
352 if (!(vport->cfg_enable_fc4_type & LPFC_ENABLE_NVME)) {
353 len = scnprintf(buf, PAGE_SIZE, "NVME Disabled\n");
356 if (phba->nvmet_support) {
357 if (!phba->targetport) {
358 len = scnprintf(buf, PAGE_SIZE,
359 "NVME Target: x%llx is not allocated\n",
360 wwn_to_u64(vport->fc_portname.u.wwn));
363 /* Port state is only one of two values for now. */
364 if (phba->targetport->port_id)
365 statep = "REGISTERED";
368 scnprintf(tmp, sizeof(tmp),
369 "NVME Target Enabled State %s\n",
371 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
374 scnprintf(tmp, sizeof(tmp),
375 "%s%d WWPN x%llx WWNN x%llx DID x%06x\n",
378 wwn_to_u64(vport->fc_portname.u.wwn),
379 wwn_to_u64(vport->fc_nodename.u.wwn),
380 phba->targetport->port_id);
381 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
384 if (strlcat(buf, "\nNVME Target: Statistics\n", PAGE_SIZE)
388 tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private;
389 scnprintf(tmp, sizeof(tmp),
390 "LS: Rcv %08x Drop %08x Abort %08x\n",
391 atomic_read(&tgtp->rcv_ls_req_in),
392 atomic_read(&tgtp->rcv_ls_req_drop),
393 atomic_read(&tgtp->xmt_ls_abort));
394 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
397 if (atomic_read(&tgtp->rcv_ls_req_in) !=
398 atomic_read(&tgtp->rcv_ls_req_out)) {
399 scnprintf(tmp, sizeof(tmp),
400 "Rcv LS: in %08x != out %08x\n",
401 atomic_read(&tgtp->rcv_ls_req_in),
402 atomic_read(&tgtp->rcv_ls_req_out));
403 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
407 scnprintf(tmp, sizeof(tmp),
408 "LS: Xmt %08x Drop %08x Cmpl %08x\n",
409 atomic_read(&tgtp->xmt_ls_rsp),
410 atomic_read(&tgtp->xmt_ls_drop),
411 atomic_read(&tgtp->xmt_ls_rsp_cmpl));
412 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
415 scnprintf(tmp, sizeof(tmp),
416 "LS: RSP Abort %08x xb %08x Err %08x\n",
417 atomic_read(&tgtp->xmt_ls_rsp_aborted),
418 atomic_read(&tgtp->xmt_ls_rsp_xb_set),
419 atomic_read(&tgtp->xmt_ls_rsp_error));
420 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
423 scnprintf(tmp, sizeof(tmp),
424 "FCP: Rcv %08x Defer %08x Release %08x "
426 atomic_read(&tgtp->rcv_fcp_cmd_in),
427 atomic_read(&tgtp->rcv_fcp_cmd_defer),
428 atomic_read(&tgtp->xmt_fcp_release),
429 atomic_read(&tgtp->rcv_fcp_cmd_drop));
430 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
433 if (atomic_read(&tgtp->rcv_fcp_cmd_in) !=
434 atomic_read(&tgtp->rcv_fcp_cmd_out)) {
435 scnprintf(tmp, sizeof(tmp),
436 "Rcv FCP: in %08x != out %08x\n",
437 atomic_read(&tgtp->rcv_fcp_cmd_in),
438 atomic_read(&tgtp->rcv_fcp_cmd_out));
439 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
443 scnprintf(tmp, sizeof(tmp),
444 "FCP Rsp: RD %08x rsp %08x WR %08x rsp %08x "
446 atomic_read(&tgtp->xmt_fcp_read),
447 atomic_read(&tgtp->xmt_fcp_read_rsp),
448 atomic_read(&tgtp->xmt_fcp_write),
449 atomic_read(&tgtp->xmt_fcp_rsp),
450 atomic_read(&tgtp->xmt_fcp_drop));
451 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
454 scnprintf(tmp, sizeof(tmp),
455 "FCP Rsp Cmpl: %08x err %08x drop %08x\n",
456 atomic_read(&tgtp->xmt_fcp_rsp_cmpl),
457 atomic_read(&tgtp->xmt_fcp_rsp_error),
458 atomic_read(&tgtp->xmt_fcp_rsp_drop));
459 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
462 scnprintf(tmp, sizeof(tmp),
463 "FCP Rsp Abort: %08x xb %08x xricqe %08x\n",
464 atomic_read(&tgtp->xmt_fcp_rsp_aborted),
465 atomic_read(&tgtp->xmt_fcp_rsp_xb_set),
466 atomic_read(&tgtp->xmt_fcp_xri_abort_cqe));
467 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
470 scnprintf(tmp, sizeof(tmp),
471 "ABORT: Xmt %08x Cmpl %08x\n",
472 atomic_read(&tgtp->xmt_fcp_abort),
473 atomic_read(&tgtp->xmt_fcp_abort_cmpl));
474 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
477 scnprintf(tmp, sizeof(tmp),
478 "ABORT: Sol %08x Usol %08x Err %08x Cmpl %08x\n",
479 atomic_read(&tgtp->xmt_abort_sol),
480 atomic_read(&tgtp->xmt_abort_unsol),
481 atomic_read(&tgtp->xmt_abort_rsp),
482 atomic_read(&tgtp->xmt_abort_rsp_error));
483 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
486 scnprintf(tmp, sizeof(tmp),
487 "DELAY: ctx %08x fod %08x wqfull %08x\n",
488 atomic_read(&tgtp->defer_ctx),
489 atomic_read(&tgtp->defer_fod),
490 atomic_read(&tgtp->defer_wqfull));
491 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
494 /* Calculate outstanding IOs */
495 tot = atomic_read(&tgtp->rcv_fcp_cmd_drop);
496 tot += atomic_read(&tgtp->xmt_fcp_release);
497 tot = atomic_read(&tgtp->rcv_fcp_cmd_in) - tot;
499 scnprintf(tmp, sizeof(tmp),
500 "IO_CTX: %08x WAIT: cur %08x tot %08x\n"
501 "CTX Outstanding %08llx\n\n",
502 phba->sli4_hba.nvmet_xri_cnt,
503 phba->sli4_hba.nvmet_io_wait_cnt,
504 phba->sli4_hba.nvmet_io_wait_total,
506 strlcat(buf, tmp, PAGE_SIZE);
510 localport = vport->localport;
512 len = scnprintf(buf, PAGE_SIZE,
513 "NVME Initiator x%llx is not allocated\n",
514 wwn_to_u64(vport->fc_portname.u.wwn));
517 lport = (struct lpfc_nvme_lport *)localport->private;
518 if (strlcat(buf, "\nNVME Initiator Enabled\n", PAGE_SIZE) >= PAGE_SIZE)
521 scnprintf(tmp, sizeof(tmp),
522 "XRI Dist lpfc%d Total %d IO %d ELS %d\n",
524 phba->sli4_hba.max_cfg_param.max_xri,
525 phba->sli4_hba.io_xri_max,
526 lpfc_sli4_get_els_iocb_cnt(phba));
527 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
530 /* Port state is only one of two values for now. */
531 if (localport->port_id)
536 scnprintf(tmp, sizeof(tmp),
537 "%s%d WWPN x%llx WWNN x%llx DID x%06x %s\n",
540 wwn_to_u64(vport->fc_portname.u.wwn),
541 wwn_to_u64(vport->fc_nodename.u.wwn),
542 localport->port_id, statep);
543 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
546 spin_lock_irq(shost->host_lock);
548 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
550 spin_lock(&ndlp->lock);
551 rport = lpfc_ndlp_get_nrport(ndlp);
553 nrport = rport->remoteport;
554 spin_unlock(&ndlp->lock);
558 /* Port state is only one of two values for now. */
559 switch (nrport->port_state) {
560 case FC_OBJSTATE_ONLINE:
563 case FC_OBJSTATE_UNKNOWN:
567 statep = "UNSUPPORTED";
571 /* Tab in to show lport ownership. */
572 if (strlcat(buf, "NVME RPORT ", PAGE_SIZE) >= PAGE_SIZE)
573 goto unlock_buf_done;
574 if (phba->brd_no >= 10) {
575 if (strlcat(buf, " ", PAGE_SIZE) >= PAGE_SIZE)
576 goto unlock_buf_done;
579 scnprintf(tmp, sizeof(tmp), "WWPN x%llx ",
581 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
582 goto unlock_buf_done;
584 scnprintf(tmp, sizeof(tmp), "WWNN x%llx ",
586 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
587 goto unlock_buf_done;
589 scnprintf(tmp, sizeof(tmp), "DID x%06x ",
591 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
592 goto unlock_buf_done;
594 /* An NVME rport can have multiple roles. */
595 if (nrport->port_role & FC_PORT_ROLE_NVME_INITIATOR) {
596 if (strlcat(buf, "INITIATOR ", PAGE_SIZE) >= PAGE_SIZE)
597 goto unlock_buf_done;
599 if (nrport->port_role & FC_PORT_ROLE_NVME_TARGET) {
600 if (strlcat(buf, "TARGET ", PAGE_SIZE) >= PAGE_SIZE)
601 goto unlock_buf_done;
603 if (nrport->port_role & FC_PORT_ROLE_NVME_DISCOVERY) {
604 if (strlcat(buf, "DISCSRVC ", PAGE_SIZE) >= PAGE_SIZE)
605 goto unlock_buf_done;
607 if (nrport->port_role & ~(FC_PORT_ROLE_NVME_INITIATOR |
608 FC_PORT_ROLE_NVME_TARGET |
609 FC_PORT_ROLE_NVME_DISCOVERY)) {
610 scnprintf(tmp, sizeof(tmp), "UNKNOWN ROLE x%x",
612 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
613 goto unlock_buf_done;
616 scnprintf(tmp, sizeof(tmp), "%s\n", statep);
617 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
618 goto unlock_buf_done;
620 spin_unlock_irq(shost->host_lock);
625 if (strlcat(buf, "\nNVME Statistics\n", PAGE_SIZE) >= PAGE_SIZE)
628 scnprintf(tmp, sizeof(tmp),
629 "LS: Xmt %010x Cmpl %010x Abort %08x\n",
630 atomic_read(&lport->fc4NvmeLsRequests),
631 atomic_read(&lport->fc4NvmeLsCmpls),
632 atomic_read(&lport->xmt_ls_abort));
633 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
636 scnprintf(tmp, sizeof(tmp),
637 "LS XMIT: Err %08x CMPL: xb %08x Err %08x\n",
638 atomic_read(&lport->xmt_ls_err),
639 atomic_read(&lport->cmpl_ls_xb),
640 atomic_read(&lport->cmpl_ls_err));
641 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
646 for (i = 0; i < phba->cfg_hdw_queue; i++) {
647 cstat = &phba->sli4_hba.hdwq[i].nvme_cstat;
648 tot = cstat->io_cmpls;
650 data1 = cstat->input_requests;
651 data2 = cstat->output_requests;
652 data3 = cstat->control_requests;
653 totout += (data1 + data2 + data3);
655 scnprintf(tmp, sizeof(tmp),
656 "Total FCP Cmpl %016llx Issue %016llx "
658 totin, totout, totout - totin);
659 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
662 scnprintf(tmp, sizeof(tmp),
663 "\tabort %08x noxri %08x nondlp %08x qdepth %08x "
664 "wqerr %08x err %08x\n",
665 atomic_read(&lport->xmt_fcp_abort),
666 atomic_read(&lport->xmt_fcp_noxri),
667 atomic_read(&lport->xmt_fcp_bad_ndlp),
668 atomic_read(&lport->xmt_fcp_qdepth),
669 atomic_read(&lport->xmt_fcp_wqerr),
670 atomic_read(&lport->xmt_fcp_err));
671 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
674 scnprintf(tmp, sizeof(tmp),
675 "FCP CMPL: xb %08x Err %08x\n",
676 atomic_read(&lport->cmpl_fcp_xb),
677 atomic_read(&lport->cmpl_fcp_err));
678 strlcat(buf, tmp, PAGE_SIZE);
680 /* host_lock is already unlocked. */
684 spin_unlock_irq(shost->host_lock);
687 len = strnlen(buf, PAGE_SIZE);
689 if (unlikely(len >= (PAGE_SIZE - 1))) {
690 lpfc_printf_log(phba, KERN_INFO, LOG_NVME,
691 "6314 Catching potential buffer "
692 "overflow > PAGE_SIZE = %lu bytes\n",
694 strscpy(buf + PAGE_SIZE - 1 - sizeof(LPFC_INFO_MORE_STR),
696 sizeof(LPFC_INFO_MORE_STR) + 1);
703 lpfc_scsi_stat_show(struct device *dev, struct device_attribute *attr,
706 struct Scsi_Host *shost = class_to_shost(dev);
707 struct lpfc_vport *vport = shost_priv(shost);
708 struct lpfc_hba *phba = vport->phba;
710 struct lpfc_fc4_ctrl_stat *cstat;
711 u64 data1, data2, data3;
712 u64 tot, totin, totout;
714 char tmp[LPFC_MAX_SCSI_INFO_TMP_LEN] = {0};
716 if (!(vport->cfg_enable_fc4_type & LPFC_ENABLE_FCP) ||
717 (phba->sli_rev != LPFC_SLI_REV4))
720 scnprintf(buf, PAGE_SIZE, "SCSI HDWQ Statistics\n");
724 for (i = 0; i < phba->cfg_hdw_queue; i++) {
725 cstat = &phba->sli4_hba.hdwq[i].scsi_cstat;
726 tot = cstat->io_cmpls;
728 data1 = cstat->input_requests;
729 data2 = cstat->output_requests;
730 data3 = cstat->control_requests;
731 totout += (data1 + data2 + data3);
733 scnprintf(tmp, sizeof(tmp), "HDWQ (%d): Rd %016llx Wr %016llx "
734 "IO %016llx ", i, data1, data2, data3);
735 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
738 scnprintf(tmp, sizeof(tmp), "Cmpl %016llx OutIO %016llx\n",
739 tot, ((data1 + data2 + data3) - tot));
740 if (strlcat(buf, tmp, PAGE_SIZE) >= PAGE_SIZE)
743 scnprintf(tmp, sizeof(tmp), "Total FCP Cmpl %016llx Issue %016llx "
744 "OutIO %016llx\n", totin, totout, totout - totin);
745 strlcat(buf, tmp, PAGE_SIZE);
748 len = strnlen(buf, PAGE_SIZE);
754 lpfc_bg_info_show(struct device *dev, struct device_attribute *attr,
757 struct Scsi_Host *shost = class_to_shost(dev);
758 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
759 struct lpfc_hba *phba = vport->phba;
761 if (phba->cfg_enable_bg) {
762 if (phba->sli3_options & LPFC_SLI3_BG_ENABLED)
763 return scnprintf(buf, PAGE_SIZE,
764 "BlockGuard Enabled\n");
766 return scnprintf(buf, PAGE_SIZE,
767 "BlockGuard Not Supported\n");
769 return scnprintf(buf, PAGE_SIZE,
770 "BlockGuard Disabled\n");
774 lpfc_bg_guard_err_show(struct device *dev, struct device_attribute *attr,
777 struct Scsi_Host *shost = class_to_shost(dev);
778 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
779 struct lpfc_hba *phba = vport->phba;
781 return scnprintf(buf, PAGE_SIZE, "%llu\n",
782 (unsigned long long)phba->bg_guard_err_cnt);
786 lpfc_bg_apptag_err_show(struct device *dev, struct device_attribute *attr,
789 struct Scsi_Host *shost = class_to_shost(dev);
790 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
791 struct lpfc_hba *phba = vport->phba;
793 return scnprintf(buf, PAGE_SIZE, "%llu\n",
794 (unsigned long long)phba->bg_apptag_err_cnt);
798 lpfc_bg_reftag_err_show(struct device *dev, struct device_attribute *attr,
801 struct Scsi_Host *shost = class_to_shost(dev);
802 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
803 struct lpfc_hba *phba = vport->phba;
805 return scnprintf(buf, PAGE_SIZE, "%llu\n",
806 (unsigned long long)phba->bg_reftag_err_cnt);
810 * lpfc_info_show - Return some pci info about the host in ascii
811 * @dev: class converted to a Scsi_host structure.
812 * @attr: device attribute, not used.
813 * @buf: on return contains the formatted text from lpfc_info().
815 * Returns: size of formatted string.
818 lpfc_info_show(struct device *dev, struct device_attribute *attr,
821 struct Scsi_Host *host = class_to_shost(dev);
823 return scnprintf(buf, PAGE_SIZE, "%s\n", lpfc_info(host));
827 * lpfc_serialnum_show - Return the hba serial number in ascii
828 * @dev: class converted to a Scsi_host structure.
829 * @attr: device attribute, not used.
830 * @buf: on return contains the formatted text serial number.
832 * Returns: size of formatted string.
835 lpfc_serialnum_show(struct device *dev, struct device_attribute *attr,
838 struct Scsi_Host *shost = class_to_shost(dev);
839 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
840 struct lpfc_hba *phba = vport->phba;
842 return scnprintf(buf, PAGE_SIZE, "%s\n", phba->SerialNumber);
846 * lpfc_temp_sensor_show - Return the temperature sensor level
847 * @dev: class converted to a Scsi_host structure.
848 * @attr: device attribute, not used.
849 * @buf: on return contains the formatted support level.
852 * Returns a number indicating the temperature sensor level currently
853 * supported, zero or one in ascii.
855 * Returns: size of formatted string.
858 lpfc_temp_sensor_show(struct device *dev, struct device_attribute *attr,
861 struct Scsi_Host *shost = class_to_shost(dev);
862 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
863 struct lpfc_hba *phba = vport->phba;
864 return scnprintf(buf, PAGE_SIZE, "%d\n", phba->temp_sensor_support);
868 * lpfc_modeldesc_show - Return the model description of the hba
869 * @dev: class converted to a Scsi_host structure.
870 * @attr: device attribute, not used.
871 * @buf: on return contains the scsi vpd model description.
873 * Returns: size of formatted string.
876 lpfc_modeldesc_show(struct device *dev, struct device_attribute *attr,
879 struct Scsi_Host *shost = class_to_shost(dev);
880 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
881 struct lpfc_hba *phba = vport->phba;
883 return scnprintf(buf, PAGE_SIZE, "%s\n", phba->ModelDesc);
887 * lpfc_modelname_show - Return the model name of the hba
888 * @dev: class converted to a Scsi_host structure.
889 * @attr: device attribute, not used.
890 * @buf: on return contains the scsi vpd model name.
892 * Returns: size of formatted string.
895 lpfc_modelname_show(struct device *dev, struct device_attribute *attr,
898 struct Scsi_Host *shost = class_to_shost(dev);
899 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
900 struct lpfc_hba *phba = vport->phba;
902 return scnprintf(buf, PAGE_SIZE, "%s\n", phba->ModelName);
906 * lpfc_programtype_show - Return the program type of the hba
907 * @dev: class converted to a Scsi_host structure.
908 * @attr: device attribute, not used.
909 * @buf: on return contains the scsi vpd program type.
911 * Returns: size of formatted string.
914 lpfc_programtype_show(struct device *dev, struct device_attribute *attr,
917 struct Scsi_Host *shost = class_to_shost(dev);
918 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
919 struct lpfc_hba *phba = vport->phba;
921 return scnprintf(buf, PAGE_SIZE, "%s\n", phba->ProgramType);
925 * lpfc_mlomgmt_show - Return the Menlo Maintenance sli flag
926 * @dev: class converted to a Scsi_host structure.
927 * @attr: device attribute, not used.
928 * @buf: on return contains the Menlo Maintenance sli flag.
930 * Returns: size of formatted string.
933 lpfc_mlomgmt_show(struct device *dev, struct device_attribute *attr, char *buf)
935 struct Scsi_Host *shost = class_to_shost(dev);
936 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
937 struct lpfc_hba *phba = vport->phba;
939 return scnprintf(buf, PAGE_SIZE, "%d\n",
940 (phba->sli.sli_flag & LPFC_MENLO_MAINT));
944 * lpfc_vportnum_show - Return the port number in ascii of the hba
945 * @dev: class converted to a Scsi_host structure.
946 * @attr: device attribute, not used.
947 * @buf: on return contains scsi vpd program type.
949 * Returns: size of formatted string.
952 lpfc_vportnum_show(struct device *dev, struct device_attribute *attr,
955 struct Scsi_Host *shost = class_to_shost(dev);
956 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
957 struct lpfc_hba *phba = vport->phba;
959 return scnprintf(buf, PAGE_SIZE, "%s\n", phba->Port);
963 * lpfc_fwrev_show - Return the firmware rev running in the hba
964 * @dev: class converted to a Scsi_host structure.
965 * @attr: device attribute, not used.
966 * @buf: on return contains the scsi vpd program type.
968 * Returns: size of formatted string.
971 lpfc_fwrev_show(struct device *dev, struct device_attribute *attr,
974 struct Scsi_Host *shost = class_to_shost(dev);
975 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
976 struct lpfc_hba *phba = vport->phba;
979 char fwrev[FW_REV_STR_SIZE];
982 lpfc_decode_firmware_rev(phba, fwrev, 1);
983 if_type = phba->sli4_hba.pc_sli4_params.if_type;
984 sli_family = phba->sli4_hba.pc_sli4_params.sli_family;
986 if (phba->sli_rev < LPFC_SLI_REV4)
987 len = scnprintf(buf, PAGE_SIZE, "%s, sli-%d\n",
988 fwrev, phba->sli_rev);
990 len = scnprintf(buf, PAGE_SIZE, "%s, sli-%d:%d:%x\n",
991 fwrev, phba->sli_rev, if_type, sli_family);
997 * lpfc_hdw_show - Return the jedec information about the hba
998 * @dev: class converted to a Scsi_host structure.
999 * @attr: device attribute, not used.
1000 * @buf: on return contains the scsi vpd program type.
1002 * Returns: size of formatted string.
1005 lpfc_hdw_show(struct device *dev, struct device_attribute *attr, char *buf)
1008 struct Scsi_Host *shost = class_to_shost(dev);
1009 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1010 struct lpfc_hba *phba = vport->phba;
1011 lpfc_vpd_t *vp = &phba->vpd;
1013 lpfc_jedec_to_ascii(vp->rev.biuRev, hdw);
1014 return scnprintf(buf, PAGE_SIZE, "%s %08x %08x\n", hdw,
1015 vp->rev.smRev, vp->rev.smFwRev);
1019 * lpfc_option_rom_version_show - Return the adapter ROM FCode version
1020 * @dev: class converted to a Scsi_host structure.
1021 * @attr: device attribute, not used.
1022 * @buf: on return contains the ROM and FCode ascii strings.
1024 * Returns: size of formatted string.
1027 lpfc_option_rom_version_show(struct device *dev, struct device_attribute *attr,
1030 struct Scsi_Host *shost = class_to_shost(dev);
1031 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1032 struct lpfc_hba *phba = vport->phba;
1033 char fwrev[FW_REV_STR_SIZE];
1035 if (phba->sli_rev < LPFC_SLI_REV4)
1036 return scnprintf(buf, PAGE_SIZE, "%s\n",
1037 phba->OptionROMVersion);
1039 lpfc_decode_firmware_rev(phba, fwrev, 1);
1040 return scnprintf(buf, PAGE_SIZE, "%s\n", fwrev);
1044 * lpfc_link_state_show - Return the link state of the port
1045 * @dev: class converted to a Scsi_host structure.
1046 * @attr: device attribute, not used.
1047 * @buf: on return contains text describing the state of the link.
1050 * The switch statement has no default so zero will be returned.
1052 * Returns: size of formatted string.
1055 lpfc_link_state_show(struct device *dev, struct device_attribute *attr,
1058 struct Scsi_Host *shost = class_to_shost(dev);
1059 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1060 struct lpfc_hba *phba = vport->phba;
1063 switch (phba->link_state) {
1064 case LPFC_LINK_UNKNOWN:
1065 case LPFC_WARM_START:
1066 case LPFC_INIT_START:
1067 case LPFC_INIT_MBX_CMDS:
1068 case LPFC_LINK_DOWN:
1069 case LPFC_HBA_ERROR:
1070 if (phba->hba_flag & LINK_DISABLED)
1071 len += scnprintf(buf + len, PAGE_SIZE-len,
1072 "Link Down - User disabled\n");
1074 len += scnprintf(buf + len, PAGE_SIZE-len,
1079 case LPFC_HBA_READY:
1080 len += scnprintf(buf + len, PAGE_SIZE-len, "Link Up - ");
1082 switch (vport->port_state) {
1083 case LPFC_LOCAL_CFG_LINK:
1084 len += scnprintf(buf + len, PAGE_SIZE-len,
1085 "Configuring Link\n");
1089 case LPFC_FABRIC_CFG_LINK:
1092 case LPFC_BUILD_DISC_LIST:
1093 case LPFC_DISC_AUTH:
1094 len += scnprintf(buf + len, PAGE_SIZE - len,
1097 case LPFC_VPORT_READY:
1098 len += scnprintf(buf + len, PAGE_SIZE - len,
1102 case LPFC_VPORT_FAILED:
1103 len += scnprintf(buf + len, PAGE_SIZE - len,
1107 case LPFC_VPORT_UNKNOWN:
1108 len += scnprintf(buf + len, PAGE_SIZE - len,
1112 if (phba->sli.sli_flag & LPFC_MENLO_MAINT)
1113 len += scnprintf(buf + len, PAGE_SIZE-len,
1114 " Menlo Maint Mode\n");
1115 else if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
1116 if (vport->fc_flag & FC_PUBLIC_LOOP)
1117 len += scnprintf(buf + len, PAGE_SIZE-len,
1120 len += scnprintf(buf + len, PAGE_SIZE-len,
1123 if (vport->fc_flag & FC_FABRIC) {
1124 if (phba->sli_rev == LPFC_SLI_REV4 &&
1125 vport->port_type == LPFC_PHYSICAL_PORT &&
1126 phba->sli4_hba.fawwpn_flag &
1128 len += scnprintf(buf + len,
1130 " Fabric FA-PWWN\n");
1132 len += scnprintf(buf + len,
1136 len += scnprintf(buf + len, PAGE_SIZE-len,
1137 " Point-2-Point\n");
1142 if ((phba->sli_rev == LPFC_SLI_REV4) &&
1143 ((bf_get(lpfc_sli_intf_if_type,
1144 &phba->sli4_hba.sli_intf) ==
1145 LPFC_SLI_INTF_IF_TYPE_6))) {
1146 struct lpfc_trunk_link link = phba->trunk_link;
1148 if (bf_get(lpfc_conf_trunk_port0, &phba->sli4_hba))
1149 len += scnprintf(buf + len, PAGE_SIZE - len,
1150 "Trunk port 0: Link %s %s\n",
1151 (link.link0.state == LPFC_LINK_UP) ?
1153 trunk_errmsg[link.link0.fault]);
1155 if (bf_get(lpfc_conf_trunk_port1, &phba->sli4_hba))
1156 len += scnprintf(buf + len, PAGE_SIZE - len,
1157 "Trunk port 1: Link %s %s\n",
1158 (link.link1.state == LPFC_LINK_UP) ?
1160 trunk_errmsg[link.link1.fault]);
1162 if (bf_get(lpfc_conf_trunk_port2, &phba->sli4_hba))
1163 len += scnprintf(buf + len, PAGE_SIZE - len,
1164 "Trunk port 2: Link %s %s\n",
1165 (link.link2.state == LPFC_LINK_UP) ?
1167 trunk_errmsg[link.link2.fault]);
1169 if (bf_get(lpfc_conf_trunk_port3, &phba->sli4_hba))
1170 len += scnprintf(buf + len, PAGE_SIZE - len,
1171 "Trunk port 3: Link %s %s\n",
1172 (link.link3.state == LPFC_LINK_UP) ?
1174 trunk_errmsg[link.link3.fault]);
1182 * lpfc_sli4_protocol_show - Return the fip mode of the HBA
1183 * @dev: class unused variable.
1184 * @attr: device attribute, not used.
1185 * @buf: on return contains the module description text.
1187 * Returns: size of formatted string.
1190 lpfc_sli4_protocol_show(struct device *dev, struct device_attribute *attr,
1193 struct Scsi_Host *shost = class_to_shost(dev);
1194 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1195 struct lpfc_hba *phba = vport->phba;
1197 if (phba->sli_rev < LPFC_SLI_REV4)
1198 return scnprintf(buf, PAGE_SIZE, "fc\n");
1200 if (phba->sli4_hba.lnk_info.lnk_dv == LPFC_LNK_DAT_VAL) {
1201 if (phba->sli4_hba.lnk_info.lnk_tp == LPFC_LNK_TYPE_GE)
1202 return scnprintf(buf, PAGE_SIZE, "fcoe\n");
1203 if (phba->sli4_hba.lnk_info.lnk_tp == LPFC_LNK_TYPE_FC)
1204 return scnprintf(buf, PAGE_SIZE, "fc\n");
1206 return scnprintf(buf, PAGE_SIZE, "unknown\n");
1210 * lpfc_oas_supported_show - Return whether or not Optimized Access Storage
1211 * (OAS) is supported.
1212 * @dev: class unused variable.
1213 * @attr: device attribute, not used.
1214 * @buf: on return contains the module description text.
1216 * Returns: size of formatted string.
1219 lpfc_oas_supported_show(struct device *dev, struct device_attribute *attr,
1222 struct Scsi_Host *shost = class_to_shost(dev);
1223 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
1224 struct lpfc_hba *phba = vport->phba;
1226 return scnprintf(buf, PAGE_SIZE, "%d\n",
1227 phba->sli4_hba.pc_sli4_params.oas_supported);
1231 * lpfc_link_state_store - Transition the link_state on an HBA port
1232 * @dev: class device that is converted into a Scsi_host.
1233 * @attr: device attribute, not used.
1234 * @buf: one or more lpfc_polling_flags values.
1238 * -EINVAL if the buffer is not "up" or "down"
1239 * return from link state change function if non-zero
1240 * length of the buf on success
1243 lpfc_link_state_store(struct device *dev, struct device_attribute *attr,
1244 const char *buf, size_t count)
1246 struct Scsi_Host *shost = class_to_shost(dev);
1247 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1248 struct lpfc_hba *phba = vport->phba;
1250 int status = -EINVAL;
1252 if ((strncmp(buf, "up", sizeof("up") - 1) == 0) &&
1253 (phba->link_state == LPFC_LINK_DOWN))
1254 status = phba->lpfc_hba_init_link(phba, MBX_NOWAIT);
1255 else if ((strncmp(buf, "down", sizeof("down") - 1) == 0) &&
1256 (phba->link_state >= LPFC_LINK_UP))
1257 status = phba->lpfc_hba_down_link(phba, MBX_NOWAIT);
1266 * lpfc_num_discovered_ports_show - Return sum of mapped and unmapped vports
1267 * @dev: class device that is converted into a Scsi_host.
1268 * @attr: device attribute, not used.
1269 * @buf: on return contains the sum of fc mapped and unmapped.
1272 * Returns the ascii text number of the sum of the fc mapped and unmapped
1275 * Returns: size of formatted string.
1278 lpfc_num_discovered_ports_show(struct device *dev,
1279 struct device_attribute *attr, char *buf)
1281 struct Scsi_Host *shost = class_to_shost(dev);
1282 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1284 return scnprintf(buf, PAGE_SIZE, "%d\n",
1285 vport->fc_map_cnt + vport->fc_unmap_cnt);
1289 * lpfc_issue_lip - Misnomer, name carried over from long ago
1290 * @shost: Scsi_Host pointer.
1293 * Bring the link down gracefully then re-init the link. The firmware will
1294 * re-init the fiber channel interface as required. Does not issue a LIP.
1297 * -EPERM port offline or management commands are being blocked
1298 * -ENOMEM cannot allocate memory for the mailbox command
1299 * -EIO error sending the mailbox command
1303 lpfc_issue_lip(struct Scsi_Host *shost)
1305 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1306 struct lpfc_hba *phba = vport->phba;
1307 LPFC_MBOXQ_t *pmboxq;
1308 int mbxstatus = MBXERR_ERROR;
1311 * If the link is offline, disabled or BLOCK_MGMT_IO
1312 * it doesn't make any sense to allow issue_lip
1314 if ((vport->fc_flag & FC_OFFLINE_MODE) ||
1315 (phba->hba_flag & LINK_DISABLED) ||
1316 (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO))
1319 pmboxq = mempool_alloc(phba->mbox_mem_pool,GFP_KERNEL);
1324 memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t));
1325 pmboxq->u.mb.mbxCommand = MBX_DOWN_LINK;
1326 pmboxq->u.mb.mbxOwner = OWN_HOST;
1328 if ((vport->fc_flag & FC_PT2PT) && (vport->fc_flag & FC_PT2PT_NO_NVME))
1329 vport->fc_flag &= ~FC_PT2PT_NO_NVME;
1331 mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq, LPFC_MBOX_TMO * 2);
1333 if ((mbxstatus == MBX_SUCCESS) &&
1334 (pmboxq->u.mb.mbxStatus == 0 ||
1335 pmboxq->u.mb.mbxStatus == MBXERR_LINK_DOWN)) {
1336 memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t));
1337 lpfc_init_link(phba, pmboxq, phba->cfg_topology,
1338 phba->cfg_link_speed);
1339 mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq,
1340 phba->fc_ratov * 2);
1341 if ((mbxstatus == MBX_SUCCESS) &&
1342 (pmboxq->u.mb.mbxStatus == MBXERR_SEC_NO_PERMISSION))
1343 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
1344 "2859 SLI authentication is required "
1345 "for INIT_LINK but has not done yet\n");
1348 lpfc_set_loopback_flag(phba);
1349 if (mbxstatus != MBX_TIMEOUT)
1350 mempool_free(pmboxq, phba->mbox_mem_pool);
1352 if (mbxstatus == MBXERR_ERROR)
1359 lpfc_emptyq_wait(struct lpfc_hba *phba, struct list_head *q, spinlock_t *lock)
1363 spin_lock_irq(lock);
1364 while (!list_empty(q)) {
1365 spin_unlock_irq(lock);
1367 if (cnt++ > 250) { /* 5 secs */
1368 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
1369 "0466 Outstanding IO when "
1370 "bringing Adapter offline\n");
1373 spin_lock_irq(lock);
1375 spin_unlock_irq(lock);
1380 * lpfc_do_offline - Issues a mailbox command to bring the link down
1381 * @phba: lpfc_hba pointer.
1382 * @type: LPFC_EVT_OFFLINE, LPFC_EVT_WARM_START, LPFC_EVT_KILL.
1385 * Assumes any error from lpfc_do_offline() will be negative.
1386 * Can wait up to 5 seconds for the port ring buffers count
1387 * to reach zero, prints a warning if it is not zero and continues.
1388 * lpfc_workq_post_event() returns a non-zero return code if call fails.
1391 * -EIO error posting the event
1395 lpfc_do_offline(struct lpfc_hba *phba, uint32_t type)
1397 struct completion online_compl;
1398 struct lpfc_queue *qp = NULL;
1399 struct lpfc_sli_ring *pring;
1400 struct lpfc_sli *psli;
1405 init_completion(&online_compl);
1406 rc = lpfc_workq_post_event(phba, &status, &online_compl,
1407 LPFC_EVT_OFFLINE_PREP);
1411 wait_for_completion(&online_compl);
1419 * If freeing the queues have already started, don't access them.
1420 * Otherwise set FREE_WAIT to indicate that queues are being used
1421 * to hold the freeing process until we finish.
1423 spin_lock_irq(&phba->hbalock);
1424 if (!(psli->sli_flag & LPFC_QUEUE_FREE_INIT)) {
1425 psli->sli_flag |= LPFC_QUEUE_FREE_WAIT;
1427 spin_unlock_irq(&phba->hbalock);
1430 spin_unlock_irq(&phba->hbalock);
1432 /* Wait a little for things to settle down, but not
1433 * long enough for dev loss timeout to expire.
1435 if (phba->sli_rev != LPFC_SLI_REV4) {
1436 for (i = 0; i < psli->num_rings; i++) {
1437 pring = &psli->sli3_ring[i];
1438 if (!lpfc_emptyq_wait(phba, &pring->txcmplq,
1443 list_for_each_entry(qp, &phba->sli4_hba.lpfc_wq_list, wq_list) {
1447 if (!lpfc_emptyq_wait(phba, &pring->txcmplq,
1453 spin_lock_irq(&phba->hbalock);
1454 psli->sli_flag &= ~LPFC_QUEUE_FREE_WAIT;
1455 spin_unlock_irq(&phba->hbalock);
1458 init_completion(&online_compl);
1459 rc = lpfc_workq_post_event(phba, &status, &online_compl, type);
1463 wait_for_completion(&online_compl);
1472 * lpfc_reset_pci_bus - resets PCI bridge controller's secondary bus of an HBA
1473 * @phba: lpfc_hba pointer.
1476 * Issues a PCI secondary bus reset for the phba->pcidev.
1479 * First walks the bus_list to ensure only PCI devices with Emulex
1480 * vendor id, device ids that support hot reset, only one occurrence
1481 * of function 0, and all ports on the bus are in offline mode to ensure the
1482 * hot reset only affects one valid HBA.
1485 * -ENOTSUPP, cfg_enable_hba_reset must be of value 2
1486 * -ENODEV, NULL ptr to pcidev
1487 * -EBADSLT, detected invalid device
1488 * -EBUSY, port is not in offline state
1492 lpfc_reset_pci_bus(struct lpfc_hba *phba)
1494 struct pci_dev *pdev = phba->pcidev;
1495 struct Scsi_Host *shost = NULL;
1496 struct lpfc_hba *phba_other = NULL;
1497 struct pci_dev *ptr = NULL;
1500 if (phba->cfg_enable_hba_reset != 2)
1504 lpfc_printf_log(phba, KERN_INFO, LOG_INIT, "8345 pdev NULL!\n");
1508 res = lpfc_check_pci_resettable(phba);
1512 /* Walk the list of devices on the pci_dev's bus */
1513 list_for_each_entry(ptr, &pdev->bus->devices, bus_list) {
1514 /* Check port is offline */
1515 shost = pci_get_drvdata(ptr);
1518 ((struct lpfc_vport *)shost->hostdata)->phba;
1519 if (!(phba_other->pport->fc_flag & FC_OFFLINE_MODE)) {
1520 lpfc_printf_log(phba_other, KERN_INFO, LOG_INIT,
1521 "8349 WWPN = 0x%02x%02x%02x%02x"
1522 "%02x%02x%02x%02x is not "
1524 phba_other->wwpn[0],
1525 phba_other->wwpn[1],
1526 phba_other->wwpn[2],
1527 phba_other->wwpn[3],
1528 phba_other->wwpn[4],
1529 phba_other->wwpn[5],
1530 phba_other->wwpn[6],
1531 phba_other->wwpn[7]);
1537 /* Issue PCI bus reset */
1538 res = pci_reset_bus(pdev);
1540 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
1541 "8350 PCI reset bus failed: %d\n", res);
1548 * lpfc_selective_reset - Offline then onlines the port
1549 * @phba: lpfc_hba pointer.
1552 * If the port is configured to allow a reset then the hba is brought
1553 * offline then online.
1556 * Assumes any error from lpfc_do_offline() will be negative.
1557 * Do not make this function static.
1560 * lpfc_do_offline() return code if not zero
1561 * -EIO reset not configured or error posting the event
1565 lpfc_selective_reset(struct lpfc_hba *phba)
1567 struct completion online_compl;
1571 if (!phba->cfg_enable_hba_reset)
1574 if (!(phba->pport->fc_flag & FC_OFFLINE_MODE)) {
1575 status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
1581 init_completion(&online_compl);
1582 rc = lpfc_workq_post_event(phba, &status, &online_compl,
1587 wait_for_completion(&online_compl);
1596 * lpfc_issue_reset - Selectively resets an adapter
1597 * @dev: class device that is converted into a Scsi_host.
1598 * @attr: device attribute, not used.
1599 * @buf: containing the string "selective".
1600 * @count: unused variable.
1603 * If the buf contains the string "selective" then lpfc_selective_reset()
1604 * is called to perform the reset.
1607 * Assumes any error from lpfc_selective_reset() will be negative.
1608 * If lpfc_selective_reset() returns zero then the length of the buffer
1609 * is returned which indicates success
1612 * -EINVAL if the buffer does not contain the string "selective"
1613 * length of buf if lpfc-selective_reset() if the call succeeds
1614 * return value of lpfc_selective_reset() if the call fails
1617 lpfc_issue_reset(struct device *dev, struct device_attribute *attr,
1618 const char *buf, size_t count)
1620 struct Scsi_Host *shost = class_to_shost(dev);
1621 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1622 struct lpfc_hba *phba = vport->phba;
1623 int status = -EINVAL;
1625 if (!phba->cfg_enable_hba_reset)
1628 if (strncmp(buf, "selective", sizeof("selective") - 1) == 0)
1629 status = phba->lpfc_selective_reset(phba);
1638 * lpfc_sli4_pdev_status_reg_wait - Wait for pdev status register for readyness
1639 * @phba: lpfc_hba pointer.
1642 * SLI4 interface type-2 device to wait on the sliport status register for
1643 * the readyness after performing a firmware reset.
1646 * zero for success, -EPERM when port does not have privilege to perform the
1647 * reset, -EIO when port timeout from recovering from the reset.
1650 * As the caller will interpret the return code by value, be careful in making
1651 * change or addition to return codes.
1654 lpfc_sli4_pdev_status_reg_wait(struct lpfc_hba *phba)
1656 struct lpfc_register portstat_reg = {0};
1660 if (lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr,
1661 &portstat_reg.word0))
1664 /* verify if privileged for the request operation */
1665 if (!bf_get(lpfc_sliport_status_rn, &portstat_reg) &&
1666 !bf_get(lpfc_sliport_status_err, &portstat_reg))
1669 /* wait for the SLI port firmware ready after firmware reset */
1670 for (i = 0; i < LPFC_FW_RESET_MAXIMUM_WAIT_10MS_CNT; i++) {
1672 if (lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr,
1673 &portstat_reg.word0))
1675 if (!bf_get(lpfc_sliport_status_err, &portstat_reg))
1677 if (!bf_get(lpfc_sliport_status_rn, &portstat_reg))
1679 if (!bf_get(lpfc_sliport_status_rdy, &portstat_reg))
1684 if (i < LPFC_FW_RESET_MAXIMUM_WAIT_10MS_CNT)
1691 * lpfc_sli4_pdev_reg_request - Request physical dev to perform a register acc
1692 * @phba: lpfc_hba pointer.
1693 * @opcode: The sli4 config command opcode.
1696 * Request SLI4 interface type-2 device to perform a physical register set
1703 lpfc_sli4_pdev_reg_request(struct lpfc_hba *phba, uint32_t opcode)
1705 struct completion online_compl;
1706 struct pci_dev *pdev = phba->pcidev;
1707 uint32_t before_fc_flag;
1708 uint32_t sriov_nr_virtfn;
1710 int status = 0, rc = 0;
1711 int job_posted = 1, sriov_err;
1713 if (!phba->cfg_enable_hba_reset)
1716 if ((phba->sli_rev < LPFC_SLI_REV4) ||
1717 (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) <
1718 LPFC_SLI_INTF_IF_TYPE_2))
1721 /* Keep state if we need to restore back */
1722 before_fc_flag = phba->pport->fc_flag;
1723 sriov_nr_virtfn = phba->cfg_sriov_nr_virtfn;
1725 if (opcode == LPFC_FW_DUMP) {
1726 init_completion(&online_compl);
1727 phba->fw_dump_cmpl = &online_compl;
1729 /* Disable SR-IOV virtual functions if enabled */
1730 if (phba->cfg_sriov_nr_virtfn) {
1731 pci_disable_sriov(pdev);
1732 phba->cfg_sriov_nr_virtfn = 0;
1735 status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
1740 /* wait for the device to be quiesced before firmware reset */
1744 reg_val = readl(phba->sli4_hba.conf_regs_memmap_p +
1745 LPFC_CTL_PDEV_CTL_OFFSET);
1747 if (opcode == LPFC_FW_DUMP)
1748 reg_val |= LPFC_FW_DUMP_REQUEST;
1749 else if (opcode == LPFC_FW_RESET)
1750 reg_val |= LPFC_CTL_PDEV_CTL_FRST;
1751 else if (opcode == LPFC_DV_RESET)
1752 reg_val |= LPFC_CTL_PDEV_CTL_DRST;
1754 writel(reg_val, phba->sli4_hba.conf_regs_memmap_p +
1755 LPFC_CTL_PDEV_CTL_OFFSET);
1757 readl(phba->sli4_hba.conf_regs_memmap_p + LPFC_CTL_PDEV_CTL_OFFSET);
1759 /* delay driver action following IF_TYPE_2 reset */
1760 rc = lpfc_sli4_pdev_status_reg_wait(phba);
1763 /* no privilege for reset */
1764 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1765 "3150 No privilege to perform the requested "
1766 "access: x%x\n", reg_val);
1767 } else if (rc == -EIO) {
1768 /* reset failed, there is nothing more we can do */
1769 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1770 "3153 Fail to perform the requested "
1771 "access: x%x\n", reg_val);
1772 if (phba->fw_dump_cmpl)
1773 phba->fw_dump_cmpl = NULL;
1777 /* keep the original port state */
1778 if (before_fc_flag & FC_OFFLINE_MODE) {
1779 if (phba->fw_dump_cmpl)
1780 phba->fw_dump_cmpl = NULL;
1784 /* Firmware dump will trigger an HA_ERATT event, and
1785 * lpfc_handle_eratt_s4 routine already handles bringing the port back
1788 if (opcode == LPFC_FW_DUMP) {
1789 wait_for_completion(phba->fw_dump_cmpl);
1791 init_completion(&online_compl);
1792 job_posted = lpfc_workq_post_event(phba, &status, &online_compl,
1797 wait_for_completion(&online_compl);
1800 /* in any case, restore the virtual functions enabled as before */
1801 if (sriov_nr_virtfn) {
1802 /* If fw_dump was performed, first disable to clean up */
1803 if (opcode == LPFC_FW_DUMP) {
1804 pci_disable_sriov(pdev);
1805 phba->cfg_sriov_nr_virtfn = 0;
1809 lpfc_sli_probe_sriov_nr_virtfn(phba, sriov_nr_virtfn);
1811 phba->cfg_sriov_nr_virtfn = sriov_nr_virtfn;
1814 /* return proper error code */
1825 * lpfc_nport_evt_cnt_show - Return the number of nport events
1826 * @dev: class device that is converted into a Scsi_host.
1827 * @attr: device attribute, not used.
1828 * @buf: on return contains the ascii number of nport events.
1830 * Returns: size of formatted string.
1833 lpfc_nport_evt_cnt_show(struct device *dev, struct device_attribute *attr,
1836 struct Scsi_Host *shost = class_to_shost(dev);
1837 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1838 struct lpfc_hba *phba = vport->phba;
1840 return scnprintf(buf, PAGE_SIZE, "%d\n", phba->nport_event_cnt);
1844 lpfc_set_trunking(struct lpfc_hba *phba, char *buff_out)
1846 LPFC_MBOXQ_t *mbox = NULL;
1847 unsigned long val = 0;
1851 if (!strncmp("enable", buff_out,
1852 strlen("enable"))) {
1853 pval = buff_out + strlen("enable") + 1;
1854 rc = kstrtoul(pval, 0, &val);
1856 return rc; /* Invalid number */
1857 } else if (!strncmp("disable", buff_out,
1858 strlen("disable"))) {
1861 return -EINVAL; /* Invalid command */
1866 val = 0x0; /* Disable */
1869 val = 0x1; /* Enable two port trunk */
1872 val = 0x2; /* Enable four port trunk */
1878 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
1879 "0070 Set trunk mode with val %ld ", val);
1881 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
1885 lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_FCOE,
1886 LPFC_MBOX_OPCODE_FCOE_FC_SET_TRUNK_MODE,
1887 12, LPFC_SLI4_MBX_EMBED);
1889 bf_set(lpfc_mbx_set_trunk_mode,
1890 &mbox->u.mqe.un.set_trunk_mode,
1892 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
1894 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
1895 "0071 Set trunk mode failed with status: %d",
1897 mempool_free(mbox, phba->mbox_mem_pool);
1903 * lpfc_board_mode_show - Return the state of the board
1904 * @dev: class device that is converted into a Scsi_host.
1905 * @attr: device attribute, not used.
1906 * @buf: on return contains the state of the adapter.
1908 * Returns: size of formatted string.
1911 lpfc_board_mode_show(struct device *dev, struct device_attribute *attr,
1914 struct Scsi_Host *shost = class_to_shost(dev);
1915 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1916 struct lpfc_hba *phba = vport->phba;
1919 if (phba->link_state == LPFC_HBA_ERROR)
1921 else if (phba->link_state == LPFC_WARM_START)
1922 state = "warm start";
1923 else if (phba->link_state == LPFC_INIT_START)
1928 return scnprintf(buf, PAGE_SIZE, "%s\n", state);
1932 * lpfc_board_mode_store - Puts the hba in online, offline, warm or error state
1933 * @dev: class device that is converted into a Scsi_host.
1934 * @attr: device attribute, not used.
1935 * @buf: containing one of the strings "online", "offline", "warm" or "error".
1936 * @count: unused variable.
1939 * -EACCES if enable hba reset not enabled
1940 * -EINVAL if the buffer does not contain a valid string (see above)
1941 * -EIO if lpfc_workq_post_event() or lpfc_do_offline() fails
1942 * buf length greater than zero indicates success
1945 lpfc_board_mode_store(struct device *dev, struct device_attribute *attr,
1946 const char *buf, size_t count)
1948 struct Scsi_Host *shost = class_to_shost(dev);
1949 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1950 struct lpfc_hba *phba = vport->phba;
1951 struct completion online_compl;
1952 char *board_mode_str = NULL;
1956 if (!phba->cfg_enable_hba_reset) {
1958 goto board_mode_out;
1961 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1962 "3050 lpfc_board_mode set to %s\n", buf);
1964 init_completion(&online_compl);
1966 if(strncmp(buf, "online", sizeof("online") - 1) == 0) {
1967 rc = lpfc_workq_post_event(phba, &status, &online_compl,
1971 goto board_mode_out;
1973 wait_for_completion(&online_compl);
1976 } else if (strncmp(buf, "offline", sizeof("offline") - 1) == 0)
1977 status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
1978 else if (strncmp(buf, "warm", sizeof("warm") - 1) == 0)
1979 if (phba->sli_rev == LPFC_SLI_REV4)
1982 status = lpfc_do_offline(phba, LPFC_EVT_WARM_START);
1983 else if (strncmp(buf, "error", sizeof("error") - 1) == 0)
1984 if (phba->sli_rev == LPFC_SLI_REV4)
1987 status = lpfc_do_offline(phba, LPFC_EVT_KILL);
1988 else if (strncmp(buf, "dump", sizeof("dump") - 1) == 0)
1989 status = lpfc_sli4_pdev_reg_request(phba, LPFC_FW_DUMP);
1990 else if (strncmp(buf, "fw_reset", sizeof("fw_reset") - 1) == 0)
1991 status = lpfc_sli4_pdev_reg_request(phba, LPFC_FW_RESET);
1992 else if (strncmp(buf, "dv_reset", sizeof("dv_reset") - 1) == 0)
1993 status = lpfc_sli4_pdev_reg_request(phba, LPFC_DV_RESET);
1994 else if (strncmp(buf, "pci_bus_reset", sizeof("pci_bus_reset") - 1)
1996 status = lpfc_reset_pci_bus(phba);
1997 else if (strncmp(buf, "heartbeat", sizeof("heartbeat") - 1) == 0)
1998 lpfc_issue_hb_tmo(phba);
1999 else if (strncmp(buf, "trunk", sizeof("trunk") - 1) == 0)
2000 status = lpfc_set_trunking(phba, (char *)buf + sizeof("trunk"));
2008 board_mode_str = strchr(buf, '\n');
2010 *board_mode_str = '\0';
2011 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2012 "3097 Failed \"%s\", status(%d), "
2014 buf, status, phba->pport->fc_flag);
2020 * lpfc_get_hba_info - Return various bits of informaton about the adapter
2021 * @phba: pointer to the adapter structure.
2022 * @mxri: max xri count.
2023 * @axri: available xri count.
2024 * @mrpi: max rpi count.
2025 * @arpi: available rpi count.
2026 * @mvpi: max vpi count.
2027 * @avpi: available vpi count.
2030 * If an integer pointer for an count is not null then the value for the
2031 * count is returned.
2038 lpfc_get_hba_info(struct lpfc_hba *phba,
2039 uint32_t *mxri, uint32_t *axri,
2040 uint32_t *mrpi, uint32_t *arpi,
2041 uint32_t *mvpi, uint32_t *avpi)
2043 struct lpfc_mbx_read_config *rd_config;
2044 LPFC_MBOXQ_t *pmboxq;
2050 * prevent udev from issuing mailbox commands until the port is
2053 if (phba->link_state < LPFC_LINK_DOWN ||
2054 !phba->mbox_mem_pool ||
2055 (phba->sli.sli_flag & LPFC_SLI_ACTIVE) == 0)
2058 if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
2061 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
2064 memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
2066 pmb = &pmboxq->u.mb;
2067 pmb->mbxCommand = MBX_READ_CONFIG;
2068 pmb->mbxOwner = OWN_HOST;
2069 pmboxq->ctx_buf = NULL;
2071 if (phba->pport->fc_flag & FC_OFFLINE_MODE)
2072 rc = MBX_NOT_FINISHED;
2074 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
2076 if (rc != MBX_SUCCESS) {
2077 if (rc != MBX_TIMEOUT)
2078 mempool_free(pmboxq, phba->mbox_mem_pool);
2082 if (phba->sli_rev == LPFC_SLI_REV4) {
2083 rd_config = &pmboxq->u.mqe.un.rd_config;
2085 *mrpi = bf_get(lpfc_mbx_rd_conf_rpi_count, rd_config);
2087 *arpi = bf_get(lpfc_mbx_rd_conf_rpi_count, rd_config) -
2088 phba->sli4_hba.max_cfg_param.rpi_used;
2090 *mxri = bf_get(lpfc_mbx_rd_conf_xri_count, rd_config);
2092 *axri = bf_get(lpfc_mbx_rd_conf_xri_count, rd_config) -
2093 phba->sli4_hba.max_cfg_param.xri_used;
2095 /* Account for differences with SLI-3. Get vpi count from
2096 * mailbox data and subtract one for max vpi value.
2098 max_vpi = (bf_get(lpfc_mbx_rd_conf_vpi_count, rd_config) > 0) ?
2099 (bf_get(lpfc_mbx_rd_conf_vpi_count, rd_config) - 1) : 0;
2101 /* Limit the max we support */
2102 if (max_vpi > LPFC_MAX_VPI)
2103 max_vpi = LPFC_MAX_VPI;
2107 *avpi = max_vpi - phba->sli4_hba.max_cfg_param.vpi_used;
2110 *mrpi = pmb->un.varRdConfig.max_rpi;
2112 *arpi = pmb->un.varRdConfig.avail_rpi;
2114 *mxri = pmb->un.varRdConfig.max_xri;
2116 *axri = pmb->un.varRdConfig.avail_xri;
2118 *mvpi = pmb->un.varRdConfig.max_vpi;
2120 /* avail_vpi is only valid if link is up and ready */
2121 if (phba->link_state == LPFC_HBA_READY)
2122 *avpi = pmb->un.varRdConfig.avail_vpi;
2124 *avpi = pmb->un.varRdConfig.max_vpi;
2128 mempool_free(pmboxq, phba->mbox_mem_pool);
2133 * lpfc_max_rpi_show - Return maximum rpi
2134 * @dev: class device that is converted into a Scsi_host.
2135 * @attr: device attribute, not used.
2136 * @buf: on return contains the maximum rpi count in decimal or "Unknown".
2139 * Calls lpfc_get_hba_info() asking for just the mrpi count.
2140 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
2141 * to "Unknown" and the buffer length is returned, therefore the caller
2142 * must check for "Unknown" in the buffer to detect a failure.
2144 * Returns: size of formatted string.
2147 lpfc_max_rpi_show(struct device *dev, struct device_attribute *attr,
2150 struct Scsi_Host *shost = class_to_shost(dev);
2151 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2152 struct lpfc_hba *phba = vport->phba;
2155 if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, NULL, NULL, NULL))
2156 return scnprintf(buf, PAGE_SIZE, "%d\n", cnt);
2157 return scnprintf(buf, PAGE_SIZE, "Unknown\n");
2161 * lpfc_used_rpi_show - Return maximum rpi minus available rpi
2162 * @dev: class device that is converted into a Scsi_host.
2163 * @attr: device attribute, not used.
2164 * @buf: containing the used rpi count in decimal or "Unknown".
2167 * Calls lpfc_get_hba_info() asking for just the mrpi and arpi counts.
2168 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
2169 * to "Unknown" and the buffer length is returned, therefore the caller
2170 * must check for "Unknown" in the buffer to detect a failure.
2172 * Returns: size of formatted string.
2175 lpfc_used_rpi_show(struct device *dev, struct device_attribute *attr,
2178 struct Scsi_Host *shost = class_to_shost(dev);
2179 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2180 struct lpfc_hba *phba = vport->phba;
2183 if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, &acnt, NULL, NULL))
2184 return scnprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
2185 return scnprintf(buf, PAGE_SIZE, "Unknown\n");
2189 * lpfc_max_xri_show - Return maximum xri
2190 * @dev: class device that is converted into a Scsi_host.
2191 * @attr: device attribute, not used.
2192 * @buf: on return contains the maximum xri count in decimal or "Unknown".
2195 * Calls lpfc_get_hba_info() asking for just the mrpi count.
2196 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
2197 * to "Unknown" and the buffer length is returned, therefore the caller
2198 * must check for "Unknown" in the buffer to detect a failure.
2200 * Returns: size of formatted string.
2203 lpfc_max_xri_show(struct device *dev, struct device_attribute *attr,
2206 struct Scsi_Host *shost = class_to_shost(dev);
2207 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2208 struct lpfc_hba *phba = vport->phba;
2211 if (lpfc_get_hba_info(phba, &cnt, NULL, NULL, NULL, NULL, NULL))
2212 return scnprintf(buf, PAGE_SIZE, "%d\n", cnt);
2213 return scnprintf(buf, PAGE_SIZE, "Unknown\n");
2217 * lpfc_used_xri_show - Return maximum xpi minus the available xpi
2218 * @dev: class device that is converted into a Scsi_host.
2219 * @attr: device attribute, not used.
2220 * @buf: on return contains the used xri count in decimal or "Unknown".
2223 * Calls lpfc_get_hba_info() asking for just the mxri and axri counts.
2224 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
2225 * to "Unknown" and the buffer length is returned, therefore the caller
2226 * must check for "Unknown" in the buffer to detect a failure.
2228 * Returns: size of formatted string.
2231 lpfc_used_xri_show(struct device *dev, struct device_attribute *attr,
2234 struct Scsi_Host *shost = class_to_shost(dev);
2235 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2236 struct lpfc_hba *phba = vport->phba;
2239 if (lpfc_get_hba_info(phba, &cnt, &acnt, NULL, NULL, NULL, NULL))
2240 return scnprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
2241 return scnprintf(buf, PAGE_SIZE, "Unknown\n");
2245 * lpfc_max_vpi_show - Return maximum vpi
2246 * @dev: class device that is converted into a Scsi_host.
2247 * @attr: device attribute, not used.
2248 * @buf: on return contains the maximum vpi count in decimal or "Unknown".
2251 * Calls lpfc_get_hba_info() asking for just the mvpi count.
2252 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
2253 * to "Unknown" and the buffer length is returned, therefore the caller
2254 * must check for "Unknown" in the buffer to detect a failure.
2256 * Returns: size of formatted string.
2259 lpfc_max_vpi_show(struct device *dev, struct device_attribute *attr,
2262 struct Scsi_Host *shost = class_to_shost(dev);
2263 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2264 struct lpfc_hba *phba = vport->phba;
2267 if (lpfc_get_hba_info(phba, NULL, NULL, NULL, NULL, &cnt, NULL))
2268 return scnprintf(buf, PAGE_SIZE, "%d\n", cnt);
2269 return scnprintf(buf, PAGE_SIZE, "Unknown\n");
2273 * lpfc_used_vpi_show - Return maximum vpi minus the available vpi
2274 * @dev: class device that is converted into a Scsi_host.
2275 * @attr: device attribute, not used.
2276 * @buf: on return contains the used vpi count in decimal or "Unknown".
2279 * Calls lpfc_get_hba_info() asking for just the mvpi and avpi counts.
2280 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
2281 * to "Unknown" and the buffer length is returned, therefore the caller
2282 * must check for "Unknown" in the buffer to detect a failure.
2284 * Returns: size of formatted string.
2287 lpfc_used_vpi_show(struct device *dev, struct device_attribute *attr,
2290 struct Scsi_Host *shost = class_to_shost(dev);
2291 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2292 struct lpfc_hba *phba = vport->phba;
2295 if (lpfc_get_hba_info(phba, NULL, NULL, NULL, NULL, &cnt, &acnt))
2296 return scnprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
2297 return scnprintf(buf, PAGE_SIZE, "Unknown\n");
2301 * lpfc_npiv_info_show - Return text about NPIV support for the adapter
2302 * @dev: class device that is converted into a Scsi_host.
2303 * @attr: device attribute, not used.
2304 * @buf: text that must be interpreted to determine if npiv is supported.
2307 * Buffer will contain text indicating npiv is not suppoerted on the port,
2308 * the port is an NPIV physical port, or it is an npiv virtual port with
2309 * the id of the vport.
2311 * Returns: size of formatted string.
2314 lpfc_npiv_info_show(struct device *dev, struct device_attribute *attr,
2317 struct Scsi_Host *shost = class_to_shost(dev);
2318 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2319 struct lpfc_hba *phba = vport->phba;
2321 if (!(phba->max_vpi))
2322 return scnprintf(buf, PAGE_SIZE, "NPIV Not Supported\n");
2323 if (vport->port_type == LPFC_PHYSICAL_PORT)
2324 return scnprintf(buf, PAGE_SIZE, "NPIV Physical\n");
2325 return scnprintf(buf, PAGE_SIZE, "NPIV Virtual (VPI %d)\n", vport->vpi);
2329 * lpfc_poll_show - Return text about poll support for the adapter
2330 * @dev: class device that is converted into a Scsi_host.
2331 * @attr: device attribute, not used.
2332 * @buf: on return contains the cfg_poll in hex.
2335 * cfg_poll should be a lpfc_polling_flags type.
2337 * Returns: size of formatted string.
2340 lpfc_poll_show(struct device *dev, struct device_attribute *attr,
2343 struct Scsi_Host *shost = class_to_shost(dev);
2344 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2345 struct lpfc_hba *phba = vport->phba;
2347 return scnprintf(buf, PAGE_SIZE, "%#x\n", phba->cfg_poll);
2351 * lpfc_poll_store - Set the value of cfg_poll for the adapter
2352 * @dev: class device that is converted into a Scsi_host.
2353 * @attr: device attribute, not used.
2354 * @buf: one or more lpfc_polling_flags values.
2358 * buf contents converted to integer and checked for a valid value.
2361 * -EINVAL if the buffer connot be converted or is out of range
2362 * length of the buf on success
2365 lpfc_poll_store(struct device *dev, struct device_attribute *attr,
2366 const char *buf, size_t count)
2368 struct Scsi_Host *shost = class_to_shost(dev);
2369 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2370 struct lpfc_hba *phba = vport->phba;
2375 if (!isdigit(buf[0]))
2378 if (sscanf(buf, "%i", &val) != 1)
2381 if ((val & 0x3) != val)
2384 if (phba->sli_rev == LPFC_SLI_REV4)
2387 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2388 "3051 lpfc_poll changed from %d to %d\n",
2389 phba->cfg_poll, val);
2391 spin_lock_irq(&phba->hbalock);
2393 old_val = phba->cfg_poll;
2395 if (val & ENABLE_FCP_RING_POLLING) {
2396 if ((val & DISABLE_FCP_RING_INT) &&
2397 !(old_val & DISABLE_FCP_RING_INT)) {
2398 if (lpfc_readl(phba->HCregaddr, &creg_val)) {
2399 spin_unlock_irq(&phba->hbalock);
2402 creg_val &= ~(HC_R0INT_ENA << LPFC_FCP_RING);
2403 writel(creg_val, phba->HCregaddr);
2404 readl(phba->HCregaddr); /* flush */
2406 lpfc_poll_start_timer(phba);
2408 } else if (val != 0x0) {
2409 spin_unlock_irq(&phba->hbalock);
2413 if (!(val & DISABLE_FCP_RING_INT) &&
2414 (old_val & DISABLE_FCP_RING_INT))
2416 spin_unlock_irq(&phba->hbalock);
2417 del_timer(&phba->fcp_poll_timer);
2418 spin_lock_irq(&phba->hbalock);
2419 if (lpfc_readl(phba->HCregaddr, &creg_val)) {
2420 spin_unlock_irq(&phba->hbalock);
2423 creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
2424 writel(creg_val, phba->HCregaddr);
2425 readl(phba->HCregaddr); /* flush */
2428 phba->cfg_poll = val;
2430 spin_unlock_irq(&phba->hbalock);
2436 * lpfc_sriov_hw_max_virtfn_show - Return maximum number of virtual functions
2437 * @dev: class converted to a Scsi_host structure.
2438 * @attr: device attribute, not used.
2439 * @buf: on return contains the formatted support level.
2442 * Returns the maximum number of virtual functions a physical function can
2443 * support, 0 will be returned if called on virtual function.
2445 * Returns: size of formatted string.
2448 lpfc_sriov_hw_max_virtfn_show(struct device *dev,
2449 struct device_attribute *attr,
2452 struct Scsi_Host *shost = class_to_shost(dev);
2453 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2454 struct lpfc_hba *phba = vport->phba;
2455 uint16_t max_nr_virtfn;
2457 max_nr_virtfn = lpfc_sli_sriov_nr_virtfn_get(phba);
2458 return scnprintf(buf, PAGE_SIZE, "%d\n", max_nr_virtfn);
2462 * lpfc_enable_bbcr_set: Sets an attribute value.
2463 * @phba: pointer the the adapter structure.
2464 * @val: integer attribute value.
2467 * Validates the min and max values then sets the
2468 * adapter config field if in the valid range. prints error message
2469 * and does not set the parameter if invalid.
2473 * -EINVAL if val is invalid
2476 lpfc_enable_bbcr_set(struct lpfc_hba *phba, uint val)
2478 if (lpfc_rangecheck(val, 0, 1) && phba->sli_rev == LPFC_SLI_REV4) {
2479 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2480 "3068 lpfc_enable_bbcr changed from %d to "
2481 "%d\n", phba->cfg_enable_bbcr, val);
2482 phba->cfg_enable_bbcr = val;
2485 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2486 "0451 lpfc_enable_bbcr cannot set to %d, range is 0, "
2492 * lpfc_param_show - Return a cfg attribute value in decimal
2495 * Macro that given an attr e.g. hba_queue_depth expands
2496 * into a function with the name lpfc_hba_queue_depth_show.
2498 * lpfc_##attr##_show: Return the decimal value of an adapters cfg_xxx field.
2499 * @dev: class device that is converted into a Scsi_host.
2500 * @attr: device attribute, not used.
2501 * @buf: on return contains the attribute value in decimal.
2503 * Returns: size of formatted string.
2505 #define lpfc_param_show(attr) \
2507 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
2510 struct Scsi_Host *shost = class_to_shost(dev);\
2511 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
2512 struct lpfc_hba *phba = vport->phba;\
2513 return scnprintf(buf, PAGE_SIZE, "%d\n",\
2518 * lpfc_param_hex_show - Return a cfg attribute value in hex
2521 * Macro that given an attr e.g. hba_queue_depth expands
2522 * into a function with the name lpfc_hba_queue_depth_show
2524 * lpfc_##attr##_show: Return the hex value of an adapters cfg_xxx field.
2525 * @dev: class device that is converted into a Scsi_host.
2526 * @attr: device attribute, not used.
2527 * @buf: on return contains the attribute value in hexadecimal.
2529 * Returns: size of formatted string.
2531 #define lpfc_param_hex_show(attr) \
2533 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
2536 struct Scsi_Host *shost = class_to_shost(dev);\
2537 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
2538 struct lpfc_hba *phba = vport->phba;\
2540 val = phba->cfg_##attr;\
2541 return scnprintf(buf, PAGE_SIZE, "%#x\n",\
2546 * lpfc_param_init - Initializes a cfg attribute
2549 * Macro that given an attr e.g. hba_queue_depth expands
2550 * into a function with the name lpfc_hba_queue_depth_init. The macro also
2551 * takes a default argument, a minimum and maximum argument.
2553 * lpfc_##attr##_init: Initializes an attribute.
2554 * @phba: pointer the the adapter structure.
2555 * @val: integer attribute value.
2557 * Validates the min and max values then sets the adapter config field
2558 * accordingly, or uses the default if out of range and prints an error message.
2562 * -EINVAL if default used
2564 #define lpfc_param_init(attr, default, minval, maxval) \
2566 lpfc_##attr##_init(struct lpfc_hba *phba, uint val) \
2568 if (lpfc_rangecheck(val, minval, maxval)) {\
2569 phba->cfg_##attr = val;\
2572 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
2573 "0449 lpfc_"#attr" attribute cannot be set to %d, "\
2574 "allowed range is ["#minval", "#maxval"]\n", val); \
2575 phba->cfg_##attr = default;\
2580 * lpfc_param_set - Set a cfg attribute value
2583 * Macro that given an attr e.g. hba_queue_depth expands
2584 * into a function with the name lpfc_hba_queue_depth_set
2586 * lpfc_##attr##_set: Sets an attribute value.
2587 * @phba: pointer the the adapter structure.
2588 * @val: integer attribute value.
2591 * Validates the min and max values then sets the
2592 * adapter config field if in the valid range. prints error message
2593 * and does not set the parameter if invalid.
2597 * -EINVAL if val is invalid
2599 #define lpfc_param_set(attr, default, minval, maxval) \
2601 lpfc_##attr##_set(struct lpfc_hba *phba, uint val) \
2603 if (lpfc_rangecheck(val, minval, maxval)) {\
2604 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
2605 "3052 lpfc_" #attr " changed from %d to %d\n", \
2606 phba->cfg_##attr, val); \
2607 phba->cfg_##attr = val;\
2610 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
2611 "0450 lpfc_"#attr" attribute cannot be set to %d, "\
2612 "allowed range is ["#minval", "#maxval"]\n", val); \
2617 * lpfc_param_store - Set a vport attribute value
2620 * Macro that given an attr e.g. hba_queue_depth expands
2621 * into a function with the name lpfc_hba_queue_depth_store.
2623 * lpfc_##attr##_store: Set an sttribute value.
2624 * @dev: class device that is converted into a Scsi_host.
2625 * @attr: device attribute, not used.
2626 * @buf: contains the attribute value in ascii.
2630 * Convert the ascii text number to an integer, then
2631 * use the lpfc_##attr##_set function to set the value.
2634 * -EINVAL if val is invalid or lpfc_##attr##_set() fails
2635 * length of buffer upon success.
2637 #define lpfc_param_store(attr) \
2639 lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
2640 const char *buf, size_t count) \
2642 struct Scsi_Host *shost = class_to_shost(dev);\
2643 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
2644 struct lpfc_hba *phba = vport->phba;\
2646 if (!isdigit(buf[0]))\
2648 if (sscanf(buf, "%i", &val) != 1)\
2650 if (lpfc_##attr##_set(phba, val) == 0) \
2651 return strlen(buf);\
2657 * lpfc_vport_param_show - Return decimal formatted cfg attribute value
2660 * Macro that given an attr e.g. hba_queue_depth expands
2661 * into a function with the name lpfc_hba_queue_depth_show
2663 * lpfc_##attr##_show: prints the attribute value in decimal.
2664 * @dev: class device that is converted into a Scsi_host.
2665 * @attr: device attribute, not used.
2666 * @buf: on return contains the attribute value in decimal.
2668 * Returns: length of formatted string.
2670 #define lpfc_vport_param_show(attr) \
2672 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
2675 struct Scsi_Host *shost = class_to_shost(dev);\
2676 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
2677 return scnprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_##attr);\
2681 * lpfc_vport_param_hex_show - Return hex formatted attribute value
2684 * Macro that given an attr e.g.
2685 * hba_queue_depth expands into a function with the name
2686 * lpfc_hba_queue_depth_show
2688 * lpfc_##attr##_show: prints the attribute value in hexadecimal.
2689 * @dev: class device that is converted into a Scsi_host.
2690 * @attr: device attribute, not used.
2691 * @buf: on return contains the attribute value in hexadecimal.
2693 * Returns: length of formatted string.
2695 #define lpfc_vport_param_hex_show(attr) \
2697 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
2700 struct Scsi_Host *shost = class_to_shost(dev);\
2701 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
2702 return scnprintf(buf, PAGE_SIZE, "%#x\n", vport->cfg_##attr);\
2706 * lpfc_vport_param_init - Initialize a vport cfg attribute
2709 * Macro that given an attr e.g. hba_queue_depth expands
2710 * into a function with the name lpfc_hba_queue_depth_init. The macro also
2711 * takes a default argument, a minimum and maximum argument.
2713 * lpfc_##attr##_init: validates the min and max values then sets the
2714 * adapter config field accordingly, or uses the default if out of range
2715 * and prints an error message.
2716 * @phba: pointer the the adapter structure.
2717 * @val: integer attribute value.
2721 * -EINVAL if default used
2723 #define lpfc_vport_param_init(attr, default, minval, maxval) \
2725 lpfc_##attr##_init(struct lpfc_vport *vport, uint val) \
2727 if (lpfc_rangecheck(val, minval, maxval)) {\
2728 vport->cfg_##attr = val;\
2731 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
2732 "0423 lpfc_"#attr" attribute cannot be set to %d, "\
2733 "allowed range is ["#minval", "#maxval"]\n", val); \
2734 vport->cfg_##attr = default;\
2739 * lpfc_vport_param_set - Set a vport cfg attribute
2742 * Macro that given an attr e.g. hba_queue_depth expands
2743 * into a function with the name lpfc_hba_queue_depth_set
2745 * lpfc_##attr##_set: validates the min and max values then sets the
2746 * adapter config field if in the valid range. prints error message
2747 * and does not set the parameter if invalid.
2748 * @phba: pointer the the adapter structure.
2749 * @val: integer attribute value.
2753 * -EINVAL if val is invalid
2755 #define lpfc_vport_param_set(attr, default, minval, maxval) \
2757 lpfc_##attr##_set(struct lpfc_vport *vport, uint val) \
2759 if (lpfc_rangecheck(val, minval, maxval)) {\
2760 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
2761 "3053 lpfc_" #attr \
2762 " changed from %d (x%x) to %d (x%x)\n", \
2763 vport->cfg_##attr, vport->cfg_##attr, \
2765 vport->cfg_##attr = val;\
2768 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
2769 "0424 lpfc_"#attr" attribute cannot be set to %d, "\
2770 "allowed range is ["#minval", "#maxval"]\n", val); \
2775 * lpfc_vport_param_store - Set a vport attribute
2778 * Macro that given an attr e.g. hba_queue_depth
2779 * expands into a function with the name lpfc_hba_queue_depth_store
2781 * lpfc_##attr##_store: convert the ascii text number to an integer, then
2782 * use the lpfc_##attr##_set function to set the value.
2783 * @cdev: class device that is converted into a Scsi_host.
2784 * @buf: contains the attribute value in decimal.
2788 * -EINVAL if val is invalid or lpfc_##attr##_set() fails
2789 * length of buffer upon success.
2791 #define lpfc_vport_param_store(attr) \
2793 lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
2794 const char *buf, size_t count) \
2796 struct Scsi_Host *shost = class_to_shost(dev);\
2797 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
2799 if (!isdigit(buf[0]))\
2801 if (sscanf(buf, "%i", &val) != 1)\
2803 if (lpfc_##attr##_set(vport, val) == 0) \
2804 return strlen(buf);\
2810 static DEVICE_ATTR(nvme_info, 0444, lpfc_nvme_info_show, NULL);
2811 static DEVICE_ATTR(scsi_stat, 0444, lpfc_scsi_stat_show, NULL);
2812 static DEVICE_ATTR(bg_info, S_IRUGO, lpfc_bg_info_show, NULL);
2813 static DEVICE_ATTR(bg_guard_err, S_IRUGO, lpfc_bg_guard_err_show, NULL);
2814 static DEVICE_ATTR(bg_apptag_err, S_IRUGO, lpfc_bg_apptag_err_show, NULL);
2815 static DEVICE_ATTR(bg_reftag_err, S_IRUGO, lpfc_bg_reftag_err_show, NULL);
2816 static DEVICE_ATTR(info, S_IRUGO, lpfc_info_show, NULL);
2817 static DEVICE_ATTR(serialnum, S_IRUGO, lpfc_serialnum_show, NULL);
2818 static DEVICE_ATTR(modeldesc, S_IRUGO, lpfc_modeldesc_show, NULL);
2819 static DEVICE_ATTR(modelname, S_IRUGO, lpfc_modelname_show, NULL);
2820 static DEVICE_ATTR(programtype, S_IRUGO, lpfc_programtype_show, NULL);
2821 static DEVICE_ATTR(portnum, S_IRUGO, lpfc_vportnum_show, NULL);
2822 static DEVICE_ATTR(fwrev, S_IRUGO, lpfc_fwrev_show, NULL);
2823 static DEVICE_ATTR(hdw, S_IRUGO, lpfc_hdw_show, NULL);
2824 static DEVICE_ATTR(link_state, S_IRUGO | S_IWUSR, lpfc_link_state_show,
2825 lpfc_link_state_store);
2826 static DEVICE_ATTR(option_rom_version, S_IRUGO,
2827 lpfc_option_rom_version_show, NULL);
2828 static DEVICE_ATTR(num_discovered_ports, S_IRUGO,
2829 lpfc_num_discovered_ports_show, NULL);
2830 static DEVICE_ATTR(menlo_mgmt_mode, S_IRUGO, lpfc_mlomgmt_show, NULL);
2831 static DEVICE_ATTR(nport_evt_cnt, S_IRUGO, lpfc_nport_evt_cnt_show, NULL);
2832 static DEVICE_ATTR_RO(lpfc_drvr_version);
2833 static DEVICE_ATTR_RO(lpfc_enable_fip);
2834 static DEVICE_ATTR(board_mode, S_IRUGO | S_IWUSR,
2835 lpfc_board_mode_show, lpfc_board_mode_store);
2836 static DEVICE_ATTR(issue_reset, S_IWUSR, NULL, lpfc_issue_reset);
2837 static DEVICE_ATTR(max_vpi, S_IRUGO, lpfc_max_vpi_show, NULL);
2838 static DEVICE_ATTR(used_vpi, S_IRUGO, lpfc_used_vpi_show, NULL);
2839 static DEVICE_ATTR(max_rpi, S_IRUGO, lpfc_max_rpi_show, NULL);
2840 static DEVICE_ATTR(used_rpi, S_IRUGO, lpfc_used_rpi_show, NULL);
2841 static DEVICE_ATTR(max_xri, S_IRUGO, lpfc_max_xri_show, NULL);
2842 static DEVICE_ATTR(used_xri, S_IRUGO, lpfc_used_xri_show, NULL);
2843 static DEVICE_ATTR(npiv_info, S_IRUGO, lpfc_npiv_info_show, NULL);
2844 static DEVICE_ATTR_RO(lpfc_temp_sensor);
2845 static DEVICE_ATTR_RO(lpfc_sriov_hw_max_virtfn);
2846 static DEVICE_ATTR(protocol, S_IRUGO, lpfc_sli4_protocol_show, NULL);
2847 static DEVICE_ATTR(lpfc_xlane_supported, S_IRUGO, lpfc_oas_supported_show,
2849 static DEVICE_ATTR(cmf_info, 0444, lpfc_cmf_info_show, NULL);
2853 * lpfc_wwn_set - Convert string to the 8 byte WWN value.
2855 * @cnt: Length of string.
2856 * @wwn: Array to receive converted wwn value.
2859 * -EINVAL if the buffer does not contain a valid wwn
2863 lpfc_wwn_set(const char *buf, size_t cnt, char wwn[])
2867 /* Count may include a LF at end of string */
2868 if (buf[cnt-1] == '\n')
2871 if ((cnt < 16) || (cnt > 18) || ((cnt == 17) && (*buf++ != 'x')) ||
2872 ((cnt == 18) && ((*buf++ != '0') || (*buf++ != 'x'))))
2875 memset(wwn, 0, WWN_SZ);
2877 /* Validate and store the new name */
2878 for (i = 0, j = 0; i < 16; i++) {
2879 if ((*buf >= 'a') && (*buf <= 'f'))
2880 j = ((j << 4) | ((*buf++ - 'a') + 10));
2881 else if ((*buf >= 'A') && (*buf <= 'F'))
2882 j = ((j << 4) | ((*buf++ - 'A') + 10));
2883 else if ((*buf >= '0') && (*buf <= '9'))
2884 j = ((j << 4) | (*buf++ - '0'));
2888 wwn[i/2] = j & 0xff;
2897 * lpfc_oas_tgt_show - Return wwpn of target whose luns maybe enabled for
2898 * Optimized Access Storage (OAS) operations.
2899 * @dev: class device that is converted into a Scsi_host.
2900 * @attr: device attribute, not used.
2901 * @buf: buffer for passing information.
2907 lpfc_oas_tgt_show(struct device *dev, struct device_attribute *attr,
2910 struct Scsi_Host *shost = class_to_shost(dev);
2911 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2913 return scnprintf(buf, PAGE_SIZE, "0x%llx\n",
2914 wwn_to_u64(phba->cfg_oas_tgt_wwpn));
2918 * lpfc_oas_tgt_store - Store wwpn of target whose luns maybe enabled for
2919 * Optimized Access Storage (OAS) operations.
2920 * @dev: class device that is converted into a Scsi_host.
2921 * @attr: device attribute, not used.
2922 * @buf: buffer for passing information.
2923 * @count: Size of the data buffer.
2926 * -EINVAL count is invalid, invalid wwpn byte invalid
2927 * -EPERM oas is not supported by hba
2928 * value of count on success
2931 lpfc_oas_tgt_store(struct device *dev, struct device_attribute *attr,
2932 const char *buf, size_t count)
2934 struct Scsi_Host *shost = class_to_shost(dev);
2935 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2936 unsigned int cnt = count;
2937 uint8_t wwpn[WWN_SZ];
2943 /* count may include a LF at end of string */
2944 if (buf[cnt-1] == '\n')
2947 rc = lpfc_wwn_set(buf, cnt, wwpn);
2951 memcpy(phba->cfg_oas_tgt_wwpn, wwpn, (8 * sizeof(uint8_t)));
2952 memcpy(phba->sli4_hba.oas_next_tgt_wwpn, wwpn, (8 * sizeof(uint8_t)));
2953 if (wwn_to_u64(wwpn) == 0)
2954 phba->cfg_oas_flags |= OAS_FIND_ANY_TARGET;
2956 phba->cfg_oas_flags &= ~OAS_FIND_ANY_TARGET;
2957 phba->cfg_oas_flags &= ~OAS_LUN_VALID;
2958 phba->sli4_hba.oas_next_lun = FIND_FIRST_OAS_LUN;
2961 static DEVICE_ATTR(lpfc_xlane_tgt, S_IRUGO | S_IWUSR,
2962 lpfc_oas_tgt_show, lpfc_oas_tgt_store);
2965 * lpfc_oas_priority_show - Return wwpn of target whose luns maybe enabled for
2966 * Optimized Access Storage (OAS) operations.
2967 * @dev: class device that is converted into a Scsi_host.
2968 * @attr: device attribute, not used.
2969 * @buf: buffer for passing information.
2975 lpfc_oas_priority_show(struct device *dev, struct device_attribute *attr,
2978 struct Scsi_Host *shost = class_to_shost(dev);
2979 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2981 return scnprintf(buf, PAGE_SIZE, "%d\n", phba->cfg_oas_priority);
2985 * lpfc_oas_priority_store - Store wwpn of target whose luns maybe enabled for
2986 * Optimized Access Storage (OAS) operations.
2987 * @dev: class device that is converted into a Scsi_host.
2988 * @attr: device attribute, not used.
2989 * @buf: buffer for passing information.
2990 * @count: Size of the data buffer.
2993 * -EINVAL count is invalid, invalid wwpn byte invalid
2994 * -EPERM oas is not supported by hba
2995 * value of count on success
2998 lpfc_oas_priority_store(struct device *dev, struct device_attribute *attr,
2999 const char *buf, size_t count)
3001 struct Scsi_Host *shost = class_to_shost(dev);
3002 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3003 unsigned int cnt = count;
3010 /* count may include a LF at end of string */
3011 if (buf[cnt-1] == '\n')
3014 ret = kstrtoul(buf, 0, &val);
3015 if (ret || (val > 0x7f))
3019 phba->cfg_oas_priority = (uint8_t)val;
3021 phba->cfg_oas_priority = phba->cfg_XLanePriority;
3024 static DEVICE_ATTR(lpfc_xlane_priority, S_IRUGO | S_IWUSR,
3025 lpfc_oas_priority_show, lpfc_oas_priority_store);
3028 * lpfc_oas_vpt_show - Return wwpn of vport whose targets maybe enabled
3029 * for Optimized Access Storage (OAS) operations.
3030 * @dev: class device that is converted into a Scsi_host.
3031 * @attr: device attribute, not used.
3032 * @buf: buffer for passing information.
3035 * value of count on success
3038 lpfc_oas_vpt_show(struct device *dev, struct device_attribute *attr,
3041 struct Scsi_Host *shost = class_to_shost(dev);
3042 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3044 return scnprintf(buf, PAGE_SIZE, "0x%llx\n",
3045 wwn_to_u64(phba->cfg_oas_vpt_wwpn));
3049 * lpfc_oas_vpt_store - Store wwpn of vport whose targets maybe enabled
3050 * for Optimized Access Storage (OAS) operations.
3051 * @dev: class device that is converted into a Scsi_host.
3052 * @attr: device attribute, not used.
3053 * @buf: buffer for passing information.
3054 * @count: Size of the data buffer.
3057 * -EINVAL count is invalid, invalid wwpn byte invalid
3058 * -EPERM oas is not supported by hba
3059 * value of count on success
3062 lpfc_oas_vpt_store(struct device *dev, struct device_attribute *attr,
3063 const char *buf, size_t count)
3065 struct Scsi_Host *shost = class_to_shost(dev);
3066 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3067 unsigned int cnt = count;
3068 uint8_t wwpn[WWN_SZ];
3074 /* count may include a LF at end of string */
3075 if (buf[cnt-1] == '\n')
3078 rc = lpfc_wwn_set(buf, cnt, wwpn);
3082 memcpy(phba->cfg_oas_vpt_wwpn, wwpn, (8 * sizeof(uint8_t)));
3083 memcpy(phba->sli4_hba.oas_next_vpt_wwpn, wwpn, (8 * sizeof(uint8_t)));
3084 if (wwn_to_u64(wwpn) == 0)
3085 phba->cfg_oas_flags |= OAS_FIND_ANY_VPORT;
3087 phba->cfg_oas_flags &= ~OAS_FIND_ANY_VPORT;
3088 phba->cfg_oas_flags &= ~OAS_LUN_VALID;
3089 if (phba->cfg_oas_priority == 0)
3090 phba->cfg_oas_priority = phba->cfg_XLanePriority;
3091 phba->sli4_hba.oas_next_lun = FIND_FIRST_OAS_LUN;
3094 static DEVICE_ATTR(lpfc_xlane_vpt, S_IRUGO | S_IWUSR,
3095 lpfc_oas_vpt_show, lpfc_oas_vpt_store);
3098 * lpfc_oas_lun_state_show - Return the current state (enabled or disabled)
3099 * of whether luns will be enabled or disabled
3100 * for Optimized Access Storage (OAS) operations.
3101 * @dev: class device that is converted into a Scsi_host.
3102 * @attr: device attribute, not used.
3103 * @buf: buffer for passing information.
3106 * size of formatted string.
3109 lpfc_oas_lun_state_show(struct device *dev, struct device_attribute *attr,
3112 struct Scsi_Host *shost = class_to_shost(dev);
3113 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3115 return scnprintf(buf, PAGE_SIZE, "%d\n", phba->cfg_oas_lun_state);
3119 * lpfc_oas_lun_state_store - Store the state (enabled or disabled)
3120 * of whether luns will be enabled or disabled
3121 * for Optimized Access Storage (OAS) operations.
3122 * @dev: class device that is converted into a Scsi_host.
3123 * @attr: device attribute, not used.
3124 * @buf: buffer for passing information.
3125 * @count: Size of the data buffer.
3128 * -EINVAL count is invalid, invalid wwpn byte invalid
3129 * -EPERM oas is not supported by hba
3130 * value of count on success
3133 lpfc_oas_lun_state_store(struct device *dev, struct device_attribute *attr,
3134 const char *buf, size_t count)
3136 struct Scsi_Host *shost = class_to_shost(dev);
3137 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3143 if (!isdigit(buf[0]))
3146 if (sscanf(buf, "%i", &val) != 1)
3149 if ((val != 0) && (val != 1))
3152 phba->cfg_oas_lun_state = val;
3155 static DEVICE_ATTR(lpfc_xlane_lun_state, S_IRUGO | S_IWUSR,
3156 lpfc_oas_lun_state_show, lpfc_oas_lun_state_store);
3159 * lpfc_oas_lun_status_show - Return the status of the Optimized Access
3160 * Storage (OAS) lun returned by the
3161 * lpfc_oas_lun_show function.
3162 * @dev: class device that is converted into a Scsi_host.
3163 * @attr: device attribute, not used.
3164 * @buf: buffer for passing information.
3167 * size of formatted string.
3170 lpfc_oas_lun_status_show(struct device *dev, struct device_attribute *attr,
3173 struct Scsi_Host *shost = class_to_shost(dev);
3174 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3176 if (!(phba->cfg_oas_flags & OAS_LUN_VALID))
3179 return scnprintf(buf, PAGE_SIZE, "%d\n", phba->cfg_oas_lun_status);
3181 static DEVICE_ATTR(lpfc_xlane_lun_status, S_IRUGO,
3182 lpfc_oas_lun_status_show, NULL);
3186 * lpfc_oas_lun_state_set - enable or disable a lun for Optimized Access Storage
3188 * @phba: lpfc_hba pointer.
3189 * @vpt_wwpn: wwpn of the vport associated with the returned lun
3190 * @tgt_wwpn: wwpn of the target associated with the returned lun
3191 * @lun: the fc lun for setting oas state.
3192 * @oas_state: the oas state to be set to the lun.
3197 * -EPERM OAS is not enabled or not supported by this port.
3201 lpfc_oas_lun_state_set(struct lpfc_hba *phba, uint8_t vpt_wwpn[],
3202 uint8_t tgt_wwpn[], uint64_t lun,
3203 uint32_t oas_state, uint8_t pri)
3212 if (!lpfc_enable_oas_lun(phba, (struct lpfc_name *)vpt_wwpn,
3213 (struct lpfc_name *)tgt_wwpn,
3217 lpfc_disable_oas_lun(phba, (struct lpfc_name *)vpt_wwpn,
3218 (struct lpfc_name *)tgt_wwpn, lun, pri);
3225 * lpfc_oas_lun_get_next - get the next lun that has been enabled for Optimized
3226 * Access Storage (OAS) operations.
3227 * @phba: lpfc_hba pointer.
3228 * @vpt_wwpn: wwpn of the vport associated with the returned lun
3229 * @tgt_wwpn: wwpn of the target associated with the returned lun
3230 * @lun_status: status of the lun returned lun
3231 * @lun_pri: priority of the lun returned lun
3233 * Returns the first or next lun enabled for OAS operations for the vport/target
3234 * specified. If a lun is found, its vport wwpn, target wwpn and status is
3235 * returned. If the lun is not found, NOT_OAS_ENABLED_LUN is returned.
3238 * lun that is OAS enabled for the vport/target
3239 * NOT_OAS_ENABLED_LUN when no oas enabled lun found.
3242 lpfc_oas_lun_get_next(struct lpfc_hba *phba, uint8_t vpt_wwpn[],
3243 uint8_t tgt_wwpn[], uint32_t *lun_status,
3248 if (unlikely(!phba) || !vpt_wwpn || !tgt_wwpn)
3249 return NOT_OAS_ENABLED_LUN;
3250 if (lpfc_find_next_oas_lun(phba, (struct lpfc_name *)
3251 phba->sli4_hba.oas_next_vpt_wwpn,
3252 (struct lpfc_name *)
3253 phba->sli4_hba.oas_next_tgt_wwpn,
3254 &phba->sli4_hba.oas_next_lun,
3255 (struct lpfc_name *)vpt_wwpn,
3256 (struct lpfc_name *)tgt_wwpn,
3257 &found_lun, lun_status, lun_pri))
3260 return NOT_OAS_ENABLED_LUN;
3264 * lpfc_oas_lun_state_change - enable/disable a lun for OAS operations
3265 * @phba: lpfc_hba pointer.
3266 * @vpt_wwpn: vport wwpn by reference.
3267 * @tgt_wwpn: target wwpn by reference.
3268 * @lun: the fc lun for setting oas state.
3269 * @oas_state: the oas state to be set to the oas_lun.
3272 * This routine enables (OAS_LUN_ENABLE) or disables (OAS_LUN_DISABLE)
3273 * a lun for OAS operations.
3277 * -ENOMEM: failed to enable an lun for OAS operations
3278 * -EPERM: OAS is not enabled
3281 lpfc_oas_lun_state_change(struct lpfc_hba *phba, uint8_t vpt_wwpn[],
3282 uint8_t tgt_wwpn[], uint64_t lun,
3283 uint32_t oas_state, uint8_t pri)
3288 rc = lpfc_oas_lun_state_set(phba, vpt_wwpn, tgt_wwpn, lun,
3294 * lpfc_oas_lun_show - Return oas enabled luns from a chosen target
3295 * @dev: class device that is converted into a Scsi_host.
3296 * @attr: device attribute, not used.
3297 * @buf: buffer for passing information.
3299 * This routine returns a lun enabled for OAS each time the function
3303 * SUCCESS: size of formatted string.
3304 * -EFAULT: target or vport wwpn was not set properly.
3305 * -EPERM: oas is not enabled.
3308 lpfc_oas_lun_show(struct device *dev, struct device_attribute *attr,
3311 struct Scsi_Host *shost = class_to_shost(dev);
3312 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3320 if (wwn_to_u64(phba->cfg_oas_vpt_wwpn) == 0)
3321 if (!(phba->cfg_oas_flags & OAS_FIND_ANY_VPORT))
3324 if (wwn_to_u64(phba->cfg_oas_tgt_wwpn) == 0)
3325 if (!(phba->cfg_oas_flags & OAS_FIND_ANY_TARGET))
3328 oas_lun = lpfc_oas_lun_get_next(phba, phba->cfg_oas_vpt_wwpn,
3329 phba->cfg_oas_tgt_wwpn,
3330 &phba->cfg_oas_lun_status,
3331 &phba->cfg_oas_priority);
3332 if (oas_lun != NOT_OAS_ENABLED_LUN)
3333 phba->cfg_oas_flags |= OAS_LUN_VALID;
3335 len += scnprintf(buf + len, PAGE_SIZE-len, "0x%llx", oas_lun);
3341 * lpfc_oas_lun_store - Sets the OAS state for lun
3342 * @dev: class device that is converted into a Scsi_host.
3343 * @attr: device attribute, not used.
3344 * @buf: buffer for passing information.
3345 * @count: size of the formatting string
3347 * This function sets the OAS state for lun. Before this function is called,
3348 * the vport wwpn, target wwpn, and oas state need to be set.
3351 * SUCCESS: size of formatted string.
3352 * -EFAULT: target or vport wwpn was not set properly.
3353 * -EPERM: oas is not enabled.
3354 * size of formatted string.
3357 lpfc_oas_lun_store(struct device *dev, struct device_attribute *attr,
3358 const char *buf, size_t count)
3360 struct Scsi_Host *shost = class_to_shost(dev);
3361 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3369 if (wwn_to_u64(phba->cfg_oas_vpt_wwpn) == 0)
3372 if (wwn_to_u64(phba->cfg_oas_tgt_wwpn) == 0)
3375 if (!isdigit(buf[0]))
3378 if (sscanf(buf, "0x%llx", &scsi_lun) != 1)
3381 pri = phba->cfg_oas_priority;
3383 pri = phba->cfg_XLanePriority;
3385 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
3386 "3372 Try to set vport 0x%llx target 0x%llx lun:0x%llx "
3387 "priority 0x%x with oas state %d\n",
3388 wwn_to_u64(phba->cfg_oas_vpt_wwpn),
3389 wwn_to_u64(phba->cfg_oas_tgt_wwpn), scsi_lun,
3390 pri, phba->cfg_oas_lun_state);
3392 rc = lpfc_oas_lun_state_change(phba, phba->cfg_oas_vpt_wwpn,
3393 phba->cfg_oas_tgt_wwpn, scsi_lun,
3394 phba->cfg_oas_lun_state, pri);
3400 static DEVICE_ATTR(lpfc_xlane_lun, S_IRUGO | S_IWUSR,
3401 lpfc_oas_lun_show, lpfc_oas_lun_store);
3403 int lpfc_enable_nvmet_cnt;
3404 unsigned long long lpfc_enable_nvmet[LPFC_NVMET_MAX_PORTS] = {
3405 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3406 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
3407 module_param_array(lpfc_enable_nvmet, ullong, &lpfc_enable_nvmet_cnt, 0444);
3408 MODULE_PARM_DESC(lpfc_enable_nvmet, "Enable HBA port(s) WWPN as a NVME Target");
3410 static int lpfc_poll = 0;
3411 module_param(lpfc_poll, int, S_IRUGO);
3412 MODULE_PARM_DESC(lpfc_poll, "FCP ring polling mode control:"
3414 " 1 - poll with interrupts enabled"
3415 " 3 - poll and disable FCP ring interrupts");
3417 static DEVICE_ATTR_RW(lpfc_poll);
3419 int lpfc_no_hba_reset_cnt;
3420 unsigned long lpfc_no_hba_reset[MAX_HBAS_NO_RESET] = {
3421 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
3422 module_param_array(lpfc_no_hba_reset, ulong, &lpfc_no_hba_reset_cnt, 0444);
3423 MODULE_PARM_DESC(lpfc_no_hba_reset, "WWPN of HBAs that should not be reset");
3425 LPFC_ATTR(sli_mode, 3, 3, 3,
3426 "SLI mode selector: 3 - select SLI-3");
3428 LPFC_ATTR_R(enable_npiv, 1, 0, 1,
3429 "Enable NPIV functionality");
3431 LPFC_ATTR_R(fcf_failover_policy, 1, 1, 2,
3432 "FCF Fast failover=1 Priority failover=2");
3435 * lpfc_fcp_wait_abts_rsp: Modifies criteria for reporting completion of
3437 * The range is [0,1]. Default value is 0
3438 * 0, IO completes after ABTS issued (default).
3439 * 1, IO completes after receipt of ABTS response or timeout.
3441 LPFC_ATTR_R(fcp_wait_abts_rsp, 0, 0, 1, "Wait for FCP ABTS completion");
3444 # lpfc_enable_rrq: Track XRI/OXID reuse after IO failures
3445 # 0x0 = disabled, XRI/OXID use not tracked.
3446 # 0x1 = XRI/OXID reuse is timed with ratov, RRQ sent.
3447 # 0x2 = XRI/OXID reuse is timed with ratov, No RRQ sent.
3449 LPFC_ATTR_R(enable_rrq, 2, 0, 2,
3450 "Enable RRQ functionality");
3453 # lpfc_suppress_link_up: Bring link up at initialization
3454 # 0x0 = bring link up (issue MBX_INIT_LINK)
3455 # 0x1 = do NOT bring link up at initialization(MBX_INIT_LINK)
3456 # 0x2 = never bring up link
3457 # Default value is 0.
3459 LPFC_ATTR_R(suppress_link_up, LPFC_INITIALIZE_LINK, LPFC_INITIALIZE_LINK,
3460 LPFC_DELAY_INIT_LINK_INDEFINITELY,
3461 "Suppress Link Up at initialization");
3464 lpfc_pls_show(struct device *dev, struct device_attribute *attr, char *buf)
3466 struct Scsi_Host *shost = class_to_shost(dev);
3467 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3469 return scnprintf(buf, PAGE_SIZE, "%d\n",
3470 phba->sli4_hba.pc_sli4_params.pls);
3472 static DEVICE_ATTR(pls, 0444,
3473 lpfc_pls_show, NULL);
3476 lpfc_pt_show(struct device *dev, struct device_attribute *attr, char *buf)
3478 struct Scsi_Host *shost = class_to_shost(dev);
3479 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
3481 return scnprintf(buf, PAGE_SIZE, "%d\n",
3482 (phba->hba_flag & HBA_PERSISTENT_TOPO) ? 1 : 0);
3484 static DEVICE_ATTR(pt, 0444,
3485 lpfc_pt_show, NULL);
3488 # lpfc_cnt: Number of IOCBs allocated for ELS, CT, and ABTS
3496 lpfc_iocb_hw_show(struct device *dev, struct device_attribute *attr, char *buf)
3498 struct Scsi_Host *shost = class_to_shost(dev);
3499 struct lpfc_hba *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
3501 return scnprintf(buf, PAGE_SIZE, "%d\n", phba->iocb_max);
3504 static DEVICE_ATTR(iocb_hw, S_IRUGO,
3505 lpfc_iocb_hw_show, NULL);
3507 lpfc_txq_hw_show(struct device *dev, struct device_attribute *attr, char *buf)
3509 struct Scsi_Host *shost = class_to_shost(dev);
3510 struct lpfc_hba *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
3511 struct lpfc_sli_ring *pring = lpfc_phba_elsring(phba);
3513 return scnprintf(buf, PAGE_SIZE, "%d\n",
3514 pring ? pring->txq_max : 0);
3517 static DEVICE_ATTR(txq_hw, S_IRUGO,
3518 lpfc_txq_hw_show, NULL);
3520 lpfc_txcmplq_hw_show(struct device *dev, struct device_attribute *attr,
3523 struct Scsi_Host *shost = class_to_shost(dev);
3524 struct lpfc_hba *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
3525 struct lpfc_sli_ring *pring = lpfc_phba_elsring(phba);
3527 return scnprintf(buf, PAGE_SIZE, "%d\n",
3528 pring ? pring->txcmplq_max : 0);
3531 static DEVICE_ATTR(txcmplq_hw, S_IRUGO,
3532 lpfc_txcmplq_hw_show, NULL);
3535 # lpfc_nodev_tmo: If set, it will hold all I/O errors on devices that disappear
3536 # until the timer expires. Value range is [0,255]. Default value is 30.
3538 static int lpfc_nodev_tmo = LPFC_DEF_DEVLOSS_TMO;
3539 static int lpfc_devloss_tmo = LPFC_DEF_DEVLOSS_TMO;
3540 module_param(lpfc_nodev_tmo, int, 0);
3541 MODULE_PARM_DESC(lpfc_nodev_tmo,
3542 "Seconds driver will hold I/O waiting "
3543 "for a device to come back");
3546 * lpfc_nodev_tmo_show - Return the hba dev loss timeout value
3547 * @dev: class converted to a Scsi_host structure.
3548 * @attr: device attribute, not used.
3549 * @buf: on return contains the dev loss timeout in decimal.
3551 * Returns: size of formatted string.
3554 lpfc_nodev_tmo_show(struct device *dev, struct device_attribute *attr,
3557 struct Scsi_Host *shost = class_to_shost(dev);
3558 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
3560 return scnprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_devloss_tmo);
3564 * lpfc_nodev_tmo_init - Set the hba nodev timeout value
3565 * @vport: lpfc vport structure pointer.
3566 * @val: contains the nodev timeout value.
3569 * If the devloss tmo is already set then nodev tmo is set to devloss tmo,
3570 * a kernel error message is printed and zero is returned.
3571 * Else if val is in range then nodev tmo and devloss tmo are set to val.
3572 * Otherwise nodev tmo is set to the default value.
3575 * zero if already set or if val is in range
3576 * -EINVAL val out of range
3579 lpfc_nodev_tmo_init(struct lpfc_vport *vport, int val)
3581 if (vport->cfg_devloss_tmo != LPFC_DEF_DEVLOSS_TMO) {
3582 vport->cfg_nodev_tmo = vport->cfg_devloss_tmo;
3583 if (val != LPFC_DEF_DEVLOSS_TMO)
3584 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3585 "0407 Ignoring lpfc_nodev_tmo module "
3586 "parameter because lpfc_devloss_tmo "
3591 if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
3592 vport->cfg_nodev_tmo = val;
3593 vport->cfg_devloss_tmo = val;
3596 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3597 "0400 lpfc_nodev_tmo attribute cannot be set to"
3598 " %d, allowed range is [%d, %d]\n",
3599 val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
3600 vport->cfg_nodev_tmo = LPFC_DEF_DEVLOSS_TMO;
3605 * lpfc_update_rport_devloss_tmo - Update dev loss tmo value
3606 * @vport: lpfc vport structure pointer.
3609 * Update all the ndlp's dev loss tmo with the vport devloss tmo value.
3612 lpfc_update_rport_devloss_tmo(struct lpfc_vport *vport)
3614 struct Scsi_Host *shost;
3615 struct lpfc_nodelist *ndlp;
3616 #if (IS_ENABLED(CONFIG_NVME_FC))
3617 struct lpfc_nvme_rport *rport;
3618 struct nvme_fc_remote_port *remoteport = NULL;
3621 shost = lpfc_shost_from_vport(vport);
3622 spin_lock_irq(shost->host_lock);
3623 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
3625 ndlp->rport->dev_loss_tmo = vport->cfg_devloss_tmo;
3626 #if (IS_ENABLED(CONFIG_NVME_FC))
3627 spin_lock(&ndlp->lock);
3628 rport = lpfc_ndlp_get_nrport(ndlp);
3630 remoteport = rport->remoteport;
3631 spin_unlock(&ndlp->lock);
3632 if (rport && remoteport)
3633 nvme_fc_set_remoteport_devloss(remoteport,
3634 vport->cfg_devloss_tmo);
3637 spin_unlock_irq(shost->host_lock);
3641 * lpfc_nodev_tmo_set - Set the vport nodev tmo and devloss tmo values
3642 * @vport: lpfc vport structure pointer.
3643 * @val: contains the tmo value.
3646 * If the devloss tmo is already set or the vport dev loss tmo has changed
3647 * then a kernel error message is printed and zero is returned.
3648 * Else if val is in range then nodev tmo and devloss tmo are set to val.
3649 * Otherwise nodev tmo is set to the default value.
3652 * zero if already set or if val is in range
3653 * -EINVAL val out of range
3656 lpfc_nodev_tmo_set(struct lpfc_vport *vport, int val)
3658 if (vport->dev_loss_tmo_changed ||
3659 (lpfc_devloss_tmo != LPFC_DEF_DEVLOSS_TMO)) {
3660 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3661 "0401 Ignoring change to lpfc_nodev_tmo "
3662 "because lpfc_devloss_tmo is set.\n");
3665 if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
3666 vport->cfg_nodev_tmo = val;
3667 vport->cfg_devloss_tmo = val;
3669 * For compat: set the fc_host dev loss so new rports
3670 * will get the value.
3672 fc_host_dev_loss_tmo(lpfc_shost_from_vport(vport)) = val;
3673 lpfc_update_rport_devloss_tmo(vport);
3676 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3677 "0403 lpfc_nodev_tmo attribute cannot be set to "
3678 "%d, allowed range is [%d, %d]\n",
3679 val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
3683 lpfc_vport_param_store(nodev_tmo)
3685 static DEVICE_ATTR_RW(lpfc_nodev_tmo);
3688 # lpfc_devloss_tmo: If set, it will hold all I/O errors on devices that
3689 # disappear until the timer expires. Value range is [0,255]. Default
3692 module_param(lpfc_devloss_tmo, int, S_IRUGO);
3693 MODULE_PARM_DESC(lpfc_devloss_tmo,
3694 "Seconds driver will hold I/O waiting "
3695 "for a device to come back");
3696 lpfc_vport_param_init(devloss_tmo, LPFC_DEF_DEVLOSS_TMO,
3697 LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO)
3698 lpfc_vport_param_show(devloss_tmo)
3701 * lpfc_devloss_tmo_set - Sets vport nodev tmo, devloss tmo values, changed bit
3702 * @vport: lpfc vport structure pointer.
3703 * @val: contains the tmo value.
3706 * If val is in a valid range then set the vport nodev tmo,
3707 * devloss tmo, also set the vport dev loss tmo changed flag.
3708 * Else a kernel error message is printed.
3711 * zero if val is in range
3712 * -EINVAL val out of range
3715 lpfc_devloss_tmo_set(struct lpfc_vport *vport, int val)
3717 if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
3718 vport->cfg_nodev_tmo = val;
3719 vport->cfg_devloss_tmo = val;
3720 vport->dev_loss_tmo_changed = 1;
3721 fc_host_dev_loss_tmo(lpfc_shost_from_vport(vport)) = val;
3722 lpfc_update_rport_devloss_tmo(vport);
3726 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3727 "0404 lpfc_devloss_tmo attribute cannot be set to "
3728 "%d, allowed range is [%d, %d]\n",
3729 val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
3733 lpfc_vport_param_store(devloss_tmo)
3734 static DEVICE_ATTR_RW(lpfc_devloss_tmo);
3737 * lpfc_suppress_rsp: Enable suppress rsp feature is firmware supports it
3738 * lpfc_suppress_rsp = 0 Disable
3739 * lpfc_suppress_rsp = 1 Enable (default)
3742 LPFC_ATTR_R(suppress_rsp, 1, 0, 1,
3743 "Enable suppress rsp feature is firmware supports it");
3746 * lpfc_nvmet_mrq: Specify number of RQ pairs for processing NVMET cmds
3747 * lpfc_nvmet_mrq = 0 driver will calcualte optimal number of RQ pairs
3748 * lpfc_nvmet_mrq = 1 use a single RQ pair
3749 * lpfc_nvmet_mrq >= 2 use specified RQ pairs for MRQ
3752 LPFC_ATTR_R(nvmet_mrq,
3753 LPFC_NVMET_MRQ_AUTO, LPFC_NVMET_MRQ_AUTO, LPFC_NVMET_MRQ_MAX,
3754 "Specify number of RQ pairs for processing NVMET cmds");
3757 * lpfc_nvmet_mrq_post: Specify number of RQ buffer to initially post
3758 * to each NVMET RQ. Range 64 to 2048, default is 512.
3760 LPFC_ATTR_R(nvmet_mrq_post,
3761 LPFC_NVMET_RQE_DEF_POST, LPFC_NVMET_RQE_MIN_POST,
3762 LPFC_NVMET_RQE_DEF_COUNT,
3763 "Specify number of RQ buffers to initially post");
3766 * lpfc_enable_fc4_type: Defines what FC4 types are supported.
3767 * Supported Values: 1 - register just FCP
3768 * 3 - register both FCP and NVME
3769 * Supported values are [1,3]. Default value is 3
3771 LPFC_ATTR_R(enable_fc4_type, LPFC_DEF_ENBL_FC4_TYPE,
3772 LPFC_ENABLE_FCP, LPFC_MAX_ENBL_FC4_TYPE,
3773 "Enable FC4 Protocol support - FCP / NVME");
3776 # lpfc_log_verbose: Only turn this flag on if you are willing to risk being
3777 # deluged with LOTS of information.
3778 # You can set a bit mask to record specific types of verbose messages:
3779 # See lpfc_logmsh.h for definitions.
3781 LPFC_VPORT_ATTR_HEX_RW(log_verbose, 0x0, 0x0, 0xffffffff,
3782 "Verbose logging bit-mask");
3785 # lpfc_enable_da_id: This turns on the DA_ID CT command that deregisters
3786 # objects that have been registered with the nameserver after login.
3788 LPFC_VPORT_ATTR_R(enable_da_id, 1, 0, 1,
3789 "Deregister nameserver objects before LOGO");
3792 # lun_queue_depth: This parameter is used to limit the number of outstanding
3793 # commands per FCP LUN.
3795 LPFC_VPORT_ATTR_R(lun_queue_depth, 64, 1, 512,
3796 "Max number of FCP commands we can queue to a specific LUN");
3799 # tgt_queue_depth: This parameter is used to limit the number of outstanding
3800 # commands per target port. Value range is [10,65535]. Default value is 65535.
3802 static uint lpfc_tgt_queue_depth = LPFC_MAX_TGT_QDEPTH;
3803 module_param(lpfc_tgt_queue_depth, uint, 0444);
3804 MODULE_PARM_DESC(lpfc_tgt_queue_depth, "Set max Target queue depth");
3805 lpfc_vport_param_show(tgt_queue_depth);
3806 lpfc_vport_param_init(tgt_queue_depth, LPFC_MAX_TGT_QDEPTH,
3807 LPFC_MIN_TGT_QDEPTH, LPFC_MAX_TGT_QDEPTH);
3810 * lpfc_tgt_queue_depth_set: Sets an attribute value.
3811 * @vport: lpfc vport structure pointer.
3812 * @val: integer attribute value.
3814 * Description: Sets the parameter to the new value.
3818 * -EINVAL if val is invalid
3821 lpfc_tgt_queue_depth_set(struct lpfc_vport *vport, uint val)
3823 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
3824 struct lpfc_nodelist *ndlp;
3826 if (!lpfc_rangecheck(val, LPFC_MIN_TGT_QDEPTH, LPFC_MAX_TGT_QDEPTH))
3829 if (val == vport->cfg_tgt_queue_depth)
3832 spin_lock_irq(shost->host_lock);
3833 vport->cfg_tgt_queue_depth = val;
3835 /* Next loop thru nodelist and change cmd_qdepth */
3836 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp)
3837 ndlp->cmd_qdepth = vport->cfg_tgt_queue_depth;
3839 spin_unlock_irq(shost->host_lock);
3843 lpfc_vport_param_store(tgt_queue_depth);
3844 static DEVICE_ATTR_RW(lpfc_tgt_queue_depth);
3847 # hba_queue_depth: This parameter is used to limit the number of outstanding
3848 # commands per lpfc HBA. Value range is [32,8192]. If this parameter
3849 # value is greater than the maximum number of exchanges supported by the HBA,
3850 # then maximum number of exchanges supported by the HBA is used to determine
3851 # the hba_queue_depth.
3853 LPFC_ATTR_R(hba_queue_depth, 8192, 32, 8192,
3854 "Max number of FCP commands we can queue to a lpfc HBA");
3857 # peer_port_login: This parameter allows/prevents logins
3858 # between peer ports hosted on the same physical port.
3859 # When this parameter is set 0 peer ports of same physical port
3860 # are not allowed to login to each other.
3861 # When this parameter is set 1 peer ports of same physical port
3862 # are allowed to login to each other.
3863 # Default value of this parameter is 0.
3865 LPFC_VPORT_ATTR_R(peer_port_login, 0, 0, 1,
3866 "Allow peer ports on the same physical port to login to each "
3870 # restrict_login: This parameter allows/prevents logins
3871 # between Virtual Ports and remote initiators.
3872 # When this parameter is not set (0) Virtual Ports will accept PLOGIs from
3873 # other initiators and will attempt to PLOGI all remote ports.
3874 # When this parameter is set (1) Virtual Ports will reject PLOGIs from
3875 # remote ports and will not attempt to PLOGI to other initiators.
3876 # This parameter does not restrict to the physical port.
3877 # This parameter does not restrict logins to Fabric resident remote ports.
3878 # Default value of this parameter is 1.
3880 static int lpfc_restrict_login = 1;
3881 module_param(lpfc_restrict_login, int, S_IRUGO);
3882 MODULE_PARM_DESC(lpfc_restrict_login,
3883 "Restrict virtual ports login to remote initiators.");
3884 lpfc_vport_param_show(restrict_login);
3887 * lpfc_restrict_login_init - Set the vport restrict login flag
3888 * @vport: lpfc vport structure pointer.
3889 * @val: contains the restrict login value.
3892 * If val is not in a valid range then log a kernel error message and set
3893 * the vport restrict login to one.
3894 * If the port type is physical clear the restrict login flag and return.
3895 * Else set the restrict login flag to val.
3898 * zero if val is in range
3899 * -EINVAL val out of range
3902 lpfc_restrict_login_init(struct lpfc_vport *vport, int val)
3904 if (val < 0 || val > 1) {
3905 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3906 "0422 lpfc_restrict_login attribute cannot "
3907 "be set to %d, allowed range is [0, 1]\n",
3909 vport->cfg_restrict_login = 1;
3912 if (vport->port_type == LPFC_PHYSICAL_PORT) {
3913 vport->cfg_restrict_login = 0;
3916 vport->cfg_restrict_login = val;
3921 * lpfc_restrict_login_set - Set the vport restrict login flag
3922 * @vport: lpfc vport structure pointer.
3923 * @val: contains the restrict login value.
3926 * If val is not in a valid range then log a kernel error message and set
3927 * the vport restrict login to one.
3928 * If the port type is physical and the val is not zero log a kernel
3929 * error message, clear the restrict login flag and return zero.
3930 * Else set the restrict login flag to val.
3933 * zero if val is in range
3934 * -EINVAL val out of range
3937 lpfc_restrict_login_set(struct lpfc_vport *vport, int val)
3939 if (val < 0 || val > 1) {
3940 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3941 "0425 lpfc_restrict_login attribute cannot "
3942 "be set to %d, allowed range is [0, 1]\n",
3944 vport->cfg_restrict_login = 1;
3947 if (vport->port_type == LPFC_PHYSICAL_PORT && val != 0) {
3948 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3949 "0468 lpfc_restrict_login must be 0 for "
3950 "Physical ports.\n");
3951 vport->cfg_restrict_login = 0;
3954 vport->cfg_restrict_login = val;
3957 lpfc_vport_param_store(restrict_login);
3958 static DEVICE_ATTR_RW(lpfc_restrict_login);
3961 # Some disk devices have a "select ID" or "select Target" capability.
3962 # From a protocol standpoint "select ID" usually means select the
3963 # Fibre channel "ALPA". In the FC-AL Profile there is an "informative
3964 # annex" which contains a table that maps a "select ID" (a number
3965 # between 0 and 7F) to an ALPA. By default, for compatibility with
3966 # older drivers, the lpfc driver scans this table from low ALPA to high
3969 # Turning on the scan-down variable (on = 1, off = 0) will
3970 # cause the lpfc driver to use an inverted table, effectively
3971 # scanning ALPAs from high to low. Value range is [0,1]. Default value is 1.
3973 # (Note: This "select ID" functionality is a LOOP ONLY characteristic
3974 # and will not work across a fabric. Also this parameter will take
3975 # effect only in the case when ALPA map is not available.)
3977 LPFC_VPORT_ATTR_R(scan_down, 1, 0, 1,
3978 "Start scanning for devices from highest ALPA to lowest");
3981 # lpfc_topology: link topology for init link
3982 # 0x0 = attempt loop mode then point-to-point
3983 # 0x01 = internal loopback mode
3984 # 0x02 = attempt point-to-point mode only
3985 # 0x04 = attempt loop mode only
3986 # 0x06 = attempt point-to-point mode then loop
3987 # Set point-to-point mode if you want to run as an N_Port.
3988 # Set loop mode if you want to run as an NL_Port. Value range is [0,0x6].
3989 # Default value is 0.
3991 LPFC_ATTR(topology, 0, 0, 6,
3992 "Select Fibre Channel topology");
3995 * lpfc_topology_store - Set the adapters topology field
3996 * @dev: class device that is converted into a scsi_host.
3997 * @attr:device attribute, not used.
3998 * @buf: buffer for passing information.
3999 * @count: size of the data buffer.
4002 * If val is in a valid range then set the adapter's topology field and
4003 * issue a lip; if the lip fails reset the topology to the old value.
4005 * If the value is not in range log a kernel error message and return an error.
4008 * zero if val is in range and lip okay
4009 * non-zero return value from lpfc_issue_lip()
4010 * -EINVAL val out of range
4013 lpfc_topology_store(struct device *dev, struct device_attribute *attr,
4014 const char *buf, size_t count)
4016 struct Scsi_Host *shost = class_to_shost(dev);
4017 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4018 struct lpfc_hba *phba = vport->phba;
4021 const char *val_buf = buf;
4024 u8 sli_family, if_type;
4026 if (!strncmp(buf, "nolip ", strlen("nolip "))) {
4028 val_buf = &buf[strlen("nolip ")];
4031 if (!isdigit(val_buf[0]))
4033 if (sscanf(val_buf, "%i", &val) != 1)
4036 if (val >= 0 && val <= 6) {
4037 prev_val = phba->cfg_topology;
4038 if (phba->cfg_link_speed == LPFC_USER_LINK_SPEED_16G &&
4040 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
4041 "3113 Loop mode not supported at speed %d\n",
4046 * The 'topology' is not a configurable parameter if :
4047 * - persistent topology enabled
4048 * - ASIC_GEN_NUM >= 0xC, with no private loop support
4050 sli_family = bf_get(lpfc_sli_intf_sli_family,
4051 &phba->sli4_hba.sli_intf);
4052 if_type = bf_get(lpfc_sli_intf_if_type,
4053 &phba->sli4_hba.sli_intf);
4054 if ((phba->hba_flag & HBA_PERSISTENT_TOPO ||
4055 (!phba->sli4_hba.pc_sli4_params.pls &&
4056 (sli_family == LPFC_SLI_INTF_FAMILY_G6 ||
4057 if_type == LPFC_SLI_INTF_IF_TYPE_6))) &&
4059 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
4060 "3114 Loop mode not supported\n");
4063 phba->cfg_topology = val;
4067 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
4068 "3054 lpfc_topology changed from %d to %d\n",
4070 if (prev_val != val && phba->sli_rev == LPFC_SLI_REV4)
4071 phba->fc_topology_changed = 1;
4072 err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport));
4074 phba->cfg_topology = prev_val;
4079 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4080 "%d:0467 lpfc_topology attribute cannot be set to %d, "
4081 "allowed range is [0, 6]\n",
4086 lpfc_param_show(topology)
4087 static DEVICE_ATTR_RW(lpfc_topology);
4090 * lpfc_static_vport_show: Read callback function for
4091 * lpfc_static_vport sysfs file.
4092 * @dev: Pointer to class device object.
4093 * @attr: device attribute structure.
4094 * @buf: Data buffer.
4096 * This function is the read call back function for
4097 * lpfc_static_vport sysfs file. The lpfc_static_vport
4098 * sysfs file report the mageability of the vport.
4101 lpfc_static_vport_show(struct device *dev, struct device_attribute *attr,
4104 struct Scsi_Host *shost = class_to_shost(dev);
4105 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4106 if (vport->vport_flag & STATIC_VPORT)
4107 sprintf(buf, "1\n");
4109 sprintf(buf, "0\n");
4115 * Sysfs attribute to control the statistical data collection.
4117 static DEVICE_ATTR_RO(lpfc_static_vport);
4120 * lpfc_stat_data_ctrl_store - write call back for lpfc_stat_data_ctrl sysfs file
4121 * @dev: Pointer to class device.
4123 * @buf: Data buffer.
4124 * @count: Size of the data buffer.
4126 * This function get called when a user write to the lpfc_stat_data_ctrl
4127 * sysfs file. This function parse the command written to the sysfs file
4128 * and take appropriate action. These commands are used for controlling
4129 * driver statistical data collection.
4130 * Following are the command this function handles.
4132 * setbucket <bucket_type> <base> <step>
4133 * = Set the latency buckets.
4134 * destroybucket = destroy all the buckets.
4135 * start = start data collection
4136 * stop = stop data collection
4137 * reset = reset the collected data
4140 lpfc_stat_data_ctrl_store(struct device *dev, struct device_attribute *attr,
4141 const char *buf, size_t count)
4143 struct Scsi_Host *shost = class_to_shost(dev);
4144 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4145 struct lpfc_hba *phba = vport->phba;
4146 #define LPFC_MAX_DATA_CTRL_LEN 1024
4147 static char bucket_data[LPFC_MAX_DATA_CTRL_LEN];
4149 char *str_ptr, *token;
4150 struct lpfc_vport **vports;
4151 struct Scsi_Host *v_shost;
4152 char *bucket_type_str, *base_str, *step_str;
4153 unsigned long base, step, bucket_type;
4155 if (!strncmp(buf, "setbucket", strlen("setbucket"))) {
4156 if (strlen(buf) > (LPFC_MAX_DATA_CTRL_LEN - 1))
4159 strncpy(bucket_data, buf, LPFC_MAX_DATA_CTRL_LEN);
4160 str_ptr = &bucket_data[0];
4161 /* Ignore this token - this is command token */
4162 token = strsep(&str_ptr, "\t ");
4166 bucket_type_str = strsep(&str_ptr, "\t ");
4167 if (!bucket_type_str)
4170 if (!strncmp(bucket_type_str, "linear", strlen("linear")))
4171 bucket_type = LPFC_LINEAR_BUCKET;
4172 else if (!strncmp(bucket_type_str, "power2", strlen("power2")))
4173 bucket_type = LPFC_POWER2_BUCKET;
4177 base_str = strsep(&str_ptr, "\t ");
4180 base = simple_strtoul(base_str, NULL, 0);
4182 step_str = strsep(&str_ptr, "\t ");
4185 step = simple_strtoul(step_str, NULL, 0);
4189 /* Block the data collection for every vport */
4190 vports = lpfc_create_vport_work_array(phba);
4194 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
4195 v_shost = lpfc_shost_from_vport(vports[i]);
4196 spin_lock_irq(v_shost->host_lock);
4197 /* Block and reset data collection */
4198 vports[i]->stat_data_blocked = 1;
4199 if (vports[i]->stat_data_enabled)
4200 lpfc_vport_reset_stat_data(vports[i]);
4201 spin_unlock_irq(v_shost->host_lock);
4204 /* Set the bucket attributes */
4205 phba->bucket_type = bucket_type;
4206 phba->bucket_base = base;
4207 phba->bucket_step = step;
4209 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
4210 v_shost = lpfc_shost_from_vport(vports[i]);
4212 /* Unblock data collection */
4213 spin_lock_irq(v_shost->host_lock);
4214 vports[i]->stat_data_blocked = 0;
4215 spin_unlock_irq(v_shost->host_lock);
4217 lpfc_destroy_vport_work_array(phba, vports);
4221 if (!strncmp(buf, "destroybucket", strlen("destroybucket"))) {
4222 vports = lpfc_create_vport_work_array(phba);
4226 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
4227 v_shost = lpfc_shost_from_vport(vports[i]);
4228 spin_lock_irq(shost->host_lock);
4229 vports[i]->stat_data_blocked = 1;
4230 lpfc_free_bucket(vport);
4231 vport->stat_data_enabled = 0;
4232 vports[i]->stat_data_blocked = 0;
4233 spin_unlock_irq(shost->host_lock);
4235 lpfc_destroy_vport_work_array(phba, vports);
4236 phba->bucket_type = LPFC_NO_BUCKET;
4237 phba->bucket_base = 0;
4238 phba->bucket_step = 0;
4242 if (!strncmp(buf, "start", strlen("start"))) {
4243 /* If no buckets configured return error */
4244 if (phba->bucket_type == LPFC_NO_BUCKET)
4246 spin_lock_irq(shost->host_lock);
4247 if (vport->stat_data_enabled) {
4248 spin_unlock_irq(shost->host_lock);
4251 lpfc_alloc_bucket(vport);
4252 vport->stat_data_enabled = 1;
4253 spin_unlock_irq(shost->host_lock);
4257 if (!strncmp(buf, "stop", strlen("stop"))) {
4258 spin_lock_irq(shost->host_lock);
4259 if (vport->stat_data_enabled == 0) {
4260 spin_unlock_irq(shost->host_lock);
4263 lpfc_free_bucket(vport);
4264 vport->stat_data_enabled = 0;
4265 spin_unlock_irq(shost->host_lock);
4269 if (!strncmp(buf, "reset", strlen("reset"))) {
4270 if ((phba->bucket_type == LPFC_NO_BUCKET)
4271 || !vport->stat_data_enabled)
4273 spin_lock_irq(shost->host_lock);
4274 vport->stat_data_blocked = 1;
4275 lpfc_vport_reset_stat_data(vport);
4276 vport->stat_data_blocked = 0;
4277 spin_unlock_irq(shost->host_lock);
4285 * lpfc_stat_data_ctrl_show - Read function for lpfc_stat_data_ctrl sysfs file
4286 * @dev: Pointer to class device.
4288 * @buf: Data buffer.
4290 * This function is the read call back function for
4291 * lpfc_stat_data_ctrl sysfs file. This function report the
4292 * current statistical data collection state.
4295 lpfc_stat_data_ctrl_show(struct device *dev, struct device_attribute *attr,
4298 struct Scsi_Host *shost = class_to_shost(dev);
4299 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4300 struct lpfc_hba *phba = vport->phba;
4304 unsigned long bucket_value;
4306 switch (phba->bucket_type) {
4307 case LPFC_LINEAR_BUCKET:
4308 bucket_type = "linear";
4310 case LPFC_POWER2_BUCKET:
4311 bucket_type = "power2";
4314 bucket_type = "No Bucket";
4318 sprintf(&buf[index], "Statistical Data enabled :%d, "
4319 "blocked :%d, Bucket type :%s, Bucket base :%d,"
4320 " Bucket step :%d\nLatency Ranges :",
4321 vport->stat_data_enabled, vport->stat_data_blocked,
4322 bucket_type, phba->bucket_base, phba->bucket_step);
4323 index = strlen(buf);
4324 if (phba->bucket_type != LPFC_NO_BUCKET) {
4325 for (i = 0; i < LPFC_MAX_BUCKET_COUNT; i++) {
4326 if (phba->bucket_type == LPFC_LINEAR_BUCKET)
4327 bucket_value = phba->bucket_base +
4328 phba->bucket_step * i;
4330 bucket_value = phba->bucket_base +
4331 (1 << i) * phba->bucket_step;
4333 if (index + 10 > PAGE_SIZE)
4335 sprintf(&buf[index], "%08ld ", bucket_value);
4336 index = strlen(buf);
4339 sprintf(&buf[index], "\n");
4344 * Sysfs attribute to control the statistical data collection.
4346 static DEVICE_ATTR_RW(lpfc_stat_data_ctrl);
4349 * lpfc_drvr_stat_data: sysfs attr to get driver statistical data.
4353 * Each Bucket takes 11 characters and 1 new line + 17 bytes WWN
4356 #define STAT_DATA_SIZE_PER_TARGET(NUM_BUCKETS) ((NUM_BUCKETS) * 11 + 18)
4357 #define MAX_STAT_DATA_SIZE_PER_TARGET \
4358 STAT_DATA_SIZE_PER_TARGET(LPFC_MAX_BUCKET_COUNT)
4362 * sysfs_drvr_stat_data_read - Read function for lpfc_drvr_stat_data attribute
4364 * @kobj: Pointer to the kernel object
4365 * @bin_attr: Attribute object
4366 * @buf: Buffer pointer
4368 * @count: Buffer size
4370 * This function is the read call back function for lpfc_drvr_stat_data
4371 * sysfs file. This function export the statistical data to user
4375 sysfs_drvr_stat_data_read(struct file *filp, struct kobject *kobj,
4376 struct bin_attribute *bin_attr,
4377 char *buf, loff_t off, size_t count)
4379 struct device *dev = container_of(kobj, struct device,
4381 struct Scsi_Host *shost = class_to_shost(dev);
4382 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4383 struct lpfc_hba *phba = vport->phba;
4384 int i = 0, index = 0;
4385 unsigned long nport_index;
4386 struct lpfc_nodelist *ndlp = NULL;
4387 nport_index = (unsigned long)off /
4388 MAX_STAT_DATA_SIZE_PER_TARGET;
4390 if (!vport->stat_data_enabled || vport->stat_data_blocked
4391 || (phba->bucket_type == LPFC_NO_BUCKET))
4394 spin_lock_irq(shost->host_lock);
4395 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
4396 if (!ndlp->lat_data)
4399 if (nport_index > 0) {
4404 if ((index + MAX_STAT_DATA_SIZE_PER_TARGET)
4408 if (!ndlp->lat_data)
4412 sprintf(&buf[index], "%02x%02x%02x%02x%02x%02x%02x%02x:",
4413 ndlp->nlp_portname.u.wwn[0],
4414 ndlp->nlp_portname.u.wwn[1],
4415 ndlp->nlp_portname.u.wwn[2],
4416 ndlp->nlp_portname.u.wwn[3],
4417 ndlp->nlp_portname.u.wwn[4],
4418 ndlp->nlp_portname.u.wwn[5],
4419 ndlp->nlp_portname.u.wwn[6],
4420 ndlp->nlp_portname.u.wwn[7]);
4422 index = strlen(buf);
4424 for (i = 0; i < LPFC_MAX_BUCKET_COUNT; i++) {
4425 sprintf(&buf[index], "%010u,",
4426 ndlp->lat_data[i].cmd_count);
4427 index = strlen(buf);
4429 sprintf(&buf[index], "\n");
4430 index = strlen(buf);
4432 spin_unlock_irq(shost->host_lock);
4436 static struct bin_attribute sysfs_drvr_stat_data_attr = {
4438 .name = "lpfc_drvr_stat_data",
4441 .size = LPFC_MAX_TARGET * MAX_STAT_DATA_SIZE_PER_TARGET,
4442 .read = sysfs_drvr_stat_data_read,
4447 # lpfc_link_speed: Link speed selection for initializing the Fibre Channel
4449 # Value range is [0,16]. Default value is 0.
4452 * lpfc_link_speed_store - Set the adapters link speed
4453 * @dev: Pointer to class device.
4455 * @buf: Data buffer.
4456 * @count: Size of the data buffer.
4459 * If val is in a valid range then set the adapter's link speed field and
4460 * issue a lip; if the lip fails reset the link speed to the old value.
4463 * If the value is not in range log a kernel error message and return an error.
4466 * zero if val is in range and lip okay.
4467 * non-zero return value from lpfc_issue_lip()
4468 * -EINVAL val out of range
4471 lpfc_link_speed_store(struct device *dev, struct device_attribute *attr,
4472 const char *buf, size_t count)
4474 struct Scsi_Host *shost = class_to_shost(dev);
4475 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4476 struct lpfc_hba *phba = vport->phba;
4477 int val = LPFC_USER_LINK_SPEED_AUTO;
4479 const char *val_buf = buf;
4481 uint32_t prev_val, if_type;
4483 if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
4484 if (if_type >= LPFC_SLI_INTF_IF_TYPE_2 &&
4485 phba->hba_flag & HBA_FORCED_LINK_SPEED)
4488 if (!strncmp(buf, "nolip ", strlen("nolip "))) {
4490 val_buf = &buf[strlen("nolip ")];
4493 if (!isdigit(val_buf[0]))
4495 if (sscanf(val_buf, "%i", &val) != 1)
4498 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
4499 "3055 lpfc_link_speed changed from %d to %d %s\n",
4500 phba->cfg_link_speed, val, nolip ? "(nolip)" : "(lip)");
4502 if (((val == LPFC_USER_LINK_SPEED_1G) && !(phba->lmt & LMT_1Gb)) ||
4503 ((val == LPFC_USER_LINK_SPEED_2G) && !(phba->lmt & LMT_2Gb)) ||
4504 ((val == LPFC_USER_LINK_SPEED_4G) && !(phba->lmt & LMT_4Gb)) ||
4505 ((val == LPFC_USER_LINK_SPEED_8G) && !(phba->lmt & LMT_8Gb)) ||
4506 ((val == LPFC_USER_LINK_SPEED_10G) && !(phba->lmt & LMT_10Gb)) ||
4507 ((val == LPFC_USER_LINK_SPEED_16G) && !(phba->lmt & LMT_16Gb)) ||
4508 ((val == LPFC_USER_LINK_SPEED_32G) && !(phba->lmt & LMT_32Gb)) ||
4509 ((val == LPFC_USER_LINK_SPEED_64G) && !(phba->lmt & LMT_64Gb))) {
4510 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4511 "2879 lpfc_link_speed attribute cannot be set "
4512 "to %d. Speed is not supported by this port.\n",
4516 if (val >= LPFC_USER_LINK_SPEED_16G &&
4517 phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
4518 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4519 "3112 lpfc_link_speed attribute cannot be set "
4520 "to %d. Speed is not supported in loop mode.\n",
4526 case LPFC_USER_LINK_SPEED_AUTO:
4527 case LPFC_USER_LINK_SPEED_1G:
4528 case LPFC_USER_LINK_SPEED_2G:
4529 case LPFC_USER_LINK_SPEED_4G:
4530 case LPFC_USER_LINK_SPEED_8G:
4531 case LPFC_USER_LINK_SPEED_16G:
4532 case LPFC_USER_LINK_SPEED_32G:
4533 case LPFC_USER_LINK_SPEED_64G:
4534 prev_val = phba->cfg_link_speed;
4535 phba->cfg_link_speed = val;
4539 err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport));
4541 phba->cfg_link_speed = prev_val;
4549 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4550 "0469 lpfc_link_speed attribute cannot be set to %d, "
4551 "allowed values are [%s]\n",
4552 val, LPFC_LINK_SPEED_STRING);
4557 static int lpfc_link_speed = 0;
4558 module_param(lpfc_link_speed, int, S_IRUGO);
4559 MODULE_PARM_DESC(lpfc_link_speed, "Select link speed");
4560 lpfc_param_show(link_speed)
4563 * lpfc_link_speed_init - Set the adapters link speed
4564 * @phba: lpfc_hba pointer.
4565 * @val: link speed value.
4568 * If val is in a valid range then set the adapter's link speed field.
4571 * If the value is not in range log a kernel error message, clear the link
4572 * speed and return an error.
4575 * zero if val saved.
4576 * -EINVAL val out of range
4579 lpfc_link_speed_init(struct lpfc_hba *phba, int val)
4581 if (val >= LPFC_USER_LINK_SPEED_16G && phba->cfg_topology == 4) {
4582 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4583 "3111 lpfc_link_speed of %d cannot "
4584 "support loop mode, setting topology to default.\n",
4586 phba->cfg_topology = 0;
4590 case LPFC_USER_LINK_SPEED_AUTO:
4591 case LPFC_USER_LINK_SPEED_1G:
4592 case LPFC_USER_LINK_SPEED_2G:
4593 case LPFC_USER_LINK_SPEED_4G:
4594 case LPFC_USER_LINK_SPEED_8G:
4595 case LPFC_USER_LINK_SPEED_16G:
4596 case LPFC_USER_LINK_SPEED_32G:
4597 case LPFC_USER_LINK_SPEED_64G:
4598 phba->cfg_link_speed = val;
4601 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4602 "0405 lpfc_link_speed attribute cannot "
4603 "be set to %d, allowed values are "
4604 "["LPFC_LINK_SPEED_STRING"]\n", val);
4605 phba->cfg_link_speed = LPFC_USER_LINK_SPEED_AUTO;
4610 static DEVICE_ATTR_RW(lpfc_link_speed);
4613 # lpfc_aer_support: Support PCIe device Advanced Error Reporting (AER)
4614 # 0 = aer disabled or not supported
4615 # 1 = aer supported and enabled (default)
4616 # Value range is [0,1]. Default value is 1.
4618 LPFC_ATTR(aer_support, 1, 0, 1,
4619 "Enable PCIe device AER support");
4620 lpfc_param_show(aer_support)
4623 * lpfc_aer_support_store - Set the adapter for aer support
4625 * @dev: class device that is converted into a Scsi_host.
4626 * @attr: device attribute, not used.
4627 * @buf: containing enable or disable aer flag.
4628 * @count: unused variable.
4631 * If the val is 1 and currently the device's AER capability was not
4632 * enabled, invoke the kernel's enable AER helper routine, trying to
4633 * enable the device's AER capability. If the helper routine enabling
4634 * AER returns success, update the device's cfg_aer_support flag to
4635 * indicate AER is supported by the device; otherwise, if the device
4636 * AER capability is already enabled to support AER, then do nothing.
4638 * If the val is 0 and currently the device's AER support was enabled,
4639 * invoke the kernel's disable AER helper routine. After that, update
4640 * the device's cfg_aer_support flag to indicate AER is not supported
4641 * by the device; otherwise, if the device AER capability is already
4642 * disabled from supporting AER, then do nothing.
4645 * length of the buf on success if val is in range the intended mode
4647 * -EINVAL if val out of range or intended mode is not supported.
4650 lpfc_aer_support_store(struct device *dev, struct device_attribute *attr,
4651 const char *buf, size_t count)
4653 struct Scsi_Host *shost = class_to_shost(dev);
4654 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
4655 struct lpfc_hba *phba = vport->phba;
4656 int val = 0, rc = -EINVAL;
4658 if (!isdigit(buf[0]))
4660 if (sscanf(buf, "%i", &val) != 1)
4665 if (phba->hba_flag & HBA_AER_ENABLED) {
4666 rc = pci_disable_pcie_error_reporting(phba->pcidev);
4668 spin_lock_irq(&phba->hbalock);
4669 phba->hba_flag &= ~HBA_AER_ENABLED;
4670 spin_unlock_irq(&phba->hbalock);
4671 phba->cfg_aer_support = 0;
4676 phba->cfg_aer_support = 0;
4681 if (!(phba->hba_flag & HBA_AER_ENABLED)) {
4682 rc = pci_enable_pcie_error_reporting(phba->pcidev);
4684 spin_lock_irq(&phba->hbalock);
4685 phba->hba_flag |= HBA_AER_ENABLED;
4686 spin_unlock_irq(&phba->hbalock);
4687 phba->cfg_aer_support = 1;
4692 phba->cfg_aer_support = 1;
4703 static DEVICE_ATTR_RW(lpfc_aer_support);
4706 * lpfc_aer_cleanup_state - Clean up aer state to the aer enabled device
4707 * @dev: class device that is converted into a Scsi_host.
4708 * @attr: device attribute, not used.
4709 * @buf: containing flag 1 for aer cleanup state.
4710 * @count: unused variable.
4713 * If the @buf contains 1 and the device currently has the AER support
4714 * enabled, then invokes the kernel AER helper routine
4715 * pci_aer_clear_nonfatal_status() to clean up the uncorrectable
4716 * error status register.
4721 * -EINVAL if the buf does not contain the 1 or the device is not currently
4722 * enabled with the AER support.
4725 lpfc_aer_cleanup_state(struct device *dev, struct device_attribute *attr,
4726 const char *buf, size_t count)
4728 struct Scsi_Host *shost = class_to_shost(dev);
4729 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4730 struct lpfc_hba *phba = vport->phba;
4733 if (!isdigit(buf[0]))
4735 if (sscanf(buf, "%i", &val) != 1)
4740 if (phba->hba_flag & HBA_AER_ENABLED)
4741 rc = pci_aer_clear_nonfatal_status(phba->pcidev);
4749 static DEVICE_ATTR(lpfc_aer_state_cleanup, S_IWUSR, NULL,
4750 lpfc_aer_cleanup_state);
4753 * lpfc_sriov_nr_virtfn_store - Enable the adapter for sr-iov virtual functions
4755 * @dev: class device that is converted into a Scsi_host.
4756 * @attr: device attribute, not used.
4757 * @buf: containing the string the number of vfs to be enabled.
4758 * @count: unused variable.
4761 * When this api is called either through user sysfs, the driver shall
4762 * try to enable or disable SR-IOV virtual functions according to the
4765 * If zero virtual function has been enabled to the physical function,
4766 * the driver shall invoke the pci enable virtual function api trying
4767 * to enable the virtual functions. If the nr_vfn provided is greater
4768 * than the maximum supported, the maximum virtual function number will
4769 * be used for invoking the api; otherwise, the nr_vfn provided shall
4770 * be used for invoking the api. If the api call returned success, the
4771 * actual number of virtual functions enabled will be set to the driver
4772 * cfg_sriov_nr_virtfn; otherwise, -EINVAL shall be returned and driver
4773 * cfg_sriov_nr_virtfn remains zero.
4775 * If none-zero virtual functions have already been enabled to the
4776 * physical function, as reflected by the driver's cfg_sriov_nr_virtfn,
4777 * -EINVAL will be returned and the driver does nothing;
4779 * If the nr_vfn provided is zero and none-zero virtual functions have
4780 * been enabled, as indicated by the driver's cfg_sriov_nr_virtfn, the
4781 * disabling virtual function api shall be invoded to disable all the
4782 * virtual functions and driver's cfg_sriov_nr_virtfn shall be set to
4783 * zero. Otherwise, if zero virtual function has been enabled, do
4787 * length of the buf on success if val is in range the intended mode
4789 * -EINVAL if val out of range or intended mode is not supported.
4792 lpfc_sriov_nr_virtfn_store(struct device *dev, struct device_attribute *attr,
4793 const char *buf, size_t count)
4795 struct Scsi_Host *shost = class_to_shost(dev);
4796 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
4797 struct lpfc_hba *phba = vport->phba;
4798 struct pci_dev *pdev = phba->pcidev;
4799 int val = 0, rc = -EINVAL;
4801 /* Sanity check on user data */
4802 if (!isdigit(buf[0]))
4804 if (sscanf(buf, "%i", &val) != 1)
4809 /* Request disabling virtual functions */
4811 if (phba->cfg_sriov_nr_virtfn > 0) {
4812 pci_disable_sriov(pdev);
4813 phba->cfg_sriov_nr_virtfn = 0;
4818 /* Request enabling virtual functions */
4819 if (phba->cfg_sriov_nr_virtfn > 0) {
4820 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4821 "3018 There are %d virtual functions "
4822 "enabled on physical function.\n",
4823 phba->cfg_sriov_nr_virtfn);
4827 if (val <= LPFC_MAX_VFN_PER_PFN)
4828 phba->cfg_sriov_nr_virtfn = val;
4830 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4831 "3019 Enabling %d virtual functions is not "
4836 rc = lpfc_sli_probe_sriov_nr_virtfn(phba, phba->cfg_sriov_nr_virtfn);
4838 phba->cfg_sriov_nr_virtfn = 0;
4846 LPFC_ATTR(sriov_nr_virtfn, LPFC_DEF_VFN_PER_PFN, 0, LPFC_MAX_VFN_PER_PFN,
4847 "Enable PCIe device SR-IOV virtual fn");
4849 lpfc_param_show(sriov_nr_virtfn)
4850 static DEVICE_ATTR_RW(lpfc_sriov_nr_virtfn);
4853 * lpfc_request_firmware_upgrade_store - Request for Linux generic firmware upgrade
4855 * @dev: class device that is converted into a Scsi_host.
4856 * @attr: device attribute, not used.
4857 * @buf: containing the string the number of vfs to be enabled.
4858 * @count: unused variable.
4863 * length of the buf on success if val is in range the intended mode
4865 * -EINVAL if val out of range or intended mode is not supported.
4868 lpfc_request_firmware_upgrade_store(struct device *dev,
4869 struct device_attribute *attr,
4870 const char *buf, size_t count)
4872 struct Scsi_Host *shost = class_to_shost(dev);
4873 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
4874 struct lpfc_hba *phba = vport->phba;
4877 /* Sanity check on user data */
4878 if (!isdigit(buf[0]))
4880 if (sscanf(buf, "%i", &val) != 1)
4885 rc = lpfc_sli4_request_firmware_update(phba, RUN_FW_UPGRADE);
4893 static int lpfc_req_fw_upgrade;
4894 module_param(lpfc_req_fw_upgrade, int, S_IRUGO|S_IWUSR);
4895 MODULE_PARM_DESC(lpfc_req_fw_upgrade, "Enable Linux generic firmware upgrade");
4896 lpfc_param_show(request_firmware_upgrade)
4899 * lpfc_request_firmware_upgrade_init - Enable initial linux generic fw upgrade
4900 * @phba: lpfc_hba pointer.
4904 * Set the initial Linux generic firmware upgrade enable or disable flag.
4907 * zero if val saved.
4908 * -EINVAL val out of range
4911 lpfc_request_firmware_upgrade_init(struct lpfc_hba *phba, int val)
4913 if (val >= 0 && val <= 1) {
4914 phba->cfg_request_firmware_upgrade = val;
4919 static DEVICE_ATTR(lpfc_req_fw_upgrade, S_IRUGO | S_IWUSR,
4920 lpfc_request_firmware_upgrade_show,
4921 lpfc_request_firmware_upgrade_store);
4924 * lpfc_force_rscn_store
4926 * @dev: class device that is converted into a Scsi_host.
4927 * @attr: device attribute, not used.
4928 * @buf: unused string
4929 * @count: unused variable.
4932 * Force the switch to send a RSCN to all other NPorts in our zone
4933 * If we are direct connect pt2pt, build the RSCN command ourself
4934 * and send to the other NPort. Not supported for private loop.
4938 * -EIO - if command is not sent
4941 lpfc_force_rscn_store(struct device *dev, struct device_attribute *attr,
4942 const char *buf, size_t count)
4944 struct Scsi_Host *shost = class_to_shost(dev);
4945 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
4948 i = lpfc_issue_els_rscn(vport, 0);
4955 * lpfc_force_rscn: Force an RSCN to be sent to all remote NPorts
4956 * connected to the HBA.
4958 * Value range is any ascii value
4960 static int lpfc_force_rscn;
4961 module_param(lpfc_force_rscn, int, 0644);
4962 MODULE_PARM_DESC(lpfc_force_rscn,
4963 "Force an RSCN to be sent to all remote NPorts");
4964 lpfc_param_show(force_rscn)
4967 * lpfc_force_rscn_init - Force an RSCN to be sent to all remote NPorts
4968 * @phba: lpfc_hba pointer.
4969 * @val: unused value.
4972 * zero if val saved.
4975 lpfc_force_rscn_init(struct lpfc_hba *phba, int val)
4979 static DEVICE_ATTR_RW(lpfc_force_rscn);
4982 * lpfc_fcp_imax_store
4984 * @dev: class device that is converted into a Scsi_host.
4985 * @attr: device attribute, not used.
4986 * @buf: string with the number of fast-path FCP interrupts per second.
4987 * @count: unused variable.
4990 * If val is in a valid range [636,651042], then set the adapter's
4991 * maximum number of fast-path FCP interrupts per second.
4994 * length of the buf on success if val is in range the intended mode
4996 * -EINVAL if val out of range or intended mode is not supported.
4999 lpfc_fcp_imax_store(struct device *dev, struct device_attribute *attr,
5000 const char *buf, size_t count)
5002 struct Scsi_Host *shost = class_to_shost(dev);
5003 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
5004 struct lpfc_hba *phba = vport->phba;
5005 struct lpfc_eq_intr_info *eqi;
5009 /* fcp_imax is only valid for SLI4 */
5010 if (phba->sli_rev != LPFC_SLI_REV4)
5013 /* Sanity check on user data */
5014 if (!isdigit(buf[0]))
5016 if (sscanf(buf, "%i", &val) != 1)
5020 * Value range for the HBA is [5000,5000000]
5021 * The value for each EQ depends on how many EQs are configured.
5024 if (val && (val < LPFC_MIN_IMAX || val > LPFC_MAX_IMAX))
5027 phba->cfg_auto_imax = (val) ? 0 : 1;
5028 if (phba->cfg_fcp_imax && !val) {
5029 queue_delayed_work(phba->wq, &phba->eq_delay_work,
5030 msecs_to_jiffies(LPFC_EQ_DELAY_MSECS));
5032 for_each_present_cpu(i) {
5033 eqi = per_cpu_ptr(phba->sli4_hba.eq_info, i);
5038 phba->cfg_fcp_imax = (uint32_t)val;
5040 if (phba->cfg_fcp_imax)
5041 usdelay = LPFC_SEC_TO_USEC / phba->cfg_fcp_imax;
5045 for (i = 0; i < phba->cfg_irq_chann; i += LPFC_MAX_EQ_DELAY_EQID_CNT)
5046 lpfc_modify_hba_eq_delay(phba, i, LPFC_MAX_EQ_DELAY_EQID_CNT,
5053 # lpfc_fcp_imax: The maximum number of fast-path FCP interrupts per second
5056 # Value range is [5,000 to 5,000,000]. Default value is 50,000.
5058 static int lpfc_fcp_imax = LPFC_DEF_IMAX;
5059 module_param(lpfc_fcp_imax, int, S_IRUGO|S_IWUSR);
5060 MODULE_PARM_DESC(lpfc_fcp_imax,
5061 "Set the maximum number of FCP interrupts per second per HBA");
5062 lpfc_param_show(fcp_imax)
5065 * lpfc_fcp_imax_init - Set the initial sr-iov virtual function enable
5066 * @phba: lpfc_hba pointer.
5067 * @val: link speed value.
5070 * If val is in a valid range [636,651042], then initialize the adapter's
5071 * maximum number of fast-path FCP interrupts per second.
5074 * zero if val saved.
5075 * -EINVAL val out of range
5078 lpfc_fcp_imax_init(struct lpfc_hba *phba, int val)
5080 if (phba->sli_rev != LPFC_SLI_REV4) {
5081 phba->cfg_fcp_imax = 0;
5085 if ((val >= LPFC_MIN_IMAX && val <= LPFC_MAX_IMAX) ||
5087 phba->cfg_fcp_imax = val;
5091 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5092 "3016 lpfc_fcp_imax: %d out of range, using default\n",
5094 phba->cfg_fcp_imax = LPFC_DEF_IMAX;
5099 static DEVICE_ATTR_RW(lpfc_fcp_imax);
5102 * lpfc_cq_max_proc_limit_store
5104 * @dev: class device that is converted into a Scsi_host.
5105 * @attr: device attribute, not used.
5106 * @buf: string with the cq max processing limit of cqes
5107 * @count: unused variable.
5110 * If val is in a valid range, then set value on each cq
5113 * The length of the buf: if successful
5114 * -ERANGE: if val is not in the valid range
5115 * -EINVAL: if bad value format or intended mode is not supported.
5118 lpfc_cq_max_proc_limit_store(struct device *dev, struct device_attribute *attr,
5119 const char *buf, size_t count)
5121 struct Scsi_Host *shost = class_to_shost(dev);
5122 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
5123 struct lpfc_hba *phba = vport->phba;
5124 struct lpfc_queue *eq, *cq;
5128 /* cq_max_proc_limit is only valid for SLI4 */
5129 if (phba->sli_rev != LPFC_SLI_REV4)
5132 /* Sanity check on user data */
5133 if (!isdigit(buf[0]))
5135 if (kstrtoul(buf, 0, &val))
5138 if (val < LPFC_CQ_MIN_PROC_LIMIT || val > LPFC_CQ_MAX_PROC_LIMIT)
5141 phba->cfg_cq_max_proc_limit = (uint32_t)val;
5143 /* set the values on the cq's */
5144 for (i = 0; i < phba->cfg_irq_chann; i++) {
5145 /* Get the EQ corresponding to the IRQ vector */
5146 eq = phba->sli4_hba.hba_eq_hdl[i].eq;
5150 list_for_each_entry(cq, &eq->child_list, list)
5151 cq->max_proc_limit = min(phba->cfg_cq_max_proc_limit,
5159 * lpfc_cq_max_proc_limit: The maximum number CQE entries processed in an
5160 * itteration of CQ processing.
5162 static int lpfc_cq_max_proc_limit = LPFC_CQ_DEF_MAX_PROC_LIMIT;
5163 module_param(lpfc_cq_max_proc_limit, int, 0644);
5164 MODULE_PARM_DESC(lpfc_cq_max_proc_limit,
5165 "Set the maximum number CQEs processed in an iteration of "
5167 lpfc_param_show(cq_max_proc_limit)
5170 * lpfc_cq_poll_threshold: Set the threshold of CQE completions in a
5171 * single handler call which should request a polled completion rather
5172 * than re-enabling interrupts.
5174 LPFC_ATTR_RW(cq_poll_threshold, LPFC_CQ_DEF_THRESHOLD_TO_POLL,
5175 LPFC_CQ_MIN_THRESHOLD_TO_POLL,
5176 LPFC_CQ_MAX_THRESHOLD_TO_POLL,
5177 "CQE Processing Threshold to enable Polling");
5180 * lpfc_cq_max_proc_limit_init - Set the initial cq max_proc_limit
5181 * @phba: lpfc_hba pointer.
5185 * If val is in a valid range, then initialize the adapter's maximum
5189 * Always returns 0 for success, even if value not always set to
5190 * requested value. If value out of range or not supported, will fall
5194 lpfc_cq_max_proc_limit_init(struct lpfc_hba *phba, int val)
5196 phba->cfg_cq_max_proc_limit = LPFC_CQ_DEF_MAX_PROC_LIMIT;
5198 if (phba->sli_rev != LPFC_SLI_REV4)
5201 if (val >= LPFC_CQ_MIN_PROC_LIMIT && val <= LPFC_CQ_MAX_PROC_LIMIT) {
5202 phba->cfg_cq_max_proc_limit = val;
5206 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5207 "0371 lpfc_cq_max_proc_limit: %d out of range, using "
5209 phba->cfg_cq_max_proc_limit);
5214 static DEVICE_ATTR_RW(lpfc_cq_max_proc_limit);
5217 * lpfc_fcp_cpu_map_show - Display current driver CPU affinity
5218 * @dev: class converted to a Scsi_host structure.
5219 * @attr: device attribute, not used.
5220 * @buf: on return contains text describing the state of the link.
5222 * Returns: size of formatted string.
5225 lpfc_fcp_cpu_map_show(struct device *dev, struct device_attribute *attr,
5228 struct Scsi_Host *shost = class_to_shost(dev);
5229 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
5230 struct lpfc_hba *phba = vport->phba;
5231 struct lpfc_vector_map_info *cpup;
5234 if ((phba->sli_rev != LPFC_SLI_REV4) ||
5235 (phba->intr_type != MSIX))
5238 switch (phba->cfg_fcp_cpu_map) {
5240 len += scnprintf(buf + len, PAGE_SIZE-len,
5241 "fcp_cpu_map: No mapping (%d)\n",
5242 phba->cfg_fcp_cpu_map);
5245 len += scnprintf(buf + len, PAGE_SIZE-len,
5246 "fcp_cpu_map: HBA centric mapping (%d): "
5247 "%d of %d CPUs online from %d possible CPUs\n",
5248 phba->cfg_fcp_cpu_map, num_online_cpus(),
5250 phba->sli4_hba.num_possible_cpu);
5254 while (phba->sli4_hba.curr_disp_cpu <
5255 phba->sli4_hba.num_possible_cpu) {
5256 cpup = &phba->sli4_hba.cpu_map[phba->sli4_hba.curr_disp_cpu];
5258 if (!cpu_present(phba->sli4_hba.curr_disp_cpu))
5259 len += scnprintf(buf + len, PAGE_SIZE - len,
5260 "CPU %02d not present\n",
5261 phba->sli4_hba.curr_disp_cpu);
5262 else if (cpup->eq == LPFC_VECTOR_MAP_EMPTY) {
5263 if (cpup->hdwq == LPFC_VECTOR_MAP_EMPTY)
5265 buf + len, PAGE_SIZE - len,
5266 "CPU %02d hdwq None "
5267 "physid %d coreid %d ht %d ua %d\n",
5268 phba->sli4_hba.curr_disp_cpu,
5269 cpup->phys_id, cpup->core_id,
5270 (cpup->flag & LPFC_CPU_MAP_HYPER),
5271 (cpup->flag & LPFC_CPU_MAP_UNASSIGN));
5274 buf + len, PAGE_SIZE - len,
5275 "CPU %02d EQ None hdwq %04d "
5276 "physid %d coreid %d ht %d ua %d\n",
5277 phba->sli4_hba.curr_disp_cpu,
5278 cpup->hdwq, cpup->phys_id,
5280 (cpup->flag & LPFC_CPU_MAP_HYPER),
5281 (cpup->flag & LPFC_CPU_MAP_UNASSIGN));
5283 if (cpup->hdwq == LPFC_VECTOR_MAP_EMPTY)
5285 buf + len, PAGE_SIZE - len,
5286 "CPU %02d hdwq None "
5287 "physid %d coreid %d ht %d ua %d IRQ %d\n",
5288 phba->sli4_hba.curr_disp_cpu,
5291 (cpup->flag & LPFC_CPU_MAP_HYPER),
5292 (cpup->flag & LPFC_CPU_MAP_UNASSIGN),
5293 lpfc_get_irq(cpup->eq));
5296 buf + len, PAGE_SIZE - len,
5297 "CPU %02d EQ %04d hdwq %04d "
5298 "physid %d coreid %d ht %d ua %d IRQ %d\n",
5299 phba->sli4_hba.curr_disp_cpu,
5300 cpup->eq, cpup->hdwq, cpup->phys_id,
5302 (cpup->flag & LPFC_CPU_MAP_HYPER),
5303 (cpup->flag & LPFC_CPU_MAP_UNASSIGN),
5304 lpfc_get_irq(cpup->eq));
5307 phba->sli4_hba.curr_disp_cpu++;
5309 /* display max number of CPUs keeping some margin */
5310 if (phba->sli4_hba.curr_disp_cpu <
5311 phba->sli4_hba.num_possible_cpu &&
5312 (len >= (PAGE_SIZE - 64))) {
5313 len += scnprintf(buf + len,
5314 PAGE_SIZE - len, "more...\n");
5319 if (phba->sli4_hba.curr_disp_cpu == phba->sli4_hba.num_possible_cpu)
5320 phba->sli4_hba.curr_disp_cpu = 0;
5326 * lpfc_fcp_cpu_map_store - Change CPU affinity of driver vectors
5327 * @dev: class device that is converted into a Scsi_host.
5328 * @attr: device attribute, not used.
5329 * @buf: one or more lpfc_polling_flags values.
5333 * -EINVAL - Not implemented yet.
5336 lpfc_fcp_cpu_map_store(struct device *dev, struct device_attribute *attr,
5337 const char *buf, size_t count)
5343 # lpfc_fcp_cpu_map: Defines how to map CPUs to IRQ vectors
5346 # Value range is [0 to 1]. Default value is LPFC_HBA_CPU_MAP (1).
5347 # 0 - Do not affinitze IRQ vectors
5348 # 1 - Affintize HBA vectors with respect to each HBA
5349 # (start with CPU0 for each HBA)
5350 # This also defines how Hardware Queues are mapped to specific CPUs.
5352 static int lpfc_fcp_cpu_map = LPFC_HBA_CPU_MAP;
5353 module_param(lpfc_fcp_cpu_map, int, S_IRUGO|S_IWUSR);
5354 MODULE_PARM_DESC(lpfc_fcp_cpu_map,
5355 "Defines how to map CPUs to IRQ vectors per HBA");
5358 * lpfc_fcp_cpu_map_init - Set the initial sr-iov virtual function enable
5359 * @phba: lpfc_hba pointer.
5360 * @val: link speed value.
5363 * If val is in a valid range [0-2], then affinitze the adapter's
5367 * zero if val saved.
5368 * -EINVAL val out of range
5371 lpfc_fcp_cpu_map_init(struct lpfc_hba *phba, int val)
5373 if (phba->sli_rev != LPFC_SLI_REV4) {
5374 phba->cfg_fcp_cpu_map = 0;
5378 if (val >= LPFC_MIN_CPU_MAP && val <= LPFC_MAX_CPU_MAP) {
5379 phba->cfg_fcp_cpu_map = val;
5383 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
5384 "3326 lpfc_fcp_cpu_map: %d out of range, using "
5386 phba->cfg_fcp_cpu_map = LPFC_HBA_CPU_MAP;
5391 static DEVICE_ATTR_RW(lpfc_fcp_cpu_map);
5394 # lpfc_fcp_class: Determines FC class to use for the FCP protocol.
5395 # Value range is [2,3]. Default value is 3.
5397 LPFC_VPORT_ATTR_R(fcp_class, 3, 2, 3,
5398 "Select Fibre Channel class of service for FCP sequences");
5401 # lpfc_use_adisc: Use ADISC for FCP rediscovery instead of PLOGI. Value range
5402 # is [0,1]. Default value is 1.
5404 LPFC_VPORT_ATTR_RW(use_adisc, 1, 0, 1,
5405 "Use ADISC on rediscovery to authenticate FCP devices");
5408 # lpfc_first_burst_size: First burst size to use on the NPorts
5409 # that support first burst.
5410 # Value range is [0,65536]. Default value is 0.
5412 LPFC_VPORT_ATTR_RW(first_burst_size, 0, 0, 65536,
5413 "First burst size for Targets that support first burst");
5416 * lpfc_nvmet_fb_size: NVME Target mode supported first burst size.
5417 * When the driver is configured as an NVME target, this value is
5418 * communicated to the NVME initiator in the PRLI response. It is
5419 * used only when the lpfc_nvme_enable_fb and lpfc_nvmet_support
5420 * parameters are set and the target is sending the PRLI RSP.
5421 * Parameter supported on physical port only - no NPIV support.
5422 * Value range is [0,65536]. Default value is 0.
5424 LPFC_ATTR_RW(nvmet_fb_size, 0, 0, 65536,
5425 "NVME Target mode first burst size in 512B increments.");
5428 * lpfc_nvme_enable_fb: Enable NVME first burst on I and T functions.
5429 * For the Initiator (I), enabling this parameter means that an NVMET
5430 * PRLI response with FBA enabled and an FB_SIZE set to a nonzero value will be
5431 * processed by the initiator for subsequent NVME FCP IO.
5432 * Currently, this feature is not supported on the NVME target
5433 * Value range is [0,1]. Default value is 0 (disabled).
5435 LPFC_ATTR_RW(nvme_enable_fb, 0, 0, 1,
5436 "Enable First Burst feature for NVME Initiator.");
5439 # lpfc_max_scsicmpl_time: Use scsi command completion time to control I/O queue
5440 # depth. Default value is 0. When the value of this parameter is zero the
5441 # SCSI command completion time is not used for controlling I/O queue depth. When
5442 # the parameter is set to a non-zero value, the I/O queue depth is controlled
5443 # to limit the I/O completion time to the parameter value.
5444 # The value is set in milliseconds.
5446 LPFC_VPORT_ATTR(max_scsicmpl_time, 0, 0, 60000,
5447 "Use command completion time to control queue depth");
5449 lpfc_vport_param_show(max_scsicmpl_time);
5451 lpfc_max_scsicmpl_time_set(struct lpfc_vport *vport, int val)
5453 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
5454 struct lpfc_nodelist *ndlp, *next_ndlp;
5456 if (val == vport->cfg_max_scsicmpl_time)
5458 if ((val < 0) || (val > 60000))
5460 vport->cfg_max_scsicmpl_time = val;
5462 spin_lock_irq(shost->host_lock);
5463 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
5464 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
5466 ndlp->cmd_qdepth = vport->cfg_tgt_queue_depth;
5468 spin_unlock_irq(shost->host_lock);
5471 lpfc_vport_param_store(max_scsicmpl_time);
5472 static DEVICE_ATTR_RW(lpfc_max_scsicmpl_time);
5475 # lpfc_ack0: Use ACK0, instead of ACK1 for class 2 acknowledgement. Value
5476 # range is [0,1]. Default value is 0.
5478 LPFC_ATTR_R(ack0, 0, 0, 1, "Enable ACK0 support");
5481 # lpfc_xri_rebalancing: enable or disable XRI rebalancing feature
5482 # range is [0,1]. Default value is 1.
5484 LPFC_ATTR_R(xri_rebalancing, 1, 0, 1, "Enable/Disable XRI rebalancing");
5487 * lpfc_io_sched: Determine scheduling algrithmn for issuing FCP cmds
5488 * range is [0,1]. Default value is 0.
5489 * For [0], FCP commands are issued to Work Queues based on upper layer
5490 * hardware queue index.
5491 * For [1], FCP commands are issued to a Work Queue associated with the
5494 * LPFC_FCP_SCHED_BY_HDWQ == 0
5495 * LPFC_FCP_SCHED_BY_CPU == 1
5497 * The driver dynamically sets this to 1 (BY_CPU) if it's able to set up cpu
5498 * affinity for FCP/NVME I/Os through Work Queues associated with the current
5499 * CPU. Otherwise, the default 0 (Round Robin) scheduling of FCP/NVME I/Os
5500 * through WQs will be used.
5502 LPFC_ATTR_RW(fcp_io_sched, LPFC_FCP_SCHED_BY_CPU,
5503 LPFC_FCP_SCHED_BY_HDWQ,
5504 LPFC_FCP_SCHED_BY_CPU,
5505 "Determine scheduling algorithm for "
5506 "issuing commands [0] - Hardware Queue, [1] - Current CPU");
5509 * lpfc_ns_query: Determine algrithmn for NameServer queries after RSCN
5510 * range is [0,1]. Default value is 0.
5511 * For [0], GID_FT is used for NameServer queries after RSCN (default)
5512 * For [1], GID_PT is used for NameServer queries after RSCN
5515 LPFC_ATTR_RW(ns_query, LPFC_NS_QUERY_GID_FT,
5516 LPFC_NS_QUERY_GID_FT, LPFC_NS_QUERY_GID_PT,
5517 "Determine algorithm NameServer queries after RSCN "
5518 "[0] - GID_FT, [1] - GID_PT");
5521 # lpfc_fcp2_no_tgt_reset: Determine bus reset behavior
5522 # range is [0,1]. Default value is 0.
5523 # For [0], bus reset issues target reset to ALL devices
5524 # For [1], bus reset issues target reset to non-FCP2 devices
5526 LPFC_ATTR_RW(fcp2_no_tgt_reset, 0, 0, 1, "Determine bus reset behavior for "
5527 "FCP2 devices [0] - issue tgt reset, [1] - no tgt reset");
5531 # lpfc_cr_delay & lpfc_cr_count: Default values for I/O colaesing
5532 # cr_delay (msec) or cr_count outstanding commands. cr_delay can take
5533 # value [0,63]. cr_count can take value [1,255]. Default value of cr_delay
5534 # is 0. Default value of cr_count is 1. The cr_count feature is disabled if
5535 # cr_delay is set to 0.
5537 LPFC_ATTR_RW(cr_delay, 0, 0, 63, "A count of milliseconds after which an "
5538 "interrupt response is generated");
5540 LPFC_ATTR_RW(cr_count, 1, 1, 255, "A count of I/O completions after which an "
5541 "interrupt response is generated");
5544 # lpfc_multi_ring_support: Determines how many rings to spread available
5545 # cmd/rsp IOCB entries across.
5546 # Value range is [1,2]. Default value is 1.
5548 LPFC_ATTR_R(multi_ring_support, 1, 1, 2, "Determines number of primary "
5549 "SLI rings to spread IOCB entries across");
5552 # lpfc_multi_ring_rctl: If lpfc_multi_ring_support is enabled, this
5553 # identifies what rctl value to configure the additional ring for.
5554 # Value range is [1,0xff]. Default value is 4 (Unsolicated Data).
5556 LPFC_ATTR_R(multi_ring_rctl, FC_RCTL_DD_UNSOL_DATA, 1,
5557 255, "Identifies RCTL for additional ring configuration");
5560 # lpfc_multi_ring_type: If lpfc_multi_ring_support is enabled, this
5561 # identifies what type value to configure the additional ring for.
5562 # Value range is [1,0xff]. Default value is 5 (LLC/SNAP).
5564 LPFC_ATTR_R(multi_ring_type, FC_TYPE_IP, 1,
5565 255, "Identifies TYPE for additional ring configuration");
5568 # lpfc_enable_SmartSAN: Sets up FDMI support for SmartSAN
5569 # 0 = SmartSAN functionality disabled (default)
5570 # 1 = SmartSAN functionality enabled
5571 # This parameter will override the value of lpfc_fdmi_on module parameter.
5572 # Value range is [0,1]. Default value is 0.
5574 LPFC_ATTR_R(enable_SmartSAN, 0, 0, 1, "Enable SmartSAN functionality");
5577 # lpfc_fdmi_on: Controls FDMI support.
5579 # 1 Traditional FDMI support (default)
5580 # Traditional FDMI support means the driver will assume FDMI-2 support;
5581 # however, if that fails, it will fallback to FDMI-1.
5582 # If lpfc_enable_SmartSAN is set to 1, the driver ignores lpfc_fdmi_on.
5583 # If lpfc_enable_SmartSAN is set 0, the driver uses the current value of
5585 # Value range [0,1]. Default value is 1.
5587 LPFC_ATTR_R(fdmi_on, 1, 0, 1, "Enable FDMI support");
5590 # Specifies the maximum number of ELS cmds we can have outstanding (for
5591 # discovery). Value range is [1,64]. Default value = 32.
5593 LPFC_VPORT_ATTR(discovery_threads, 32, 1, 64, "Maximum number of ELS commands "
5594 "during discovery");
5597 # lpfc_max_luns: maximum allowed LUN ID. This is the highest LUN ID that
5598 # will be scanned by the SCSI midlayer when sequential scanning is
5599 # used; and is also the highest LUN ID allowed when the SCSI midlayer
5600 # parses REPORT_LUN responses. The lpfc driver has no LUN count or
5601 # LUN ID limit, but the SCSI midlayer requires this field for the uses
5602 # above. The lpfc driver limits the default value to 255 for two reasons.
5603 # As it bounds the sequential scan loop, scanning for thousands of luns
5604 # on a target can take minutes of wall clock time. Additionally,
5605 # there are FC targets, such as JBODs, that only recognize 8-bits of
5606 # LUN ID. When they receive a value greater than 8 bits, they chop off
5607 # the high order bits. In other words, they see LUN IDs 0, 256, 512,
5608 # and so on all as LUN ID 0. This causes the linux kernel, which sees
5609 # valid responses at each of the LUN IDs, to believe there are multiple
5610 # devices present, when in fact, there is only 1.
5611 # A customer that is aware of their target behaviors, and the results as
5612 # indicated above, is welcome to increase the lpfc_max_luns value.
5613 # As mentioned, this value is not used by the lpfc driver, only the
5615 # Value range is [0,65535]. Default value is 255.
5616 # NOTE: The SCSI layer might probe all allowed LUN on some old targets.
5618 LPFC_VPORT_ULL_ATTR_R(max_luns, 255, 0, 65535, "Maximum allowed LUN ID");
5621 # lpfc_poll_tmo: .Milliseconds driver will wait between polling FCP ring.
5622 # Value range is [1,255], default value is 10.
5624 LPFC_ATTR_RW(poll_tmo, 10, 1, 255,
5625 "Milliseconds driver will wait between polling FCP ring");
5628 # lpfc_task_mgmt_tmo: Maximum time to wait for task management commands
5629 # to complete in seconds. Value range is [5,180], default value is 60.
5631 LPFC_ATTR_RW(task_mgmt_tmo, 60, 5, 180,
5632 "Maximum time to wait for task management commands to complete");
5634 # lpfc_use_msi: Use MSI (Message Signaled Interrupts) in systems that
5635 # support this feature
5638 # 2 = MSI-X enabled (default)
5639 # Value range is [0,2]. Default value is 2.
5641 LPFC_ATTR_R(use_msi, 2, 0, 2, "Use Message Signaled Interrupts (1) or "
5642 "MSI-X (2), if possible");
5645 * lpfc_nvme_oas: Use the oas bit when sending NVME/NVMET IOs
5647 * 0 = NVME OAS disabled
5648 * 1 = NVME OAS enabled
5650 * Value range is [0,1]. Default value is 0.
5652 LPFC_ATTR_RW(nvme_oas, 0, 0, 1,
5653 "Use OAS bit on NVME IOs");
5656 * lpfc_nvme_embed_cmd: Use the oas bit when sending NVME/NVMET IOs
5658 * 0 = Put NVME Command in SGL
5659 * 1 = Embed NVME Command in WQE (unless G7)
5660 * 2 = Embed NVME Command in WQE (force)
5662 * Value range is [0,2]. Default value is 1.
5664 LPFC_ATTR_RW(nvme_embed_cmd, 1, 0, 2,
5665 "Embed NVME Command in WQE");
5668 * lpfc_fcp_mq_threshold: Set the maximum number of Hardware Queues
5669 * the driver will advertise it supports to the SCSI layer.
5671 * 0 = Set nr_hw_queues by the number of CPUs or HW queues.
5672 * 1,256 = Manually specify nr_hw_queue value to be advertised,
5674 * Value range is [0,256]. Default value is 8.
5676 LPFC_ATTR_R(fcp_mq_threshold, LPFC_FCP_MQ_THRESHOLD_DEF,
5677 LPFC_FCP_MQ_THRESHOLD_MIN, LPFC_FCP_MQ_THRESHOLD_MAX,
5678 "Set the number of SCSI Queues advertised");
5681 * lpfc_hdw_queue: Set the number of Hardware Queues the driver
5682 * will advertise it supports to the NVME and SCSI layers. This also
5683 * will map to the number of CQ/WQ pairs the driver will create.
5685 * The NVME Layer will try to create this many, plus 1 administrative
5686 * hardware queue. The administrative queue will always map to WQ 0
5687 * A hardware IO queue maps (qidx) to a specific driver CQ/WQ.
5689 * 0 = Configure the number of hdw queues to the number of active CPUs.
5690 * 1,256 = Manually specify how many hdw queues to use.
5692 * Value range is [0,256]. Default value is 0.
5694 LPFC_ATTR_R(hdw_queue,
5696 LPFC_HBA_HDWQ_MIN, LPFC_HBA_HDWQ_MAX,
5697 "Set the number of I/O Hardware Queues");
5699 #if IS_ENABLED(CONFIG_X86)
5701 * lpfc_cpumask_irq_mode_init - initalizes cpumask of phba based on
5703 * @phba: Pointer to HBA context object.
5706 lpfc_cpumask_irq_mode_init(struct lpfc_hba *phba)
5708 unsigned int cpu, first_cpu, numa_node = NUMA_NO_NODE;
5709 const struct cpumask *sibling_mask;
5710 struct cpumask *aff_mask = &phba->sli4_hba.irq_aff_mask;
5712 cpumask_clear(aff_mask);
5714 if (phba->irq_chann_mode == NUMA_MODE) {
5715 /* Check if we're a NUMA architecture */
5716 numa_node = dev_to_node(&phba->pcidev->dev);
5717 if (numa_node == NUMA_NO_NODE) {
5718 phba->irq_chann_mode = NORMAL_MODE;
5723 for_each_possible_cpu(cpu) {
5724 switch (phba->irq_chann_mode) {
5726 if (cpu_to_node(cpu) == numa_node)
5727 cpumask_set_cpu(cpu, aff_mask);
5730 sibling_mask = topology_sibling_cpumask(cpu);
5731 first_cpu = cpumask_first(sibling_mask);
5732 if (first_cpu < nr_cpu_ids)
5733 cpumask_set_cpu(first_cpu, aff_mask);
5743 lpfc_assign_default_irq_chann(struct lpfc_hba *phba)
5745 #if IS_ENABLED(CONFIG_X86)
5746 switch (boot_cpu_data.x86_vendor) {
5747 case X86_VENDOR_AMD:
5748 /* If AMD architecture, then default is NUMA_MODE */
5749 phba->irq_chann_mode = NUMA_MODE;
5751 case X86_VENDOR_INTEL:
5752 /* If Intel architecture, then default is no hyperthread mode */
5753 phba->irq_chann_mode = NHT_MODE;
5756 phba->irq_chann_mode = NORMAL_MODE;
5759 lpfc_cpumask_irq_mode_init(phba);
5761 phba->irq_chann_mode = NORMAL_MODE;
5766 * lpfc_irq_chann: Set the number of IRQ vectors that are available
5767 * for Hardware Queues to utilize. This also will map to the number
5768 * of EQ / MSI-X vectors the driver will create. This should never be
5769 * more than the number of Hardware Queues
5771 * 0 = Configure number of IRQ Channels to:
5772 * if AMD architecture, number of CPUs on HBA's NUMA node
5773 * if Intel architecture, number of physical CPUs.
5774 * otherwise, number of active CPUs.
5775 * [1,256] = Manually specify how many IRQ Channels to use.
5777 * Value range is [0,256]. Default value is [0].
5779 static uint lpfc_irq_chann = LPFC_IRQ_CHANN_DEF;
5780 module_param(lpfc_irq_chann, uint, 0444);
5781 MODULE_PARM_DESC(lpfc_irq_chann, "Set number of interrupt vectors to allocate");
5783 /* lpfc_irq_chann_init - Set the hba irq_chann initial value
5784 * @phba: lpfc_hba pointer.
5785 * @val: contains the initial value
5788 * Validates the initial value is within range and assigns it to the
5789 * adapter. If not in range, an error message is posted and the
5790 * default value is assigned.
5793 * zero if value is in range and is set
5794 * -EINVAL if value was out of range
5797 lpfc_irq_chann_init(struct lpfc_hba *phba, uint32_t val)
5799 const struct cpumask *aff_mask;
5801 if (phba->cfg_use_msi != 2) {
5802 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5803 "8532 use_msi = %u ignoring cfg_irq_numa\n",
5805 phba->irq_chann_mode = NORMAL_MODE;
5806 phba->cfg_irq_chann = LPFC_IRQ_CHANN_DEF;
5810 /* Check if default setting was passed */
5811 if (val == LPFC_IRQ_CHANN_DEF &&
5812 phba->cfg_hdw_queue == LPFC_HBA_HDWQ_DEF &&
5813 phba->sli_rev == LPFC_SLI_REV4)
5814 lpfc_assign_default_irq_chann(phba);
5816 if (phba->irq_chann_mode != NORMAL_MODE) {
5817 aff_mask = &phba->sli4_hba.irq_aff_mask;
5819 if (cpumask_empty(aff_mask)) {
5820 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5821 "8533 Could not identify CPUS for "
5822 "mode %d, ignoring\n",
5823 phba->irq_chann_mode);
5824 phba->irq_chann_mode = NORMAL_MODE;
5825 phba->cfg_irq_chann = LPFC_IRQ_CHANN_DEF;
5827 phba->cfg_irq_chann = cpumask_weight(aff_mask);
5829 /* If no hyperthread mode, then set hdwq count to
5830 * aff_mask weight as well
5832 if (phba->irq_chann_mode == NHT_MODE)
5833 phba->cfg_hdw_queue = phba->cfg_irq_chann;
5835 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5836 "8543 lpfc_irq_chann set to %u "
5837 "(mode: %d)\n", phba->cfg_irq_chann,
5838 phba->irq_chann_mode);
5841 if (val > LPFC_IRQ_CHANN_MAX) {
5842 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
5843 "8545 lpfc_irq_chann attribute cannot "
5844 "be set to %u, allowed range is "
5848 LPFC_IRQ_CHANN_MAX);
5849 phba->cfg_irq_chann = LPFC_IRQ_CHANN_DEF;
5852 if (phba->sli_rev == LPFC_SLI_REV4) {
5853 phba->cfg_irq_chann = val;
5855 phba->cfg_irq_chann = 2;
5856 phba->cfg_hdw_queue = 1;
5864 * lpfc_irq_chann_show - Display value of irq_chann
5865 * @dev: class converted to a Scsi_host structure.
5866 * @attr: device attribute, not used.
5867 * @buf: on return contains a string with the list sizes
5869 * Returns: size of formatted string.
5872 lpfc_irq_chann_show(struct device *dev, struct device_attribute *attr,
5875 struct Scsi_Host *shost = class_to_shost(dev);
5876 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
5877 struct lpfc_hba *phba = vport->phba;
5879 return scnprintf(buf, PAGE_SIZE, "%u\n", phba->cfg_irq_chann);
5882 static DEVICE_ATTR_RO(lpfc_irq_chann);
5885 # lpfc_enable_hba_reset: Allow or prevent HBA resets to the hardware.
5886 # 0 = HBA resets disabled
5887 # 1 = HBA resets enabled (default)
5888 # 2 = HBA reset via PCI bus reset enabled
5889 # Value range is [0,2]. Default value is 1.
5891 LPFC_ATTR_RW(enable_hba_reset, 1, 0, 2, "Enable HBA resets from the driver.");
5894 # lpfc_enable_hba_heartbeat: Disable HBA heartbeat timer..
5895 # 0 = HBA Heartbeat disabled
5896 # 1 = HBA Heartbeat enabled (default)
5897 # Value range is [0,1]. Default value is 1.
5899 LPFC_ATTR_R(enable_hba_heartbeat, 0, 0, 1, "Enable HBA Heartbeat.");
5902 # lpfc_EnableXLane: Enable Express Lane Feature
5903 # 0x0 Express Lane Feature disabled
5904 # 0x1 Express Lane Feature enabled
5905 # Value range is [0,1]. Default value is 0.
5907 LPFC_ATTR_R(EnableXLane, 0, 0, 1, "Enable Express Lane Feature.");
5910 # lpfc_XLanePriority: Define CS_CTL priority for Express Lane Feature
5911 # 0x0 - 0x7f = CS_CTL field in FC header (high 7 bits)
5912 # Value range is [0x0,0x7f]. Default value is 0
5914 LPFC_ATTR_RW(XLanePriority, 0, 0x0, 0x7f, "CS_CTL for Express Lane Feature.");
5917 # lpfc_enable_bg: Enable BlockGuard (Emulex's Implementation of T10-DIF)
5918 # 0 = BlockGuard disabled (default)
5919 # 1 = BlockGuard enabled
5920 # Value range is [0,1]. Default value is 0.
5922 LPFC_ATTR_R(enable_bg, 0, 0, 1, "Enable BlockGuard Support");
5926 # - Bit mask of host protection capabilities used to register with the
5928 # - Only meaningful if BG is turned on (lpfc_enable_bg=1).
5929 # - Allows you to ultimately specify which profiles to use
5930 # - Default will result in registering capabilities for all profiles.
5931 # - SHOST_DIF_TYPE1_PROTECTION 1
5932 # HBA supports T10 DIF Type 1: HBA to Target Type 1 Protection
5933 # - SHOST_DIX_TYPE0_PROTECTION 8
5934 # HBA supports DIX Type 0: Host to HBA protection only
5935 # - SHOST_DIX_TYPE1_PROTECTION 16
5936 # HBA supports DIX Type 1: Host to HBA Type 1 protection
5939 LPFC_ATTR(prot_mask,
5940 (SHOST_DIF_TYPE1_PROTECTION |
5941 SHOST_DIX_TYPE0_PROTECTION |
5942 SHOST_DIX_TYPE1_PROTECTION),
5944 (SHOST_DIF_TYPE1_PROTECTION |
5945 SHOST_DIX_TYPE0_PROTECTION |
5946 SHOST_DIX_TYPE1_PROTECTION),
5947 "T10-DIF host protection capabilities mask");
5951 # - Bit mask of protection guard types to register with the SCSI mid-layer
5952 # - Guard types are currently either 1) T10-DIF CRC 2) IP checksum
5953 # - Allows you to ultimately specify which profiles to use
5954 # - Default will result in registering capabilities for all guard types
5957 LPFC_ATTR(prot_guard,
5958 SHOST_DIX_GUARD_IP, SHOST_DIX_GUARD_CRC, SHOST_DIX_GUARD_IP,
5959 "T10-DIF host protection guard type");
5962 * Delay initial NPort discovery when Clean Address bit is cleared in
5963 * FLOGI/FDISC accept and FCID/Fabric name/Fabric portname is changed.
5964 * This parameter can have value 0 or 1.
5965 * When this parameter is set to 0, no delay is added to the initial
5967 * When this parameter is set to non-zero value, initial Nport discovery is
5968 * delayed by ra_tov seconds when Clean Address bit is cleared in FLOGI/FDISC
5969 * accept and FCID/Fabric name/Fabric portname is changed.
5970 * Driver always delay Nport discovery for subsequent FLOGI/FDISC completion
5971 * when Clean Address bit is cleared in FLOGI/FDISC
5972 * accept and FCID/Fabric name/Fabric portname is changed.
5973 * Default value is 0.
5975 LPFC_ATTR(delay_discovery, 0, 0, 1,
5976 "Delay NPort discovery when Clean Address bit is cleared.");
5979 * lpfc_sg_seg_cnt - Initial Maximum DMA Segment Count
5980 * This value can be set to values between 64 and 4096. The default value
5981 * is 64, but may be increased to allow for larger Max I/O sizes. The scsi
5982 * and nvme layers will allow I/O sizes up to (MAX_SEG_COUNT * SEG_SIZE).
5983 * Because of the additional overhead involved in setting up T10-DIF,
5984 * this parameter will be limited to 128 if BlockGuard is enabled under SLI4
5985 * and will be limited to 512 if BlockGuard is enabled under SLI3.
5987 static uint lpfc_sg_seg_cnt = LPFC_DEFAULT_SG_SEG_CNT;
5988 module_param(lpfc_sg_seg_cnt, uint, 0444);
5989 MODULE_PARM_DESC(lpfc_sg_seg_cnt, "Max Scatter Gather Segment Count");
5992 * lpfc_sg_seg_cnt_show - Display the scatter/gather list sizes
5993 * configured for the adapter
5994 * @dev: class converted to a Scsi_host structure.
5995 * @attr: device attribute, not used.
5996 * @buf: on return contains a string with the list sizes
5998 * Returns: size of formatted string.
6001 lpfc_sg_seg_cnt_show(struct device *dev, struct device_attribute *attr,
6004 struct Scsi_Host *shost = class_to_shost(dev);
6005 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
6006 struct lpfc_hba *phba = vport->phba;
6009 len = scnprintf(buf, PAGE_SIZE, "SGL sz: %d total SGEs: %d\n",
6010 phba->cfg_sg_dma_buf_size, phba->cfg_total_seg_cnt);
6012 len += scnprintf(buf + len, PAGE_SIZE - len,
6013 "Cfg: %d SCSI: %d NVME: %d\n",
6014 phba->cfg_sg_seg_cnt, phba->cfg_scsi_seg_cnt,
6015 phba->cfg_nvme_seg_cnt);
6019 static DEVICE_ATTR_RO(lpfc_sg_seg_cnt);
6022 * lpfc_sg_seg_cnt_init - Set the hba sg_seg_cnt initial value
6023 * @phba: lpfc_hba pointer.
6024 * @val: contains the initial value
6027 * Validates the initial value is within range and assigns it to the
6028 * adapter. If not in range, an error message is posted and the
6029 * default value is assigned.
6032 * zero if value is in range and is set
6033 * -EINVAL if value was out of range
6036 lpfc_sg_seg_cnt_init(struct lpfc_hba *phba, int val)
6038 if (val >= LPFC_MIN_SG_SEG_CNT && val <= LPFC_MAX_SG_SEG_CNT) {
6039 phba->cfg_sg_seg_cnt = val;
6042 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
6043 "0409 lpfc_sg_seg_cnt attribute cannot be set to %d, "
6044 "allowed range is [%d, %d]\n",
6045 val, LPFC_MIN_SG_SEG_CNT, LPFC_MAX_SG_SEG_CNT);
6046 phba->cfg_sg_seg_cnt = LPFC_DEFAULT_SG_SEG_CNT;
6051 * lpfc_enable_mds_diags: Enable MDS Diagnostics
6052 * 0 = MDS Diagnostics disabled (default)
6053 * 1 = MDS Diagnostics enabled
6054 * Value range is [0,1]. Default value is 0.
6056 LPFC_ATTR_RW(enable_mds_diags, 0, 0, 1, "Enable MDS Diagnostics");
6059 * lpfc_ras_fwlog_buffsize: Firmware logging host buffer size
6060 * 0 = Disable firmware logging (default)
6061 * [1-4] = Multiple of 1/4th Mb of host memory for FW logging
6062 * Value range [0..4]. Default value is 0
6064 LPFC_ATTR(ras_fwlog_buffsize, 0, 0, 4, "Host memory for FW logging");
6065 lpfc_param_show(ras_fwlog_buffsize);
6068 lpfc_ras_fwlog_buffsize_set(struct lpfc_hba *phba, uint val)
6071 enum ras_state state;
6073 if (!lpfc_rangecheck(val, 0, 4))
6076 if (phba->cfg_ras_fwlog_buffsize == val)
6079 if (phba->cfg_ras_fwlog_func != PCI_FUNC(phba->pcidev->devfn))
6082 spin_lock_irq(&phba->hbalock);
6083 state = phba->ras_fwlog.state;
6084 spin_unlock_irq(&phba->hbalock);
6086 if (state == REG_INPROGRESS) {
6087 lpfc_printf_log(phba, KERN_ERR, LOG_SLI, "6147 RAS Logging "
6088 "registration is in progress\n");
6092 /* For disable logging: stop the logs and free the DMA.
6093 * For ras_fwlog_buffsize size change we still need to free and
6094 * reallocate the DMA in lpfc_sli4_ras_fwlog_init.
6096 phba->cfg_ras_fwlog_buffsize = val;
6097 if (state == ACTIVE) {
6098 lpfc_ras_stop_fwlog(phba);
6099 lpfc_sli4_ras_dma_free(phba);
6102 lpfc_sli4_ras_init(phba);
6103 if (phba->ras_fwlog.ras_enabled)
6104 ret = lpfc_sli4_ras_fwlog_init(phba, phba->cfg_ras_fwlog_level,
6105 LPFC_RAS_ENABLE_LOGGING);
6109 lpfc_param_store(ras_fwlog_buffsize);
6110 static DEVICE_ATTR_RW(lpfc_ras_fwlog_buffsize);
6113 * lpfc_ras_fwlog_level: Firmware logging verbosity level
6114 * Valid only if firmware logging is enabled
6115 * 0(Least Verbosity) 4 (most verbosity)
6116 * Value range is [0..4]. Default value is 0
6118 LPFC_ATTR_RW(ras_fwlog_level, 0, 0, 4, "Firmware Logging Level");
6121 * lpfc_ras_fwlog_func: Firmware logging enabled on function number
6122 * Default function which has RAS support : 0
6123 * Value Range is [0..7].
6124 * FW logging is a global action and enablement is via a specific
6127 LPFC_ATTR_RW(ras_fwlog_func, 0, 0, 7, "Firmware Logging Enabled on Function");
6130 * lpfc_enable_bbcr: Enable BB Credit Recovery
6131 * 0 = BB Credit Recovery disabled
6132 * 1 = BB Credit Recovery enabled (default)
6133 * Value range is [0,1]. Default value is 1.
6135 LPFC_BBCR_ATTR_RW(enable_bbcr, 1, 0, 1, "Enable BBC Recovery");
6137 /* Signaling module parameters */
6138 int lpfc_fabric_cgn_frequency = 100; /* 100 ms default */
6139 module_param(lpfc_fabric_cgn_frequency, int, 0444);
6140 MODULE_PARM_DESC(lpfc_fabric_cgn_frequency, "Congestion signaling fabric freq");
6142 int lpfc_acqe_cgn_frequency = 10; /* 10 sec default */
6143 module_param(lpfc_acqe_cgn_frequency, int, 0444);
6144 MODULE_PARM_DESC(lpfc_acqe_cgn_frequency, "Congestion signaling ACQE freq");
6146 int lpfc_use_cgn_signal = 1; /* 0 - only use FPINs, 1 - Use signals if avail */
6147 module_param(lpfc_use_cgn_signal, int, 0444);
6148 MODULE_PARM_DESC(lpfc_use_cgn_signal, "Use Congestion signaling if available");
6151 * lpfc_enable_dpp: Enable DPP on G7
6152 * 0 = DPP on G7 disabled
6153 * 1 = DPP on G7 enabled (default)
6154 * Value range is [0,1]. Default value is 1.
6156 LPFC_ATTR_RW(enable_dpp, 1, 0, 1, "Enable Direct Packet Push");
6159 * lpfc_enable_mi: Enable FDMI MIB
6161 * 1 = enabled (default)
6162 * Value range is [0,1].
6164 LPFC_ATTR_R(enable_mi, 1, 0, 1, "Enable MI");
6167 * lpfc_max_vmid: Maximum number of VMs to be tagged. This is valid only if
6168 * either vmid_app_header or vmid_priority_tagging is enabled.
6169 * 4 - 255 = vmid support enabled for 4-255 VMs
6170 * Value range is [4,255].
6172 LPFC_ATTR_RW(max_vmid, LPFC_MIN_VMID, LPFC_MIN_VMID, LPFC_MAX_VMID,
6173 "Maximum number of VMs supported");
6176 * lpfc_vmid_inactivity_timeout: Inactivity timeout duration in hours
6177 * 0 = Timeout is disabled
6178 * Value range is [0,24].
6180 LPFC_ATTR_RW(vmid_inactivity_timeout, 4, 0, 24,
6181 "Inactivity timeout in hours");
6184 * lpfc_vmid_app_header: Enable App Header VMID support
6185 * 0 = Support is disabled (default)
6186 * 1 = Support is enabled
6187 * Value range is [0,1].
6189 LPFC_ATTR_RW(vmid_app_header, LPFC_VMID_APP_HEADER_DISABLE,
6190 LPFC_VMID_APP_HEADER_DISABLE, LPFC_VMID_APP_HEADER_ENABLE,
6191 "Enable App Header VMID support");
6194 * lpfc_vmid_priority_tagging: Enable Priority Tagging VMID support
6195 * 0 = Support is disabled (default)
6196 * 1 = Allow supported targets only
6197 * 2 = Allow all targets
6198 * Value range is [0,2].
6200 LPFC_ATTR_RW(vmid_priority_tagging, LPFC_VMID_PRIO_TAG_DISABLE,
6201 LPFC_VMID_PRIO_TAG_DISABLE,
6202 LPFC_VMID_PRIO_TAG_ALL_TARGETS,
6203 "Enable Priority Tagging VMID support");
6205 static struct attribute *lpfc_hba_attrs[] = {
6206 &dev_attr_nvme_info.attr,
6207 &dev_attr_scsi_stat.attr,
6208 &dev_attr_bg_info.attr,
6209 &dev_attr_bg_guard_err.attr,
6210 &dev_attr_bg_apptag_err.attr,
6211 &dev_attr_bg_reftag_err.attr,
6212 &dev_attr_info.attr,
6213 &dev_attr_serialnum.attr,
6214 &dev_attr_modeldesc.attr,
6215 &dev_attr_modelname.attr,
6216 &dev_attr_programtype.attr,
6217 &dev_attr_portnum.attr,
6218 &dev_attr_fwrev.attr,
6220 &dev_attr_option_rom_version.attr,
6221 &dev_attr_link_state.attr,
6222 &dev_attr_num_discovered_ports.attr,
6223 &dev_attr_menlo_mgmt_mode.attr,
6224 &dev_attr_lpfc_drvr_version.attr,
6225 &dev_attr_lpfc_enable_fip.attr,
6226 &dev_attr_lpfc_temp_sensor.attr,
6227 &dev_attr_lpfc_log_verbose.attr,
6228 &dev_attr_lpfc_lun_queue_depth.attr,
6229 &dev_attr_lpfc_tgt_queue_depth.attr,
6230 &dev_attr_lpfc_hba_queue_depth.attr,
6231 &dev_attr_lpfc_peer_port_login.attr,
6232 &dev_attr_lpfc_nodev_tmo.attr,
6233 &dev_attr_lpfc_devloss_tmo.attr,
6234 &dev_attr_lpfc_enable_fc4_type.attr,
6235 &dev_attr_lpfc_fcp_class.attr,
6236 &dev_attr_lpfc_use_adisc.attr,
6237 &dev_attr_lpfc_first_burst_size.attr,
6238 &dev_attr_lpfc_ack0.attr,
6239 &dev_attr_lpfc_xri_rebalancing.attr,
6240 &dev_attr_lpfc_topology.attr,
6241 &dev_attr_lpfc_scan_down.attr,
6242 &dev_attr_lpfc_link_speed.attr,
6243 &dev_attr_lpfc_fcp_io_sched.attr,
6244 &dev_attr_lpfc_ns_query.attr,
6245 &dev_attr_lpfc_fcp2_no_tgt_reset.attr,
6246 &dev_attr_lpfc_cr_delay.attr,
6247 &dev_attr_lpfc_cr_count.attr,
6248 &dev_attr_lpfc_multi_ring_support.attr,
6249 &dev_attr_lpfc_multi_ring_rctl.attr,
6250 &dev_attr_lpfc_multi_ring_type.attr,
6251 &dev_attr_lpfc_fdmi_on.attr,
6252 &dev_attr_lpfc_enable_SmartSAN.attr,
6253 &dev_attr_lpfc_max_luns.attr,
6254 &dev_attr_lpfc_enable_npiv.attr,
6255 &dev_attr_lpfc_fcf_failover_policy.attr,
6256 &dev_attr_lpfc_enable_rrq.attr,
6257 &dev_attr_lpfc_fcp_wait_abts_rsp.attr,
6258 &dev_attr_nport_evt_cnt.attr,
6259 &dev_attr_board_mode.attr,
6260 &dev_attr_max_vpi.attr,
6261 &dev_attr_used_vpi.attr,
6262 &dev_attr_max_rpi.attr,
6263 &dev_attr_used_rpi.attr,
6264 &dev_attr_max_xri.attr,
6265 &dev_attr_used_xri.attr,
6266 &dev_attr_npiv_info.attr,
6267 &dev_attr_issue_reset.attr,
6268 &dev_attr_lpfc_poll.attr,
6269 &dev_attr_lpfc_poll_tmo.attr,
6270 &dev_attr_lpfc_task_mgmt_tmo.attr,
6271 &dev_attr_lpfc_use_msi.attr,
6272 &dev_attr_lpfc_nvme_oas.attr,
6273 &dev_attr_lpfc_nvme_embed_cmd.attr,
6274 &dev_attr_lpfc_fcp_imax.attr,
6275 &dev_attr_lpfc_force_rscn.attr,
6276 &dev_attr_lpfc_cq_poll_threshold.attr,
6277 &dev_attr_lpfc_cq_max_proc_limit.attr,
6278 &dev_attr_lpfc_fcp_cpu_map.attr,
6279 &dev_attr_lpfc_fcp_mq_threshold.attr,
6280 &dev_attr_lpfc_hdw_queue.attr,
6281 &dev_attr_lpfc_irq_chann.attr,
6282 &dev_attr_lpfc_suppress_rsp.attr,
6283 &dev_attr_lpfc_nvmet_mrq.attr,
6284 &dev_attr_lpfc_nvmet_mrq_post.attr,
6285 &dev_attr_lpfc_nvme_enable_fb.attr,
6286 &dev_attr_lpfc_nvmet_fb_size.attr,
6287 &dev_attr_lpfc_enable_bg.attr,
6288 &dev_attr_lpfc_enable_hba_reset.attr,
6289 &dev_attr_lpfc_enable_hba_heartbeat.attr,
6290 &dev_attr_lpfc_EnableXLane.attr,
6291 &dev_attr_lpfc_XLanePriority.attr,
6292 &dev_attr_lpfc_xlane_lun.attr,
6293 &dev_attr_lpfc_xlane_tgt.attr,
6294 &dev_attr_lpfc_xlane_vpt.attr,
6295 &dev_attr_lpfc_xlane_lun_state.attr,
6296 &dev_attr_lpfc_xlane_lun_status.attr,
6297 &dev_attr_lpfc_xlane_priority.attr,
6298 &dev_attr_lpfc_sg_seg_cnt.attr,
6299 &dev_attr_lpfc_max_scsicmpl_time.attr,
6300 &dev_attr_lpfc_stat_data_ctrl.attr,
6301 &dev_attr_lpfc_aer_support.attr,
6302 &dev_attr_lpfc_aer_state_cleanup.attr,
6303 &dev_attr_lpfc_sriov_nr_virtfn.attr,
6304 &dev_attr_lpfc_req_fw_upgrade.attr,
6305 &dev_attr_lpfc_suppress_link_up.attr,
6306 &dev_attr_iocb_hw.attr,
6309 &dev_attr_txq_hw.attr,
6310 &dev_attr_txcmplq_hw.attr,
6311 &dev_attr_lpfc_sriov_hw_max_virtfn.attr,
6312 &dev_attr_protocol.attr,
6313 &dev_attr_lpfc_xlane_supported.attr,
6314 &dev_attr_lpfc_enable_mds_diags.attr,
6315 &dev_attr_lpfc_ras_fwlog_buffsize.attr,
6316 &dev_attr_lpfc_ras_fwlog_level.attr,
6317 &dev_attr_lpfc_ras_fwlog_func.attr,
6318 &dev_attr_lpfc_enable_bbcr.attr,
6319 &dev_attr_lpfc_enable_dpp.attr,
6320 &dev_attr_lpfc_enable_mi.attr,
6321 &dev_attr_cmf_info.attr,
6322 &dev_attr_lpfc_max_vmid.attr,
6323 &dev_attr_lpfc_vmid_inactivity_timeout.attr,
6324 &dev_attr_lpfc_vmid_app_header.attr,
6325 &dev_attr_lpfc_vmid_priority_tagging.attr,
6329 static const struct attribute_group lpfc_hba_attr_group = {
6330 .attrs = lpfc_hba_attrs
6333 const struct attribute_group *lpfc_hba_groups[] = {
6334 &lpfc_hba_attr_group,
6338 static struct attribute *lpfc_vport_attrs[] = {
6339 &dev_attr_info.attr,
6340 &dev_attr_link_state.attr,
6341 &dev_attr_num_discovered_ports.attr,
6342 &dev_attr_lpfc_drvr_version.attr,
6343 &dev_attr_lpfc_log_verbose.attr,
6344 &dev_attr_lpfc_lun_queue_depth.attr,
6345 &dev_attr_lpfc_tgt_queue_depth.attr,
6346 &dev_attr_lpfc_nodev_tmo.attr,
6347 &dev_attr_lpfc_devloss_tmo.attr,
6348 &dev_attr_lpfc_hba_queue_depth.attr,
6349 &dev_attr_lpfc_peer_port_login.attr,
6350 &dev_attr_lpfc_restrict_login.attr,
6351 &dev_attr_lpfc_fcp_class.attr,
6352 &dev_attr_lpfc_use_adisc.attr,
6353 &dev_attr_lpfc_first_burst_size.attr,
6354 &dev_attr_lpfc_max_luns.attr,
6355 &dev_attr_nport_evt_cnt.attr,
6356 &dev_attr_npiv_info.attr,
6357 &dev_attr_lpfc_enable_da_id.attr,
6358 &dev_attr_lpfc_max_scsicmpl_time.attr,
6359 &dev_attr_lpfc_stat_data_ctrl.attr,
6360 &dev_attr_lpfc_static_vport.attr,
6361 &dev_attr_cmf_info.attr,
6365 static const struct attribute_group lpfc_vport_attr_group = {
6366 .attrs = lpfc_vport_attrs
6369 const struct attribute_group *lpfc_vport_groups[] = {
6370 &lpfc_vport_attr_group,
6375 * sysfs_ctlreg_write - Write method for writing to ctlreg
6376 * @filp: open sysfs file
6377 * @kobj: kernel kobject that contains the kernel class device.
6378 * @bin_attr: kernel attributes passed to us.
6379 * @buf: contains the data to be written to the adapter IOREG space.
6380 * @off: offset into buffer to beginning of data.
6381 * @count: bytes to transfer.
6384 * Accessed via /sys/class/scsi_host/hostxxx/ctlreg.
6385 * Uses the adapter io control registers to send buf contents to the adapter.
6388 * -ERANGE off and count combo out of range
6389 * -EINVAL off, count or buff address invalid
6390 * -EPERM adapter is offline
6391 * value of count, buf contents written
6394 sysfs_ctlreg_write(struct file *filp, struct kobject *kobj,
6395 struct bin_attribute *bin_attr,
6396 char *buf, loff_t off, size_t count)
6399 struct device *dev = container_of(kobj, struct device, kobj);
6400 struct Scsi_Host *shost = class_to_shost(dev);
6401 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6402 struct lpfc_hba *phba = vport->phba;
6404 if (phba->sli_rev >= LPFC_SLI_REV4)
6407 if ((off + count) > FF_REG_AREA_SIZE)
6410 if (count <= LPFC_REG_WRITE_KEY_SIZE)
6413 if (off % 4 || count % 4 || (unsigned long)buf % 4)
6416 /* This is to protect HBA registers from accidental writes. */
6417 if (memcmp(buf, LPFC_REG_WRITE_KEY, LPFC_REG_WRITE_KEY_SIZE))
6420 if (!(vport->fc_flag & FC_OFFLINE_MODE))
6423 spin_lock_irq(&phba->hbalock);
6424 for (buf_off = 0; buf_off < count - LPFC_REG_WRITE_KEY_SIZE;
6425 buf_off += sizeof(uint32_t))
6426 writel(*((uint32_t *)(buf + buf_off + LPFC_REG_WRITE_KEY_SIZE)),
6427 phba->ctrl_regs_memmap_p + off + buf_off);
6429 spin_unlock_irq(&phba->hbalock);
6435 * sysfs_ctlreg_read - Read method for reading from ctlreg
6436 * @filp: open sysfs file
6437 * @kobj: kernel kobject that contains the kernel class device.
6438 * @bin_attr: kernel attributes passed to us.
6439 * @buf: if successful contains the data from the adapter IOREG space.
6440 * @off: offset into buffer to beginning of data.
6441 * @count: bytes to transfer.
6444 * Accessed via /sys/class/scsi_host/hostxxx/ctlreg.
6445 * Uses the adapter io control registers to read data into buf.
6448 * -ERANGE off and count combo out of range
6449 * -EINVAL off, count or buff address invalid
6450 * value of count, buf contents read
6453 sysfs_ctlreg_read(struct file *filp, struct kobject *kobj,
6454 struct bin_attribute *bin_attr,
6455 char *buf, loff_t off, size_t count)
6459 struct device *dev = container_of(kobj, struct device, kobj);
6460 struct Scsi_Host *shost = class_to_shost(dev);
6461 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6462 struct lpfc_hba *phba = vport->phba;
6464 if (phba->sli_rev >= LPFC_SLI_REV4)
6467 if (off > FF_REG_AREA_SIZE)
6470 if ((off + count) > FF_REG_AREA_SIZE)
6471 count = FF_REG_AREA_SIZE - off;
6473 if (count == 0) return 0;
6475 if (off % 4 || count % 4 || (unsigned long)buf % 4)
6478 spin_lock_irq(&phba->hbalock);
6480 for (buf_off = 0; buf_off < count; buf_off += sizeof(uint32_t)) {
6481 tmp_ptr = (uint32_t *)(buf + buf_off);
6482 *tmp_ptr = readl(phba->ctrl_regs_memmap_p + off + buf_off);
6485 spin_unlock_irq(&phba->hbalock);
6490 static struct bin_attribute sysfs_ctlreg_attr = {
6493 .mode = S_IRUSR | S_IWUSR,
6496 .read = sysfs_ctlreg_read,
6497 .write = sysfs_ctlreg_write,
6501 * sysfs_mbox_write - Write method for writing information via mbox
6502 * @filp: open sysfs file
6503 * @kobj: kernel kobject that contains the kernel class device.
6504 * @bin_attr: kernel attributes passed to us.
6505 * @buf: contains the data to be written to sysfs mbox.
6506 * @off: offset into buffer to beginning of data.
6507 * @count: bytes to transfer.
6510 * Deprecated function. All mailbox access from user space is performed via the
6514 * -EPERM operation not permitted
6517 sysfs_mbox_write(struct file *filp, struct kobject *kobj,
6518 struct bin_attribute *bin_attr,
6519 char *buf, loff_t off, size_t count)
6525 * sysfs_mbox_read - Read method for reading information via mbox
6526 * @filp: open sysfs file
6527 * @kobj: kernel kobject that contains the kernel class device.
6528 * @bin_attr: kernel attributes passed to us.
6529 * @buf: contains the data to be read from sysfs mbox.
6530 * @off: offset into buffer to beginning of data.
6531 * @count: bytes to transfer.
6534 * Deprecated function. All mailbox access from user space is performed via the
6538 * -EPERM operation not permitted
6541 sysfs_mbox_read(struct file *filp, struct kobject *kobj,
6542 struct bin_attribute *bin_attr,
6543 char *buf, loff_t off, size_t count)
6548 static struct bin_attribute sysfs_mbox_attr = {
6551 .mode = S_IRUSR | S_IWUSR,
6553 .size = MAILBOX_SYSFS_MAX,
6554 .read = sysfs_mbox_read,
6555 .write = sysfs_mbox_write,
6559 * lpfc_alloc_sysfs_attr - Creates the ctlreg and mbox entries
6560 * @vport: address of lpfc vport structure.
6564 * error return code from sysfs_create_bin_file()
6567 lpfc_alloc_sysfs_attr(struct lpfc_vport *vport)
6569 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
6572 error = sysfs_create_bin_file(&shost->shost_dev.kobj,
6573 &sysfs_drvr_stat_data_attr);
6575 /* Virtual ports do not need ctrl_reg and mbox */
6576 if (error || vport->port_type == LPFC_NPIV_PORT)
6579 error = sysfs_create_bin_file(&shost->shost_dev.kobj,
6580 &sysfs_ctlreg_attr);
6582 goto out_remove_stat_attr;
6584 error = sysfs_create_bin_file(&shost->shost_dev.kobj,
6587 goto out_remove_ctlreg_attr;
6590 out_remove_ctlreg_attr:
6591 sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr);
6592 out_remove_stat_attr:
6593 sysfs_remove_bin_file(&shost->shost_dev.kobj,
6594 &sysfs_drvr_stat_data_attr);
6600 * lpfc_free_sysfs_attr - Removes the ctlreg and mbox entries
6601 * @vport: address of lpfc vport structure.
6604 lpfc_free_sysfs_attr(struct lpfc_vport *vport)
6606 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
6607 sysfs_remove_bin_file(&shost->shost_dev.kobj,
6608 &sysfs_drvr_stat_data_attr);
6609 /* Virtual ports do not need ctrl_reg and mbox */
6610 if (vport->port_type == LPFC_NPIV_PORT)
6612 sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_mbox_attr);
6613 sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr);
6617 * Dynamic FC Host Attributes Support
6621 * lpfc_get_host_symbolic_name - Copy symbolic name into the scsi host
6622 * @shost: kernel scsi host pointer.
6625 lpfc_get_host_symbolic_name(struct Scsi_Host *shost)
6627 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
6629 lpfc_vport_symbolic_node_name(vport, fc_host_symbolic_name(shost),
6630 sizeof fc_host_symbolic_name(shost));
6634 * lpfc_get_host_port_id - Copy the vport DID into the scsi host port id
6635 * @shost: kernel scsi host pointer.
6638 lpfc_get_host_port_id(struct Scsi_Host *shost)
6640 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6642 /* note: fc_myDID already in cpu endianness */
6643 fc_host_port_id(shost) = vport->fc_myDID;
6647 * lpfc_get_host_port_type - Set the value of the scsi host port type
6648 * @shost: kernel scsi host pointer.
6651 lpfc_get_host_port_type(struct Scsi_Host *shost)
6653 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6654 struct lpfc_hba *phba = vport->phba;
6656 spin_lock_irq(shost->host_lock);
6658 if (vport->port_type == LPFC_NPIV_PORT) {
6659 fc_host_port_type(shost) = FC_PORTTYPE_NPIV;
6660 } else if (lpfc_is_link_up(phba)) {
6661 if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
6662 if (vport->fc_flag & FC_PUBLIC_LOOP)
6663 fc_host_port_type(shost) = FC_PORTTYPE_NLPORT;
6665 fc_host_port_type(shost) = FC_PORTTYPE_LPORT;
6667 if (vport->fc_flag & FC_FABRIC)
6668 fc_host_port_type(shost) = FC_PORTTYPE_NPORT;
6670 fc_host_port_type(shost) = FC_PORTTYPE_PTP;
6673 fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN;
6675 spin_unlock_irq(shost->host_lock);
6679 * lpfc_get_host_port_state - Set the value of the scsi host port state
6680 * @shost: kernel scsi host pointer.
6683 lpfc_get_host_port_state(struct Scsi_Host *shost)
6685 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6686 struct lpfc_hba *phba = vport->phba;
6688 spin_lock_irq(shost->host_lock);
6690 if (vport->fc_flag & FC_OFFLINE_MODE)
6691 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
6693 switch (phba->link_state) {
6694 case LPFC_LINK_UNKNOWN:
6695 case LPFC_LINK_DOWN:
6696 fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
6700 case LPFC_HBA_READY:
6701 /* Links up, reports port state accordingly */
6702 if (vport->port_state < LPFC_VPORT_READY)
6703 fc_host_port_state(shost) =
6704 FC_PORTSTATE_BYPASSED;
6706 fc_host_port_state(shost) =
6707 FC_PORTSTATE_ONLINE;
6709 case LPFC_HBA_ERROR:
6710 fc_host_port_state(shost) = FC_PORTSTATE_ERROR;
6713 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
6718 spin_unlock_irq(shost->host_lock);
6722 * lpfc_get_host_speed - Set the value of the scsi host speed
6723 * @shost: kernel scsi host pointer.
6726 lpfc_get_host_speed(struct Scsi_Host *shost)
6728 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6729 struct lpfc_hba *phba = vport->phba;
6731 spin_lock_irq(shost->host_lock);
6733 if ((lpfc_is_link_up(phba)) && (!(phba->hba_flag & HBA_FCOE_MODE))) {
6734 switch(phba->fc_linkspeed) {
6735 case LPFC_LINK_SPEED_1GHZ:
6736 fc_host_speed(shost) = FC_PORTSPEED_1GBIT;
6738 case LPFC_LINK_SPEED_2GHZ:
6739 fc_host_speed(shost) = FC_PORTSPEED_2GBIT;
6741 case LPFC_LINK_SPEED_4GHZ:
6742 fc_host_speed(shost) = FC_PORTSPEED_4GBIT;
6744 case LPFC_LINK_SPEED_8GHZ:
6745 fc_host_speed(shost) = FC_PORTSPEED_8GBIT;
6747 case LPFC_LINK_SPEED_10GHZ:
6748 fc_host_speed(shost) = FC_PORTSPEED_10GBIT;
6750 case LPFC_LINK_SPEED_16GHZ:
6751 fc_host_speed(shost) = FC_PORTSPEED_16GBIT;
6753 case LPFC_LINK_SPEED_32GHZ:
6754 fc_host_speed(shost) = FC_PORTSPEED_32GBIT;
6756 case LPFC_LINK_SPEED_64GHZ:
6757 fc_host_speed(shost) = FC_PORTSPEED_64GBIT;
6759 case LPFC_LINK_SPEED_128GHZ:
6760 fc_host_speed(shost) = FC_PORTSPEED_128GBIT;
6762 case LPFC_LINK_SPEED_256GHZ:
6763 fc_host_speed(shost) = FC_PORTSPEED_256GBIT;
6766 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
6769 } else if (lpfc_is_link_up(phba) && (phba->hba_flag & HBA_FCOE_MODE)) {
6770 switch (phba->fc_linkspeed) {
6771 case LPFC_ASYNC_LINK_SPEED_1GBPS:
6772 fc_host_speed(shost) = FC_PORTSPEED_1GBIT;
6774 case LPFC_ASYNC_LINK_SPEED_10GBPS:
6775 fc_host_speed(shost) = FC_PORTSPEED_10GBIT;
6777 case LPFC_ASYNC_LINK_SPEED_20GBPS:
6778 fc_host_speed(shost) = FC_PORTSPEED_20GBIT;
6780 case LPFC_ASYNC_LINK_SPEED_25GBPS:
6781 fc_host_speed(shost) = FC_PORTSPEED_25GBIT;
6783 case LPFC_ASYNC_LINK_SPEED_40GBPS:
6784 fc_host_speed(shost) = FC_PORTSPEED_40GBIT;
6786 case LPFC_ASYNC_LINK_SPEED_100GBPS:
6787 fc_host_speed(shost) = FC_PORTSPEED_100GBIT;
6790 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
6794 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
6796 spin_unlock_irq(shost->host_lock);
6800 * lpfc_get_host_fabric_name - Set the value of the scsi host fabric name
6801 * @shost: kernel scsi host pointer.
6804 lpfc_get_host_fabric_name (struct Scsi_Host *shost)
6806 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6807 struct lpfc_hba *phba = vport->phba;
6810 spin_lock_irq(shost->host_lock);
6812 if ((vport->port_state > LPFC_FLOGI) &&
6813 ((vport->fc_flag & FC_FABRIC) ||
6814 ((phba->fc_topology == LPFC_TOPOLOGY_LOOP) &&
6815 (vport->fc_flag & FC_PUBLIC_LOOP))))
6816 node_name = wwn_to_u64(phba->fc_fabparam.nodeName.u.wwn);
6818 /* fabric is local port if there is no F/FL_Port */
6821 spin_unlock_irq(shost->host_lock);
6823 fc_host_fabric_name(shost) = node_name;
6827 * lpfc_get_stats - Return statistical information about the adapter
6828 * @shost: kernel scsi host pointer.
6831 * NULL on error for link down, no mbox pool, sli2 active,
6832 * management not allowed, memory allocation error, or mbox error.
6836 * address of the adapter host statistics
6838 static struct fc_host_statistics *
6839 lpfc_get_stats(struct Scsi_Host *shost)
6841 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6842 struct lpfc_hba *phba = vport->phba;
6843 struct lpfc_sli *psli = &phba->sli;
6844 struct fc_host_statistics *hs = &phba->link_stats;
6845 struct lpfc_lnk_stat * lso = &psli->lnk_stat_offsets;
6846 LPFC_MBOXQ_t *pmboxq;
6851 * prevent udev from issuing mailbox commands until the port is
6854 if (phba->link_state < LPFC_LINK_DOWN ||
6855 !phba->mbox_mem_pool ||
6856 (phba->sli.sli_flag & LPFC_SLI_ACTIVE) == 0)
6859 if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
6862 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
6865 memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
6867 pmb = &pmboxq->u.mb;
6868 pmb->mbxCommand = MBX_READ_STATUS;
6869 pmb->mbxOwner = OWN_HOST;
6870 pmboxq->ctx_buf = NULL;
6871 pmboxq->vport = vport;
6873 if (vport->fc_flag & FC_OFFLINE_MODE) {
6874 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
6875 if (rc != MBX_SUCCESS) {
6876 mempool_free(pmboxq, phba->mbox_mem_pool);
6880 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
6881 if (rc != MBX_SUCCESS) {
6882 if (rc != MBX_TIMEOUT)
6883 mempool_free(pmboxq, phba->mbox_mem_pool);
6888 memset(hs, 0, sizeof (struct fc_host_statistics));
6890 hs->tx_frames = pmb->un.varRdStatus.xmitFrameCnt;
6891 hs->rx_frames = pmb->un.varRdStatus.rcvFrameCnt;
6894 * The MBX_READ_STATUS returns tx_k_bytes which has to be
6895 * converted to words.
6897 * Check if extended byte flag is set, to know when to collect upper
6898 * bits of 64 bit wide statistics counter.
6900 if (pmb->un.varRdStatus.xkb & RD_ST_XKB) {
6901 hs->tx_words = (u64)
6902 ((((u64)(pmb->un.varRdStatus.xmit_xkb &
6903 RD_ST_XMIT_XKB_MASK) << 32) |
6904 (u64)pmb->un.varRdStatus.xmitByteCnt) *
6906 hs->rx_words = (u64)
6907 ((((u64)(pmb->un.varRdStatus.rcv_xkb &
6908 RD_ST_RCV_XKB_MASK) << 32) |
6909 (u64)pmb->un.varRdStatus.rcvByteCnt) *
6912 hs->tx_words = (uint64_t)
6913 ((uint64_t)pmb->un.varRdStatus.xmitByteCnt
6915 hs->rx_words = (uint64_t)
6916 ((uint64_t)pmb->un.varRdStatus.rcvByteCnt
6920 memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
6921 pmb->mbxCommand = MBX_READ_LNK_STAT;
6922 pmb->mbxOwner = OWN_HOST;
6923 pmboxq->ctx_buf = NULL;
6924 pmboxq->vport = vport;
6926 if (vport->fc_flag & FC_OFFLINE_MODE) {
6927 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
6928 if (rc != MBX_SUCCESS) {
6929 mempool_free(pmboxq, phba->mbox_mem_pool);
6933 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
6934 if (rc != MBX_SUCCESS) {
6935 if (rc != MBX_TIMEOUT)
6936 mempool_free(pmboxq, phba->mbox_mem_pool);
6941 hs->link_failure_count = pmb->un.varRdLnk.linkFailureCnt;
6942 hs->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt;
6943 hs->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt;
6944 hs->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt;
6945 hs->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord;
6946 hs->invalid_crc_count = pmb->un.varRdLnk.crcCnt;
6947 hs->error_frames = pmb->un.varRdLnk.crcCnt;
6949 hs->cn_sig_warn = atomic64_read(&phba->cgn_acqe_stat.warn);
6950 hs->cn_sig_alarm = atomic64_read(&phba->cgn_acqe_stat.alarm);
6952 hs->link_failure_count -= lso->link_failure_count;
6953 hs->loss_of_sync_count -= lso->loss_of_sync_count;
6954 hs->loss_of_signal_count -= lso->loss_of_signal_count;
6955 hs->prim_seq_protocol_err_count -= lso->prim_seq_protocol_err_count;
6956 hs->invalid_tx_word_count -= lso->invalid_tx_word_count;
6957 hs->invalid_crc_count -= lso->invalid_crc_count;
6958 hs->error_frames -= lso->error_frames;
6960 if (phba->hba_flag & HBA_FCOE_MODE) {
6962 hs->nos_count = (phba->link_events >> 1);
6963 hs->nos_count -= lso->link_events;
6964 } else if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
6965 hs->lip_count = (phba->fc_eventTag >> 1);
6966 hs->lip_count -= lso->link_events;
6970 hs->nos_count = (phba->fc_eventTag >> 1);
6971 hs->nos_count -= lso->link_events;
6974 hs->dumped_frames = -1;
6976 hs->seconds_since_last_reset = ktime_get_seconds() - psli->stats_start;
6978 mempool_free(pmboxq, phba->mbox_mem_pool);
6984 * lpfc_reset_stats - Copy the adapter link stats information
6985 * @shost: kernel scsi host pointer.
6988 lpfc_reset_stats(struct Scsi_Host *shost)
6990 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
6991 struct lpfc_hba *phba = vport->phba;
6992 struct lpfc_sli *psli = &phba->sli;
6993 struct lpfc_lnk_stat *lso = &psli->lnk_stat_offsets;
6994 LPFC_MBOXQ_t *pmboxq;
6998 if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
7001 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
7004 memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
7006 pmb = &pmboxq->u.mb;
7007 pmb->mbxCommand = MBX_READ_STATUS;
7008 pmb->mbxOwner = OWN_HOST;
7009 pmb->un.varWords[0] = 0x1; /* reset request */
7010 pmboxq->ctx_buf = NULL;
7011 pmboxq->vport = vport;
7013 if ((vport->fc_flag & FC_OFFLINE_MODE) ||
7014 (!(psli->sli_flag & LPFC_SLI_ACTIVE))) {
7015 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
7016 if (rc != MBX_SUCCESS) {
7017 mempool_free(pmboxq, phba->mbox_mem_pool);
7021 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
7022 if (rc != MBX_SUCCESS) {
7023 if (rc != MBX_TIMEOUT)
7024 mempool_free(pmboxq, phba->mbox_mem_pool);
7029 memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
7030 pmb->mbxCommand = MBX_READ_LNK_STAT;
7031 pmb->mbxOwner = OWN_HOST;
7032 pmboxq->ctx_buf = NULL;
7033 pmboxq->vport = vport;
7035 if ((vport->fc_flag & FC_OFFLINE_MODE) ||
7036 (!(psli->sli_flag & LPFC_SLI_ACTIVE))) {
7037 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
7038 if (rc != MBX_SUCCESS) {
7039 mempool_free(pmboxq, phba->mbox_mem_pool);
7043 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
7044 if (rc != MBX_SUCCESS) {
7045 if (rc != MBX_TIMEOUT)
7046 mempool_free(pmboxq, phba->mbox_mem_pool);
7051 lso->link_failure_count = pmb->un.varRdLnk.linkFailureCnt;
7052 lso->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt;
7053 lso->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt;
7054 lso->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt;
7055 lso->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord;
7056 lso->invalid_crc_count = pmb->un.varRdLnk.crcCnt;
7057 lso->error_frames = pmb->un.varRdLnk.crcCnt;
7058 if (phba->hba_flag & HBA_FCOE_MODE)
7059 lso->link_events = (phba->link_events >> 1);
7061 lso->link_events = (phba->fc_eventTag >> 1);
7063 atomic64_set(&phba->cgn_acqe_stat.warn, 0);
7064 atomic64_set(&phba->cgn_acqe_stat.alarm, 0);
7066 memset(&shost_to_fc_host(shost)->fpin_stats, 0,
7067 sizeof(shost_to_fc_host(shost)->fpin_stats));
7069 psli->stats_start = ktime_get_seconds();
7071 mempool_free(pmboxq, phba->mbox_mem_pool);
7077 * The LPFC driver treats linkdown handling as target loss events so there
7078 * are no sysfs handlers for link_down_tmo.
7082 * lpfc_get_node_by_target - Return the nodelist for a target
7083 * @starget: kernel scsi target pointer.
7086 * address of the node list if found
7087 * NULL target not found
7089 static struct lpfc_nodelist *
7090 lpfc_get_node_by_target(struct scsi_target *starget)
7092 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
7093 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
7094 struct lpfc_nodelist *ndlp;
7096 spin_lock_irq(shost->host_lock);
7097 /* Search for this, mapped, target ID */
7098 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
7099 if (ndlp->nlp_state == NLP_STE_MAPPED_NODE &&
7100 starget->id == ndlp->nlp_sid) {
7101 spin_unlock_irq(shost->host_lock);
7105 spin_unlock_irq(shost->host_lock);
7110 * lpfc_get_starget_port_id - Set the target port id to the ndlp DID or -1
7111 * @starget: kernel scsi target pointer.
7114 lpfc_get_starget_port_id(struct scsi_target *starget)
7116 struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
7118 fc_starget_port_id(starget) = ndlp ? ndlp->nlp_DID : -1;
7122 * lpfc_get_starget_node_name - Set the target node name
7123 * @starget: kernel scsi target pointer.
7125 * Description: Set the target node name to the ndlp node name wwn or zero.
7128 lpfc_get_starget_node_name(struct scsi_target *starget)
7130 struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
7132 fc_starget_node_name(starget) =
7133 ndlp ? wwn_to_u64(ndlp->nlp_nodename.u.wwn) : 0;
7137 * lpfc_get_starget_port_name - Set the target port name
7138 * @starget: kernel scsi target pointer.
7140 * Description: set the target port name to the ndlp port name wwn or zero.
7143 lpfc_get_starget_port_name(struct scsi_target *starget)
7145 struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
7147 fc_starget_port_name(starget) =
7148 ndlp ? wwn_to_u64(ndlp->nlp_portname.u.wwn) : 0;
7152 * lpfc_set_rport_loss_tmo - Set the rport dev loss tmo
7153 * @rport: fc rport address.
7154 * @timeout: new value for dev loss tmo.
7157 * If timeout is non zero set the dev_loss_tmo to timeout, else set
7158 * dev_loss_tmo to one.
7161 lpfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
7163 struct lpfc_rport_data *rdata = rport->dd_data;
7164 struct lpfc_nodelist *ndlp = rdata->pnode;
7165 #if (IS_ENABLED(CONFIG_NVME_FC))
7166 struct lpfc_nvme_rport *nrport = NULL;
7170 rport->dev_loss_tmo = timeout;
7172 rport->dev_loss_tmo = 1;
7175 dev_info(&rport->dev, "Cannot find remote node to "
7176 "set rport dev loss tmo, port_id x%x\n",
7181 #if (IS_ENABLED(CONFIG_NVME_FC))
7182 nrport = lpfc_ndlp_get_nrport(ndlp);
7184 if (nrport && nrport->remoteport)
7185 nvme_fc_set_remoteport_devloss(nrport->remoteport,
7186 rport->dev_loss_tmo);
7191 * lpfc_rport_show_function - Return rport target information
7194 * Macro that uses field to generate a function with the name lpfc_show_rport_
7196 * lpfc_show_rport_##field: returns the bytes formatted in buf
7197 * @cdev: class converted to an fc_rport.
7198 * @buf: on return contains the target_field or zero.
7200 * Returns: size of formatted string.
7202 #define lpfc_rport_show_function(field, format_string, sz, cast) \
7204 lpfc_show_rport_##field (struct device *dev, \
7205 struct device_attribute *attr, \
7208 struct fc_rport *rport = transport_class_to_rport(dev); \
7209 struct lpfc_rport_data *rdata = rport->hostdata; \
7210 return scnprintf(buf, sz, format_string, \
7211 (rdata->target) ? cast rdata->target->field : 0); \
7214 #define lpfc_rport_rd_attr(field, format_string, sz) \
7215 lpfc_rport_show_function(field, format_string, sz, ) \
7216 static FC_RPORT_ATTR(field, S_IRUGO, lpfc_show_rport_##field, NULL)
7219 * lpfc_set_vport_symbolic_name - Set the vport's symbolic name
7220 * @fc_vport: The fc_vport who's symbolic name has been changed.
7223 * This function is called by the transport after the @fc_vport's symbolic name
7224 * has been changed. This function re-registers the symbolic name with the
7225 * switch to propagate the change into the fabric if the vport is active.
7228 lpfc_set_vport_symbolic_name(struct fc_vport *fc_vport)
7230 struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
7232 if (vport->port_state == LPFC_VPORT_READY)
7233 lpfc_ns_cmd(vport, SLI_CTNS_RSPN_ID, 0, 0);
7237 * lpfc_hba_log_verbose_init - Set hba's log verbose level
7238 * @phba: Pointer to lpfc_hba struct.
7239 * @verbose: Verbose level to set.
7241 * This function is called by the lpfc_get_cfgparam() routine to set the
7242 * module lpfc_log_verbose into the @phba cfg_log_verbose for use with
7243 * log message according to the module's lpfc_log_verbose parameter setting
7244 * before hba port or vport created.
7247 lpfc_hba_log_verbose_init(struct lpfc_hba *phba, uint32_t verbose)
7249 phba->cfg_log_verbose = verbose;
7252 struct fc_function_template lpfc_transport_functions = {
7253 /* fixed attributes the driver supports */
7254 .show_host_node_name = 1,
7255 .show_host_port_name = 1,
7256 .show_host_supported_classes = 1,
7257 .show_host_supported_fc4s = 1,
7258 .show_host_supported_speeds = 1,
7259 .show_host_maxframe_size = 1,
7261 .get_host_symbolic_name = lpfc_get_host_symbolic_name,
7262 .show_host_symbolic_name = 1,
7264 /* dynamic attributes the driver supports */
7265 .get_host_port_id = lpfc_get_host_port_id,
7266 .show_host_port_id = 1,
7268 .get_host_port_type = lpfc_get_host_port_type,
7269 .show_host_port_type = 1,
7271 .get_host_port_state = lpfc_get_host_port_state,
7272 .show_host_port_state = 1,
7274 /* active_fc4s is shown but doesn't change (thus no get function) */
7275 .show_host_active_fc4s = 1,
7277 .get_host_speed = lpfc_get_host_speed,
7278 .show_host_speed = 1,
7280 .get_host_fabric_name = lpfc_get_host_fabric_name,
7281 .show_host_fabric_name = 1,
7284 * The LPFC driver treats linkdown handling as target loss events
7285 * so there are no sysfs handlers for link_down_tmo.
7288 .get_fc_host_stats = lpfc_get_stats,
7289 .reset_fc_host_stats = lpfc_reset_stats,
7291 .dd_fcrport_size = sizeof(struct lpfc_rport_data),
7292 .show_rport_maxframe_size = 1,
7293 .show_rport_supported_classes = 1,
7295 .set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo,
7296 .show_rport_dev_loss_tmo = 1,
7298 .get_starget_port_id = lpfc_get_starget_port_id,
7299 .show_starget_port_id = 1,
7301 .get_starget_node_name = lpfc_get_starget_node_name,
7302 .show_starget_node_name = 1,
7304 .get_starget_port_name = lpfc_get_starget_port_name,
7305 .show_starget_port_name = 1,
7307 .issue_fc_host_lip = lpfc_issue_lip,
7308 .dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk,
7309 .terminate_rport_io = lpfc_terminate_rport_io,
7311 .dd_fcvport_size = sizeof(struct lpfc_vport *),
7313 .vport_disable = lpfc_vport_disable,
7315 .set_vport_symbolic_name = lpfc_set_vport_symbolic_name,
7317 .bsg_request = lpfc_bsg_request,
7318 .bsg_timeout = lpfc_bsg_timeout,
7321 struct fc_function_template lpfc_vport_transport_functions = {
7322 /* fixed attributes the driver supports */
7323 .show_host_node_name = 1,
7324 .show_host_port_name = 1,
7325 .show_host_supported_classes = 1,
7326 .show_host_supported_fc4s = 1,
7327 .show_host_supported_speeds = 1,
7328 .show_host_maxframe_size = 1,
7330 .get_host_symbolic_name = lpfc_get_host_symbolic_name,
7331 .show_host_symbolic_name = 1,
7333 /* dynamic attributes the driver supports */
7334 .get_host_port_id = lpfc_get_host_port_id,
7335 .show_host_port_id = 1,
7337 .get_host_port_type = lpfc_get_host_port_type,
7338 .show_host_port_type = 1,
7340 .get_host_port_state = lpfc_get_host_port_state,
7341 .show_host_port_state = 1,
7343 /* active_fc4s is shown but doesn't change (thus no get function) */
7344 .show_host_active_fc4s = 1,
7346 .get_host_speed = lpfc_get_host_speed,
7347 .show_host_speed = 1,
7349 .get_host_fabric_name = lpfc_get_host_fabric_name,
7350 .show_host_fabric_name = 1,
7353 * The LPFC driver treats linkdown handling as target loss events
7354 * so there are no sysfs handlers for link_down_tmo.
7357 .get_fc_host_stats = lpfc_get_stats,
7358 .reset_fc_host_stats = lpfc_reset_stats,
7360 .dd_fcrport_size = sizeof(struct lpfc_rport_data),
7361 .show_rport_maxframe_size = 1,
7362 .show_rport_supported_classes = 1,
7364 .set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo,
7365 .show_rport_dev_loss_tmo = 1,
7367 .get_starget_port_id = lpfc_get_starget_port_id,
7368 .show_starget_port_id = 1,
7370 .get_starget_node_name = lpfc_get_starget_node_name,
7371 .show_starget_node_name = 1,
7373 .get_starget_port_name = lpfc_get_starget_port_name,
7374 .show_starget_port_name = 1,
7376 .dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk,
7377 .terminate_rport_io = lpfc_terminate_rport_io,
7379 .vport_disable = lpfc_vport_disable,
7381 .set_vport_symbolic_name = lpfc_set_vport_symbolic_name,
7385 * lpfc_get_hba_function_mode - Used to determine the HBA function in FCoE
7387 * @phba: lpfc_hba pointer.
7390 lpfc_get_hba_function_mode(struct lpfc_hba *phba)
7392 /* If the adapter supports FCoE mode */
7393 switch (phba->pcidev->device) {
7394 case PCI_DEVICE_ID_SKYHAWK:
7395 case PCI_DEVICE_ID_SKYHAWK_VF:
7396 case PCI_DEVICE_ID_LANCER_FCOE:
7397 case PCI_DEVICE_ID_LANCER_FCOE_VF:
7398 case PCI_DEVICE_ID_ZEPHYR_DCSP:
7399 case PCI_DEVICE_ID_HORNET:
7400 case PCI_DEVICE_ID_TIGERSHARK:
7401 case PCI_DEVICE_ID_TOMCAT:
7402 phba->hba_flag |= HBA_FCOE_MODE;
7405 /* for others, clear the flag */
7406 phba->hba_flag &= ~HBA_FCOE_MODE;
7411 * lpfc_get_cfgparam - Used during probe_one to init the adapter structure
7412 * @phba: lpfc_hba pointer.
7415 lpfc_get_cfgparam(struct lpfc_hba *phba)
7417 lpfc_hba_log_verbose_init(phba, lpfc_log_verbose);
7418 lpfc_fcp_io_sched_init(phba, lpfc_fcp_io_sched);
7419 lpfc_ns_query_init(phba, lpfc_ns_query);
7420 lpfc_fcp2_no_tgt_reset_init(phba, lpfc_fcp2_no_tgt_reset);
7421 lpfc_cr_delay_init(phba, lpfc_cr_delay);
7422 lpfc_cr_count_init(phba, lpfc_cr_count);
7423 lpfc_multi_ring_support_init(phba, lpfc_multi_ring_support);
7424 lpfc_multi_ring_rctl_init(phba, lpfc_multi_ring_rctl);
7425 lpfc_multi_ring_type_init(phba, lpfc_multi_ring_type);
7426 lpfc_ack0_init(phba, lpfc_ack0);
7427 lpfc_xri_rebalancing_init(phba, lpfc_xri_rebalancing);
7428 lpfc_topology_init(phba, lpfc_topology);
7429 lpfc_link_speed_init(phba, lpfc_link_speed);
7430 lpfc_poll_tmo_init(phba, lpfc_poll_tmo);
7431 lpfc_task_mgmt_tmo_init(phba, lpfc_task_mgmt_tmo);
7432 lpfc_enable_npiv_init(phba, lpfc_enable_npiv);
7433 lpfc_fcf_failover_policy_init(phba, lpfc_fcf_failover_policy);
7434 lpfc_enable_rrq_init(phba, lpfc_enable_rrq);
7435 lpfc_fcp_wait_abts_rsp_init(phba, lpfc_fcp_wait_abts_rsp);
7436 lpfc_fdmi_on_init(phba, lpfc_fdmi_on);
7437 lpfc_enable_SmartSAN_init(phba, lpfc_enable_SmartSAN);
7438 lpfc_use_msi_init(phba, lpfc_use_msi);
7439 lpfc_nvme_oas_init(phba, lpfc_nvme_oas);
7440 lpfc_nvme_embed_cmd_init(phba, lpfc_nvme_embed_cmd);
7441 lpfc_fcp_imax_init(phba, lpfc_fcp_imax);
7442 lpfc_force_rscn_init(phba, lpfc_force_rscn);
7443 lpfc_cq_poll_threshold_init(phba, lpfc_cq_poll_threshold);
7444 lpfc_cq_max_proc_limit_init(phba, lpfc_cq_max_proc_limit);
7445 lpfc_fcp_cpu_map_init(phba, lpfc_fcp_cpu_map);
7446 lpfc_enable_hba_reset_init(phba, lpfc_enable_hba_reset);
7447 lpfc_enable_hba_heartbeat_init(phba, lpfc_enable_hba_heartbeat);
7449 lpfc_EnableXLane_init(phba, lpfc_EnableXLane);
7451 lpfc_max_vmid_init(phba, lpfc_max_vmid);
7452 lpfc_vmid_inactivity_timeout_init(phba, lpfc_vmid_inactivity_timeout);
7453 lpfc_vmid_app_header_init(phba, lpfc_vmid_app_header);
7454 lpfc_vmid_priority_tagging_init(phba, lpfc_vmid_priority_tagging);
7455 if (phba->sli_rev != LPFC_SLI_REV4)
7456 phba->cfg_EnableXLane = 0;
7457 lpfc_XLanePriority_init(phba, lpfc_XLanePriority);
7459 memset(phba->cfg_oas_tgt_wwpn, 0, (8 * sizeof(uint8_t)));
7460 memset(phba->cfg_oas_vpt_wwpn, 0, (8 * sizeof(uint8_t)));
7461 phba->cfg_oas_lun_state = 0;
7462 phba->cfg_oas_lun_status = 0;
7463 phba->cfg_oas_flags = 0;
7464 phba->cfg_oas_priority = 0;
7465 lpfc_enable_bg_init(phba, lpfc_enable_bg);
7466 lpfc_prot_mask_init(phba, lpfc_prot_mask);
7467 lpfc_prot_guard_init(phba, lpfc_prot_guard);
7468 if (phba->sli_rev == LPFC_SLI_REV4)
7471 phba->cfg_poll = lpfc_poll;
7473 /* Get the function mode */
7474 lpfc_get_hba_function_mode(phba);
7476 /* BlockGuard allowed for FC only. */
7477 if (phba->cfg_enable_bg && phba->hba_flag & HBA_FCOE_MODE) {
7478 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
7479 "0581 BlockGuard feature not supported\n");
7480 /* If set, clear the BlockGuard support param */
7481 phba->cfg_enable_bg = 0;
7482 } else if (phba->cfg_enable_bg) {
7483 phba->sli3_options |= LPFC_SLI3_BG_ENABLED;
7486 lpfc_suppress_rsp_init(phba, lpfc_suppress_rsp);
7488 lpfc_enable_fc4_type_init(phba, lpfc_enable_fc4_type);
7489 lpfc_nvmet_mrq_init(phba, lpfc_nvmet_mrq);
7490 lpfc_nvmet_mrq_post_init(phba, lpfc_nvmet_mrq_post);
7492 /* Initialize first burst. Target vs Initiator are different. */
7493 lpfc_nvme_enable_fb_init(phba, lpfc_nvme_enable_fb);
7494 lpfc_nvmet_fb_size_init(phba, lpfc_nvmet_fb_size);
7495 lpfc_fcp_mq_threshold_init(phba, lpfc_fcp_mq_threshold);
7496 lpfc_hdw_queue_init(phba, lpfc_hdw_queue);
7497 lpfc_irq_chann_init(phba, lpfc_irq_chann);
7498 lpfc_enable_bbcr_init(phba, lpfc_enable_bbcr);
7499 lpfc_enable_dpp_init(phba, lpfc_enable_dpp);
7500 lpfc_enable_mi_init(phba, lpfc_enable_mi);
7502 phba->cgn_p.cgn_param_mode = LPFC_CFG_OFF;
7503 phba->cmf_active_mode = LPFC_CFG_OFF;
7504 if (lpfc_fabric_cgn_frequency > EDC_CG_SIGFREQ_CNT_MAX ||
7505 lpfc_fabric_cgn_frequency < EDC_CG_SIGFREQ_CNT_MIN)
7506 lpfc_fabric_cgn_frequency = 100; /* 100 ms default */
7508 if (phba->sli_rev != LPFC_SLI_REV4) {
7509 /* NVME only supported on SLI4 */
7510 phba->nvmet_support = 0;
7511 phba->cfg_nvmet_mrq = 0;
7512 phba->cfg_enable_fc4_type = LPFC_ENABLE_FCP;
7513 phba->cfg_enable_bbcr = 0;
7514 phba->cfg_xri_rebalancing = 0;
7516 /* We MUST have FCP support */
7517 if (!(phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP))
7518 phba->cfg_enable_fc4_type |= LPFC_ENABLE_FCP;
7521 phba->cfg_auto_imax = (phba->cfg_fcp_imax) ? 0 : 1;
7523 phba->cfg_enable_pbde = 0;
7525 /* A value of 0 means use the number of CPUs found in the system */
7526 if (phba->cfg_hdw_queue == 0)
7527 phba->cfg_hdw_queue = phba->sli4_hba.num_present_cpu;
7528 if (phba->cfg_irq_chann == 0)
7529 phba->cfg_irq_chann = phba->sli4_hba.num_present_cpu;
7530 if (phba->cfg_irq_chann > phba->cfg_hdw_queue &&
7531 phba->sli_rev == LPFC_SLI_REV4)
7532 phba->cfg_irq_chann = phba->cfg_hdw_queue;
7534 lpfc_sg_seg_cnt_init(phba, lpfc_sg_seg_cnt);
7535 lpfc_hba_queue_depth_init(phba, lpfc_hba_queue_depth);
7536 lpfc_aer_support_init(phba, lpfc_aer_support);
7537 lpfc_sriov_nr_virtfn_init(phba, lpfc_sriov_nr_virtfn);
7538 lpfc_request_firmware_upgrade_init(phba, lpfc_req_fw_upgrade);
7539 lpfc_suppress_link_up_init(phba, lpfc_suppress_link_up);
7540 lpfc_delay_discovery_init(phba, lpfc_delay_discovery);
7541 lpfc_sli_mode_init(phba, lpfc_sli_mode);
7542 lpfc_enable_mds_diags_init(phba, lpfc_enable_mds_diags);
7543 lpfc_ras_fwlog_buffsize_init(phba, lpfc_ras_fwlog_buffsize);
7544 lpfc_ras_fwlog_level_init(phba, lpfc_ras_fwlog_level);
7545 lpfc_ras_fwlog_func_init(phba, lpfc_ras_fwlog_func);
7551 * lpfc_nvme_mod_param_dep - Adjust module parameter value based on
7552 * dependencies between protocols and roles.
7553 * @phba: lpfc_hba pointer.
7556 lpfc_nvme_mod_param_dep(struct lpfc_hba *phba)
7560 if (phba->cfg_hdw_queue > phba->sli4_hba.num_present_cpu) {
7561 phba->cfg_hdw_queue = phba->sli4_hba.num_present_cpu;
7564 if (phba->cfg_irq_chann > phba->sli4_hba.num_present_cpu) {
7565 phba->cfg_irq_chann = phba->sli4_hba.num_present_cpu;
7568 if (phba->cfg_irq_chann > phba->cfg_hdw_queue) {
7569 phba->cfg_irq_chann = phba->cfg_hdw_queue;
7573 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
7574 "2006 Reducing Queues - CPU limitation: "
7576 phba->cfg_irq_chann,
7577 phba->cfg_hdw_queue);
7579 if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME &&
7580 phba->nvmet_support) {
7581 phba->cfg_enable_fc4_type &= ~LPFC_ENABLE_FCP;
7583 lpfc_printf_log(phba, KERN_INFO, LOG_NVME_DISC,
7584 "6013 %s x%x fb_size x%x, fb_max x%x\n",
7585 "NVME Target PRLI ACC enable_fb ",
7586 phba->cfg_nvme_enable_fb,
7587 phba->cfg_nvmet_fb_size,
7588 LPFC_NVMET_FB_SZ_MAX);
7590 if (phba->cfg_nvme_enable_fb == 0)
7591 phba->cfg_nvmet_fb_size = 0;
7593 if (phba->cfg_nvmet_fb_size > LPFC_NVMET_FB_SZ_MAX)
7594 phba->cfg_nvmet_fb_size = LPFC_NVMET_FB_SZ_MAX;
7597 if (!phba->cfg_nvmet_mrq)
7598 phba->cfg_nvmet_mrq = phba->cfg_hdw_queue;
7600 /* Adjust lpfc_nvmet_mrq to avoid running out of WQE slots */
7601 if (phba->cfg_nvmet_mrq > phba->cfg_hdw_queue) {
7602 phba->cfg_nvmet_mrq = phba->cfg_hdw_queue;
7603 lpfc_printf_log(phba, KERN_ERR, LOG_NVME_DISC,
7604 "6018 Adjust lpfc_nvmet_mrq to %d\n",
7605 phba->cfg_nvmet_mrq);
7607 if (phba->cfg_nvmet_mrq > LPFC_NVMET_MRQ_MAX)
7608 phba->cfg_nvmet_mrq = LPFC_NVMET_MRQ_MAX;
7611 /* Not NVME Target mode. Turn off Target parameters. */
7612 phba->nvmet_support = 0;
7613 phba->cfg_nvmet_mrq = 0;
7614 phba->cfg_nvmet_fb_size = 0;
7619 * lpfc_get_vport_cfgparam - Used during port create, init the vport structure
7620 * @vport: lpfc_vport pointer.
7623 lpfc_get_vport_cfgparam(struct lpfc_vport *vport)
7625 lpfc_log_verbose_init(vport, lpfc_log_verbose);
7626 lpfc_lun_queue_depth_init(vport, lpfc_lun_queue_depth);
7627 lpfc_tgt_queue_depth_init(vport, lpfc_tgt_queue_depth);
7628 lpfc_devloss_tmo_init(vport, lpfc_devloss_tmo);
7629 lpfc_nodev_tmo_init(vport, lpfc_nodev_tmo);
7630 lpfc_peer_port_login_init(vport, lpfc_peer_port_login);
7631 lpfc_restrict_login_init(vport, lpfc_restrict_login);
7632 lpfc_fcp_class_init(vport, lpfc_fcp_class);
7633 lpfc_use_adisc_init(vport, lpfc_use_adisc);
7634 lpfc_first_burst_size_init(vport, lpfc_first_burst_size);
7635 lpfc_max_scsicmpl_time_init(vport, lpfc_max_scsicmpl_time);
7636 lpfc_discovery_threads_init(vport, lpfc_discovery_threads);
7637 lpfc_max_luns_init(vport, lpfc_max_luns);
7638 lpfc_scan_down_init(vport, lpfc_scan_down);
7639 lpfc_enable_da_id_init(vport, lpfc_enable_da_id);