1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2017 Broadcom. All Rights Reserved. The term *
5 * “Broadcom” refers to Broadcom Limited 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>
40 #include <linux/nvme-fc-driver.h>
45 #include "lpfc_sli4.h"
47 #include "lpfc_disc.h"
49 #include "lpfc_scsi.h"
50 #include "lpfc_nvme.h"
51 #include "lpfc_nvmet.h"
52 #include "lpfc_logmsg.h"
53 #include "lpfc_version.h"
54 #include "lpfc_compat.h"
55 #include "lpfc_crtn.h"
56 #include "lpfc_vport.h"
57 #include "lpfc_attr.h"
59 #define LPFC_DEF_DEVLOSS_TMO 30
60 #define LPFC_MIN_DEVLOSS_TMO 1
61 #define LPFC_MAX_DEVLOSS_TMO 255
63 #define LPFC_DEF_MRQ_POST 256
64 #define LPFC_MIN_MRQ_POST 32
65 #define LPFC_MAX_MRQ_POST 512
68 * Write key size should be multiple of 4. If write key is changed
69 * make sure that library write key is also changed.
71 #define LPFC_REG_WRITE_KEY_SIZE 4
72 #define LPFC_REG_WRITE_KEY "EMLX"
75 * lpfc_jedec_to_ascii - Hex to ascii convertor according to JEDEC rules
76 * @incr: integer to convert.
77 * @hdw: ascii string holding converted integer plus a string terminator.
80 * JEDEC Joint Electron Device Engineering Council.
81 * Convert a 32 bit integer composed of 8 nibbles into an 8 byte ascii
82 * character string. The string is then terminated with a NULL in byte 9.
83 * Hex 0-9 becomes ascii '0' to '9'.
84 * Hex a-f becomes ascii '=' to 'B' capital B.
87 * Coded for 32 bit integers only.
90 lpfc_jedec_to_ascii(int incr, char hdw[])
93 for (i = 0; i < 8; i++) {
96 hdw[7 - i] = 0x30 + j;
98 hdw[7 - i] = 0x61 + j - 10;
106 * lpfc_drvr_version_show - Return the Emulex driver string with version number
107 * @dev: class unused variable.
108 * @attr: device attribute, not used.
109 * @buf: on return contains the module description text.
111 * Returns: size of formatted string.
114 lpfc_drvr_version_show(struct device *dev, struct device_attribute *attr,
117 return snprintf(buf, PAGE_SIZE, LPFC_MODULE_DESC "\n");
121 * lpfc_enable_fip_show - Return the fip mode of the HBA
122 * @dev: class unused variable.
123 * @attr: device attribute, not used.
124 * @buf: on return contains the module description text.
126 * Returns: size of formatted string.
129 lpfc_enable_fip_show(struct device *dev, struct device_attribute *attr,
132 struct Scsi_Host *shost = class_to_shost(dev);
133 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
134 struct lpfc_hba *phba = vport->phba;
136 if (phba->hba_flag & HBA_FIP_SUPPORT)
137 return snprintf(buf, PAGE_SIZE, "1\n");
139 return snprintf(buf, PAGE_SIZE, "0\n");
143 lpfc_nvme_info_show(struct device *dev, struct device_attribute *attr,
146 struct Scsi_Host *shost = class_to_shost(dev);
147 struct lpfc_vport *vport = shost_priv(shost);
148 struct lpfc_hba *phba = vport->phba;
149 struct lpfc_nvmet_tgtport *tgtp;
150 struct nvme_fc_local_port *localport;
151 struct lpfc_nvme_lport *lport;
152 struct lpfc_nvme_rport *rport;
153 struct nvme_fc_remote_port *nrport;
157 if (!(phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME)) {
158 len += snprintf(buf, PAGE_SIZE, "NVME Disabled\n");
161 if (phba->nvmet_support) {
162 if (!phba->targetport) {
163 len = snprintf(buf, PAGE_SIZE,
164 "NVME Target: x%llx is not allocated\n",
165 wwn_to_u64(vport->fc_portname.u.wwn));
168 /* Port state is only one of two values for now. */
169 if (phba->targetport->port_id)
170 statep = "REGISTERED";
173 len += snprintf(buf + len, PAGE_SIZE - len,
174 "NVME Target: Enabled State %s\n",
176 len += snprintf(buf + len, PAGE_SIZE - len,
177 "%s%d WWPN x%llx WWNN x%llx DID x%06x\n",
180 wwn_to_u64(vport->fc_portname.u.wwn),
181 wwn_to_u64(vport->fc_nodename.u.wwn),
182 phba->targetport->port_id);
184 len += snprintf(buf + len, PAGE_SIZE - len,
185 "\nNVME Target: Statistics\n");
186 tgtp = (struct lpfc_nvmet_tgtport *)phba->targetport->private;
187 len += snprintf(buf+len, PAGE_SIZE-len,
188 "LS: Rcv %08x Drop %08x Abort %08x\n",
189 atomic_read(&tgtp->rcv_ls_req_in),
190 atomic_read(&tgtp->rcv_ls_req_drop),
191 atomic_read(&tgtp->xmt_ls_abort));
192 if (atomic_read(&tgtp->rcv_ls_req_in) !=
193 atomic_read(&tgtp->rcv_ls_req_out)) {
194 len += snprintf(buf+len, PAGE_SIZE-len,
195 "Rcv LS: in %08x != out %08x\n",
196 atomic_read(&tgtp->rcv_ls_req_in),
197 atomic_read(&tgtp->rcv_ls_req_out));
200 len += snprintf(buf+len, PAGE_SIZE-len,
201 "LS: Xmt %08x Drop %08x Cmpl %08x Err %08x\n",
202 atomic_read(&tgtp->xmt_ls_rsp),
203 atomic_read(&tgtp->xmt_ls_drop),
204 atomic_read(&tgtp->xmt_ls_rsp_cmpl),
205 atomic_read(&tgtp->xmt_ls_rsp_error));
207 len += snprintf(buf+len, PAGE_SIZE-len,
208 "FCP: Rcv %08x Drop %08x\n",
209 atomic_read(&tgtp->rcv_fcp_cmd_in),
210 atomic_read(&tgtp->rcv_fcp_cmd_drop));
212 if (atomic_read(&tgtp->rcv_fcp_cmd_in) !=
213 atomic_read(&tgtp->rcv_fcp_cmd_out)) {
214 len += snprintf(buf+len, PAGE_SIZE-len,
215 "Rcv FCP: in %08x != out %08x\n",
216 atomic_read(&tgtp->rcv_fcp_cmd_in),
217 atomic_read(&tgtp->rcv_fcp_cmd_out));
220 len += snprintf(buf+len, PAGE_SIZE-len,
221 "FCP Rsp: RD %08x rsp %08x WR %08x rsp %08x\n",
222 atomic_read(&tgtp->xmt_fcp_read),
223 atomic_read(&tgtp->xmt_fcp_read_rsp),
224 atomic_read(&tgtp->xmt_fcp_write),
225 atomic_read(&tgtp->xmt_fcp_rsp));
227 len += snprintf(buf+len, PAGE_SIZE-len,
228 "FCP Rsp: abort %08x drop %08x\n",
229 atomic_read(&tgtp->xmt_fcp_abort),
230 atomic_read(&tgtp->xmt_fcp_drop));
232 len += snprintf(buf+len, PAGE_SIZE-len,
233 "FCP Rsp Cmpl: %08x err %08x drop %08x\n",
234 atomic_read(&tgtp->xmt_fcp_rsp_cmpl),
235 atomic_read(&tgtp->xmt_fcp_rsp_error),
236 atomic_read(&tgtp->xmt_fcp_rsp_drop));
238 len += snprintf(buf+len, PAGE_SIZE-len,
239 "ABORT: Xmt %08x Err %08x Cmpl %08x",
240 atomic_read(&tgtp->xmt_abort_rsp),
241 atomic_read(&tgtp->xmt_abort_rsp_error),
242 atomic_read(&tgtp->xmt_abort_cmpl));
244 len += snprintf(buf+len, PAGE_SIZE-len, "\n");
248 localport = vport->localport;
250 len = snprintf(buf, PAGE_SIZE,
251 "NVME Initiator x%llx is not allocated\n",
252 wwn_to_u64(vport->fc_portname.u.wwn));
255 len = snprintf(buf, PAGE_SIZE, "NVME Initiator Enabled\n");
257 spin_lock_irq(shost->host_lock);
258 lport = (struct lpfc_nvme_lport *)localport->private;
260 /* Port state is only one of two values for now. */
261 if (localport->port_id)
266 len += snprintf(buf + len, PAGE_SIZE - len,
267 "%s%d WWPN x%llx WWNN x%llx DID x%06x %s\n",
270 wwn_to_u64(vport->fc_portname.u.wwn),
271 wwn_to_u64(vport->fc_nodename.u.wwn),
272 localport->port_id, statep);
274 list_for_each_entry(rport, &lport->rport_list, list) {
275 /* local short-hand pointer. */
276 nrport = rport->remoteport;
278 /* Port state is only one of two values for now. */
279 switch (nrport->port_state) {
280 case FC_OBJSTATE_ONLINE:
283 case FC_OBJSTATE_UNKNOWN:
287 statep = "UNSUPPORTED";
291 /* Tab in to show lport ownership. */
292 len += snprintf(buf + len, PAGE_SIZE - len,
294 if (phba->brd_no >= 10)
295 len += snprintf(buf + len, PAGE_SIZE - len, " ");
297 len += snprintf(buf + len, PAGE_SIZE - len, "WWPN x%llx ",
299 len += snprintf(buf + len, PAGE_SIZE - len, "WWNN x%llx ",
301 len += snprintf(buf + len, PAGE_SIZE - len, "DID x%06x ",
304 switch (nrport->port_role) {
305 case FC_PORT_ROLE_NVME_INITIATOR:
306 len += snprintf(buf + len, PAGE_SIZE - len,
309 case FC_PORT_ROLE_NVME_TARGET:
310 len += snprintf(buf + len, PAGE_SIZE - len,
313 case FC_PORT_ROLE_NVME_DISCOVERY:
314 len += snprintf(buf + len, PAGE_SIZE - len,
318 len += snprintf(buf + len, PAGE_SIZE - len,
323 len += snprintf(buf + len, PAGE_SIZE - len, "%s ", statep);
324 /* Terminate the string. */
325 len += snprintf(buf + len, PAGE_SIZE - len, "\n");
327 spin_unlock_irq(shost->host_lock);
329 len += snprintf(buf + len, PAGE_SIZE - len, "\nNVME Statistics\n");
330 len += snprintf(buf+len, PAGE_SIZE-len,
331 "LS: Xmt %016llx Cmpl %016llx\n",
332 phba->fc4NvmeLsRequests,
333 phba->fc4NvmeLsCmpls);
335 len += snprintf(buf+len, PAGE_SIZE-len,
336 "FCP: Rd %016llx Wr %016llx IO %016llx\n",
337 phba->fc4NvmeInputRequests,
338 phba->fc4NvmeOutputRequests,
339 phba->fc4NvmeControlRequests);
341 len += snprintf(buf+len, PAGE_SIZE-len,
342 " Cmpl %016llx\n", phba->fc4NvmeIoCmpls);
348 lpfc_bg_info_show(struct device *dev, struct device_attribute *attr,
351 struct Scsi_Host *shost = class_to_shost(dev);
352 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
353 struct lpfc_hba *phba = vport->phba;
355 if (phba->cfg_enable_bg)
356 if (phba->sli3_options & LPFC_SLI3_BG_ENABLED)
357 return snprintf(buf, PAGE_SIZE, "BlockGuard Enabled\n");
359 return snprintf(buf, PAGE_SIZE,
360 "BlockGuard Not Supported\n");
362 return snprintf(buf, PAGE_SIZE,
363 "BlockGuard Disabled\n");
367 lpfc_bg_guard_err_show(struct device *dev, struct device_attribute *attr,
370 struct Scsi_Host *shost = class_to_shost(dev);
371 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
372 struct lpfc_hba *phba = vport->phba;
374 return snprintf(buf, PAGE_SIZE, "%llu\n",
375 (unsigned long long)phba->bg_guard_err_cnt);
379 lpfc_bg_apptag_err_show(struct device *dev, struct device_attribute *attr,
382 struct Scsi_Host *shost = class_to_shost(dev);
383 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
384 struct lpfc_hba *phba = vport->phba;
386 return snprintf(buf, PAGE_SIZE, "%llu\n",
387 (unsigned long long)phba->bg_apptag_err_cnt);
391 lpfc_bg_reftag_err_show(struct device *dev, struct device_attribute *attr,
394 struct Scsi_Host *shost = class_to_shost(dev);
395 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
396 struct lpfc_hba *phba = vport->phba;
398 return snprintf(buf, PAGE_SIZE, "%llu\n",
399 (unsigned long long)phba->bg_reftag_err_cnt);
403 * lpfc_info_show - Return some pci info about the host in ascii
404 * @dev: class converted to a Scsi_host structure.
405 * @attr: device attribute, not used.
406 * @buf: on return contains the formatted text from lpfc_info().
408 * Returns: size of formatted string.
411 lpfc_info_show(struct device *dev, struct device_attribute *attr,
414 struct Scsi_Host *host = class_to_shost(dev);
416 return snprintf(buf, PAGE_SIZE, "%s\n",lpfc_info(host));
420 * lpfc_serialnum_show - Return the hba serial number in ascii
421 * @dev: class converted to a Scsi_host structure.
422 * @attr: device attribute, not used.
423 * @buf: on return contains the formatted text serial number.
425 * Returns: size of formatted string.
428 lpfc_serialnum_show(struct device *dev, struct device_attribute *attr,
431 struct Scsi_Host *shost = class_to_shost(dev);
432 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
433 struct lpfc_hba *phba = vport->phba;
435 return snprintf(buf, PAGE_SIZE, "%s\n",phba->SerialNumber);
439 * lpfc_temp_sensor_show - Return the temperature sensor level
440 * @dev: class converted to a Scsi_host structure.
441 * @attr: device attribute, not used.
442 * @buf: on return contains the formatted support level.
445 * Returns a number indicating the temperature sensor level currently
446 * supported, zero or one in ascii.
448 * Returns: size of formatted string.
451 lpfc_temp_sensor_show(struct device *dev, struct device_attribute *attr,
454 struct Scsi_Host *shost = class_to_shost(dev);
455 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
456 struct lpfc_hba *phba = vport->phba;
457 return snprintf(buf, PAGE_SIZE, "%d\n",phba->temp_sensor_support);
461 * lpfc_modeldesc_show - Return the model description of the hba
462 * @dev: class converted to a Scsi_host structure.
463 * @attr: device attribute, not used.
464 * @buf: on return contains the scsi vpd model description.
466 * Returns: size of formatted string.
469 lpfc_modeldesc_show(struct device *dev, struct device_attribute *attr,
472 struct Scsi_Host *shost = class_to_shost(dev);
473 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
474 struct lpfc_hba *phba = vport->phba;
476 return snprintf(buf, PAGE_SIZE, "%s\n",phba->ModelDesc);
480 * lpfc_modelname_show - Return the model name of the hba
481 * @dev: class converted to a Scsi_host structure.
482 * @attr: device attribute, not used.
483 * @buf: on return contains the scsi vpd model name.
485 * Returns: size of formatted string.
488 lpfc_modelname_show(struct device *dev, struct device_attribute *attr,
491 struct Scsi_Host *shost = class_to_shost(dev);
492 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
493 struct lpfc_hba *phba = vport->phba;
495 return snprintf(buf, PAGE_SIZE, "%s\n",phba->ModelName);
499 * lpfc_programtype_show - Return the program type of the hba
500 * @dev: class converted to a Scsi_host structure.
501 * @attr: device attribute, not used.
502 * @buf: on return contains the scsi vpd program type.
504 * Returns: size of formatted string.
507 lpfc_programtype_show(struct device *dev, struct device_attribute *attr,
510 struct Scsi_Host *shost = class_to_shost(dev);
511 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
512 struct lpfc_hba *phba = vport->phba;
514 return snprintf(buf, PAGE_SIZE, "%s\n",phba->ProgramType);
518 * lpfc_mlomgmt_show - Return the Menlo Maintenance sli flag
519 * @dev: class converted to a Scsi_host structure.
520 * @attr: device attribute, not used.
521 * @buf: on return contains the Menlo Maintenance sli flag.
523 * Returns: size of formatted string.
526 lpfc_mlomgmt_show(struct device *dev, struct device_attribute *attr, char *buf)
528 struct Scsi_Host *shost = class_to_shost(dev);
529 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
530 struct lpfc_hba *phba = vport->phba;
532 return snprintf(buf, PAGE_SIZE, "%d\n",
533 (phba->sli.sli_flag & LPFC_MENLO_MAINT));
537 * lpfc_vportnum_show - Return the port number in ascii of the hba
538 * @dev: class converted to a Scsi_host structure.
539 * @attr: device attribute, not used.
540 * @buf: on return contains scsi vpd program type.
542 * Returns: size of formatted string.
545 lpfc_vportnum_show(struct device *dev, struct device_attribute *attr,
548 struct Scsi_Host *shost = class_to_shost(dev);
549 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
550 struct lpfc_hba *phba = vport->phba;
552 return snprintf(buf, PAGE_SIZE, "%s\n",phba->Port);
556 * lpfc_fwrev_show - Return the firmware rev running in the hba
557 * @dev: class converted to a Scsi_host structure.
558 * @attr: device attribute, not used.
559 * @buf: on return contains the scsi vpd program type.
561 * Returns: size of formatted string.
564 lpfc_fwrev_show(struct device *dev, struct device_attribute *attr,
567 struct Scsi_Host *shost = class_to_shost(dev);
568 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
569 struct lpfc_hba *phba = vport->phba;
572 char fwrev[FW_REV_STR_SIZE];
575 lpfc_decode_firmware_rev(phba, fwrev, 1);
576 if_type = phba->sli4_hba.pc_sli4_params.if_type;
577 sli_family = phba->sli4_hba.pc_sli4_params.sli_family;
579 if (phba->sli_rev < LPFC_SLI_REV4)
580 len = snprintf(buf, PAGE_SIZE, "%s, sli-%d\n",
581 fwrev, phba->sli_rev);
583 len = snprintf(buf, PAGE_SIZE, "%s, sli-%d:%d:%x\n",
584 fwrev, phba->sli_rev, if_type, sli_family);
590 * lpfc_hdw_show - Return the jedec information about the hba
591 * @dev: class converted to a Scsi_host structure.
592 * @attr: device attribute, not used.
593 * @buf: on return contains the scsi vpd program type.
595 * Returns: size of formatted string.
598 lpfc_hdw_show(struct device *dev, struct device_attribute *attr, char *buf)
601 struct Scsi_Host *shost = class_to_shost(dev);
602 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
603 struct lpfc_hba *phba = vport->phba;
604 lpfc_vpd_t *vp = &phba->vpd;
606 lpfc_jedec_to_ascii(vp->rev.biuRev, hdw);
607 return snprintf(buf, PAGE_SIZE, "%s\n", hdw);
611 * lpfc_option_rom_version_show - Return the adapter ROM FCode version
612 * @dev: class converted to a Scsi_host structure.
613 * @attr: device attribute, not used.
614 * @buf: on return contains the ROM and FCode ascii strings.
616 * Returns: size of formatted string.
619 lpfc_option_rom_version_show(struct device *dev, struct device_attribute *attr,
622 struct Scsi_Host *shost = class_to_shost(dev);
623 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
624 struct lpfc_hba *phba = vport->phba;
625 char fwrev[FW_REV_STR_SIZE];
627 if (phba->sli_rev < LPFC_SLI_REV4)
628 return snprintf(buf, PAGE_SIZE, "%s\n", phba->OptionROMVersion);
630 lpfc_decode_firmware_rev(phba, fwrev, 1);
631 return snprintf(buf, PAGE_SIZE, "%s\n", fwrev);
635 * lpfc_state_show - Return the link state of the port
636 * @dev: class converted to a Scsi_host structure.
637 * @attr: device attribute, not used.
638 * @buf: on return contains text describing the state of the link.
641 * The switch statement has no default so zero will be returned.
643 * Returns: size of formatted string.
646 lpfc_link_state_show(struct device *dev, struct device_attribute *attr,
649 struct Scsi_Host *shost = class_to_shost(dev);
650 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
651 struct lpfc_hba *phba = vport->phba;
654 switch (phba->link_state) {
655 case LPFC_LINK_UNKNOWN:
656 case LPFC_WARM_START:
657 case LPFC_INIT_START:
658 case LPFC_INIT_MBX_CMDS:
661 if (phba->hba_flag & LINK_DISABLED)
662 len += snprintf(buf + len, PAGE_SIZE-len,
663 "Link Down - User disabled\n");
665 len += snprintf(buf + len, PAGE_SIZE-len,
671 len += snprintf(buf + len, PAGE_SIZE-len, "Link Up - ");
673 switch (vport->port_state) {
674 case LPFC_LOCAL_CFG_LINK:
675 len += snprintf(buf + len, PAGE_SIZE-len,
676 "Configuring Link\n");
680 case LPFC_FABRIC_CFG_LINK:
683 case LPFC_BUILD_DISC_LIST:
685 len += snprintf(buf + len, PAGE_SIZE - len,
688 case LPFC_VPORT_READY:
689 len += snprintf(buf + len, PAGE_SIZE - len, "Ready\n");
692 case LPFC_VPORT_FAILED:
693 len += snprintf(buf + len, PAGE_SIZE - len, "Failed\n");
696 case LPFC_VPORT_UNKNOWN:
697 len += snprintf(buf + len, PAGE_SIZE - len,
701 if (phba->sli.sli_flag & LPFC_MENLO_MAINT)
702 len += snprintf(buf + len, PAGE_SIZE-len,
703 " Menlo Maint Mode\n");
704 else if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
705 if (vport->fc_flag & FC_PUBLIC_LOOP)
706 len += snprintf(buf + len, PAGE_SIZE-len,
709 len += snprintf(buf + len, PAGE_SIZE-len,
712 if (vport->fc_flag & FC_FABRIC)
713 len += snprintf(buf + len, PAGE_SIZE-len,
716 len += snprintf(buf + len, PAGE_SIZE-len,
725 * lpfc_sli4_protocol_show - Return the fip mode of the HBA
726 * @dev: class unused variable.
727 * @attr: device attribute, not used.
728 * @buf: on return contains the module description text.
730 * Returns: size of formatted string.
733 lpfc_sli4_protocol_show(struct device *dev, struct device_attribute *attr,
736 struct Scsi_Host *shost = class_to_shost(dev);
737 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
738 struct lpfc_hba *phba = vport->phba;
740 if (phba->sli_rev < LPFC_SLI_REV4)
741 return snprintf(buf, PAGE_SIZE, "fc\n");
743 if (phba->sli4_hba.lnk_info.lnk_dv == LPFC_LNK_DAT_VAL) {
744 if (phba->sli4_hba.lnk_info.lnk_tp == LPFC_LNK_TYPE_GE)
745 return snprintf(buf, PAGE_SIZE, "fcoe\n");
746 if (phba->sli4_hba.lnk_info.lnk_tp == LPFC_LNK_TYPE_FC)
747 return snprintf(buf, PAGE_SIZE, "fc\n");
749 return snprintf(buf, PAGE_SIZE, "unknown\n");
753 * lpfc_oas_supported_show - Return whether or not Optimized Access Storage
754 * (OAS) is supported.
755 * @dev: class unused variable.
756 * @attr: device attribute, not used.
757 * @buf: on return contains the module description text.
759 * Returns: size of formatted string.
762 lpfc_oas_supported_show(struct device *dev, struct device_attribute *attr,
765 struct Scsi_Host *shost = class_to_shost(dev);
766 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
767 struct lpfc_hba *phba = vport->phba;
769 return snprintf(buf, PAGE_SIZE, "%d\n",
770 phba->sli4_hba.pc_sli4_params.oas_supported);
774 * lpfc_link_state_store - Transition the link_state on an HBA port
775 * @dev: class device that is converted into a Scsi_host.
776 * @attr: device attribute, not used.
777 * @buf: one or more lpfc_polling_flags values.
781 * -EINVAL if the buffer is not "up" or "down"
782 * return from link state change function if non-zero
783 * length of the buf on success
786 lpfc_link_state_store(struct device *dev, struct device_attribute *attr,
787 const char *buf, size_t count)
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 int status = -EINVAL;
795 if ((strncmp(buf, "up", sizeof("up") - 1) == 0) &&
796 (phba->link_state == LPFC_LINK_DOWN))
797 status = phba->lpfc_hba_init_link(phba, MBX_NOWAIT);
798 else if ((strncmp(buf, "down", sizeof("down") - 1) == 0) &&
799 (phba->link_state >= LPFC_LINK_UP))
800 status = phba->lpfc_hba_down_link(phba, MBX_NOWAIT);
809 * lpfc_num_discovered_ports_show - Return sum of mapped and unmapped vports
810 * @dev: class device that is converted into a Scsi_host.
811 * @attr: device attribute, not used.
812 * @buf: on return contains the sum of fc mapped and unmapped.
815 * Returns the ascii text number of the sum of the fc mapped and unmapped
818 * Returns: size of formatted string.
821 lpfc_num_discovered_ports_show(struct device *dev,
822 struct device_attribute *attr, char *buf)
824 struct Scsi_Host *shost = class_to_shost(dev);
825 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
827 return snprintf(buf, PAGE_SIZE, "%d\n",
828 vport->fc_map_cnt + vport->fc_unmap_cnt);
832 * lpfc_issue_lip - Misnomer, name carried over from long ago
833 * @shost: Scsi_Host pointer.
836 * Bring the link down gracefully then re-init the link. The firmware will
837 * re-init the fiber channel interface as required. Does not issue a LIP.
840 * -EPERM port offline or management commands are being blocked
841 * -ENOMEM cannot allocate memory for the mailbox command
842 * -EIO error sending the mailbox command
846 lpfc_issue_lip(struct Scsi_Host *shost)
848 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
849 struct lpfc_hba *phba = vport->phba;
850 LPFC_MBOXQ_t *pmboxq;
851 int mbxstatus = MBXERR_ERROR;
853 if ((vport->fc_flag & FC_OFFLINE_MODE) ||
854 (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO))
857 pmboxq = mempool_alloc(phba->mbox_mem_pool,GFP_KERNEL);
862 memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t));
863 pmboxq->u.mb.mbxCommand = MBX_DOWN_LINK;
864 pmboxq->u.mb.mbxOwner = OWN_HOST;
866 mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq, LPFC_MBOX_TMO * 2);
868 if ((mbxstatus == MBX_SUCCESS) &&
869 (pmboxq->u.mb.mbxStatus == 0 ||
870 pmboxq->u.mb.mbxStatus == MBXERR_LINK_DOWN)) {
871 memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t));
872 lpfc_init_link(phba, pmboxq, phba->cfg_topology,
873 phba->cfg_link_speed);
874 mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq,
876 if ((mbxstatus == MBX_SUCCESS) &&
877 (pmboxq->u.mb.mbxStatus == MBXERR_SEC_NO_PERMISSION))
878 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
879 "2859 SLI authentication is required "
880 "for INIT_LINK but has not done yet\n");
883 lpfc_set_loopback_flag(phba);
884 if (mbxstatus != MBX_TIMEOUT)
885 mempool_free(pmboxq, phba->mbox_mem_pool);
887 if (mbxstatus == MBXERR_ERROR)
894 lpfc_emptyq_wait(struct lpfc_hba *phba, struct list_head *q, spinlock_t *lock)
899 while (!list_empty(q)) {
900 spin_unlock_irq(lock);
902 if (cnt++ > 250) { /* 5 secs */
903 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
905 "Outstanding IO when ",
906 "bringing Adapter offline\n");
911 spin_unlock_irq(lock);
916 * lpfc_do_offline - Issues a mailbox command to bring the link down
917 * @phba: lpfc_hba pointer.
918 * @type: LPFC_EVT_OFFLINE, LPFC_EVT_WARM_START, LPFC_EVT_KILL.
921 * Assumes any error from lpfc_do_offline() will be negative.
922 * Can wait up to 5 seconds for the port ring buffers count
923 * to reach zero, prints a warning if it is not zero and continues.
924 * lpfc_workq_post_event() returns a non-zero return code if call fails.
927 * -EIO error posting the event
931 lpfc_do_offline(struct lpfc_hba *phba, uint32_t type)
933 struct completion online_compl;
934 struct lpfc_queue *qp = NULL;
935 struct lpfc_sli_ring *pring;
936 struct lpfc_sli *psli;
941 init_completion(&online_compl);
942 rc = lpfc_workq_post_event(phba, &status, &online_compl,
943 LPFC_EVT_OFFLINE_PREP);
947 wait_for_completion(&online_compl);
954 /* Wait a little for things to settle down, but not
955 * long enough for dev loss timeout to expire.
957 if (phba->sli_rev != LPFC_SLI_REV4) {
958 for (i = 0; i < psli->num_rings; i++) {
959 pring = &psli->sli3_ring[i];
960 if (!lpfc_emptyq_wait(phba, &pring->txcmplq,
965 list_for_each_entry(qp, &phba->sli4_hba.lpfc_wq_list, wq_list) {
969 if (!lpfc_emptyq_wait(phba, &pring->txcmplq,
975 init_completion(&online_compl);
976 rc = lpfc_workq_post_event(phba, &status, &online_compl, type);
980 wait_for_completion(&online_compl);
989 * lpfc_selective_reset - Offline then onlines the port
990 * @phba: lpfc_hba pointer.
993 * If the port is configured to allow a reset then the hba is brought
994 * offline then online.
997 * Assumes any error from lpfc_do_offline() will be negative.
998 * Do not make this function static.
1001 * lpfc_do_offline() return code if not zero
1002 * -EIO reset not configured or error posting the event
1006 lpfc_selective_reset(struct lpfc_hba *phba)
1008 struct completion online_compl;
1012 if (!phba->cfg_enable_hba_reset)
1015 if (!(phba->pport->fc_flag & FC_OFFLINE_MODE)) {
1016 status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
1022 init_completion(&online_compl);
1023 rc = lpfc_workq_post_event(phba, &status, &online_compl,
1028 wait_for_completion(&online_compl);
1037 * lpfc_issue_reset - Selectively resets an adapter
1038 * @dev: class device that is converted into a Scsi_host.
1039 * @attr: device attribute, not used.
1040 * @buf: containing the string "selective".
1041 * @count: unused variable.
1044 * If the buf contains the string "selective" then lpfc_selective_reset()
1045 * is called to perform the reset.
1048 * Assumes any error from lpfc_selective_reset() will be negative.
1049 * If lpfc_selective_reset() returns zero then the length of the buffer
1050 * is returned which indicates success
1053 * -EINVAL if the buffer does not contain the string "selective"
1054 * length of buf if lpfc-selective_reset() if the call succeeds
1055 * return value of lpfc_selective_reset() if the call fails
1058 lpfc_issue_reset(struct device *dev, struct device_attribute *attr,
1059 const char *buf, size_t count)
1061 struct Scsi_Host *shost = class_to_shost(dev);
1062 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1063 struct lpfc_hba *phba = vport->phba;
1064 int status = -EINVAL;
1066 if (!phba->cfg_enable_hba_reset)
1069 if (strncmp(buf, "selective", sizeof("selective") - 1) == 0)
1070 status = phba->lpfc_selective_reset(phba);
1079 * lpfc_sli4_pdev_status_reg_wait - Wait for pdev status register for readyness
1080 * @phba: lpfc_hba pointer.
1083 * SLI4 interface type-2 device to wait on the sliport status register for
1084 * the readyness after performing a firmware reset.
1087 * zero for success, -EPERM when port does not have privilege to perform the
1088 * reset, -EIO when port timeout from recovering from the reset.
1091 * As the caller will interpret the return code by value, be careful in making
1092 * change or addition to return codes.
1095 lpfc_sli4_pdev_status_reg_wait(struct lpfc_hba *phba)
1097 struct lpfc_register portstat_reg = {0};
1101 lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr,
1102 &portstat_reg.word0);
1104 /* verify if privileged for the request operation */
1105 if (!bf_get(lpfc_sliport_status_rn, &portstat_reg) &&
1106 !bf_get(lpfc_sliport_status_err, &portstat_reg))
1109 /* wait for the SLI port firmware ready after firmware reset */
1110 for (i = 0; i < LPFC_FW_RESET_MAXIMUM_WAIT_10MS_CNT; i++) {
1112 lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr,
1113 &portstat_reg.word0);
1114 if (!bf_get(lpfc_sliport_status_err, &portstat_reg))
1116 if (!bf_get(lpfc_sliport_status_rn, &portstat_reg))
1118 if (!bf_get(lpfc_sliport_status_rdy, &portstat_reg))
1123 if (i < LPFC_FW_RESET_MAXIMUM_WAIT_10MS_CNT)
1130 * lpfc_sli4_pdev_reg_request - Request physical dev to perform a register acc
1131 * @phba: lpfc_hba pointer.
1134 * Request SLI4 interface type-2 device to perform a physical register set
1141 lpfc_sli4_pdev_reg_request(struct lpfc_hba *phba, uint32_t opcode)
1143 struct completion online_compl;
1144 struct pci_dev *pdev = phba->pcidev;
1145 uint32_t before_fc_flag;
1146 uint32_t sriov_nr_virtfn;
1148 int status = 0, rc = 0;
1149 int job_posted = 1, sriov_err;
1151 if (!phba->cfg_enable_hba_reset)
1154 if ((phba->sli_rev < LPFC_SLI_REV4) ||
1155 (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
1156 LPFC_SLI_INTF_IF_TYPE_2))
1159 /* Keep state if we need to restore back */
1160 before_fc_flag = phba->pport->fc_flag;
1161 sriov_nr_virtfn = phba->cfg_sriov_nr_virtfn;
1163 /* Disable SR-IOV virtual functions if enabled */
1164 if (phba->cfg_sriov_nr_virtfn) {
1165 pci_disable_sriov(pdev);
1166 phba->cfg_sriov_nr_virtfn = 0;
1169 if (opcode == LPFC_FW_DUMP)
1170 phba->hba_flag |= HBA_FW_DUMP_OP;
1172 status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
1175 phba->hba_flag &= ~HBA_FW_DUMP_OP;
1179 /* wait for the device to be quiesced before firmware reset */
1182 reg_val = readl(phba->sli4_hba.conf_regs_memmap_p +
1183 LPFC_CTL_PDEV_CTL_OFFSET);
1185 if (opcode == LPFC_FW_DUMP)
1186 reg_val |= LPFC_FW_DUMP_REQUEST;
1187 else if (opcode == LPFC_FW_RESET)
1188 reg_val |= LPFC_CTL_PDEV_CTL_FRST;
1189 else if (opcode == LPFC_DV_RESET)
1190 reg_val |= LPFC_CTL_PDEV_CTL_DRST;
1192 writel(reg_val, phba->sli4_hba.conf_regs_memmap_p +
1193 LPFC_CTL_PDEV_CTL_OFFSET);
1195 readl(phba->sli4_hba.conf_regs_memmap_p + LPFC_CTL_PDEV_CTL_OFFSET);
1197 /* delay driver action following IF_TYPE_2 reset */
1198 rc = lpfc_sli4_pdev_status_reg_wait(phba);
1201 /* no privilege for reset */
1202 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1203 "3150 No privilege to perform the requested "
1204 "access: x%x\n", reg_val);
1205 } else if (rc == -EIO) {
1206 /* reset failed, there is nothing more we can do */
1207 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
1208 "3153 Fail to perform the requested "
1209 "access: x%x\n", reg_val);
1213 /* keep the original port state */
1214 if (before_fc_flag & FC_OFFLINE_MODE)
1217 init_completion(&online_compl);
1218 job_posted = lpfc_workq_post_event(phba, &status, &online_compl,
1223 wait_for_completion(&online_compl);
1226 /* in any case, restore the virtual functions enabled as before */
1227 if (sriov_nr_virtfn) {
1229 lpfc_sli_probe_sriov_nr_virtfn(phba, sriov_nr_virtfn);
1231 phba->cfg_sriov_nr_virtfn = sriov_nr_virtfn;
1234 /* return proper error code */
1245 * lpfc_nport_evt_cnt_show - Return the number of nport events
1246 * @dev: class device that is converted into a Scsi_host.
1247 * @attr: device attribute, not used.
1248 * @buf: on return contains the ascii number of nport events.
1250 * Returns: size of formatted string.
1253 lpfc_nport_evt_cnt_show(struct device *dev, struct device_attribute *attr,
1256 struct Scsi_Host *shost = class_to_shost(dev);
1257 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1258 struct lpfc_hba *phba = vport->phba;
1260 return snprintf(buf, PAGE_SIZE, "%d\n", phba->nport_event_cnt);
1264 * lpfc_board_mode_show - Return the state of the board
1265 * @dev: class device that is converted into a Scsi_host.
1266 * @attr: device attribute, not used.
1267 * @buf: on return contains the state of the adapter.
1269 * Returns: size of formatted string.
1272 lpfc_board_mode_show(struct device *dev, struct device_attribute *attr,
1275 struct Scsi_Host *shost = class_to_shost(dev);
1276 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1277 struct lpfc_hba *phba = vport->phba;
1280 if (phba->link_state == LPFC_HBA_ERROR)
1282 else if (phba->link_state == LPFC_WARM_START)
1283 state = "warm start";
1284 else if (phba->link_state == LPFC_INIT_START)
1289 return snprintf(buf, PAGE_SIZE, "%s\n", state);
1293 * lpfc_board_mode_store - Puts the hba in online, offline, warm or error state
1294 * @dev: class device that is converted into a Scsi_host.
1295 * @attr: device attribute, not used.
1296 * @buf: containing one of the strings "online", "offline", "warm" or "error".
1297 * @count: unused variable.
1300 * -EACCES if enable hba reset not enabled
1301 * -EINVAL if the buffer does not contain a valid string (see above)
1302 * -EIO if lpfc_workq_post_event() or lpfc_do_offline() fails
1303 * buf length greater than zero indicates success
1306 lpfc_board_mode_store(struct device *dev, struct device_attribute *attr,
1307 const char *buf, size_t count)
1309 struct Scsi_Host *shost = class_to_shost(dev);
1310 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1311 struct lpfc_hba *phba = vport->phba;
1312 struct completion online_compl;
1313 char *board_mode_str = NULL;
1317 if (!phba->cfg_enable_hba_reset) {
1319 goto board_mode_out;
1322 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1323 "3050 lpfc_board_mode set to %s\n", buf);
1325 init_completion(&online_compl);
1327 if(strncmp(buf, "online", sizeof("online") - 1) == 0) {
1328 rc = lpfc_workq_post_event(phba, &status, &online_compl,
1332 goto board_mode_out;
1334 wait_for_completion(&online_compl);
1335 } else if (strncmp(buf, "offline", sizeof("offline") - 1) == 0)
1336 status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
1337 else if (strncmp(buf, "warm", sizeof("warm") - 1) == 0)
1338 if (phba->sli_rev == LPFC_SLI_REV4)
1341 status = lpfc_do_offline(phba, LPFC_EVT_WARM_START);
1342 else if (strncmp(buf, "error", sizeof("error") - 1) == 0)
1343 if (phba->sli_rev == LPFC_SLI_REV4)
1346 status = lpfc_do_offline(phba, LPFC_EVT_KILL);
1347 else if (strncmp(buf, "dump", sizeof("dump") - 1) == 0)
1348 status = lpfc_sli4_pdev_reg_request(phba, LPFC_FW_DUMP);
1349 else if (strncmp(buf, "fw_reset", sizeof("fw_reset") - 1) == 0)
1350 status = lpfc_sli4_pdev_reg_request(phba, LPFC_FW_RESET);
1351 else if (strncmp(buf, "dv_reset", sizeof("dv_reset") - 1) == 0)
1352 status = lpfc_sli4_pdev_reg_request(phba, LPFC_DV_RESET);
1360 board_mode_str = strchr(buf, '\n');
1362 *board_mode_str = '\0';
1363 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1364 "3097 Failed \"%s\", status(%d), "
1366 buf, status, phba->pport->fc_flag);
1372 * lpfc_get_hba_info - Return various bits of informaton about the adapter
1373 * @phba: pointer to the adapter structure.
1374 * @mxri: max xri count.
1375 * @axri: available xri count.
1376 * @mrpi: max rpi count.
1377 * @arpi: available rpi count.
1378 * @mvpi: max vpi count.
1379 * @avpi: available vpi count.
1382 * If an integer pointer for an count is not null then the value for the
1383 * count is returned.
1390 lpfc_get_hba_info(struct lpfc_hba *phba,
1391 uint32_t *mxri, uint32_t *axri,
1392 uint32_t *mrpi, uint32_t *arpi,
1393 uint32_t *mvpi, uint32_t *avpi)
1395 struct lpfc_mbx_read_config *rd_config;
1396 LPFC_MBOXQ_t *pmboxq;
1402 * prevent udev from issuing mailbox commands until the port is
1405 if (phba->link_state < LPFC_LINK_DOWN ||
1406 !phba->mbox_mem_pool ||
1407 (phba->sli.sli_flag & LPFC_SLI_ACTIVE) == 0)
1410 if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
1413 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
1416 memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
1418 pmb = &pmboxq->u.mb;
1419 pmb->mbxCommand = MBX_READ_CONFIG;
1420 pmb->mbxOwner = OWN_HOST;
1421 pmboxq->context1 = NULL;
1423 if (phba->pport->fc_flag & FC_OFFLINE_MODE)
1424 rc = MBX_NOT_FINISHED;
1426 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
1428 if (rc != MBX_SUCCESS) {
1429 if (rc != MBX_TIMEOUT)
1430 mempool_free(pmboxq, phba->mbox_mem_pool);
1434 if (phba->sli_rev == LPFC_SLI_REV4) {
1435 rd_config = &pmboxq->u.mqe.un.rd_config;
1437 *mrpi = bf_get(lpfc_mbx_rd_conf_rpi_count, rd_config);
1439 *arpi = bf_get(lpfc_mbx_rd_conf_rpi_count, rd_config) -
1440 phba->sli4_hba.max_cfg_param.rpi_used;
1442 *mxri = bf_get(lpfc_mbx_rd_conf_xri_count, rd_config);
1444 *axri = bf_get(lpfc_mbx_rd_conf_xri_count, rd_config) -
1445 phba->sli4_hba.max_cfg_param.xri_used;
1447 /* Account for differences with SLI-3. Get vpi count from
1448 * mailbox data and subtract one for max vpi value.
1450 max_vpi = (bf_get(lpfc_mbx_rd_conf_vpi_count, rd_config) > 0) ?
1451 (bf_get(lpfc_mbx_rd_conf_vpi_count, rd_config) - 1) : 0;
1456 *avpi = max_vpi - phba->sli4_hba.max_cfg_param.vpi_used;
1459 *mrpi = pmb->un.varRdConfig.max_rpi;
1461 *arpi = pmb->un.varRdConfig.avail_rpi;
1463 *mxri = pmb->un.varRdConfig.max_xri;
1465 *axri = pmb->un.varRdConfig.avail_xri;
1467 *mvpi = pmb->un.varRdConfig.max_vpi;
1469 *avpi = pmb->un.varRdConfig.avail_vpi;
1472 mempool_free(pmboxq, phba->mbox_mem_pool);
1477 * lpfc_max_rpi_show - Return maximum rpi
1478 * @dev: class device that is converted into a Scsi_host.
1479 * @attr: device attribute, not used.
1480 * @buf: on return contains the maximum rpi count in decimal or "Unknown".
1483 * Calls lpfc_get_hba_info() asking for just the mrpi count.
1484 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1485 * to "Unknown" and the buffer length is returned, therefore the caller
1486 * must check for "Unknown" in the buffer to detect a failure.
1488 * Returns: size of formatted string.
1491 lpfc_max_rpi_show(struct device *dev, struct device_attribute *attr,
1494 struct Scsi_Host *shost = class_to_shost(dev);
1495 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1496 struct lpfc_hba *phba = vport->phba;
1499 if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, NULL, NULL, NULL))
1500 return snprintf(buf, PAGE_SIZE, "%d\n", cnt);
1501 return snprintf(buf, PAGE_SIZE, "Unknown\n");
1505 * lpfc_used_rpi_show - Return maximum rpi minus available rpi
1506 * @dev: class device that is converted into a Scsi_host.
1507 * @attr: device attribute, not used.
1508 * @buf: containing the used rpi count in decimal or "Unknown".
1511 * Calls lpfc_get_hba_info() asking for just the mrpi and arpi counts.
1512 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1513 * to "Unknown" and the buffer length is returned, therefore the caller
1514 * must check for "Unknown" in the buffer to detect a failure.
1516 * Returns: size of formatted string.
1519 lpfc_used_rpi_show(struct device *dev, struct device_attribute *attr,
1522 struct Scsi_Host *shost = class_to_shost(dev);
1523 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1524 struct lpfc_hba *phba = vport->phba;
1527 if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, &acnt, NULL, NULL))
1528 return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
1529 return snprintf(buf, PAGE_SIZE, "Unknown\n");
1533 * lpfc_max_xri_show - Return maximum xri
1534 * @dev: class device that is converted into a Scsi_host.
1535 * @attr: device attribute, not used.
1536 * @buf: on return contains the maximum xri count in decimal or "Unknown".
1539 * Calls lpfc_get_hba_info() asking for just the mrpi count.
1540 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1541 * to "Unknown" and the buffer length is returned, therefore the caller
1542 * must check for "Unknown" in the buffer to detect a failure.
1544 * Returns: size of formatted string.
1547 lpfc_max_xri_show(struct device *dev, struct device_attribute *attr,
1550 struct Scsi_Host *shost = class_to_shost(dev);
1551 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1552 struct lpfc_hba *phba = vport->phba;
1555 if (lpfc_get_hba_info(phba, &cnt, NULL, NULL, NULL, NULL, NULL))
1556 return snprintf(buf, PAGE_SIZE, "%d\n", cnt);
1557 return snprintf(buf, PAGE_SIZE, "Unknown\n");
1561 * lpfc_used_xri_show - Return maximum xpi minus the available xpi
1562 * @dev: class device that is converted into a Scsi_host.
1563 * @attr: device attribute, not used.
1564 * @buf: on return contains the used xri count in decimal or "Unknown".
1567 * Calls lpfc_get_hba_info() asking for just the mxri and axri counts.
1568 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1569 * to "Unknown" and the buffer length is returned, therefore the caller
1570 * must check for "Unknown" in the buffer to detect a failure.
1572 * Returns: size of formatted string.
1575 lpfc_used_xri_show(struct device *dev, struct device_attribute *attr,
1578 struct Scsi_Host *shost = class_to_shost(dev);
1579 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1580 struct lpfc_hba *phba = vport->phba;
1583 if (lpfc_get_hba_info(phba, &cnt, &acnt, NULL, NULL, NULL, NULL))
1584 return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
1585 return snprintf(buf, PAGE_SIZE, "Unknown\n");
1589 * lpfc_max_vpi_show - Return maximum vpi
1590 * @dev: class device that is converted into a Scsi_host.
1591 * @attr: device attribute, not used.
1592 * @buf: on return contains the maximum vpi count in decimal or "Unknown".
1595 * Calls lpfc_get_hba_info() asking for just the mvpi count.
1596 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1597 * to "Unknown" and the buffer length is returned, therefore the caller
1598 * must check for "Unknown" in the buffer to detect a failure.
1600 * Returns: size of formatted string.
1603 lpfc_max_vpi_show(struct device *dev, struct device_attribute *attr,
1606 struct Scsi_Host *shost = class_to_shost(dev);
1607 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1608 struct lpfc_hba *phba = vport->phba;
1611 if (lpfc_get_hba_info(phba, NULL, NULL, NULL, NULL, &cnt, NULL))
1612 return snprintf(buf, PAGE_SIZE, "%d\n", cnt);
1613 return snprintf(buf, PAGE_SIZE, "Unknown\n");
1617 * lpfc_used_vpi_show - Return maximum vpi minus the available vpi
1618 * @dev: class device that is converted into a Scsi_host.
1619 * @attr: device attribute, not used.
1620 * @buf: on return contains the used vpi count in decimal or "Unknown".
1623 * Calls lpfc_get_hba_info() asking for just the mvpi and avpi counts.
1624 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1625 * to "Unknown" and the buffer length is returned, therefore the caller
1626 * must check for "Unknown" in the buffer to detect a failure.
1628 * Returns: size of formatted string.
1631 lpfc_used_vpi_show(struct device *dev, struct device_attribute *attr,
1634 struct Scsi_Host *shost = class_to_shost(dev);
1635 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1636 struct lpfc_hba *phba = vport->phba;
1639 if (lpfc_get_hba_info(phba, NULL, NULL, NULL, NULL, &cnt, &acnt))
1640 return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
1641 return snprintf(buf, PAGE_SIZE, "Unknown\n");
1645 * lpfc_npiv_info_show - Return text about NPIV support for the adapter
1646 * @dev: class device that is converted into a Scsi_host.
1647 * @attr: device attribute, not used.
1648 * @buf: text that must be interpreted to determine if npiv is supported.
1651 * Buffer will contain text indicating npiv is not suppoerted on the port,
1652 * the port is an NPIV physical port, or it is an npiv virtual port with
1653 * the id of the vport.
1655 * Returns: size of formatted string.
1658 lpfc_npiv_info_show(struct device *dev, struct device_attribute *attr,
1661 struct Scsi_Host *shost = class_to_shost(dev);
1662 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1663 struct lpfc_hba *phba = vport->phba;
1665 if (!(phba->max_vpi))
1666 return snprintf(buf, PAGE_SIZE, "NPIV Not Supported\n");
1667 if (vport->port_type == LPFC_PHYSICAL_PORT)
1668 return snprintf(buf, PAGE_SIZE, "NPIV Physical\n");
1669 return snprintf(buf, PAGE_SIZE, "NPIV Virtual (VPI %d)\n", vport->vpi);
1673 * lpfc_poll_show - Return text about poll support for the adapter
1674 * @dev: class device that is converted into a Scsi_host.
1675 * @attr: device attribute, not used.
1676 * @buf: on return contains the cfg_poll in hex.
1679 * cfg_poll should be a lpfc_polling_flags type.
1681 * Returns: size of formatted string.
1684 lpfc_poll_show(struct device *dev, struct device_attribute *attr,
1687 struct Scsi_Host *shost = class_to_shost(dev);
1688 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1689 struct lpfc_hba *phba = vport->phba;
1691 return snprintf(buf, PAGE_SIZE, "%#x\n", phba->cfg_poll);
1695 * lpfc_poll_store - Set the value of cfg_poll for the adapter
1696 * @dev: class device that is converted into a Scsi_host.
1697 * @attr: device attribute, not used.
1698 * @buf: one or more lpfc_polling_flags values.
1702 * buf contents converted to integer and checked for a valid value.
1705 * -EINVAL if the buffer connot be converted or is out of range
1706 * length of the buf on success
1709 lpfc_poll_store(struct device *dev, struct device_attribute *attr,
1710 const char *buf, size_t count)
1712 struct Scsi_Host *shost = class_to_shost(dev);
1713 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1714 struct lpfc_hba *phba = vport->phba;
1719 if (!isdigit(buf[0]))
1722 if (sscanf(buf, "%i", &val) != 1)
1725 if ((val & 0x3) != val)
1728 if (phba->sli_rev == LPFC_SLI_REV4)
1731 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1732 "3051 lpfc_poll changed from %d to %d\n",
1733 phba->cfg_poll, val);
1735 spin_lock_irq(&phba->hbalock);
1737 old_val = phba->cfg_poll;
1739 if (val & ENABLE_FCP_RING_POLLING) {
1740 if ((val & DISABLE_FCP_RING_INT) &&
1741 !(old_val & DISABLE_FCP_RING_INT)) {
1742 if (lpfc_readl(phba->HCregaddr, &creg_val)) {
1743 spin_unlock_irq(&phba->hbalock);
1746 creg_val &= ~(HC_R0INT_ENA << LPFC_FCP_RING);
1747 writel(creg_val, phba->HCregaddr);
1748 readl(phba->HCregaddr); /* flush */
1750 lpfc_poll_start_timer(phba);
1752 } else if (val != 0x0) {
1753 spin_unlock_irq(&phba->hbalock);
1757 if (!(val & DISABLE_FCP_RING_INT) &&
1758 (old_val & DISABLE_FCP_RING_INT))
1760 spin_unlock_irq(&phba->hbalock);
1761 del_timer(&phba->fcp_poll_timer);
1762 spin_lock_irq(&phba->hbalock);
1763 if (lpfc_readl(phba->HCregaddr, &creg_val)) {
1764 spin_unlock_irq(&phba->hbalock);
1767 creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
1768 writel(creg_val, phba->HCregaddr);
1769 readl(phba->HCregaddr); /* flush */
1772 phba->cfg_poll = val;
1774 spin_unlock_irq(&phba->hbalock);
1780 * lpfc_fips_level_show - Return the current FIPS level for the HBA
1781 * @dev: class unused variable.
1782 * @attr: device attribute, not used.
1783 * @buf: on return contains the module description text.
1785 * Returns: size of formatted string.
1788 lpfc_fips_level_show(struct device *dev, struct device_attribute *attr,
1791 struct Scsi_Host *shost = class_to_shost(dev);
1792 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1793 struct lpfc_hba *phba = vport->phba;
1795 return snprintf(buf, PAGE_SIZE, "%d\n", phba->fips_level);
1799 * lpfc_fips_rev_show - Return the FIPS Spec revision for the HBA
1800 * @dev: class unused variable.
1801 * @attr: device attribute, not used.
1802 * @buf: on return contains the module description text.
1804 * Returns: size of formatted string.
1807 lpfc_fips_rev_show(struct device *dev, struct device_attribute *attr,
1810 struct Scsi_Host *shost = class_to_shost(dev);
1811 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1812 struct lpfc_hba *phba = vport->phba;
1814 return snprintf(buf, PAGE_SIZE, "%d\n", phba->fips_spec_rev);
1818 * lpfc_dss_show - Return the current state of dss and the configured state
1819 * @dev: class converted to a Scsi_host structure.
1820 * @attr: device attribute, not used.
1821 * @buf: on return contains the formatted text.
1823 * Returns: size of formatted string.
1826 lpfc_dss_show(struct device *dev, struct device_attribute *attr,
1829 struct Scsi_Host *shost = class_to_shost(dev);
1830 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1831 struct lpfc_hba *phba = vport->phba;
1833 return snprintf(buf, PAGE_SIZE, "%s - %sOperational\n",
1834 (phba->cfg_enable_dss) ? "Enabled" : "Disabled",
1835 (phba->sli3_options & LPFC_SLI3_DSS_ENABLED) ?
1840 * lpfc_sriov_hw_max_virtfn_show - Return maximum number of virtual functions
1841 * @dev: class converted to a Scsi_host structure.
1842 * @attr: device attribute, not used.
1843 * @buf: on return contains the formatted support level.
1846 * Returns the maximum number of virtual functions a physical function can
1847 * support, 0 will be returned if called on virtual function.
1849 * Returns: size of formatted string.
1852 lpfc_sriov_hw_max_virtfn_show(struct device *dev,
1853 struct device_attribute *attr,
1856 struct Scsi_Host *shost = class_to_shost(dev);
1857 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1858 struct lpfc_hba *phba = vport->phba;
1859 uint16_t max_nr_virtfn;
1861 max_nr_virtfn = lpfc_sli_sriov_nr_virtfn_get(phba);
1862 return snprintf(buf, PAGE_SIZE, "%d\n", max_nr_virtfn);
1865 static inline bool lpfc_rangecheck(uint val, uint min, uint max)
1867 return val >= min && val <= max;
1871 * lpfc_param_show - Return a cfg attribute value in decimal
1874 * Macro that given an attr e.g. hba_queue_depth expands
1875 * into a function with the name lpfc_hba_queue_depth_show.
1877 * lpfc_##attr##_show: Return the decimal value of an adapters cfg_xxx field.
1878 * @dev: class device that is converted into a Scsi_host.
1879 * @attr: device attribute, not used.
1880 * @buf: on return contains the attribute value in decimal.
1882 * Returns: size of formatted string.
1884 #define lpfc_param_show(attr) \
1886 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
1889 struct Scsi_Host *shost = class_to_shost(dev);\
1890 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1891 struct lpfc_hba *phba = vport->phba;\
1892 return snprintf(buf, PAGE_SIZE, "%d\n",\
1897 * lpfc_param_hex_show - Return a cfg attribute value in hex
1900 * Macro that given an attr e.g. hba_queue_depth expands
1901 * into a function with the name lpfc_hba_queue_depth_show
1903 * lpfc_##attr##_show: Return the hex value of an adapters cfg_xxx field.
1904 * @dev: class device that is converted into a Scsi_host.
1905 * @attr: device attribute, not used.
1906 * @buf: on return contains the attribute value in hexadecimal.
1908 * Returns: size of formatted string.
1910 #define lpfc_param_hex_show(attr) \
1912 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
1915 struct Scsi_Host *shost = class_to_shost(dev);\
1916 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1917 struct lpfc_hba *phba = vport->phba;\
1919 val = phba->cfg_##attr;\
1920 return snprintf(buf, PAGE_SIZE, "%#x\n",\
1925 * lpfc_param_init - Initializes a cfg attribute
1928 * Macro that given an attr e.g. hba_queue_depth expands
1929 * into a function with the name lpfc_hba_queue_depth_init. The macro also
1930 * takes a default argument, a minimum and maximum argument.
1932 * lpfc_##attr##_init: Initializes an attribute.
1933 * @phba: pointer the the adapter structure.
1934 * @val: integer attribute value.
1936 * Validates the min and max values then sets the adapter config field
1937 * accordingly, or uses the default if out of range and prints an error message.
1941 * -EINVAL if default used
1943 #define lpfc_param_init(attr, default, minval, maxval) \
1945 lpfc_##attr##_init(struct lpfc_hba *phba, uint val) \
1947 if (lpfc_rangecheck(val, minval, maxval)) {\
1948 phba->cfg_##attr = val;\
1951 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
1952 "0449 lpfc_"#attr" attribute cannot be set to %d, "\
1953 "allowed range is ["#minval", "#maxval"]\n", val); \
1954 phba->cfg_##attr = default;\
1959 * lpfc_param_set - Set a cfg attribute value
1962 * Macro that given an attr e.g. hba_queue_depth expands
1963 * into a function with the name lpfc_hba_queue_depth_set
1965 * lpfc_##attr##_set: Sets an attribute value.
1966 * @phba: pointer the the adapter structure.
1967 * @val: integer attribute value.
1970 * Validates the min and max values then sets the
1971 * adapter config field if in the valid range. prints error message
1972 * and does not set the parameter if invalid.
1976 * -EINVAL if val is invalid
1978 #define lpfc_param_set(attr, default, minval, maxval) \
1980 lpfc_##attr##_set(struct lpfc_hba *phba, uint val) \
1982 if (lpfc_rangecheck(val, minval, maxval)) {\
1983 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
1984 "3052 lpfc_" #attr " changed from %d to %d\n", \
1985 phba->cfg_##attr, val); \
1986 phba->cfg_##attr = val;\
1989 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
1990 "0450 lpfc_"#attr" attribute cannot be set to %d, "\
1991 "allowed range is ["#minval", "#maxval"]\n", val); \
1996 * lpfc_param_store - Set a vport attribute value
1999 * Macro that given an attr e.g. hba_queue_depth expands
2000 * into a function with the name lpfc_hba_queue_depth_store.
2002 * lpfc_##attr##_store: Set an sttribute value.
2003 * @dev: class device that is converted into a Scsi_host.
2004 * @attr: device attribute, not used.
2005 * @buf: contains the attribute value in ascii.
2009 * Convert the ascii text number to an integer, then
2010 * use the lpfc_##attr##_set function to set the value.
2013 * -EINVAL if val is invalid or lpfc_##attr##_set() fails
2014 * length of buffer upon success.
2016 #define lpfc_param_store(attr) \
2018 lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
2019 const char *buf, size_t count) \
2021 struct Scsi_Host *shost = class_to_shost(dev);\
2022 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
2023 struct lpfc_hba *phba = vport->phba;\
2025 if (!isdigit(buf[0]))\
2027 if (sscanf(buf, "%i", &val) != 1)\
2029 if (lpfc_##attr##_set(phba, val) == 0) \
2030 return strlen(buf);\
2036 * lpfc_vport_param_show - Return decimal formatted cfg attribute value
2039 * Macro that given an attr e.g. hba_queue_depth expands
2040 * into a function with the name lpfc_hba_queue_depth_show
2042 * lpfc_##attr##_show: prints the attribute value in decimal.
2043 * @dev: class device that is converted into a Scsi_host.
2044 * @attr: device attribute, not used.
2045 * @buf: on return contains the attribute value in decimal.
2047 * Returns: length of formatted string.
2049 #define lpfc_vport_param_show(attr) \
2051 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
2054 struct Scsi_Host *shost = class_to_shost(dev);\
2055 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
2056 return snprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_##attr);\
2060 * lpfc_vport_param_hex_show - Return hex formatted attribute value
2063 * Macro that given an attr e.g.
2064 * hba_queue_depth expands into a function with the name
2065 * lpfc_hba_queue_depth_show
2067 * lpfc_##attr##_show: prints the attribute value in hexadecimal.
2068 * @dev: class device that is converted into a Scsi_host.
2069 * @attr: device attribute, not used.
2070 * @buf: on return contains the attribute value in hexadecimal.
2072 * Returns: length of formatted string.
2074 #define lpfc_vport_param_hex_show(attr) \
2076 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
2079 struct Scsi_Host *shost = class_to_shost(dev);\
2080 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
2081 return snprintf(buf, PAGE_SIZE, "%#x\n", vport->cfg_##attr);\
2085 * lpfc_vport_param_init - Initialize a vport cfg attribute
2088 * Macro that given an attr e.g. hba_queue_depth expands
2089 * into a function with the name lpfc_hba_queue_depth_init. The macro also
2090 * takes a default argument, a minimum and maximum argument.
2092 * lpfc_##attr##_init: validates the min and max values then sets the
2093 * adapter config field accordingly, or uses the default if out of range
2094 * and prints an error message.
2095 * @phba: pointer the the adapter structure.
2096 * @val: integer attribute value.
2100 * -EINVAL if default used
2102 #define lpfc_vport_param_init(attr, default, minval, maxval) \
2104 lpfc_##attr##_init(struct lpfc_vport *vport, uint val) \
2106 if (lpfc_rangecheck(val, minval, maxval)) {\
2107 vport->cfg_##attr = val;\
2110 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
2111 "0423 lpfc_"#attr" attribute cannot be set to %d, "\
2112 "allowed range is ["#minval", "#maxval"]\n", val); \
2113 vport->cfg_##attr = default;\
2118 * lpfc_vport_param_set - Set a vport cfg attribute
2121 * Macro that given an attr e.g. hba_queue_depth expands
2122 * into a function with the name lpfc_hba_queue_depth_set
2124 * lpfc_##attr##_set: validates the min and max values then sets the
2125 * adapter config field if in the valid range. prints error message
2126 * and does not set the parameter if invalid.
2127 * @phba: pointer the the adapter structure.
2128 * @val: integer attribute value.
2132 * -EINVAL if val is invalid
2134 #define lpfc_vport_param_set(attr, default, minval, maxval) \
2136 lpfc_##attr##_set(struct lpfc_vport *vport, uint val) \
2138 if (lpfc_rangecheck(val, minval, maxval)) {\
2139 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
2140 "3053 lpfc_" #attr \
2141 " changed from %d (x%x) to %d (x%x)\n", \
2142 vport->cfg_##attr, vport->cfg_##attr, \
2144 vport->cfg_##attr = val;\
2147 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
2148 "0424 lpfc_"#attr" attribute cannot be set to %d, "\
2149 "allowed range is ["#minval", "#maxval"]\n", val); \
2154 * lpfc_vport_param_store - Set a vport attribute
2157 * Macro that given an attr e.g. hba_queue_depth
2158 * expands into a function with the name lpfc_hba_queue_depth_store
2160 * lpfc_##attr##_store: convert the ascii text number to an integer, then
2161 * use the lpfc_##attr##_set function to set the value.
2162 * @cdev: class device that is converted into a Scsi_host.
2163 * @buf: contains the attribute value in decimal.
2167 * -EINVAL if val is invalid or lpfc_##attr##_set() fails
2168 * length of buffer upon success.
2170 #define lpfc_vport_param_store(attr) \
2172 lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
2173 const char *buf, size_t count) \
2175 struct Scsi_Host *shost = class_to_shost(dev);\
2176 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
2178 if (!isdigit(buf[0]))\
2180 if (sscanf(buf, "%i", &val) != 1)\
2182 if (lpfc_##attr##_set(vport, val) == 0) \
2183 return strlen(buf);\
2189 static DEVICE_ATTR(nvme_info, 0444, lpfc_nvme_info_show, NULL);
2190 static DEVICE_ATTR(bg_info, S_IRUGO, lpfc_bg_info_show, NULL);
2191 static DEVICE_ATTR(bg_guard_err, S_IRUGO, lpfc_bg_guard_err_show, NULL);
2192 static DEVICE_ATTR(bg_apptag_err, S_IRUGO, lpfc_bg_apptag_err_show, NULL);
2193 static DEVICE_ATTR(bg_reftag_err, S_IRUGO, lpfc_bg_reftag_err_show, NULL);
2194 static DEVICE_ATTR(info, S_IRUGO, lpfc_info_show, NULL);
2195 static DEVICE_ATTR(serialnum, S_IRUGO, lpfc_serialnum_show, NULL);
2196 static DEVICE_ATTR(modeldesc, S_IRUGO, lpfc_modeldesc_show, NULL);
2197 static DEVICE_ATTR(modelname, S_IRUGO, lpfc_modelname_show, NULL);
2198 static DEVICE_ATTR(programtype, S_IRUGO, lpfc_programtype_show, NULL);
2199 static DEVICE_ATTR(portnum, S_IRUGO, lpfc_vportnum_show, NULL);
2200 static DEVICE_ATTR(fwrev, S_IRUGO, lpfc_fwrev_show, NULL);
2201 static DEVICE_ATTR(hdw, S_IRUGO, lpfc_hdw_show, NULL);
2202 static DEVICE_ATTR(link_state, S_IRUGO | S_IWUSR, lpfc_link_state_show,
2203 lpfc_link_state_store);
2204 static DEVICE_ATTR(option_rom_version, S_IRUGO,
2205 lpfc_option_rom_version_show, NULL);
2206 static DEVICE_ATTR(num_discovered_ports, S_IRUGO,
2207 lpfc_num_discovered_ports_show, NULL);
2208 static DEVICE_ATTR(menlo_mgmt_mode, S_IRUGO, lpfc_mlomgmt_show, NULL);
2209 static DEVICE_ATTR(nport_evt_cnt, S_IRUGO, lpfc_nport_evt_cnt_show, NULL);
2210 static DEVICE_ATTR(lpfc_drvr_version, S_IRUGO, lpfc_drvr_version_show, NULL);
2211 static DEVICE_ATTR(lpfc_enable_fip, S_IRUGO, lpfc_enable_fip_show, NULL);
2212 static DEVICE_ATTR(board_mode, S_IRUGO | S_IWUSR,
2213 lpfc_board_mode_show, lpfc_board_mode_store);
2214 static DEVICE_ATTR(issue_reset, S_IWUSR, NULL, lpfc_issue_reset);
2215 static DEVICE_ATTR(max_vpi, S_IRUGO, lpfc_max_vpi_show, NULL);
2216 static DEVICE_ATTR(used_vpi, S_IRUGO, lpfc_used_vpi_show, NULL);
2217 static DEVICE_ATTR(max_rpi, S_IRUGO, lpfc_max_rpi_show, NULL);
2218 static DEVICE_ATTR(used_rpi, S_IRUGO, lpfc_used_rpi_show, NULL);
2219 static DEVICE_ATTR(max_xri, S_IRUGO, lpfc_max_xri_show, NULL);
2220 static DEVICE_ATTR(used_xri, S_IRUGO, lpfc_used_xri_show, NULL);
2221 static DEVICE_ATTR(npiv_info, S_IRUGO, lpfc_npiv_info_show, NULL);
2222 static DEVICE_ATTR(lpfc_temp_sensor, S_IRUGO, lpfc_temp_sensor_show, NULL);
2223 static DEVICE_ATTR(lpfc_fips_level, S_IRUGO, lpfc_fips_level_show, NULL);
2224 static DEVICE_ATTR(lpfc_fips_rev, S_IRUGO, lpfc_fips_rev_show, NULL);
2225 static DEVICE_ATTR(lpfc_dss, S_IRUGO, lpfc_dss_show, NULL);
2226 static DEVICE_ATTR(lpfc_sriov_hw_max_virtfn, S_IRUGO,
2227 lpfc_sriov_hw_max_virtfn_show, NULL);
2228 static DEVICE_ATTR(protocol, S_IRUGO, lpfc_sli4_protocol_show, NULL);
2229 static DEVICE_ATTR(lpfc_xlane_supported, S_IRUGO, lpfc_oas_supported_show,
2232 static char *lpfc_soft_wwn_key = "C99G71SL8032A";
2235 * lpfc_wwn_set - Convert string to the 8 byte WWN value.
2237 * @cnt: Length of string.
2238 * @wwn: Array to receive converted wwn value.
2241 * -EINVAL if the buffer does not contain a valid wwn
2245 lpfc_wwn_set(const char *buf, size_t cnt, char wwn[])
2249 /* Count may include a LF at end of string */
2250 if (buf[cnt-1] == '\n')
2253 if ((cnt < 16) || (cnt > 18) || ((cnt == 17) && (*buf++ != 'x')) ||
2254 ((cnt == 18) && ((*buf++ != '0') || (*buf++ != 'x'))))
2257 memset(wwn, 0, WWN_SZ);
2259 /* Validate and store the new name */
2260 for (i = 0, j = 0; i < 16; i++) {
2261 if ((*buf >= 'a') && (*buf <= 'f'))
2262 j = ((j << 4) | ((*buf++ - 'a') + 10));
2263 else if ((*buf >= 'A') && (*buf <= 'F'))
2264 j = ((j << 4) | ((*buf++ - 'A') + 10));
2265 else if ((*buf >= '0') && (*buf <= '9'))
2266 j = ((j << 4) | (*buf++ - '0'));
2270 wwn[i/2] = j & 0xff;
2277 * lpfc_soft_wwn_enable_store - Allows setting of the wwn if the key is valid
2278 * @dev: class device that is converted into a Scsi_host.
2279 * @attr: device attribute, not used.
2280 * @buf: containing the string lpfc_soft_wwn_key.
2281 * @count: must be size of lpfc_soft_wwn_key.
2284 * -EINVAL if the buffer does not contain lpfc_soft_wwn_key
2285 * length of buf indicates success
2288 lpfc_soft_wwn_enable_store(struct device *dev, struct device_attribute *attr,
2289 const char *buf, size_t count)
2291 struct Scsi_Host *shost = class_to_shost(dev);
2292 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2293 struct lpfc_hba *phba = vport->phba;
2294 unsigned int cnt = count;
2295 uint8_t vvvl = vport->fc_sparam.cmn.valid_vendor_ver_level;
2296 u32 *fawwpn_key = (uint32_t *)&vport->fc_sparam.un.vendorVersion[0];
2299 * We're doing a simple sanity check for soft_wwpn setting.
2300 * We require that the user write a specific key to enable
2301 * the soft_wwpn attribute to be settable. Once the attribute
2302 * is written, the enable key resets. If further updates are
2303 * desired, the key must be written again to re-enable the
2306 * The "key" is not secret - it is a hardcoded string shown
2307 * here. The intent is to protect against the random user or
2308 * application that is just writing attributes.
2310 if (vvvl == 1 && cpu_to_be32(*fawwpn_key) == FAPWWN_KEY_VENDOR) {
2311 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2312 "0051 "LPFC_DRIVER_NAME" soft wwpn can not"
2313 " be enabled: fawwpn is enabled\n");
2317 /* count may include a LF at end of string */
2318 if (buf[cnt-1] == '\n')
2321 if ((cnt != strlen(lpfc_soft_wwn_key)) ||
2322 (strncmp(buf, lpfc_soft_wwn_key, strlen(lpfc_soft_wwn_key)) != 0))
2325 phba->soft_wwn_enable = 1;
2327 dev_printk(KERN_WARNING, &phba->pcidev->dev,
2328 "lpfc%d: soft_wwpn assignment has been enabled.\n",
2330 dev_printk(KERN_WARNING, &phba->pcidev->dev,
2331 " The soft_wwpn feature is not supported by Broadcom.");
2335 static DEVICE_ATTR(lpfc_soft_wwn_enable, S_IWUSR, NULL,
2336 lpfc_soft_wwn_enable_store);
2339 * lpfc_soft_wwpn_show - Return the cfg soft ww port name of the adapter
2340 * @dev: class device that is converted into a Scsi_host.
2341 * @attr: device attribute, not used.
2342 * @buf: on return contains the wwpn in hexadecimal.
2344 * Returns: size of formatted string.
2347 lpfc_soft_wwpn_show(struct device *dev, struct device_attribute *attr,
2350 struct Scsi_Host *shost = class_to_shost(dev);
2351 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2352 struct lpfc_hba *phba = vport->phba;
2354 return snprintf(buf, PAGE_SIZE, "0x%llx\n",
2355 (unsigned long long)phba->cfg_soft_wwpn);
2359 * lpfc_soft_wwpn_store - Set the ww port name of the adapter
2360 * @dev class device that is converted into a Scsi_host.
2361 * @attr: device attribute, not used.
2362 * @buf: contains the wwpn in hexadecimal.
2363 * @count: number of wwpn bytes in buf
2366 * -EACCES hba reset not enabled, adapter over temp
2367 * -EINVAL soft wwn not enabled, count is invalid, invalid wwpn byte invalid
2368 * -EIO error taking adapter offline or online
2369 * value of count on success
2372 lpfc_soft_wwpn_store(struct device *dev, struct device_attribute *attr,
2373 const char *buf, size_t count)
2375 struct Scsi_Host *shost = class_to_shost(dev);
2376 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2377 struct lpfc_hba *phba = vport->phba;
2378 struct completion online_compl;
2379 int stat1 = 0, stat2 = 0;
2380 unsigned int cnt = count;
2384 if (!phba->cfg_enable_hba_reset)
2386 spin_lock_irq(&phba->hbalock);
2387 if (phba->over_temp_state == HBA_OVER_TEMP) {
2388 spin_unlock_irq(&phba->hbalock);
2391 spin_unlock_irq(&phba->hbalock);
2392 /* count may include a LF at end of string */
2393 if (buf[cnt-1] == '\n')
2396 if (!phba->soft_wwn_enable)
2399 /* lock setting wwpn, wwnn down */
2400 phba->soft_wwn_enable = 0;
2402 rc = lpfc_wwn_set(buf, cnt, wwpn);
2404 /* not able to set wwpn, unlock it */
2405 phba->soft_wwn_enable = 1;
2409 phba->cfg_soft_wwpn = wwn_to_u64(wwpn);
2410 fc_host_port_name(shost) = phba->cfg_soft_wwpn;
2411 if (phba->cfg_soft_wwnn)
2412 fc_host_node_name(shost) = phba->cfg_soft_wwnn;
2414 dev_printk(KERN_NOTICE, &phba->pcidev->dev,
2415 "lpfc%d: Reinitializing to use soft_wwpn\n", phba->brd_no);
2417 stat1 = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
2419 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2420 "0463 lpfc_soft_wwpn attribute set failed to "
2421 "reinit adapter - %d\n", stat1);
2422 init_completion(&online_compl);
2423 rc = lpfc_workq_post_event(phba, &stat2, &online_compl,
2428 wait_for_completion(&online_compl);
2430 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2431 "0464 lpfc_soft_wwpn attribute set failed to "
2432 "reinit adapter - %d\n", stat2);
2433 return (stat1 || stat2) ? -EIO : count;
2435 static DEVICE_ATTR(lpfc_soft_wwpn, S_IRUGO | S_IWUSR,
2436 lpfc_soft_wwpn_show, lpfc_soft_wwpn_store);
2439 * lpfc_soft_wwnn_show - Return the cfg soft ww node name for the adapter
2440 * @dev: class device that is converted into a Scsi_host.
2441 * @attr: device attribute, not used.
2442 * @buf: on return contains the wwnn in hexadecimal.
2444 * Returns: size of formatted string.
2447 lpfc_soft_wwnn_show(struct device *dev, struct device_attribute *attr,
2450 struct Scsi_Host *shost = class_to_shost(dev);
2451 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2452 return snprintf(buf, PAGE_SIZE, "0x%llx\n",
2453 (unsigned long long)phba->cfg_soft_wwnn);
2457 * lpfc_soft_wwnn_store - sets the ww node name of the adapter
2458 * @cdev: class device that is converted into a Scsi_host.
2459 * @buf: contains the ww node name in hexadecimal.
2460 * @count: number of wwnn bytes in buf.
2463 * -EINVAL soft wwn not enabled, count is invalid, invalid wwnn byte invalid
2464 * value of count on success
2467 lpfc_soft_wwnn_store(struct device *dev, struct device_attribute *attr,
2468 const char *buf, size_t count)
2470 struct Scsi_Host *shost = class_to_shost(dev);
2471 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2472 unsigned int cnt = count;
2476 /* count may include a LF at end of string */
2477 if (buf[cnt-1] == '\n')
2480 if (!phba->soft_wwn_enable)
2483 rc = lpfc_wwn_set(buf, cnt, wwnn);
2485 /* Allow wwnn to be set many times, as long as the enable
2486 * is set. However, once the wwpn is set, everything locks.
2491 phba->cfg_soft_wwnn = wwn_to_u64(wwnn);
2493 dev_printk(KERN_NOTICE, &phba->pcidev->dev,
2494 "lpfc%d: soft_wwnn set. Value will take effect upon "
2495 "setting of the soft_wwpn\n", phba->brd_no);
2499 static DEVICE_ATTR(lpfc_soft_wwnn, S_IRUGO | S_IWUSR,
2500 lpfc_soft_wwnn_show, lpfc_soft_wwnn_store);
2503 * lpfc_oas_tgt_show - Return wwpn of target whose luns maybe enabled for
2504 * Optimized Access Storage (OAS) operations.
2505 * @dev: class device that is converted into a Scsi_host.
2506 * @attr: device attribute, not used.
2507 * @buf: buffer for passing information.
2513 lpfc_oas_tgt_show(struct device *dev, struct device_attribute *attr,
2516 struct Scsi_Host *shost = class_to_shost(dev);
2517 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2519 return snprintf(buf, PAGE_SIZE, "0x%llx\n",
2520 wwn_to_u64(phba->cfg_oas_tgt_wwpn));
2524 * lpfc_oas_tgt_store - Store wwpn of target whose luns maybe enabled for
2525 * Optimized Access Storage (OAS) operations.
2526 * @dev: class device that is converted into a Scsi_host.
2527 * @attr: device attribute, not used.
2528 * @buf: buffer for passing information.
2529 * @count: Size of the data buffer.
2532 * -EINVAL count is invalid, invalid wwpn byte invalid
2533 * -EPERM oas is not supported by hba
2534 * value of count on success
2537 lpfc_oas_tgt_store(struct device *dev, struct device_attribute *attr,
2538 const char *buf, size_t count)
2540 struct Scsi_Host *shost = class_to_shost(dev);
2541 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2542 unsigned int cnt = count;
2543 uint8_t wwpn[WWN_SZ];
2549 /* count may include a LF at end of string */
2550 if (buf[cnt-1] == '\n')
2553 rc = lpfc_wwn_set(buf, cnt, wwpn);
2557 memcpy(phba->cfg_oas_tgt_wwpn, wwpn, (8 * sizeof(uint8_t)));
2558 memcpy(phba->sli4_hba.oas_next_tgt_wwpn, wwpn, (8 * sizeof(uint8_t)));
2559 if (wwn_to_u64(wwpn) == 0)
2560 phba->cfg_oas_flags |= OAS_FIND_ANY_TARGET;
2562 phba->cfg_oas_flags &= ~OAS_FIND_ANY_TARGET;
2563 phba->cfg_oas_flags &= ~OAS_LUN_VALID;
2564 phba->sli4_hba.oas_next_lun = FIND_FIRST_OAS_LUN;
2567 static DEVICE_ATTR(lpfc_xlane_tgt, S_IRUGO | S_IWUSR,
2568 lpfc_oas_tgt_show, lpfc_oas_tgt_store);
2571 * lpfc_oas_priority_show - Return wwpn of target whose luns maybe enabled for
2572 * Optimized Access Storage (OAS) operations.
2573 * @dev: class device that is converted into a Scsi_host.
2574 * @attr: device attribute, not used.
2575 * @buf: buffer for passing information.
2581 lpfc_oas_priority_show(struct device *dev, struct device_attribute *attr,
2584 struct Scsi_Host *shost = class_to_shost(dev);
2585 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2587 return snprintf(buf, PAGE_SIZE, "%d\n", phba->cfg_oas_priority);
2591 * lpfc_oas_priority_store - Store wwpn of target whose luns maybe enabled for
2592 * Optimized Access Storage (OAS) operations.
2593 * @dev: class device that is converted into a Scsi_host.
2594 * @attr: device attribute, not used.
2595 * @buf: buffer for passing information.
2596 * @count: Size of the data buffer.
2599 * -EINVAL count is invalid, invalid wwpn byte invalid
2600 * -EPERM oas is not supported by hba
2601 * value of count on success
2604 lpfc_oas_priority_store(struct device *dev, struct device_attribute *attr,
2605 const char *buf, size_t count)
2607 struct Scsi_Host *shost = class_to_shost(dev);
2608 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2609 unsigned int cnt = count;
2616 /* count may include a LF at end of string */
2617 if (buf[cnt-1] == '\n')
2620 ret = kstrtoul(buf, 0, &val);
2621 if (ret || (val > 0x7f))
2625 phba->cfg_oas_priority = (uint8_t)val;
2627 phba->cfg_oas_priority = phba->cfg_XLanePriority;
2630 static DEVICE_ATTR(lpfc_xlane_priority, S_IRUGO | S_IWUSR,
2631 lpfc_oas_priority_show, lpfc_oas_priority_store);
2634 * lpfc_oas_vpt_show - Return wwpn of vport whose targets maybe enabled
2635 * for Optimized Access Storage (OAS) operations.
2636 * @dev: class device that is converted into a Scsi_host.
2637 * @attr: device attribute, not used.
2638 * @buf: buffer for passing information.
2641 * value of count on success
2644 lpfc_oas_vpt_show(struct device *dev, struct device_attribute *attr,
2647 struct Scsi_Host *shost = class_to_shost(dev);
2648 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2650 return snprintf(buf, PAGE_SIZE, "0x%llx\n",
2651 wwn_to_u64(phba->cfg_oas_vpt_wwpn));
2655 * lpfc_oas_vpt_store - Store wwpn of vport whose targets maybe enabled
2656 * for Optimized Access Storage (OAS) operations.
2657 * @dev: class device that is converted into a Scsi_host.
2658 * @attr: device attribute, not used.
2659 * @buf: buffer for passing information.
2660 * @count: Size of the data buffer.
2663 * -EINVAL count is invalid, invalid wwpn byte invalid
2664 * -EPERM oas is not supported by hba
2665 * value of count on success
2668 lpfc_oas_vpt_store(struct device *dev, struct device_attribute *attr,
2669 const char *buf, size_t count)
2671 struct Scsi_Host *shost = class_to_shost(dev);
2672 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2673 unsigned int cnt = count;
2674 uint8_t wwpn[WWN_SZ];
2680 /* count may include a LF at end of string */
2681 if (buf[cnt-1] == '\n')
2684 rc = lpfc_wwn_set(buf, cnt, wwpn);
2688 memcpy(phba->cfg_oas_vpt_wwpn, wwpn, (8 * sizeof(uint8_t)));
2689 memcpy(phba->sli4_hba.oas_next_vpt_wwpn, wwpn, (8 * sizeof(uint8_t)));
2690 if (wwn_to_u64(wwpn) == 0)
2691 phba->cfg_oas_flags |= OAS_FIND_ANY_VPORT;
2693 phba->cfg_oas_flags &= ~OAS_FIND_ANY_VPORT;
2694 phba->cfg_oas_flags &= ~OAS_LUN_VALID;
2695 if (phba->cfg_oas_priority == 0)
2696 phba->cfg_oas_priority = phba->cfg_XLanePriority;
2697 phba->sli4_hba.oas_next_lun = FIND_FIRST_OAS_LUN;
2700 static DEVICE_ATTR(lpfc_xlane_vpt, S_IRUGO | S_IWUSR,
2701 lpfc_oas_vpt_show, lpfc_oas_vpt_store);
2704 * lpfc_oas_lun_state_show - Return the current state (enabled or disabled)
2705 * of whether luns will be enabled or disabled
2706 * for Optimized Access Storage (OAS) operations.
2707 * @dev: class device that is converted into a Scsi_host.
2708 * @attr: device attribute, not used.
2709 * @buf: buffer for passing information.
2712 * size of formatted string.
2715 lpfc_oas_lun_state_show(struct device *dev, struct device_attribute *attr,
2718 struct Scsi_Host *shost = class_to_shost(dev);
2719 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2721 return snprintf(buf, PAGE_SIZE, "%d\n", phba->cfg_oas_lun_state);
2725 * lpfc_oas_lun_state_store - Store the state (enabled or disabled)
2726 * of whether luns will be enabled or disabled
2727 * for Optimized Access Storage (OAS) operations.
2728 * @dev: class device that is converted into a Scsi_host.
2729 * @attr: device attribute, not used.
2730 * @buf: buffer for passing information.
2731 * @count: Size of the data buffer.
2734 * -EINVAL count is invalid, invalid wwpn byte invalid
2735 * -EPERM oas is not supported by hba
2736 * value of count on success
2739 lpfc_oas_lun_state_store(struct device *dev, struct device_attribute *attr,
2740 const char *buf, size_t count)
2742 struct Scsi_Host *shost = class_to_shost(dev);
2743 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2749 if (!isdigit(buf[0]))
2752 if (sscanf(buf, "%i", &val) != 1)
2755 if ((val != 0) && (val != 1))
2758 phba->cfg_oas_lun_state = val;
2761 static DEVICE_ATTR(lpfc_xlane_lun_state, S_IRUGO | S_IWUSR,
2762 lpfc_oas_lun_state_show, lpfc_oas_lun_state_store);
2765 * lpfc_oas_lun_status_show - Return the status of the Optimized Access
2766 * Storage (OAS) lun returned by the
2767 * lpfc_oas_lun_show function.
2768 * @dev: class device that is converted into a Scsi_host.
2769 * @attr: device attribute, not used.
2770 * @buf: buffer for passing information.
2773 * size of formatted string.
2776 lpfc_oas_lun_status_show(struct device *dev, struct device_attribute *attr,
2779 struct Scsi_Host *shost = class_to_shost(dev);
2780 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2782 if (!(phba->cfg_oas_flags & OAS_LUN_VALID))
2785 return snprintf(buf, PAGE_SIZE, "%d\n", phba->cfg_oas_lun_status);
2787 static DEVICE_ATTR(lpfc_xlane_lun_status, S_IRUGO,
2788 lpfc_oas_lun_status_show, NULL);
2792 * lpfc_oas_lun_state_set - enable or disable a lun for Optimized Access Storage
2794 * @phba: lpfc_hba pointer.
2795 * @ndlp: pointer to fcp target node.
2796 * @lun: the fc lun for setting oas state.
2797 * @oas_state: the oas state to be set to the lun.
2801 * -EPERM OAS is not enabled or not supported by this port.
2805 lpfc_oas_lun_state_set(struct lpfc_hba *phba, uint8_t vpt_wwpn[],
2806 uint8_t tgt_wwpn[], uint64_t lun,
2807 uint32_t oas_state, uint8_t pri)
2816 if (!lpfc_enable_oas_lun(phba, (struct lpfc_name *)vpt_wwpn,
2817 (struct lpfc_name *)tgt_wwpn,
2821 lpfc_disable_oas_lun(phba, (struct lpfc_name *)vpt_wwpn,
2822 (struct lpfc_name *)tgt_wwpn, lun, pri);
2829 * lpfc_oas_lun_get_next - get the next lun that has been enabled for Optimized
2830 * Access Storage (OAS) operations.
2831 * @phba: lpfc_hba pointer.
2832 * @vpt_wwpn: wwpn of the vport associated with the returned lun
2833 * @tgt_wwpn: wwpn of the target associated with the returned lun
2834 * @lun_status: status of the lun returned lun
2836 * Returns the first or next lun enabled for OAS operations for the vport/target
2837 * specified. If a lun is found, its vport wwpn, target wwpn and status is
2838 * returned. If the lun is not found, NOT_OAS_ENABLED_LUN is returned.
2841 * lun that is OAS enabled for the vport/target
2842 * NOT_OAS_ENABLED_LUN when no oas enabled lun found.
2845 lpfc_oas_lun_get_next(struct lpfc_hba *phba, uint8_t vpt_wwpn[],
2846 uint8_t tgt_wwpn[], uint32_t *lun_status,
2851 if (unlikely(!phba) || !vpt_wwpn || !tgt_wwpn)
2852 return NOT_OAS_ENABLED_LUN;
2853 if (lpfc_find_next_oas_lun(phba, (struct lpfc_name *)
2854 phba->sli4_hba.oas_next_vpt_wwpn,
2855 (struct lpfc_name *)
2856 phba->sli4_hba.oas_next_tgt_wwpn,
2857 &phba->sli4_hba.oas_next_lun,
2858 (struct lpfc_name *)vpt_wwpn,
2859 (struct lpfc_name *)tgt_wwpn,
2860 &found_lun, lun_status, lun_pri))
2863 return NOT_OAS_ENABLED_LUN;
2867 * lpfc_oas_lun_state_change - enable/disable a lun for OAS operations
2868 * @phba: lpfc_hba pointer.
2869 * @vpt_wwpn: vport wwpn by reference.
2870 * @tgt_wwpn: target wwpn by reference.
2871 * @lun: the fc lun for setting oas state.
2872 * @oas_state: the oas state to be set to the oas_lun.
2874 * This routine enables (OAS_LUN_ENABLE) or disables (OAS_LUN_DISABLE)
2875 * a lun for OAS operations.
2879 * -ENOMEM: failed to enable an lun for OAS operations
2880 * -EPERM: OAS is not enabled
2883 lpfc_oas_lun_state_change(struct lpfc_hba *phba, uint8_t vpt_wwpn[],
2884 uint8_t tgt_wwpn[], uint64_t lun,
2885 uint32_t oas_state, uint8_t pri)
2890 rc = lpfc_oas_lun_state_set(phba, vpt_wwpn, tgt_wwpn, lun,
2896 * lpfc_oas_lun_show - Return oas enabled luns from a chosen target
2897 * @dev: class device that is converted into a Scsi_host.
2898 * @attr: device attribute, not used.
2899 * @buf: buffer for passing information.
2901 * This routine returns a lun enabled for OAS each time the function
2905 * SUCCESS: size of formatted string.
2906 * -EFAULT: target or vport wwpn was not set properly.
2907 * -EPERM: oas is not enabled.
2910 lpfc_oas_lun_show(struct device *dev, struct device_attribute *attr,
2913 struct Scsi_Host *shost = class_to_shost(dev);
2914 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2922 if (wwn_to_u64(phba->cfg_oas_vpt_wwpn) == 0)
2923 if (!(phba->cfg_oas_flags & OAS_FIND_ANY_VPORT))
2926 if (wwn_to_u64(phba->cfg_oas_tgt_wwpn) == 0)
2927 if (!(phba->cfg_oas_flags & OAS_FIND_ANY_TARGET))
2930 oas_lun = lpfc_oas_lun_get_next(phba, phba->cfg_oas_vpt_wwpn,
2931 phba->cfg_oas_tgt_wwpn,
2932 &phba->cfg_oas_lun_status,
2933 &phba->cfg_oas_priority);
2934 if (oas_lun != NOT_OAS_ENABLED_LUN)
2935 phba->cfg_oas_flags |= OAS_LUN_VALID;
2937 len += snprintf(buf + len, PAGE_SIZE-len, "0x%llx", oas_lun);
2943 * lpfc_oas_lun_store - Sets the OAS state for lun
2944 * @dev: class device that is converted into a Scsi_host.
2945 * @attr: device attribute, not used.
2946 * @buf: buffer for passing information.
2948 * This function sets the OAS state for lun. Before this function is called,
2949 * the vport wwpn, target wwpn, and oas state need to be set.
2952 * SUCCESS: size of formatted string.
2953 * -EFAULT: target or vport wwpn was not set properly.
2954 * -EPERM: oas is not enabled.
2955 * size of formatted string.
2958 lpfc_oas_lun_store(struct device *dev, struct device_attribute *attr,
2959 const char *buf, size_t count)
2961 struct Scsi_Host *shost = class_to_shost(dev);
2962 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2970 if (wwn_to_u64(phba->cfg_oas_vpt_wwpn) == 0)
2973 if (wwn_to_u64(phba->cfg_oas_tgt_wwpn) == 0)
2976 if (!isdigit(buf[0]))
2979 if (sscanf(buf, "0x%llx", &scsi_lun) != 1)
2982 pri = phba->cfg_oas_priority;
2984 pri = phba->cfg_XLanePriority;
2986 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
2987 "3372 Try to set vport 0x%llx target 0x%llx lun:0x%llx "
2988 "priority 0x%x with oas state %d\n",
2989 wwn_to_u64(phba->cfg_oas_vpt_wwpn),
2990 wwn_to_u64(phba->cfg_oas_tgt_wwpn), scsi_lun,
2991 pri, phba->cfg_oas_lun_state);
2993 rc = lpfc_oas_lun_state_change(phba, phba->cfg_oas_vpt_wwpn,
2994 phba->cfg_oas_tgt_wwpn, scsi_lun,
2995 phba->cfg_oas_lun_state, pri);
3001 static DEVICE_ATTR(lpfc_xlane_lun, S_IRUGO | S_IWUSR,
3002 lpfc_oas_lun_show, lpfc_oas_lun_store);
3004 int lpfc_enable_nvmet_cnt;
3005 unsigned long long lpfc_enable_nvmet[LPFC_NVMET_MAX_PORTS] = {
3006 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
3007 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
3008 module_param_array(lpfc_enable_nvmet, ullong, &lpfc_enable_nvmet_cnt, 0444);
3009 MODULE_PARM_DESC(lpfc_enable_nvmet, "Enable HBA port(s) WWPN as a NVME Target");
3011 static int lpfc_poll = 0;
3012 module_param(lpfc_poll, int, S_IRUGO);
3013 MODULE_PARM_DESC(lpfc_poll, "FCP ring polling mode control:"
3015 " 1 - poll with interrupts enabled"
3016 " 3 - poll and disable FCP ring interrupts");
3018 static DEVICE_ATTR(lpfc_poll, S_IRUGO | S_IWUSR,
3019 lpfc_poll_show, lpfc_poll_store);
3021 int lpfc_no_hba_reset_cnt;
3022 unsigned long lpfc_no_hba_reset[MAX_HBAS_NO_RESET] = {
3023 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
3024 module_param_array(lpfc_no_hba_reset, ulong, &lpfc_no_hba_reset_cnt, 0444);
3025 MODULE_PARM_DESC(lpfc_no_hba_reset, "WWPN of HBAs that should not be reset");
3027 LPFC_ATTR(sli_mode, 0, 0, 3,
3028 "SLI mode selector:"
3029 " 0 - auto (SLI-3 if supported),"
3030 " 2 - select SLI-2 even on SLI-3 capable HBAs,"
3031 " 3 - select SLI-3");
3033 LPFC_ATTR_R(enable_npiv, 1, 0, 1,
3034 "Enable NPIV functionality");
3036 LPFC_ATTR_R(fcf_failover_policy, 1, 1, 2,
3037 "FCF Fast failover=1 Priority failover=2");
3040 # lpfc_enable_rrq: Track XRI/OXID reuse after IO failures
3041 # 0x0 = disabled, XRI/OXID use not tracked.
3042 # 0x1 = XRI/OXID reuse is timed with ratov, RRQ sent.
3043 # 0x2 = XRI/OXID reuse is timed with ratov, No RRQ sent.
3045 LPFC_ATTR_R(enable_rrq, 2, 0, 2,
3046 "Enable RRQ functionality");
3049 # lpfc_suppress_link_up: Bring link up at initialization
3050 # 0x0 = bring link up (issue MBX_INIT_LINK)
3051 # 0x1 = do NOT bring link up at initialization(MBX_INIT_LINK)
3052 # 0x2 = never bring up link
3053 # Default value is 0.
3055 LPFC_ATTR_R(suppress_link_up, LPFC_INITIALIZE_LINK, LPFC_INITIALIZE_LINK,
3056 LPFC_DELAY_INIT_LINK_INDEFINITELY,
3057 "Suppress Link Up at initialization");
3059 # lpfc_cnt: Number of IOCBs allocated for ELS, CT, and ABTS
3067 lpfc_iocb_hw_show(struct device *dev, struct device_attribute *attr, char *buf)
3069 struct Scsi_Host *shost = class_to_shost(dev);
3070 struct lpfc_hba *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
3072 return snprintf(buf, PAGE_SIZE, "%d\n", phba->iocb_max);
3075 static DEVICE_ATTR(iocb_hw, S_IRUGO,
3076 lpfc_iocb_hw_show, NULL);
3078 lpfc_txq_hw_show(struct device *dev, struct device_attribute *attr, char *buf)
3080 struct Scsi_Host *shost = class_to_shost(dev);
3081 struct lpfc_hba *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
3082 struct lpfc_sli_ring *pring = lpfc_phba_elsring(phba);
3084 return snprintf(buf, PAGE_SIZE, "%d\n", pring->txq_max);
3087 static DEVICE_ATTR(txq_hw, S_IRUGO,
3088 lpfc_txq_hw_show, NULL);
3090 lpfc_txcmplq_hw_show(struct device *dev, struct device_attribute *attr,
3093 struct Scsi_Host *shost = class_to_shost(dev);
3094 struct lpfc_hba *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
3095 struct lpfc_sli_ring *pring = lpfc_phba_elsring(phba);
3097 return snprintf(buf, PAGE_SIZE, "%d\n", pring->txcmplq_max);
3100 static DEVICE_ATTR(txcmplq_hw, S_IRUGO,
3101 lpfc_txcmplq_hw_show, NULL);
3103 LPFC_ATTR_R(iocb_cnt, 2, 1, 5,
3104 "Number of IOCBs alloc for ELS, CT, and ABTS: 1k to 5k IOCBs");
3107 # lpfc_nodev_tmo: If set, it will hold all I/O errors on devices that disappear
3108 # until the timer expires. Value range is [0,255]. Default value is 30.
3110 static int lpfc_nodev_tmo = LPFC_DEF_DEVLOSS_TMO;
3111 static int lpfc_devloss_tmo = LPFC_DEF_DEVLOSS_TMO;
3112 module_param(lpfc_nodev_tmo, int, 0);
3113 MODULE_PARM_DESC(lpfc_nodev_tmo,
3114 "Seconds driver will hold I/O waiting "
3115 "for a device to come back");
3118 * lpfc_nodev_tmo_show - Return the hba dev loss timeout value
3119 * @dev: class converted to a Scsi_host structure.
3120 * @attr: device attribute, not used.
3121 * @buf: on return contains the dev loss timeout in decimal.
3123 * Returns: size of formatted string.
3126 lpfc_nodev_tmo_show(struct device *dev, struct device_attribute *attr,
3129 struct Scsi_Host *shost = class_to_shost(dev);
3130 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
3132 return snprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_devloss_tmo);
3136 * lpfc_nodev_tmo_init - Set the hba nodev timeout value
3137 * @vport: lpfc vport structure pointer.
3138 * @val: contains the nodev timeout value.
3141 * If the devloss tmo is already set then nodev tmo is set to devloss tmo,
3142 * a kernel error message is printed and zero is returned.
3143 * Else if val is in range then nodev tmo and devloss tmo are set to val.
3144 * Otherwise nodev tmo is set to the default value.
3147 * zero if already set or if val is in range
3148 * -EINVAL val out of range
3151 lpfc_nodev_tmo_init(struct lpfc_vport *vport, int val)
3153 if (vport->cfg_devloss_tmo != LPFC_DEF_DEVLOSS_TMO) {
3154 vport->cfg_nodev_tmo = vport->cfg_devloss_tmo;
3155 if (val != LPFC_DEF_DEVLOSS_TMO)
3156 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3157 "0407 Ignoring lpfc_nodev_tmo module "
3158 "parameter because lpfc_devloss_tmo "
3163 if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
3164 vport->cfg_nodev_tmo = val;
3165 vport->cfg_devloss_tmo = val;
3168 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3169 "0400 lpfc_nodev_tmo attribute cannot be set to"
3170 " %d, allowed range is [%d, %d]\n",
3171 val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
3172 vport->cfg_nodev_tmo = LPFC_DEF_DEVLOSS_TMO;
3177 * lpfc_update_rport_devloss_tmo - Update dev loss tmo value
3178 * @vport: lpfc vport structure pointer.
3181 * Update all the ndlp's dev loss tmo with the vport devloss tmo value.
3184 lpfc_update_rport_devloss_tmo(struct lpfc_vport *vport)
3186 struct Scsi_Host *shost;
3187 struct lpfc_nodelist *ndlp;
3189 shost = lpfc_shost_from_vport(vport);
3190 spin_lock_irq(shost->host_lock);
3191 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp)
3192 if (NLP_CHK_NODE_ACT(ndlp) && ndlp->rport)
3193 ndlp->rport->dev_loss_tmo = vport->cfg_devloss_tmo;
3194 spin_unlock_irq(shost->host_lock);
3198 * lpfc_nodev_tmo_set - Set the vport nodev tmo and devloss tmo values
3199 * @vport: lpfc vport structure pointer.
3200 * @val: contains the tmo value.
3203 * If the devloss tmo is already set or the vport dev loss tmo has changed
3204 * then a kernel error message is printed and zero is returned.
3205 * Else if val is in range then nodev tmo and devloss tmo are set to val.
3206 * Otherwise nodev tmo is set to the default value.
3209 * zero if already set or if val is in range
3210 * -EINVAL val out of range
3213 lpfc_nodev_tmo_set(struct lpfc_vport *vport, int val)
3215 if (vport->dev_loss_tmo_changed ||
3216 (lpfc_devloss_tmo != LPFC_DEF_DEVLOSS_TMO)) {
3217 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3218 "0401 Ignoring change to lpfc_nodev_tmo "
3219 "because lpfc_devloss_tmo is set.\n");
3222 if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
3223 vport->cfg_nodev_tmo = val;
3224 vport->cfg_devloss_tmo = val;
3226 * For compat: set the fc_host dev loss so new rports
3227 * will get the value.
3229 fc_host_dev_loss_tmo(lpfc_shost_from_vport(vport)) = val;
3230 lpfc_update_rport_devloss_tmo(vport);
3233 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3234 "0403 lpfc_nodev_tmo attribute cannot be set to "
3235 "%d, allowed range is [%d, %d]\n",
3236 val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
3240 lpfc_vport_param_store(nodev_tmo)
3242 static DEVICE_ATTR(lpfc_nodev_tmo, S_IRUGO | S_IWUSR,
3243 lpfc_nodev_tmo_show, lpfc_nodev_tmo_store);
3246 # lpfc_devloss_tmo: If set, it will hold all I/O errors on devices that
3247 # disappear until the timer expires. Value range is [0,255]. Default
3250 module_param(lpfc_devloss_tmo, int, S_IRUGO);
3251 MODULE_PARM_DESC(lpfc_devloss_tmo,
3252 "Seconds driver will hold I/O waiting "
3253 "for a device to come back");
3254 lpfc_vport_param_init(devloss_tmo, LPFC_DEF_DEVLOSS_TMO,
3255 LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO)
3256 lpfc_vport_param_show(devloss_tmo)
3259 * lpfc_devloss_tmo_set - Sets vport nodev tmo, devloss tmo values, changed bit
3260 * @vport: lpfc vport structure pointer.
3261 * @val: contains the tmo value.
3264 * If val is in a valid range then set the vport nodev tmo,
3265 * devloss tmo, also set the vport dev loss tmo changed flag.
3266 * Else a kernel error message is printed.
3269 * zero if val is in range
3270 * -EINVAL val out of range
3273 lpfc_devloss_tmo_set(struct lpfc_vport *vport, int val)
3275 if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
3276 vport->cfg_nodev_tmo = val;
3277 vport->cfg_devloss_tmo = val;
3278 vport->dev_loss_tmo_changed = 1;
3279 fc_host_dev_loss_tmo(lpfc_shost_from_vport(vport)) = val;
3280 lpfc_update_rport_devloss_tmo(vport);
3284 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3285 "0404 lpfc_devloss_tmo attribute cannot be set to "
3286 "%d, allowed range is [%d, %d]\n",
3287 val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
3291 lpfc_vport_param_store(devloss_tmo)
3292 static DEVICE_ATTR(lpfc_devloss_tmo, S_IRUGO | S_IWUSR,
3293 lpfc_devloss_tmo_show, lpfc_devloss_tmo_store);
3296 * lpfc_suppress_rsp: Enable suppress rsp feature is firmware supports it
3297 * lpfc_suppress_rsp = 0 Disable
3298 * lpfc_suppress_rsp = 1 Enable (default)
3301 LPFC_ATTR_R(suppress_rsp, 1, 0, 1,
3302 "Enable suppress rsp feature is firmware supports it");
3305 * lpfc_nvmet_mrq: Specify number of RQ pairs for processing NVMET cmds
3306 * lpfc_nvmet_mrq = 1 use a single RQ pair
3307 * lpfc_nvmet_mrq >= 2 use specified RQ pairs for MRQ
3310 LPFC_ATTR_R(nvmet_mrq,
3312 "Specify number of RQ pairs for processing NVMET cmds");
3315 * lpfc_nvmet_mrq_post: Specify number buffers to post on every MRQ
3318 LPFC_ATTR_R(nvmet_mrq_post, LPFC_DEF_MRQ_POST,
3319 LPFC_MIN_MRQ_POST, LPFC_MAX_MRQ_POST,
3320 "Specify number of buffers to post on every MRQ");
3323 * lpfc_enable_fc4_type: Defines what FC4 types are supported.
3324 * Supported Values: 1 - register just FCP
3325 * 3 - register both FCP and NVME
3326 * Supported values are [1,3]. Default value is 1
3328 LPFC_ATTR_R(enable_fc4_type, LPFC_ENABLE_FCP,
3329 LPFC_ENABLE_FCP, LPFC_ENABLE_BOTH,
3330 "Define fc4 type to register with fabric.");
3333 * lpfc_xri_split: Defines the division of XRI resources between SCSI and NVME
3334 * This parameter is only used if:
3335 * lpfc_enable_fc4_type is 3 - register both FCP and NVME and
3336 * port is not configured for NVMET.
3338 * ELS/CT always get 10% of XRIs, up to a maximum of 250
3339 * The remaining XRIs get split up based on lpfc_xri_split per port:
3341 * Supported Values are in percentages
3342 * the xri_split value is the percentage the SCSI port will get. The remaining
3343 * percentage will go to NVME.
3345 LPFC_ATTR_R(xri_split, 50, 10, 90,
3346 "Division of XRI resources between SCSI and NVME");
3349 # lpfc_log_verbose: Only turn this flag on if you are willing to risk being
3350 # deluged with LOTS of information.
3351 # You can set a bit mask to record specific types of verbose messages:
3352 # See lpfc_logmsh.h for definitions.
3354 LPFC_VPORT_ATTR_HEX_RW(log_verbose, 0x0, 0x0, 0xffffffff,
3355 "Verbose logging bit-mask");
3358 # lpfc_enable_da_id: This turns on the DA_ID CT command that deregisters
3359 # objects that have been registered with the nameserver after login.
3361 LPFC_VPORT_ATTR_R(enable_da_id, 1, 0, 1,
3362 "Deregister nameserver objects before LOGO");
3365 # lun_queue_depth: This parameter is used to limit the number of outstanding
3366 # commands per FCP LUN. Value range is [1,512]. Default value is 30.
3367 # If this parameter value is greater than 1/8th the maximum number of exchanges
3368 # supported by the HBA port, then the lun queue depth will be reduced to
3369 # 1/8th the maximum number of exchanges.
3371 LPFC_VPORT_ATTR_R(lun_queue_depth, 30, 1, 512,
3372 "Max number of FCP commands we can queue to a specific LUN");
3375 # tgt_queue_depth: This parameter is used to limit the number of outstanding
3376 # commands per target port. Value range is [10,65535]. Default value is 65535.
3378 LPFC_VPORT_ATTR_R(tgt_queue_depth, 65535, 10, 65535,
3379 "Max number of FCP commands we can queue to a specific target port");
3382 # hba_queue_depth: This parameter is used to limit the number of outstanding
3383 # commands per lpfc HBA. Value range is [32,8192]. If this parameter
3384 # value is greater than the maximum number of exchanges supported by the HBA,
3385 # then maximum number of exchanges supported by the HBA is used to determine
3386 # the hba_queue_depth.
3388 LPFC_ATTR_R(hba_queue_depth, 8192, 32, 8192,
3389 "Max number of FCP commands we can queue to a lpfc HBA");
3392 # peer_port_login: This parameter allows/prevents logins
3393 # between peer ports hosted on the same physical port.
3394 # When this parameter is set 0 peer ports of same physical port
3395 # are not allowed to login to each other.
3396 # When this parameter is set 1 peer ports of same physical port
3397 # are allowed to login to each other.
3398 # Default value of this parameter is 0.
3400 LPFC_VPORT_ATTR_R(peer_port_login, 0, 0, 1,
3401 "Allow peer ports on the same physical port to login to each "
3405 # restrict_login: This parameter allows/prevents logins
3406 # between Virtual Ports and remote initiators.
3407 # When this parameter is not set (0) Virtual Ports will accept PLOGIs from
3408 # other initiators and will attempt to PLOGI all remote ports.
3409 # When this parameter is set (1) Virtual Ports will reject PLOGIs from
3410 # remote ports and will not attempt to PLOGI to other initiators.
3411 # This parameter does not restrict to the physical port.
3412 # This parameter does not restrict logins to Fabric resident remote ports.
3413 # Default value of this parameter is 1.
3415 static int lpfc_restrict_login = 1;
3416 module_param(lpfc_restrict_login, int, S_IRUGO);
3417 MODULE_PARM_DESC(lpfc_restrict_login,
3418 "Restrict virtual ports login to remote initiators.");
3419 lpfc_vport_param_show(restrict_login);
3422 * lpfc_restrict_login_init - Set the vport restrict login flag
3423 * @vport: lpfc vport structure pointer.
3424 * @val: contains the restrict login value.
3427 * If val is not in a valid range then log a kernel error message and set
3428 * the vport restrict login to one.
3429 * If the port type is physical clear the restrict login flag and return.
3430 * Else set the restrict login flag to val.
3433 * zero if val is in range
3434 * -EINVAL val out of range
3437 lpfc_restrict_login_init(struct lpfc_vport *vport, int val)
3439 if (val < 0 || val > 1) {
3440 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3441 "0422 lpfc_restrict_login attribute cannot "
3442 "be set to %d, allowed range is [0, 1]\n",
3444 vport->cfg_restrict_login = 1;
3447 if (vport->port_type == LPFC_PHYSICAL_PORT) {
3448 vport->cfg_restrict_login = 0;
3451 vport->cfg_restrict_login = val;
3456 * lpfc_restrict_login_set - Set the vport restrict login flag
3457 * @vport: lpfc vport structure pointer.
3458 * @val: contains the restrict login value.
3461 * If val is not in a valid range then log a kernel error message and set
3462 * the vport restrict login to one.
3463 * If the port type is physical and the val is not zero log a kernel
3464 * error message, clear the restrict login flag and return zero.
3465 * Else set the restrict login flag to val.
3468 * zero if val is in range
3469 * -EINVAL val out of range
3472 lpfc_restrict_login_set(struct lpfc_vport *vport, int val)
3474 if (val < 0 || val > 1) {
3475 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3476 "0425 lpfc_restrict_login attribute cannot "
3477 "be set to %d, allowed range is [0, 1]\n",
3479 vport->cfg_restrict_login = 1;
3482 if (vport->port_type == LPFC_PHYSICAL_PORT && val != 0) {
3483 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3484 "0468 lpfc_restrict_login must be 0 for "
3485 "Physical ports.\n");
3486 vport->cfg_restrict_login = 0;
3489 vport->cfg_restrict_login = val;
3492 lpfc_vport_param_store(restrict_login);
3493 static DEVICE_ATTR(lpfc_restrict_login, S_IRUGO | S_IWUSR,
3494 lpfc_restrict_login_show, lpfc_restrict_login_store);
3497 # Some disk devices have a "select ID" or "select Target" capability.
3498 # From a protocol standpoint "select ID" usually means select the
3499 # Fibre channel "ALPA". In the FC-AL Profile there is an "informative
3500 # annex" which contains a table that maps a "select ID" (a number
3501 # between 0 and 7F) to an ALPA. By default, for compatibility with
3502 # older drivers, the lpfc driver scans this table from low ALPA to high
3505 # Turning on the scan-down variable (on = 1, off = 0) will
3506 # cause the lpfc driver to use an inverted table, effectively
3507 # scanning ALPAs from high to low. Value range is [0,1]. Default value is 1.
3509 # (Note: This "select ID" functionality is a LOOP ONLY characteristic
3510 # and will not work across a fabric. Also this parameter will take
3511 # effect only in the case when ALPA map is not available.)
3513 LPFC_VPORT_ATTR_R(scan_down, 1, 0, 1,
3514 "Start scanning for devices from highest ALPA to lowest");
3517 # lpfc_topology: link topology for init link
3518 # 0x0 = attempt loop mode then point-to-point
3519 # 0x01 = internal loopback mode
3520 # 0x02 = attempt point-to-point mode only
3521 # 0x04 = attempt loop mode only
3522 # 0x06 = attempt point-to-point mode then loop
3523 # Set point-to-point mode if you want to run as an N_Port.
3524 # Set loop mode if you want to run as an NL_Port. Value range is [0,0x6].
3525 # Default value is 0.
3527 LPFC_ATTR(topology, 0, 0, 6,
3528 "Select Fibre Channel topology");
3531 * lpfc_topology_set - Set the adapters topology field
3532 * @phba: lpfc_hba pointer.
3533 * @val: topology value.
3536 * If val is in a valid range then set the adapter's topology field and
3537 * issue a lip; if the lip fails reset the topology to the old value.
3539 * If the value is not in range log a kernel error message and return an error.
3542 * zero if val is in range and lip okay
3543 * non-zero return value from lpfc_issue_lip()
3544 * -EINVAL val out of range
3547 lpfc_topology_store(struct device *dev, struct device_attribute *attr,
3548 const char *buf, size_t count)
3550 struct Scsi_Host *shost = class_to_shost(dev);
3551 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
3552 struct lpfc_hba *phba = vport->phba;
3555 const char *val_buf = buf;
3559 if (!strncmp(buf, "nolip ", strlen("nolip "))) {
3561 val_buf = &buf[strlen("nolip ")];
3564 if (!isdigit(val_buf[0]))
3566 if (sscanf(val_buf, "%i", &val) != 1)
3569 if (val >= 0 && val <= 6) {
3570 prev_val = phba->cfg_topology;
3571 if (phba->cfg_link_speed == LPFC_USER_LINK_SPEED_16G &&
3573 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3574 "3113 Loop mode not supported at speed %d\n",
3578 if (phba->pcidev->device == PCI_DEVICE_ID_LANCER_G6_FC &&
3580 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3581 "3114 Loop mode not supported\n");
3584 phba->cfg_topology = val;
3588 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3589 "3054 lpfc_topology changed from %d to %d\n",
3591 if (prev_val != val && phba->sli_rev == LPFC_SLI_REV4)
3592 phba->fc_topology_changed = 1;
3593 err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport));
3595 phba->cfg_topology = prev_val;
3600 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3601 "%d:0467 lpfc_topology attribute cannot be set to %d, "
3602 "allowed range is [0, 6]\n",
3607 lpfc_param_show(topology)
3608 static DEVICE_ATTR(lpfc_topology, S_IRUGO | S_IWUSR,
3609 lpfc_topology_show, lpfc_topology_store);
3612 * lpfc_static_vport_show: Read callback function for
3613 * lpfc_static_vport sysfs file.
3614 * @dev: Pointer to class device object.
3615 * @attr: device attribute structure.
3616 * @buf: Data buffer.
3618 * This function is the read call back function for
3619 * lpfc_static_vport sysfs file. The lpfc_static_vport
3620 * sysfs file report the mageability of the vport.
3623 lpfc_static_vport_show(struct device *dev, struct device_attribute *attr,
3626 struct Scsi_Host *shost = class_to_shost(dev);
3627 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
3628 if (vport->vport_flag & STATIC_VPORT)
3629 sprintf(buf, "1\n");
3631 sprintf(buf, "0\n");
3637 * Sysfs attribute to control the statistical data collection.
3639 static DEVICE_ATTR(lpfc_static_vport, S_IRUGO,
3640 lpfc_static_vport_show, NULL);
3643 * lpfc_stat_data_ctrl_store - write call back for lpfc_stat_data_ctrl sysfs file
3644 * @dev: Pointer to class device.
3645 * @buf: Data buffer.
3646 * @count: Size of the data buffer.
3648 * This function get called when a user write to the lpfc_stat_data_ctrl
3649 * sysfs file. This function parse the command written to the sysfs file
3650 * and take appropriate action. These commands are used for controlling
3651 * driver statistical data collection.
3652 * Following are the command this function handles.
3654 * setbucket <bucket_type> <base> <step>
3655 * = Set the latency buckets.
3656 * destroybucket = destroy all the buckets.
3657 * start = start data collection
3658 * stop = stop data collection
3659 * reset = reset the collected data
3662 lpfc_stat_data_ctrl_store(struct device *dev, struct device_attribute *attr,
3663 const char *buf, size_t count)
3665 struct Scsi_Host *shost = class_to_shost(dev);
3666 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
3667 struct lpfc_hba *phba = vport->phba;
3668 #define LPFC_MAX_DATA_CTRL_LEN 1024
3669 static char bucket_data[LPFC_MAX_DATA_CTRL_LEN];
3671 char *str_ptr, *token;
3672 struct lpfc_vport **vports;
3673 struct Scsi_Host *v_shost;
3674 char *bucket_type_str, *base_str, *step_str;
3675 unsigned long base, step, bucket_type;
3677 if (!strncmp(buf, "setbucket", strlen("setbucket"))) {
3678 if (strlen(buf) > (LPFC_MAX_DATA_CTRL_LEN - 1))
3681 strncpy(bucket_data, buf, LPFC_MAX_DATA_CTRL_LEN);
3682 str_ptr = &bucket_data[0];
3683 /* Ignore this token - this is command token */
3684 token = strsep(&str_ptr, "\t ");
3688 bucket_type_str = strsep(&str_ptr, "\t ");
3689 if (!bucket_type_str)
3692 if (!strncmp(bucket_type_str, "linear", strlen("linear")))
3693 bucket_type = LPFC_LINEAR_BUCKET;
3694 else if (!strncmp(bucket_type_str, "power2", strlen("power2")))
3695 bucket_type = LPFC_POWER2_BUCKET;
3699 base_str = strsep(&str_ptr, "\t ");
3702 base = simple_strtoul(base_str, NULL, 0);
3704 step_str = strsep(&str_ptr, "\t ");
3707 step = simple_strtoul(step_str, NULL, 0);
3711 /* Block the data collection for every vport */
3712 vports = lpfc_create_vport_work_array(phba);
3716 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
3717 v_shost = lpfc_shost_from_vport(vports[i]);
3718 spin_lock_irq(v_shost->host_lock);
3719 /* Block and reset data collection */
3720 vports[i]->stat_data_blocked = 1;
3721 if (vports[i]->stat_data_enabled)
3722 lpfc_vport_reset_stat_data(vports[i]);
3723 spin_unlock_irq(v_shost->host_lock);
3726 /* Set the bucket attributes */
3727 phba->bucket_type = bucket_type;
3728 phba->bucket_base = base;
3729 phba->bucket_step = step;
3731 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
3732 v_shost = lpfc_shost_from_vport(vports[i]);
3734 /* Unblock data collection */
3735 spin_lock_irq(v_shost->host_lock);
3736 vports[i]->stat_data_blocked = 0;
3737 spin_unlock_irq(v_shost->host_lock);
3739 lpfc_destroy_vport_work_array(phba, vports);
3743 if (!strncmp(buf, "destroybucket", strlen("destroybucket"))) {
3744 vports = lpfc_create_vport_work_array(phba);
3748 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
3749 v_shost = lpfc_shost_from_vport(vports[i]);
3750 spin_lock_irq(shost->host_lock);
3751 vports[i]->stat_data_blocked = 1;
3752 lpfc_free_bucket(vport);
3753 vport->stat_data_enabled = 0;
3754 vports[i]->stat_data_blocked = 0;
3755 spin_unlock_irq(shost->host_lock);
3757 lpfc_destroy_vport_work_array(phba, vports);
3758 phba->bucket_type = LPFC_NO_BUCKET;
3759 phba->bucket_base = 0;
3760 phba->bucket_step = 0;
3764 if (!strncmp(buf, "start", strlen("start"))) {
3765 /* If no buckets configured return error */
3766 if (phba->bucket_type == LPFC_NO_BUCKET)
3768 spin_lock_irq(shost->host_lock);
3769 if (vport->stat_data_enabled) {
3770 spin_unlock_irq(shost->host_lock);
3773 lpfc_alloc_bucket(vport);
3774 vport->stat_data_enabled = 1;
3775 spin_unlock_irq(shost->host_lock);
3779 if (!strncmp(buf, "stop", strlen("stop"))) {
3780 spin_lock_irq(shost->host_lock);
3781 if (vport->stat_data_enabled == 0) {
3782 spin_unlock_irq(shost->host_lock);
3785 lpfc_free_bucket(vport);
3786 vport->stat_data_enabled = 0;
3787 spin_unlock_irq(shost->host_lock);
3791 if (!strncmp(buf, "reset", strlen("reset"))) {
3792 if ((phba->bucket_type == LPFC_NO_BUCKET)
3793 || !vport->stat_data_enabled)
3795 spin_lock_irq(shost->host_lock);
3796 vport->stat_data_blocked = 1;
3797 lpfc_vport_reset_stat_data(vport);
3798 vport->stat_data_blocked = 0;
3799 spin_unlock_irq(shost->host_lock);
3807 * lpfc_stat_data_ctrl_show - Read function for lpfc_stat_data_ctrl sysfs file
3808 * @dev: Pointer to class device object.
3809 * @buf: Data buffer.
3811 * This function is the read call back function for
3812 * lpfc_stat_data_ctrl sysfs file. This function report the
3813 * current statistical data collection state.
3816 lpfc_stat_data_ctrl_show(struct device *dev, struct device_attribute *attr,
3819 struct Scsi_Host *shost = class_to_shost(dev);
3820 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
3821 struct lpfc_hba *phba = vport->phba;
3825 unsigned long bucket_value;
3827 switch (phba->bucket_type) {
3828 case LPFC_LINEAR_BUCKET:
3829 bucket_type = "linear";
3831 case LPFC_POWER2_BUCKET:
3832 bucket_type = "power2";
3835 bucket_type = "No Bucket";
3839 sprintf(&buf[index], "Statistical Data enabled :%d, "
3840 "blocked :%d, Bucket type :%s, Bucket base :%d,"
3841 " Bucket step :%d\nLatency Ranges :",
3842 vport->stat_data_enabled, vport->stat_data_blocked,
3843 bucket_type, phba->bucket_base, phba->bucket_step);
3844 index = strlen(buf);
3845 if (phba->bucket_type != LPFC_NO_BUCKET) {
3846 for (i = 0; i < LPFC_MAX_BUCKET_COUNT; i++) {
3847 if (phba->bucket_type == LPFC_LINEAR_BUCKET)
3848 bucket_value = phba->bucket_base +
3849 phba->bucket_step * i;
3851 bucket_value = phba->bucket_base +
3852 (1 << i) * phba->bucket_step;
3854 if (index + 10 > PAGE_SIZE)
3856 sprintf(&buf[index], "%08ld ", bucket_value);
3857 index = strlen(buf);
3860 sprintf(&buf[index], "\n");
3865 * Sysfs attribute to control the statistical data collection.
3867 static DEVICE_ATTR(lpfc_stat_data_ctrl, S_IRUGO | S_IWUSR,
3868 lpfc_stat_data_ctrl_show, lpfc_stat_data_ctrl_store);
3871 * lpfc_drvr_stat_data: sysfs attr to get driver statistical data.
3875 * Each Bucket takes 11 characters and 1 new line + 17 bytes WWN
3878 #define STAT_DATA_SIZE_PER_TARGET(NUM_BUCKETS) ((NUM_BUCKETS) * 11 + 18)
3879 #define MAX_STAT_DATA_SIZE_PER_TARGET \
3880 STAT_DATA_SIZE_PER_TARGET(LPFC_MAX_BUCKET_COUNT)
3884 * sysfs_drvr_stat_data_read - Read function for lpfc_drvr_stat_data attribute
3886 * @kobj: Pointer to the kernel object
3887 * @bin_attr: Attribute object
3888 * @buff: Buffer pointer
3890 * @count: Buffer size
3892 * This function is the read call back function for lpfc_drvr_stat_data
3893 * sysfs file. This function export the statistical data to user
3897 sysfs_drvr_stat_data_read(struct file *filp, struct kobject *kobj,
3898 struct bin_attribute *bin_attr,
3899 char *buf, loff_t off, size_t count)
3901 struct device *dev = container_of(kobj, struct device,
3903 struct Scsi_Host *shost = class_to_shost(dev);
3904 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
3905 struct lpfc_hba *phba = vport->phba;
3906 int i = 0, index = 0;
3907 unsigned long nport_index;
3908 struct lpfc_nodelist *ndlp = NULL;
3909 nport_index = (unsigned long)off /
3910 MAX_STAT_DATA_SIZE_PER_TARGET;
3912 if (!vport->stat_data_enabled || vport->stat_data_blocked
3913 || (phba->bucket_type == LPFC_NO_BUCKET))
3916 spin_lock_irq(shost->host_lock);
3917 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
3918 if (!NLP_CHK_NODE_ACT(ndlp) || !ndlp->lat_data)
3921 if (nport_index > 0) {
3926 if ((index + MAX_STAT_DATA_SIZE_PER_TARGET)
3930 if (!ndlp->lat_data)
3934 sprintf(&buf[index], "%02x%02x%02x%02x%02x%02x%02x%02x:",
3935 ndlp->nlp_portname.u.wwn[0],
3936 ndlp->nlp_portname.u.wwn[1],
3937 ndlp->nlp_portname.u.wwn[2],
3938 ndlp->nlp_portname.u.wwn[3],
3939 ndlp->nlp_portname.u.wwn[4],
3940 ndlp->nlp_portname.u.wwn[5],
3941 ndlp->nlp_portname.u.wwn[6],
3942 ndlp->nlp_portname.u.wwn[7]);
3944 index = strlen(buf);
3946 for (i = 0; i < LPFC_MAX_BUCKET_COUNT; i++) {
3947 sprintf(&buf[index], "%010u,",
3948 ndlp->lat_data[i].cmd_count);
3949 index = strlen(buf);
3951 sprintf(&buf[index], "\n");
3952 index = strlen(buf);
3954 spin_unlock_irq(shost->host_lock);
3958 static struct bin_attribute sysfs_drvr_stat_data_attr = {
3960 .name = "lpfc_drvr_stat_data",
3963 .size = LPFC_MAX_TARGET * MAX_STAT_DATA_SIZE_PER_TARGET,
3964 .read = sysfs_drvr_stat_data_read,
3969 # lpfc_link_speed: Link speed selection for initializing the Fibre Channel
3971 # Value range is [0,16]. Default value is 0.
3974 * lpfc_link_speed_set - Set the adapters link speed
3975 * @phba: lpfc_hba pointer.
3976 * @val: link speed value.
3979 * If val is in a valid range then set the adapter's link speed field and
3980 * issue a lip; if the lip fails reset the link speed to the old value.
3983 * If the value is not in range log a kernel error message and return an error.
3986 * zero if val is in range and lip okay.
3987 * non-zero return value from lpfc_issue_lip()
3988 * -EINVAL val out of range
3991 lpfc_link_speed_store(struct device *dev, struct device_attribute *attr,
3992 const char *buf, size_t count)
3994 struct Scsi_Host *shost = class_to_shost(dev);
3995 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
3996 struct lpfc_hba *phba = vport->phba;
3997 int val = LPFC_USER_LINK_SPEED_AUTO;
3999 const char *val_buf = buf;
4001 uint32_t prev_val, if_type;
4003 if_type = bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf);
4004 if (if_type == LPFC_SLI_INTF_IF_TYPE_2 &&
4005 phba->hba_flag & HBA_FORCED_LINK_SPEED)
4008 if (!strncmp(buf, "nolip ", strlen("nolip "))) {
4010 val_buf = &buf[strlen("nolip ")];
4013 if (!isdigit(val_buf[0]))
4015 if (sscanf(val_buf, "%i", &val) != 1)
4018 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
4019 "3055 lpfc_link_speed changed from %d to %d %s\n",
4020 phba->cfg_link_speed, val, nolip ? "(nolip)" : "(lip)");
4022 if (((val == LPFC_USER_LINK_SPEED_1G) && !(phba->lmt & LMT_1Gb)) ||
4023 ((val == LPFC_USER_LINK_SPEED_2G) && !(phba->lmt & LMT_2Gb)) ||
4024 ((val == LPFC_USER_LINK_SPEED_4G) && !(phba->lmt & LMT_4Gb)) ||
4025 ((val == LPFC_USER_LINK_SPEED_8G) && !(phba->lmt & LMT_8Gb)) ||
4026 ((val == LPFC_USER_LINK_SPEED_10G) && !(phba->lmt & LMT_10Gb)) ||
4027 ((val == LPFC_USER_LINK_SPEED_16G) && !(phba->lmt & LMT_16Gb)) ||
4028 ((val == LPFC_USER_LINK_SPEED_32G) && !(phba->lmt & LMT_32Gb))) {
4029 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4030 "2879 lpfc_link_speed attribute cannot be set "
4031 "to %d. Speed is not supported by this port.\n",
4035 if (val == LPFC_USER_LINK_SPEED_16G &&
4036 phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
4037 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4038 "3112 lpfc_link_speed attribute cannot be set "
4039 "to %d. Speed is not supported in loop mode.\n",
4043 if ((val >= 0) && (val <= LPFC_USER_LINK_SPEED_MAX) &&
4044 (LPFC_USER_LINK_SPEED_BITMAP & (1 << val))) {
4045 prev_val = phba->cfg_link_speed;
4046 phba->cfg_link_speed = val;
4050 err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport));
4052 phba->cfg_link_speed = prev_val;
4057 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4058 "0469 lpfc_link_speed attribute cannot be set to %d, "
4059 "allowed values are ["LPFC_LINK_SPEED_STRING"]\n", val);
4063 static int lpfc_link_speed = 0;
4064 module_param(lpfc_link_speed, int, S_IRUGO);
4065 MODULE_PARM_DESC(lpfc_link_speed, "Select link speed");
4066 lpfc_param_show(link_speed)
4069 * lpfc_link_speed_init - Set the adapters link speed
4070 * @phba: lpfc_hba pointer.
4071 * @val: link speed value.
4074 * If val is in a valid range then set the adapter's link speed field.
4077 * If the value is not in range log a kernel error message, clear the link
4078 * speed and return an error.
4081 * zero if val saved.
4082 * -EINVAL val out of range
4085 lpfc_link_speed_init(struct lpfc_hba *phba, int val)
4087 if (val == LPFC_USER_LINK_SPEED_16G && phba->cfg_topology == 4) {
4088 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4089 "3111 lpfc_link_speed of %d cannot "
4090 "support loop mode, setting topology to default.\n",
4092 phba->cfg_topology = 0;
4094 if ((val >= 0) && (val <= LPFC_USER_LINK_SPEED_MAX) &&
4095 (LPFC_USER_LINK_SPEED_BITMAP & (1 << val))) {
4096 phba->cfg_link_speed = val;
4099 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4100 "0405 lpfc_link_speed attribute cannot "
4101 "be set to %d, allowed values are "
4102 "["LPFC_LINK_SPEED_STRING"]\n", val);
4103 phba->cfg_link_speed = LPFC_USER_LINK_SPEED_AUTO;
4107 static DEVICE_ATTR(lpfc_link_speed, S_IRUGO | S_IWUSR,
4108 lpfc_link_speed_show, lpfc_link_speed_store);
4111 # lpfc_aer_support: Support PCIe device Advanced Error Reporting (AER)
4112 # 0 = aer disabled or not supported
4113 # 1 = aer supported and enabled (default)
4114 # Value range is [0,1]. Default value is 1.
4116 LPFC_ATTR(aer_support, 1, 0, 1,
4117 "Enable PCIe device AER support");
4118 lpfc_param_show(aer_support)
4121 * lpfc_aer_support_store - Set the adapter for aer support
4123 * @dev: class device that is converted into a Scsi_host.
4124 * @attr: device attribute, not used.
4125 * @buf: containing enable or disable aer flag.
4126 * @count: unused variable.
4129 * If the val is 1 and currently the device's AER capability was not
4130 * enabled, invoke the kernel's enable AER helper routine, trying to
4131 * enable the device's AER capability. If the helper routine enabling
4132 * AER returns success, update the device's cfg_aer_support flag to
4133 * indicate AER is supported by the device; otherwise, if the device
4134 * AER capability is already enabled to support AER, then do nothing.
4136 * If the val is 0 and currently the device's AER support was enabled,
4137 * invoke the kernel's disable AER helper routine. After that, update
4138 * the device's cfg_aer_support flag to indicate AER is not supported
4139 * by the device; otherwise, if the device AER capability is already
4140 * disabled from supporting AER, then do nothing.
4143 * length of the buf on success if val is in range the intended mode
4145 * -EINVAL if val out of range or intended mode is not supported.
4148 lpfc_aer_support_store(struct device *dev, struct device_attribute *attr,
4149 const char *buf, size_t count)
4151 struct Scsi_Host *shost = class_to_shost(dev);
4152 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
4153 struct lpfc_hba *phba = vport->phba;
4154 int val = 0, rc = -EINVAL;
4156 if (!isdigit(buf[0]))
4158 if (sscanf(buf, "%i", &val) != 1)
4163 if (phba->hba_flag & HBA_AER_ENABLED) {
4164 rc = pci_disable_pcie_error_reporting(phba->pcidev);
4166 spin_lock_irq(&phba->hbalock);
4167 phba->hba_flag &= ~HBA_AER_ENABLED;
4168 spin_unlock_irq(&phba->hbalock);
4169 phba->cfg_aer_support = 0;
4174 phba->cfg_aer_support = 0;
4179 if (!(phba->hba_flag & HBA_AER_ENABLED)) {
4180 rc = pci_enable_pcie_error_reporting(phba->pcidev);
4182 spin_lock_irq(&phba->hbalock);
4183 phba->hba_flag |= HBA_AER_ENABLED;
4184 spin_unlock_irq(&phba->hbalock);
4185 phba->cfg_aer_support = 1;
4190 phba->cfg_aer_support = 1;
4201 static DEVICE_ATTR(lpfc_aer_support, S_IRUGO | S_IWUSR,
4202 lpfc_aer_support_show, lpfc_aer_support_store);
4205 * lpfc_aer_cleanup_state - Clean up aer state to the aer enabled device
4206 * @dev: class device that is converted into a Scsi_host.
4207 * @attr: device attribute, not used.
4208 * @buf: containing flag 1 for aer cleanup state.
4209 * @count: unused variable.
4212 * If the @buf contains 1 and the device currently has the AER support
4213 * enabled, then invokes the kernel AER helper routine
4214 * pci_cleanup_aer_uncorrect_error_status to clean up the uncorrectable
4215 * error status register.
4220 * -EINVAL if the buf does not contain the 1 or the device is not currently
4221 * enabled with the AER support.
4224 lpfc_aer_cleanup_state(struct device *dev, struct device_attribute *attr,
4225 const char *buf, size_t count)
4227 struct Scsi_Host *shost = class_to_shost(dev);
4228 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4229 struct lpfc_hba *phba = vport->phba;
4232 if (!isdigit(buf[0]))
4234 if (sscanf(buf, "%i", &val) != 1)
4239 if (phba->hba_flag & HBA_AER_ENABLED)
4240 rc = pci_cleanup_aer_uncorrect_error_status(phba->pcidev);
4248 static DEVICE_ATTR(lpfc_aer_state_cleanup, S_IWUSR, NULL,
4249 lpfc_aer_cleanup_state);
4252 * lpfc_sriov_nr_virtfn_store - Enable the adapter for sr-iov virtual functions
4254 * @dev: class device that is converted into a Scsi_host.
4255 * @attr: device attribute, not used.
4256 * @buf: containing the string the number of vfs to be enabled.
4257 * @count: unused variable.
4260 * When this api is called either through user sysfs, the driver shall
4261 * try to enable or disable SR-IOV virtual functions according to the
4264 * If zero virtual function has been enabled to the physical function,
4265 * the driver shall invoke the pci enable virtual function api trying
4266 * to enable the virtual functions. If the nr_vfn provided is greater
4267 * than the maximum supported, the maximum virtual function number will
4268 * be used for invoking the api; otherwise, the nr_vfn provided shall
4269 * be used for invoking the api. If the api call returned success, the
4270 * actual number of virtual functions enabled will be set to the driver
4271 * cfg_sriov_nr_virtfn; otherwise, -EINVAL shall be returned and driver
4272 * cfg_sriov_nr_virtfn remains zero.
4274 * If none-zero virtual functions have already been enabled to the
4275 * physical function, as reflected by the driver's cfg_sriov_nr_virtfn,
4276 * -EINVAL will be returned and the driver does nothing;
4278 * If the nr_vfn provided is zero and none-zero virtual functions have
4279 * been enabled, as indicated by the driver's cfg_sriov_nr_virtfn, the
4280 * disabling virtual function api shall be invoded to disable all the
4281 * virtual functions and driver's cfg_sriov_nr_virtfn shall be set to
4282 * zero. Otherwise, if zero virtual function has been enabled, do
4286 * length of the buf on success if val is in range the intended mode
4288 * -EINVAL if val out of range or intended mode is not supported.
4291 lpfc_sriov_nr_virtfn_store(struct device *dev, struct device_attribute *attr,
4292 const char *buf, size_t count)
4294 struct Scsi_Host *shost = class_to_shost(dev);
4295 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
4296 struct lpfc_hba *phba = vport->phba;
4297 struct pci_dev *pdev = phba->pcidev;
4298 int val = 0, rc = -EINVAL;
4300 /* Sanity check on user data */
4301 if (!isdigit(buf[0]))
4303 if (sscanf(buf, "%i", &val) != 1)
4308 /* Request disabling virtual functions */
4310 if (phba->cfg_sriov_nr_virtfn > 0) {
4311 pci_disable_sriov(pdev);
4312 phba->cfg_sriov_nr_virtfn = 0;
4317 /* Request enabling virtual functions */
4318 if (phba->cfg_sriov_nr_virtfn > 0) {
4319 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4320 "3018 There are %d virtual functions "
4321 "enabled on physical function.\n",
4322 phba->cfg_sriov_nr_virtfn);
4326 if (val <= LPFC_MAX_VFN_PER_PFN)
4327 phba->cfg_sriov_nr_virtfn = val;
4329 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4330 "3019 Enabling %d virtual functions is not "
4335 rc = lpfc_sli_probe_sriov_nr_virtfn(phba, phba->cfg_sriov_nr_virtfn);
4337 phba->cfg_sriov_nr_virtfn = 0;
4345 LPFC_ATTR(sriov_nr_virtfn, LPFC_DEF_VFN_PER_PFN, 0, LPFC_MAX_VFN_PER_PFN,
4346 "Enable PCIe device SR-IOV virtual fn");
4348 lpfc_param_show(sriov_nr_virtfn)
4349 static DEVICE_ATTR(lpfc_sriov_nr_virtfn, S_IRUGO | S_IWUSR,
4350 lpfc_sriov_nr_virtfn_show, lpfc_sriov_nr_virtfn_store);
4353 * lpfc_request_firmware_store - Request for Linux generic firmware upgrade
4355 * @dev: class device that is converted into a Scsi_host.
4356 * @attr: device attribute, not used.
4357 * @buf: containing the string the number of vfs to be enabled.
4358 * @count: unused variable.
4363 * length of the buf on success if val is in range the intended mode
4365 * -EINVAL if val out of range or intended mode is not supported.
4368 lpfc_request_firmware_upgrade_store(struct device *dev,
4369 struct device_attribute *attr,
4370 const char *buf, size_t count)
4372 struct Scsi_Host *shost = class_to_shost(dev);
4373 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
4374 struct lpfc_hba *phba = vport->phba;
4375 int val = 0, rc = -EINVAL;
4377 /* Sanity check on user data */
4378 if (!isdigit(buf[0]))
4380 if (sscanf(buf, "%i", &val) != 1)
4385 rc = lpfc_sli4_request_firmware_update(phba, RUN_FW_UPGRADE);
4393 static int lpfc_req_fw_upgrade;
4394 module_param(lpfc_req_fw_upgrade, int, S_IRUGO|S_IWUSR);
4395 MODULE_PARM_DESC(lpfc_req_fw_upgrade, "Enable Linux generic firmware upgrade");
4396 lpfc_param_show(request_firmware_upgrade)
4399 * lpfc_request_firmware_upgrade_init - Enable initial linux generic fw upgrade
4400 * @phba: lpfc_hba pointer.
4404 * Set the initial Linux generic firmware upgrade enable or disable flag.
4407 * zero if val saved.
4408 * -EINVAL val out of range
4411 lpfc_request_firmware_upgrade_init(struct lpfc_hba *phba, int val)
4413 if (val >= 0 && val <= 1) {
4414 phba->cfg_request_firmware_upgrade = val;
4419 static DEVICE_ATTR(lpfc_req_fw_upgrade, S_IRUGO | S_IWUSR,
4420 lpfc_request_firmware_upgrade_show,
4421 lpfc_request_firmware_upgrade_store);
4424 * lpfc_fcp_imax_store
4426 * @dev: class device that is converted into a Scsi_host.
4427 * @attr: device attribute, not used.
4428 * @buf: string with the number of fast-path FCP interrupts per second.
4429 * @count: unused variable.
4432 * If val is in a valid range [636,651042], then set the adapter's
4433 * maximum number of fast-path FCP interrupts per second.
4436 * length of the buf on success if val is in range the intended mode
4438 * -EINVAL if val out of range or intended mode is not supported.
4441 lpfc_fcp_imax_store(struct device *dev, struct device_attribute *attr,
4442 const char *buf, size_t count)
4444 struct Scsi_Host *shost = class_to_shost(dev);
4445 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
4446 struct lpfc_hba *phba = vport->phba;
4449 /* fcp_imax is only valid for SLI4 */
4450 if (phba->sli_rev != LPFC_SLI_REV4)
4453 /* Sanity check on user data */
4454 if (!isdigit(buf[0]))
4456 if (sscanf(buf, "%i", &val) != 1)
4460 * Value range for the HBA is [5000,5000000]
4461 * The value for each EQ depends on how many EQs are configured.
4464 if (val && (val < LPFC_MIN_IMAX || val > LPFC_MAX_IMAX))
4467 phba->cfg_fcp_imax = (uint32_t)val;
4469 for (i = 0; i < phba->io_channel_irqs; i += LPFC_MAX_EQ_DELAY_EQID_CNT)
4470 lpfc_modify_hba_eq_delay(phba, i);
4476 # lpfc_fcp_imax: The maximum number of fast-path FCP interrupts per second
4479 # Value range is [5,000 to 5,000,000]. Default value is 50,000.
4481 static int lpfc_fcp_imax = LPFC_DEF_IMAX;
4482 module_param(lpfc_fcp_imax, int, S_IRUGO|S_IWUSR);
4483 MODULE_PARM_DESC(lpfc_fcp_imax,
4484 "Set the maximum number of FCP interrupts per second per HBA");
4485 lpfc_param_show(fcp_imax)
4488 * lpfc_fcp_imax_init - Set the initial sr-iov virtual function enable
4489 * @phba: lpfc_hba pointer.
4490 * @val: link speed value.
4493 * If val is in a valid range [636,651042], then initialize the adapter's
4494 * maximum number of fast-path FCP interrupts per second.
4497 * zero if val saved.
4498 * -EINVAL val out of range
4501 lpfc_fcp_imax_init(struct lpfc_hba *phba, int val)
4503 if (phba->sli_rev != LPFC_SLI_REV4) {
4504 phba->cfg_fcp_imax = 0;
4508 if ((val >= LPFC_MIN_IMAX && val <= LPFC_MAX_IMAX) ||
4510 phba->cfg_fcp_imax = val;
4514 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4515 "3016 lpfc_fcp_imax: %d out of range, using default\n",
4517 phba->cfg_fcp_imax = LPFC_DEF_IMAX;
4522 static DEVICE_ATTR(lpfc_fcp_imax, S_IRUGO | S_IWUSR,
4523 lpfc_fcp_imax_show, lpfc_fcp_imax_store);
4526 * lpfc_state_show - Display current driver CPU affinity
4527 * @dev: class converted to a Scsi_host structure.
4528 * @attr: device attribute, not used.
4529 * @buf: on return contains text describing the state of the link.
4531 * Returns: size of formatted string.
4534 lpfc_fcp_cpu_map_show(struct device *dev, struct device_attribute *attr,
4537 struct Scsi_Host *shost = class_to_shost(dev);
4538 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
4539 struct lpfc_hba *phba = vport->phba;
4540 struct lpfc_vector_map_info *cpup;
4543 if ((phba->sli_rev != LPFC_SLI_REV4) ||
4544 (phba->intr_type != MSIX))
4547 switch (phba->cfg_fcp_cpu_map) {
4549 len += snprintf(buf + len, PAGE_SIZE-len,
4550 "fcp_cpu_map: No mapping (%d)\n",
4551 phba->cfg_fcp_cpu_map);
4554 len += snprintf(buf + len, PAGE_SIZE-len,
4555 "fcp_cpu_map: HBA centric mapping (%d): "
4557 phba->cfg_fcp_cpu_map,
4558 phba->sli4_hba.num_online_cpu);
4561 len += snprintf(buf + len, PAGE_SIZE-len,
4562 "fcp_cpu_map: Driver centric mapping (%d): "
4564 phba->cfg_fcp_cpu_map,
4565 phba->sli4_hba.num_online_cpu);
4569 while (phba->sli4_hba.curr_disp_cpu < phba->sli4_hba.num_present_cpu) {
4570 cpup = &phba->sli4_hba.cpu_map[phba->sli4_hba.curr_disp_cpu];
4572 /* margin should fit in this and the truncated message */
4573 if (cpup->irq == LPFC_VECTOR_MAP_EMPTY)
4574 len += snprintf(buf + len, PAGE_SIZE-len,
4575 "CPU %02d io_chan %02d "
4576 "physid %d coreid %d\n",
4577 phba->sli4_hba.curr_disp_cpu,
4578 cpup->channel_id, cpup->phys_id,
4581 len += snprintf(buf + len, PAGE_SIZE-len,
4582 "CPU %02d io_chan %02d "
4583 "physid %d coreid %d IRQ %d\n",
4584 phba->sli4_hba.curr_disp_cpu,
4585 cpup->channel_id, cpup->phys_id,
4586 cpup->core_id, cpup->irq);
4588 phba->sli4_hba.curr_disp_cpu++;
4590 /* display max number of CPUs keeping some margin */
4591 if (phba->sli4_hba.curr_disp_cpu <
4592 phba->sli4_hba.num_present_cpu &&
4593 (len >= (PAGE_SIZE - 64))) {
4594 len += snprintf(buf + len, PAGE_SIZE-len, "more...\n");
4599 if (phba->sli4_hba.curr_disp_cpu == phba->sli4_hba.num_present_cpu)
4600 phba->sli4_hba.curr_disp_cpu = 0;
4606 * lpfc_fcp_cpu_map_store - Change CPU affinity of driver vectors
4607 * @dev: class device that is converted into a Scsi_host.
4608 * @attr: device attribute, not used.
4609 * @buf: one or more lpfc_polling_flags values.
4613 * -EINVAL - Not implemented yet.
4616 lpfc_fcp_cpu_map_store(struct device *dev, struct device_attribute *attr,
4617 const char *buf, size_t count)
4619 int status = -EINVAL;
4624 # lpfc_fcp_cpu_map: Defines how to map CPUs to IRQ vectors
4627 # Value range is [0 to 2]. Default value is LPFC_DRIVER_CPU_MAP (2).
4628 # 0 - Do not affinitze IRQ vectors
4629 # 1 - Affintize HBA vectors with respect to each HBA
4630 # (start with CPU0 for each HBA)
4631 # 2 - Affintize HBA vectors with respect to the entire driver
4632 # (round robin thru all CPUs across all HBAs)
4634 static int lpfc_fcp_cpu_map = LPFC_DRIVER_CPU_MAP;
4635 module_param(lpfc_fcp_cpu_map, int, S_IRUGO|S_IWUSR);
4636 MODULE_PARM_DESC(lpfc_fcp_cpu_map,
4637 "Defines how to map CPUs to IRQ vectors per HBA");
4640 * lpfc_fcp_cpu_map_init - Set the initial sr-iov virtual function enable
4641 * @phba: lpfc_hba pointer.
4642 * @val: link speed value.
4645 * If val is in a valid range [0-2], then affinitze the adapter's
4649 * zero if val saved.
4650 * -EINVAL val out of range
4653 lpfc_fcp_cpu_map_init(struct lpfc_hba *phba, int val)
4655 if (phba->sli_rev != LPFC_SLI_REV4) {
4656 phba->cfg_fcp_cpu_map = 0;
4660 if (val >= LPFC_MIN_CPU_MAP && val <= LPFC_MAX_CPU_MAP) {
4661 phba->cfg_fcp_cpu_map = val;
4665 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
4666 "3326 lpfc_fcp_cpu_map: %d out of range, using "
4668 phba->cfg_fcp_cpu_map = LPFC_DRIVER_CPU_MAP;
4673 static DEVICE_ATTR(lpfc_fcp_cpu_map, S_IRUGO | S_IWUSR,
4674 lpfc_fcp_cpu_map_show, lpfc_fcp_cpu_map_store);
4677 # lpfc_fcp_class: Determines FC class to use for the FCP protocol.
4678 # Value range is [2,3]. Default value is 3.
4680 LPFC_VPORT_ATTR_R(fcp_class, 3, 2, 3,
4681 "Select Fibre Channel class of service for FCP sequences");
4684 # lpfc_use_adisc: Use ADISC for FCP rediscovery instead of PLOGI. Value range
4685 # is [0,1]. Default value is 0.
4687 LPFC_VPORT_ATTR_RW(use_adisc, 0, 0, 1,
4688 "Use ADISC on rediscovery to authenticate FCP devices");
4691 # lpfc_first_burst_size: First burst size to use on the NPorts
4692 # that support first burst.
4693 # Value range is [0,65536]. Default value is 0.
4695 LPFC_VPORT_ATTR_RW(first_burst_size, 0, 0, 65536,
4696 "First burst size for Targets that support first burst");
4699 * lpfc_nvmet_fb_size: NVME Target mode supported first burst size.
4700 * When the driver is configured as an NVME target, this value is
4701 * communicated to the NVME initiator in the PRLI response. It is
4702 * used only when the lpfc_nvme_enable_fb and lpfc_nvmet_support
4703 * parameters are set and the target is sending the PRLI RSP.
4704 * Parameter supported on physical port only - no NPIV support.
4705 * Value range is [0,65536]. Default value is 0.
4707 LPFC_ATTR_RW(nvmet_fb_size, 0, 0, 65536,
4708 "NVME Target mode first burst size in 512B increments.");
4711 * lpfc_nvme_enable_fb: Enable NVME first burst on I and T functions.
4712 * For the Initiator (I), enabling this parameter means that an NVMET
4713 * PRLI response with FBA enabled and an FB_SIZE set to a nonzero value will be
4714 * processed by the initiator for subsequent NVME FCP IO. For the target
4715 * function (T), enabling this parameter qualifies the lpfc_nvmet_fb_size
4716 * driver parameter as the target function's first burst size returned to the
4717 * initiator in the target's NVME PRLI response. Parameter supported on physical
4718 * port only - no NPIV support.
4719 * Value range is [0,1]. Default value is 0 (disabled).
4721 LPFC_ATTR_RW(nvme_enable_fb, 0, 0, 1,
4722 "Enable First Burst feature on I and T functions.");
4725 # lpfc_max_scsicmpl_time: Use scsi command completion time to control I/O queue
4726 # depth. Default value is 0. When the value of this parameter is zero the
4727 # SCSI command completion time is not used for controlling I/O queue depth. When
4728 # the parameter is set to a non-zero value, the I/O queue depth is controlled
4729 # to limit the I/O completion time to the parameter value.
4730 # The value is set in milliseconds.
4732 LPFC_VPORT_ATTR(max_scsicmpl_time, 0, 0, 60000,
4733 "Use command completion time to control queue depth");
4735 lpfc_vport_param_show(max_scsicmpl_time);
4737 lpfc_max_scsicmpl_time_set(struct lpfc_vport *vport, int val)
4739 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
4740 struct lpfc_nodelist *ndlp, *next_ndlp;
4742 if (val == vport->cfg_max_scsicmpl_time)
4744 if ((val < 0) || (val > 60000))
4746 vport->cfg_max_scsicmpl_time = val;
4748 spin_lock_irq(shost->host_lock);
4749 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
4750 if (!NLP_CHK_NODE_ACT(ndlp))
4752 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
4754 ndlp->cmd_qdepth = vport->cfg_tgt_queue_depth;
4756 spin_unlock_irq(shost->host_lock);
4759 lpfc_vport_param_store(max_scsicmpl_time);
4760 static DEVICE_ATTR(lpfc_max_scsicmpl_time, S_IRUGO | S_IWUSR,
4761 lpfc_max_scsicmpl_time_show,
4762 lpfc_max_scsicmpl_time_store);
4765 # lpfc_ack0: Use ACK0, instead of ACK1 for class 2 acknowledgement. Value
4766 # range is [0,1]. Default value is 0.
4768 LPFC_ATTR_R(ack0, 0, 0, 1, "Enable ACK0 support");
4771 * lpfc_io_sched: Determine scheduling algrithmn for issuing FCP cmds
4772 * range is [0,1]. Default value is 0.
4773 * For [0], FCP commands are issued to Work Queues ina round robin fashion.
4774 * For [1], FCP commands are issued to a Work Queue associated with the
4777 * LPFC_FCP_SCHED_ROUND_ROBIN == 0
4778 * LPFC_FCP_SCHED_BY_CPU == 1
4780 * The driver dynamically sets this to 1 (BY_CPU) if it's able to set up cpu
4781 * affinity for FCP/NVME I/Os through Work Queues associated with the current
4782 * CPU. Otherwise, the default 0 (Round Robin) scheduling of FCP/NVME I/Os
4783 * through WQs will be used.
4785 LPFC_ATTR_RW(fcp_io_sched, LPFC_FCP_SCHED_ROUND_ROBIN,
4786 LPFC_FCP_SCHED_ROUND_ROBIN,
4787 LPFC_FCP_SCHED_BY_CPU,
4788 "Determine scheduling algorithm for "
4789 "issuing commands [0] - Round Robin, [1] - Current CPU");
4792 # lpfc_fcp2_no_tgt_reset: Determine bus reset behavior
4793 # range is [0,1]. Default value is 0.
4794 # For [0], bus reset issues target reset to ALL devices
4795 # For [1], bus reset issues target reset to non-FCP2 devices
4797 LPFC_ATTR_RW(fcp2_no_tgt_reset, 0, 0, 1, "Determine bus reset behavior for "
4798 "FCP2 devices [0] - issue tgt reset, [1] - no tgt reset");
4802 # lpfc_cr_delay & lpfc_cr_count: Default values for I/O colaesing
4803 # cr_delay (msec) or cr_count outstanding commands. cr_delay can take
4804 # value [0,63]. cr_count can take value [1,255]. Default value of cr_delay
4805 # is 0. Default value of cr_count is 1. The cr_count feature is disabled if
4806 # cr_delay is set to 0.
4808 LPFC_ATTR_RW(cr_delay, 0, 0, 63, "A count of milliseconds after which an "
4809 "interrupt response is generated");
4811 LPFC_ATTR_RW(cr_count, 1, 1, 255, "A count of I/O completions after which an "
4812 "interrupt response is generated");
4815 # lpfc_multi_ring_support: Determines how many rings to spread available
4816 # cmd/rsp IOCB entries across.
4817 # Value range is [1,2]. Default value is 1.
4819 LPFC_ATTR_R(multi_ring_support, 1, 1, 2, "Determines number of primary "
4820 "SLI rings to spread IOCB entries across");
4823 # lpfc_multi_ring_rctl: If lpfc_multi_ring_support is enabled, this
4824 # identifies what rctl value to configure the additional ring for.
4825 # Value range is [1,0xff]. Default value is 4 (Unsolicated Data).
4827 LPFC_ATTR_R(multi_ring_rctl, FC_RCTL_DD_UNSOL_DATA, 1,
4828 255, "Identifies RCTL for additional ring configuration");
4831 # lpfc_multi_ring_type: If lpfc_multi_ring_support is enabled, this
4832 # identifies what type value to configure the additional ring for.
4833 # Value range is [1,0xff]. Default value is 5 (LLC/SNAP).
4835 LPFC_ATTR_R(multi_ring_type, FC_TYPE_IP, 1,
4836 255, "Identifies TYPE for additional ring configuration");
4839 # lpfc_enable_SmartSAN: Sets up FDMI support for SmartSAN
4840 # 0 = SmartSAN functionality disabled (default)
4841 # 1 = SmartSAN functionality enabled
4842 # This parameter will override the value of lpfc_fdmi_on module parameter.
4843 # Value range is [0,1]. Default value is 0.
4845 LPFC_ATTR_R(enable_SmartSAN, 0, 0, 1, "Enable SmartSAN functionality");
4848 # lpfc_fdmi_on: Controls FDMI support.
4849 # 0 No FDMI support (default)
4850 # 1 Traditional FDMI support
4851 # Traditional FDMI support means the driver will assume FDMI-2 support;
4852 # however, if that fails, it will fallback to FDMI-1.
4853 # If lpfc_enable_SmartSAN is set to 1, the driver ignores lpfc_fdmi_on.
4854 # If lpfc_enable_SmartSAN is set 0, the driver uses the current value of
4856 # Value range [0,1]. Default value is 0.
4858 LPFC_ATTR_R(fdmi_on, 0, 0, 1, "Enable FDMI support");
4861 # Specifies the maximum number of ELS cmds we can have outstanding (for
4862 # discovery). Value range is [1,64]. Default value = 32.
4864 LPFC_VPORT_ATTR(discovery_threads, 32, 1, 64, "Maximum number of ELS commands "
4865 "during discovery");
4868 # lpfc_max_luns: maximum allowed LUN ID. This is the highest LUN ID that
4869 # will be scanned by the SCSI midlayer when sequential scanning is
4870 # used; and is also the highest LUN ID allowed when the SCSI midlayer
4871 # parses REPORT_LUN responses. The lpfc driver has no LUN count or
4872 # LUN ID limit, but the SCSI midlayer requires this field for the uses
4873 # above. The lpfc driver limits the default value to 255 for two reasons.
4874 # As it bounds the sequential scan loop, scanning for thousands of luns
4875 # on a target can take minutes of wall clock time. Additionally,
4876 # there are FC targets, such as JBODs, that only recognize 8-bits of
4877 # LUN ID. When they receive a value greater than 8 bits, they chop off
4878 # the high order bits. In other words, they see LUN IDs 0, 256, 512,
4879 # and so on all as LUN ID 0. This causes the linux kernel, which sees
4880 # valid responses at each of the LUN IDs, to believe there are multiple
4881 # devices present, when in fact, there is only 1.
4882 # A customer that is aware of their target behaviors, and the results as
4883 # indicated above, is welcome to increase the lpfc_max_luns value.
4884 # As mentioned, this value is not used by the lpfc driver, only the
4886 # Value range is [0,65535]. Default value is 255.
4887 # NOTE: The SCSI layer might probe all allowed LUN on some old targets.
4889 LPFC_VPORT_ULL_ATTR_R(max_luns, 255, 0, 65535, "Maximum allowed LUN ID");
4892 # lpfc_poll_tmo: .Milliseconds driver will wait between polling FCP ring.
4893 # Value range is [1,255], default value is 10.
4895 LPFC_ATTR_RW(poll_tmo, 10, 1, 255,
4896 "Milliseconds driver will wait between polling FCP ring");
4899 # lpfc_task_mgmt_tmo: Maximum time to wait for task management commands
4900 # to complete in seconds. Value range is [5,180], default value is 60.
4902 LPFC_ATTR_RW(task_mgmt_tmo, 60, 5, 180,
4903 "Maximum time to wait for task management commands to complete");
4905 # lpfc_use_msi: Use MSI (Message Signaled Interrupts) in systems that
4906 # support this feature
4909 # 2 = MSI-X enabled (default)
4910 # Value range is [0,2]. Default value is 2.
4912 LPFC_ATTR_R(use_msi, 2, 0, 2, "Use Message Signaled Interrupts (1) or "
4913 "MSI-X (2), if possible");
4916 * lpfc_nvme_oas: Use the oas bit when sending NVME/NVMET IOs
4918 * 0 = NVME OAS disabled
4919 * 1 = NVME OAS enabled
4921 * Value range is [0,1]. Default value is 0.
4923 LPFC_ATTR_RW(nvme_oas, 0, 0, 1,
4924 "Use OAS bit on NVME IOs");
4927 * lpfc_fcp_io_channel: Set the number of FCP IO channels the driver
4928 * will advertise it supports to the SCSI layer. This also will map to
4929 * the number of WQs the driver will create.
4931 * 0 = Configure the number of io channels to the number of active CPUs.
4932 * 1,32 = Manually specify how many io channels to use.
4934 * Value range is [0,32]. Default value is 4.
4936 LPFC_ATTR_R(fcp_io_channel,
4937 LPFC_FCP_IO_CHAN_DEF,
4938 LPFC_HBA_IO_CHAN_MIN, LPFC_HBA_IO_CHAN_MAX,
4939 "Set the number of FCP I/O channels");
4942 * lpfc_nvme_io_channel: Set the number of IO hardware queues the driver
4943 * will advertise it supports to the NVME layer. This also will map to
4944 * the number of WQs the driver will create.
4946 * This module parameter is valid when lpfc_enable_fc4_type is set
4949 * The NVME Layer will try to create this many, plus 1 administrative
4950 * hardware queue. The administrative queue will always map to WQ 0
4951 * A hardware IO queue maps (qidx) to a specific driver WQ.
4953 * 0 = Configure the number of io channels to the number of active CPUs.
4954 * 1,32 = Manually specify how many io channels to use.
4956 * Value range is [0,32]. Default value is 0.
4958 LPFC_ATTR_R(nvme_io_channel,
4959 LPFC_NVME_IO_CHAN_DEF,
4960 LPFC_HBA_IO_CHAN_MIN, LPFC_HBA_IO_CHAN_MAX,
4961 "Set the number of NVME I/O channels");
4964 # lpfc_enable_hba_reset: Allow or prevent HBA resets to the hardware.
4965 # 0 = HBA resets disabled
4966 # 1 = HBA resets enabled (default)
4967 # Value range is [0,1]. Default value is 1.
4969 LPFC_ATTR_R(enable_hba_reset, 1, 0, 1, "Enable HBA resets from the driver.");
4972 # lpfc_enable_hba_heartbeat: Disable HBA heartbeat timer..
4973 # 0 = HBA Heartbeat disabled
4974 # 1 = HBA Heartbeat enabled (default)
4975 # Value range is [0,1]. Default value is 1.
4977 LPFC_ATTR_R(enable_hba_heartbeat, 0, 0, 1, "Enable HBA Heartbeat.");
4980 # lpfc_EnableXLane: Enable Express Lane Feature
4981 # 0x0 Express Lane Feature disabled
4982 # 0x1 Express Lane Feature enabled
4983 # Value range is [0,1]. Default value is 0.
4985 LPFC_ATTR_R(EnableXLane, 0, 0, 1, "Enable Express Lane Feature.");
4988 # lpfc_XLanePriority: Define CS_CTL priority for Express Lane Feature
4989 # 0x0 - 0x7f = CS_CTL field in FC header (high 7 bits)
4990 # Value range is [0x0,0x7f]. Default value is 0
4992 LPFC_ATTR_RW(XLanePriority, 0, 0x0, 0x7f, "CS_CTL for Express Lane Feature.");
4995 # lpfc_enable_bg: Enable BlockGuard (Emulex's Implementation of T10-DIF)
4996 # 0 = BlockGuard disabled (default)
4997 # 1 = BlockGuard enabled
4998 # Value range is [0,1]. Default value is 0.
5000 LPFC_ATTR_R(enable_bg, 0, 0, 1, "Enable BlockGuard Support");
5003 # lpfc_fcp_look_ahead: Look ahead for completions in FCP start routine
5004 # 0 = disabled (default)
5006 # Value range is [0,1]. Default value is 0.
5008 # This feature in under investigation and may be supported in the future.
5010 unsigned int lpfc_fcp_look_ahead = LPFC_LOOK_AHEAD_OFF;
5014 # - Bit mask of host protection capabilities used to register with the
5016 # - Only meaningful if BG is turned on (lpfc_enable_bg=1).
5017 # - Allows you to ultimately specify which profiles to use
5018 # - Default will result in registering capabilities for all profiles.
5019 # - SHOST_DIF_TYPE1_PROTECTION 1
5020 # HBA supports T10 DIF Type 1: HBA to Target Type 1 Protection
5021 # - SHOST_DIX_TYPE0_PROTECTION 8
5022 # HBA supports DIX Type 0: Host to HBA protection only
5023 # - SHOST_DIX_TYPE1_PROTECTION 16
5024 # HBA supports DIX Type 1: Host to HBA Type 1 protection
5027 LPFC_ATTR(prot_mask,
5028 (SHOST_DIF_TYPE1_PROTECTION |
5029 SHOST_DIX_TYPE0_PROTECTION |
5030 SHOST_DIX_TYPE1_PROTECTION),
5032 (SHOST_DIF_TYPE1_PROTECTION |
5033 SHOST_DIX_TYPE0_PROTECTION |
5034 SHOST_DIX_TYPE1_PROTECTION),
5035 "T10-DIF host protection capabilities mask");
5038 # lpfc_prot_guard: i
5039 # - Bit mask of protection guard types to register with the SCSI mid-layer
5040 # - Guard types are currently either 1) T10-DIF CRC 2) IP checksum
5041 # - Allows you to ultimately specify which profiles to use
5042 # - Default will result in registering capabilities for all guard types
5045 LPFC_ATTR(prot_guard,
5046 SHOST_DIX_GUARD_IP, SHOST_DIX_GUARD_CRC, SHOST_DIX_GUARD_IP,
5047 "T10-DIF host protection guard type");
5050 * Delay initial NPort discovery when Clean Address bit is cleared in
5051 * FLOGI/FDISC accept and FCID/Fabric name/Fabric portname is changed.
5052 * This parameter can have value 0 or 1.
5053 * When this parameter is set to 0, no delay is added to the initial
5055 * When this parameter is set to non-zero value, initial Nport discovery is
5056 * delayed by ra_tov seconds when Clean Address bit is cleared in FLOGI/FDISC
5057 * accept and FCID/Fabric name/Fabric portname is changed.
5058 * Driver always delay Nport discovery for subsequent FLOGI/FDISC completion
5059 * when Clean Address bit is cleared in FLOGI/FDISC
5060 * accept and FCID/Fabric name/Fabric portname is changed.
5061 * Default value is 0.
5063 LPFC_ATTR(delay_discovery, 0, 0, 1,
5064 "Delay NPort discovery when Clean Address bit is cleared.");
5067 * lpfc_sg_seg_cnt - Initial Maximum DMA Segment Count
5068 * This value can be set to values between 64 and 4096. The default value is
5069 * 64, but may be increased to allow for larger Max I/O sizes. The scsi layer
5070 * will be allowed to request I/Os of sizes up to (MAX_SEG_COUNT * SEG_SIZE).
5071 * Because of the additional overhead involved in setting up T10-DIF,
5072 * this parameter will be limited to 128 if BlockGuard is enabled under SLI4
5073 * and will be limited to 512 if BlockGuard is enabled under SLI3.
5075 LPFC_ATTR_R(sg_seg_cnt, LPFC_DEFAULT_SG_SEG_CNT, LPFC_DEFAULT_SG_SEG_CNT,
5076 LPFC_MAX_SG_SEG_CNT, "Max Scatter Gather Segment Count");
5079 * lpfc_enable_mds_diags: Enable MDS Diagnostics
5080 * 0 = MDS Diagnostics disabled (default)
5081 * 1 = MDS Diagnostics enabled
5082 * Value range is [0,1]. Default value is 0.
5084 LPFC_ATTR_R(enable_mds_diags, 0, 0, 1, "Enable MDS Diagnostics");
5086 struct device_attribute *lpfc_hba_attrs[] = {
5087 &dev_attr_nvme_info,
5089 &dev_attr_bg_guard_err,
5090 &dev_attr_bg_apptag_err,
5091 &dev_attr_bg_reftag_err,
5093 &dev_attr_serialnum,
5094 &dev_attr_modeldesc,
5095 &dev_attr_modelname,
5096 &dev_attr_programtype,
5100 &dev_attr_option_rom_version,
5101 &dev_attr_link_state,
5102 &dev_attr_num_discovered_ports,
5103 &dev_attr_menlo_mgmt_mode,
5104 &dev_attr_lpfc_drvr_version,
5105 &dev_attr_lpfc_enable_fip,
5106 &dev_attr_lpfc_temp_sensor,
5107 &dev_attr_lpfc_log_verbose,
5108 &dev_attr_lpfc_lun_queue_depth,
5109 &dev_attr_lpfc_tgt_queue_depth,
5110 &dev_attr_lpfc_hba_queue_depth,
5111 &dev_attr_lpfc_peer_port_login,
5112 &dev_attr_lpfc_nodev_tmo,
5113 &dev_attr_lpfc_devloss_tmo,
5114 &dev_attr_lpfc_enable_fc4_type,
5115 &dev_attr_lpfc_xri_split,
5116 &dev_attr_lpfc_fcp_class,
5117 &dev_attr_lpfc_use_adisc,
5118 &dev_attr_lpfc_first_burst_size,
5119 &dev_attr_lpfc_ack0,
5120 &dev_attr_lpfc_topology,
5121 &dev_attr_lpfc_scan_down,
5122 &dev_attr_lpfc_link_speed,
5123 &dev_attr_lpfc_fcp_io_sched,
5124 &dev_attr_lpfc_fcp2_no_tgt_reset,
5125 &dev_attr_lpfc_cr_delay,
5126 &dev_attr_lpfc_cr_count,
5127 &dev_attr_lpfc_multi_ring_support,
5128 &dev_attr_lpfc_multi_ring_rctl,
5129 &dev_attr_lpfc_multi_ring_type,
5130 &dev_attr_lpfc_fdmi_on,
5131 &dev_attr_lpfc_enable_SmartSAN,
5132 &dev_attr_lpfc_max_luns,
5133 &dev_attr_lpfc_enable_npiv,
5134 &dev_attr_lpfc_fcf_failover_policy,
5135 &dev_attr_lpfc_enable_rrq,
5136 &dev_attr_nport_evt_cnt,
5137 &dev_attr_board_mode,
5144 &dev_attr_npiv_info,
5145 &dev_attr_issue_reset,
5146 &dev_attr_lpfc_poll,
5147 &dev_attr_lpfc_poll_tmo,
5148 &dev_attr_lpfc_task_mgmt_tmo,
5149 &dev_attr_lpfc_use_msi,
5150 &dev_attr_lpfc_nvme_oas,
5151 &dev_attr_lpfc_fcp_imax,
5152 &dev_attr_lpfc_fcp_cpu_map,
5153 &dev_attr_lpfc_fcp_io_channel,
5154 &dev_attr_lpfc_suppress_rsp,
5155 &dev_attr_lpfc_nvme_io_channel,
5156 &dev_attr_lpfc_nvmet_mrq,
5157 &dev_attr_lpfc_nvmet_mrq_post,
5158 &dev_attr_lpfc_nvme_enable_fb,
5159 &dev_attr_lpfc_nvmet_fb_size,
5160 &dev_attr_lpfc_enable_bg,
5161 &dev_attr_lpfc_soft_wwnn,
5162 &dev_attr_lpfc_soft_wwpn,
5163 &dev_attr_lpfc_soft_wwn_enable,
5164 &dev_attr_lpfc_enable_hba_reset,
5165 &dev_attr_lpfc_enable_hba_heartbeat,
5166 &dev_attr_lpfc_EnableXLane,
5167 &dev_attr_lpfc_XLanePriority,
5168 &dev_attr_lpfc_xlane_lun,
5169 &dev_attr_lpfc_xlane_tgt,
5170 &dev_attr_lpfc_xlane_vpt,
5171 &dev_attr_lpfc_xlane_lun_state,
5172 &dev_attr_lpfc_xlane_lun_status,
5173 &dev_attr_lpfc_xlane_priority,
5174 &dev_attr_lpfc_sg_seg_cnt,
5175 &dev_attr_lpfc_max_scsicmpl_time,
5176 &dev_attr_lpfc_stat_data_ctrl,
5177 &dev_attr_lpfc_aer_support,
5178 &dev_attr_lpfc_aer_state_cleanup,
5179 &dev_attr_lpfc_sriov_nr_virtfn,
5180 &dev_attr_lpfc_req_fw_upgrade,
5181 &dev_attr_lpfc_suppress_link_up,
5182 &dev_attr_lpfc_iocb_cnt,
5185 &dev_attr_txcmplq_hw,
5186 &dev_attr_lpfc_fips_level,
5187 &dev_attr_lpfc_fips_rev,
5189 &dev_attr_lpfc_sriov_hw_max_virtfn,
5191 &dev_attr_lpfc_xlane_supported,
5192 &dev_attr_lpfc_enable_mds_diags,
5196 struct device_attribute *lpfc_vport_attrs[] = {
5198 &dev_attr_link_state,
5199 &dev_attr_num_discovered_ports,
5200 &dev_attr_lpfc_drvr_version,
5201 &dev_attr_lpfc_log_verbose,
5202 &dev_attr_lpfc_lun_queue_depth,
5203 &dev_attr_lpfc_tgt_queue_depth,
5204 &dev_attr_lpfc_nodev_tmo,
5205 &dev_attr_lpfc_devloss_tmo,
5206 &dev_attr_lpfc_hba_queue_depth,
5207 &dev_attr_lpfc_peer_port_login,
5208 &dev_attr_lpfc_restrict_login,
5209 &dev_attr_lpfc_fcp_class,
5210 &dev_attr_lpfc_use_adisc,
5211 &dev_attr_lpfc_first_burst_size,
5212 &dev_attr_lpfc_max_luns,
5213 &dev_attr_nport_evt_cnt,
5214 &dev_attr_npiv_info,
5215 &dev_attr_lpfc_enable_da_id,
5216 &dev_attr_lpfc_max_scsicmpl_time,
5217 &dev_attr_lpfc_stat_data_ctrl,
5218 &dev_attr_lpfc_static_vport,
5219 &dev_attr_lpfc_fips_level,
5220 &dev_attr_lpfc_fips_rev,
5225 * sysfs_ctlreg_write - Write method for writing to ctlreg
5226 * @filp: open sysfs file
5227 * @kobj: kernel kobject that contains the kernel class device.
5228 * @bin_attr: kernel attributes passed to us.
5229 * @buf: contains the data to be written to the adapter IOREG space.
5230 * @off: offset into buffer to beginning of data.
5231 * @count: bytes to transfer.
5234 * Accessed via /sys/class/scsi_host/hostxxx/ctlreg.
5235 * Uses the adapter io control registers to send buf contents to the adapter.
5238 * -ERANGE off and count combo out of range
5239 * -EINVAL off, count or buff address invalid
5240 * -EPERM adapter is offline
5241 * value of count, buf contents written
5244 sysfs_ctlreg_write(struct file *filp, struct kobject *kobj,
5245 struct bin_attribute *bin_attr,
5246 char *buf, loff_t off, size_t count)
5249 struct device *dev = container_of(kobj, struct device, kobj);
5250 struct Scsi_Host *shost = class_to_shost(dev);
5251 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
5252 struct lpfc_hba *phba = vport->phba;
5254 if (phba->sli_rev >= LPFC_SLI_REV4)
5257 if ((off + count) > FF_REG_AREA_SIZE)
5260 if (count <= LPFC_REG_WRITE_KEY_SIZE)
5263 if (off % 4 || count % 4 || (unsigned long)buf % 4)
5266 /* This is to protect HBA registers from accidental writes. */
5267 if (memcmp(buf, LPFC_REG_WRITE_KEY, LPFC_REG_WRITE_KEY_SIZE))
5270 if (!(vport->fc_flag & FC_OFFLINE_MODE))
5273 spin_lock_irq(&phba->hbalock);
5274 for (buf_off = 0; buf_off < count - LPFC_REG_WRITE_KEY_SIZE;
5275 buf_off += sizeof(uint32_t))
5276 writel(*((uint32_t *)(buf + buf_off + LPFC_REG_WRITE_KEY_SIZE)),
5277 phba->ctrl_regs_memmap_p + off + buf_off);
5279 spin_unlock_irq(&phba->hbalock);
5285 * sysfs_ctlreg_read - Read method for reading from ctlreg
5286 * @filp: open sysfs file
5287 * @kobj: kernel kobject that contains the kernel class device.
5288 * @bin_attr: kernel attributes passed to us.
5289 * @buf: if successful contains the data from the adapter IOREG space.
5290 * @off: offset into buffer to beginning of data.
5291 * @count: bytes to transfer.
5294 * Accessed via /sys/class/scsi_host/hostxxx/ctlreg.
5295 * Uses the adapter io control registers to read data into buf.
5298 * -ERANGE off and count combo out of range
5299 * -EINVAL off, count or buff address invalid
5300 * value of count, buf contents read
5303 sysfs_ctlreg_read(struct file *filp, struct kobject *kobj,
5304 struct bin_attribute *bin_attr,
5305 char *buf, loff_t off, size_t count)
5309 struct device *dev = container_of(kobj, struct device, kobj);
5310 struct Scsi_Host *shost = class_to_shost(dev);
5311 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
5312 struct lpfc_hba *phba = vport->phba;
5314 if (phba->sli_rev >= LPFC_SLI_REV4)
5317 if (off > FF_REG_AREA_SIZE)
5320 if ((off + count) > FF_REG_AREA_SIZE)
5321 count = FF_REG_AREA_SIZE - off;
5323 if (count == 0) return 0;
5325 if (off % 4 || count % 4 || (unsigned long)buf % 4)
5328 spin_lock_irq(&phba->hbalock);
5330 for (buf_off = 0; buf_off < count; buf_off += sizeof(uint32_t)) {
5331 tmp_ptr = (uint32_t *)(buf + buf_off);
5332 *tmp_ptr = readl(phba->ctrl_regs_memmap_p + off + buf_off);
5335 spin_unlock_irq(&phba->hbalock);
5340 static struct bin_attribute sysfs_ctlreg_attr = {
5343 .mode = S_IRUSR | S_IWUSR,
5346 .read = sysfs_ctlreg_read,
5347 .write = sysfs_ctlreg_write,
5351 * sysfs_mbox_write - Write method for writing information via mbox
5352 * @filp: open sysfs file
5353 * @kobj: kernel kobject that contains the kernel class device.
5354 * @bin_attr: kernel attributes passed to us.
5355 * @buf: contains the data to be written to sysfs mbox.
5356 * @off: offset into buffer to beginning of data.
5357 * @count: bytes to transfer.
5360 * Deprecated function. All mailbox access from user space is performed via the
5364 * -EPERM operation not permitted
5367 sysfs_mbox_write(struct file *filp, struct kobject *kobj,
5368 struct bin_attribute *bin_attr,
5369 char *buf, loff_t off, size_t count)
5375 * sysfs_mbox_read - Read method for reading information via mbox
5376 * @filp: open sysfs file
5377 * @kobj: kernel kobject that contains the kernel class device.
5378 * @bin_attr: kernel attributes passed to us.
5379 * @buf: contains the data to be read from sysfs mbox.
5380 * @off: offset into buffer to beginning of data.
5381 * @count: bytes to transfer.
5384 * Deprecated function. All mailbox access from user space is performed via the
5388 * -EPERM operation not permitted
5391 sysfs_mbox_read(struct file *filp, struct kobject *kobj,
5392 struct bin_attribute *bin_attr,
5393 char *buf, loff_t off, size_t count)
5398 static struct bin_attribute sysfs_mbox_attr = {
5401 .mode = S_IRUSR | S_IWUSR,
5403 .size = MAILBOX_SYSFS_MAX,
5404 .read = sysfs_mbox_read,
5405 .write = sysfs_mbox_write,
5409 * lpfc_alloc_sysfs_attr - Creates the ctlreg and mbox entries
5410 * @vport: address of lpfc vport structure.
5414 * error return code from sysfs_create_bin_file()
5417 lpfc_alloc_sysfs_attr(struct lpfc_vport *vport)
5419 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
5422 error = sysfs_create_bin_file(&shost->shost_dev.kobj,
5423 &sysfs_drvr_stat_data_attr);
5425 /* Virtual ports do not need ctrl_reg and mbox */
5426 if (error || vport->port_type == LPFC_NPIV_PORT)
5429 error = sysfs_create_bin_file(&shost->shost_dev.kobj,
5430 &sysfs_ctlreg_attr);
5432 goto out_remove_stat_attr;
5434 error = sysfs_create_bin_file(&shost->shost_dev.kobj,
5437 goto out_remove_ctlreg_attr;
5440 out_remove_ctlreg_attr:
5441 sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr);
5442 out_remove_stat_attr:
5443 sysfs_remove_bin_file(&shost->shost_dev.kobj,
5444 &sysfs_drvr_stat_data_attr);
5450 * lpfc_free_sysfs_attr - Removes the ctlreg and mbox entries
5451 * @vport: address of lpfc vport structure.
5454 lpfc_free_sysfs_attr(struct lpfc_vport *vport)
5456 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
5457 sysfs_remove_bin_file(&shost->shost_dev.kobj,
5458 &sysfs_drvr_stat_data_attr);
5459 /* Virtual ports do not need ctrl_reg and mbox */
5460 if (vport->port_type == LPFC_NPIV_PORT)
5462 sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_mbox_attr);
5463 sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr);
5467 * Dynamic FC Host Attributes Support
5471 * lpfc_get_host_symbolic_name - Copy symbolic name into the scsi host
5472 * @shost: kernel scsi host pointer.
5475 lpfc_get_host_symbolic_name(struct Scsi_Host *shost)
5477 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
5479 lpfc_vport_symbolic_node_name(vport, fc_host_symbolic_name(shost),
5480 sizeof fc_host_symbolic_name(shost));
5484 * lpfc_get_host_port_id - Copy the vport DID into the scsi host port id
5485 * @shost: kernel scsi host pointer.
5488 lpfc_get_host_port_id(struct Scsi_Host *shost)
5490 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
5492 /* note: fc_myDID already in cpu endianness */
5493 fc_host_port_id(shost) = vport->fc_myDID;
5497 * lpfc_get_host_port_type - Set the value of the scsi host port type
5498 * @shost: kernel scsi host pointer.
5501 lpfc_get_host_port_type(struct Scsi_Host *shost)
5503 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
5504 struct lpfc_hba *phba = vport->phba;
5506 spin_lock_irq(shost->host_lock);
5508 if (vport->port_type == LPFC_NPIV_PORT) {
5509 fc_host_port_type(shost) = FC_PORTTYPE_NPIV;
5510 } else if (lpfc_is_link_up(phba)) {
5511 if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
5512 if (vport->fc_flag & FC_PUBLIC_LOOP)
5513 fc_host_port_type(shost) = FC_PORTTYPE_NLPORT;
5515 fc_host_port_type(shost) = FC_PORTTYPE_LPORT;
5517 if (vport->fc_flag & FC_FABRIC)
5518 fc_host_port_type(shost) = FC_PORTTYPE_NPORT;
5520 fc_host_port_type(shost) = FC_PORTTYPE_PTP;
5523 fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN;
5525 spin_unlock_irq(shost->host_lock);
5529 * lpfc_get_host_port_state - Set the value of the scsi host port state
5530 * @shost: kernel scsi host pointer.
5533 lpfc_get_host_port_state(struct Scsi_Host *shost)
5535 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
5536 struct lpfc_hba *phba = vport->phba;
5538 spin_lock_irq(shost->host_lock);
5540 if (vport->fc_flag & FC_OFFLINE_MODE)
5541 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
5543 switch (phba->link_state) {
5544 case LPFC_LINK_UNKNOWN:
5545 case LPFC_LINK_DOWN:
5546 fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
5550 case LPFC_HBA_READY:
5551 /* Links up, reports port state accordingly */
5552 if (vport->port_state < LPFC_VPORT_READY)
5553 fc_host_port_state(shost) =
5554 FC_PORTSTATE_BYPASSED;
5556 fc_host_port_state(shost) =
5557 FC_PORTSTATE_ONLINE;
5559 case LPFC_HBA_ERROR:
5560 fc_host_port_state(shost) = FC_PORTSTATE_ERROR;
5563 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
5568 spin_unlock_irq(shost->host_lock);
5572 * lpfc_get_host_speed - Set the value of the scsi host speed
5573 * @shost: kernel scsi host pointer.
5576 lpfc_get_host_speed(struct Scsi_Host *shost)
5578 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
5579 struct lpfc_hba *phba = vport->phba;
5581 spin_lock_irq(shost->host_lock);
5583 if ((lpfc_is_link_up(phba)) && (!(phba->hba_flag & HBA_FCOE_MODE))) {
5584 switch(phba->fc_linkspeed) {
5585 case LPFC_LINK_SPEED_1GHZ:
5586 fc_host_speed(shost) = FC_PORTSPEED_1GBIT;
5588 case LPFC_LINK_SPEED_2GHZ:
5589 fc_host_speed(shost) = FC_PORTSPEED_2GBIT;
5591 case LPFC_LINK_SPEED_4GHZ:
5592 fc_host_speed(shost) = FC_PORTSPEED_4GBIT;
5594 case LPFC_LINK_SPEED_8GHZ:
5595 fc_host_speed(shost) = FC_PORTSPEED_8GBIT;
5597 case LPFC_LINK_SPEED_10GHZ:
5598 fc_host_speed(shost) = FC_PORTSPEED_10GBIT;
5600 case LPFC_LINK_SPEED_16GHZ:
5601 fc_host_speed(shost) = FC_PORTSPEED_16GBIT;
5603 case LPFC_LINK_SPEED_32GHZ:
5604 fc_host_speed(shost) = FC_PORTSPEED_32GBIT;
5607 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
5611 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
5613 spin_unlock_irq(shost->host_lock);
5617 * lpfc_get_host_fabric_name - Set the value of the scsi host fabric name
5618 * @shost: kernel scsi host pointer.
5621 lpfc_get_host_fabric_name (struct Scsi_Host *shost)
5623 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
5624 struct lpfc_hba *phba = vport->phba;
5627 spin_lock_irq(shost->host_lock);
5629 if ((vport->port_state > LPFC_FLOGI) &&
5630 ((vport->fc_flag & FC_FABRIC) ||
5631 ((phba->fc_topology == LPFC_TOPOLOGY_LOOP) &&
5632 (vport->fc_flag & FC_PUBLIC_LOOP))))
5633 node_name = wwn_to_u64(phba->fc_fabparam.nodeName.u.wwn);
5635 /* fabric is local port if there is no F/FL_Port */
5638 spin_unlock_irq(shost->host_lock);
5640 fc_host_fabric_name(shost) = node_name;
5644 * lpfc_get_stats - Return statistical information about the adapter
5645 * @shost: kernel scsi host pointer.
5648 * NULL on error for link down, no mbox pool, sli2 active,
5649 * management not allowed, memory allocation error, or mbox error.
5653 * address of the adapter host statistics
5655 static struct fc_host_statistics *
5656 lpfc_get_stats(struct Scsi_Host *shost)
5658 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
5659 struct lpfc_hba *phba = vport->phba;
5660 struct lpfc_sli *psli = &phba->sli;
5661 struct fc_host_statistics *hs = &phba->link_stats;
5662 struct lpfc_lnk_stat * lso = &psli->lnk_stat_offsets;
5663 LPFC_MBOXQ_t *pmboxq;
5665 unsigned long seconds;
5669 * prevent udev from issuing mailbox commands until the port is
5672 if (phba->link_state < LPFC_LINK_DOWN ||
5673 !phba->mbox_mem_pool ||
5674 (phba->sli.sli_flag & LPFC_SLI_ACTIVE) == 0)
5677 if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
5680 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
5683 memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
5685 pmb = &pmboxq->u.mb;
5686 pmb->mbxCommand = MBX_READ_STATUS;
5687 pmb->mbxOwner = OWN_HOST;
5688 pmboxq->context1 = NULL;
5689 pmboxq->vport = vport;
5691 if (vport->fc_flag & FC_OFFLINE_MODE)
5692 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
5694 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
5696 if (rc != MBX_SUCCESS) {
5697 if (rc != MBX_TIMEOUT)
5698 mempool_free(pmboxq, phba->mbox_mem_pool);
5702 memset(hs, 0, sizeof (struct fc_host_statistics));
5704 hs->tx_frames = pmb->un.varRdStatus.xmitFrameCnt;
5706 * The MBX_READ_STATUS returns tx_k_bytes which has to
5707 * converted to words
5709 hs->tx_words = (uint64_t)
5710 ((uint64_t)pmb->un.varRdStatus.xmitByteCnt
5712 hs->rx_frames = pmb->un.varRdStatus.rcvFrameCnt;
5713 hs->rx_words = (uint64_t)
5714 ((uint64_t)pmb->un.varRdStatus.rcvByteCnt
5717 memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
5718 pmb->mbxCommand = MBX_READ_LNK_STAT;
5719 pmb->mbxOwner = OWN_HOST;
5720 pmboxq->context1 = NULL;
5721 pmboxq->vport = vport;
5723 if (vport->fc_flag & FC_OFFLINE_MODE)
5724 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
5726 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
5728 if (rc != MBX_SUCCESS) {
5729 if (rc != MBX_TIMEOUT)
5730 mempool_free(pmboxq, phba->mbox_mem_pool);
5734 hs->link_failure_count = pmb->un.varRdLnk.linkFailureCnt;
5735 hs->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt;
5736 hs->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt;
5737 hs->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt;
5738 hs->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord;
5739 hs->invalid_crc_count = pmb->un.varRdLnk.crcCnt;
5740 hs->error_frames = pmb->un.varRdLnk.crcCnt;
5742 hs->link_failure_count -= lso->link_failure_count;
5743 hs->loss_of_sync_count -= lso->loss_of_sync_count;
5744 hs->loss_of_signal_count -= lso->loss_of_signal_count;
5745 hs->prim_seq_protocol_err_count -= lso->prim_seq_protocol_err_count;
5746 hs->invalid_tx_word_count -= lso->invalid_tx_word_count;
5747 hs->invalid_crc_count -= lso->invalid_crc_count;
5748 hs->error_frames -= lso->error_frames;
5750 if (phba->hba_flag & HBA_FCOE_MODE) {
5752 hs->nos_count = (phba->link_events >> 1);
5753 hs->nos_count -= lso->link_events;
5754 } else if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
5755 hs->lip_count = (phba->fc_eventTag >> 1);
5756 hs->lip_count -= lso->link_events;
5760 hs->nos_count = (phba->fc_eventTag >> 1);
5761 hs->nos_count -= lso->link_events;
5764 hs->dumped_frames = -1;
5766 seconds = get_seconds();
5767 if (seconds < psli->stats_start)
5768 hs->seconds_since_last_reset = seconds +
5769 ((unsigned long)-1 - psli->stats_start);
5771 hs->seconds_since_last_reset = seconds - psli->stats_start;
5773 mempool_free(pmboxq, phba->mbox_mem_pool);
5779 * lpfc_reset_stats - Copy the adapter link stats information
5780 * @shost: kernel scsi host pointer.
5783 lpfc_reset_stats(struct Scsi_Host *shost)
5785 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
5786 struct lpfc_hba *phba = vport->phba;
5787 struct lpfc_sli *psli = &phba->sli;
5788 struct lpfc_lnk_stat *lso = &psli->lnk_stat_offsets;
5789 LPFC_MBOXQ_t *pmboxq;
5793 if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
5796 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
5799 memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
5801 pmb = &pmboxq->u.mb;
5802 pmb->mbxCommand = MBX_READ_STATUS;
5803 pmb->mbxOwner = OWN_HOST;
5804 pmb->un.varWords[0] = 0x1; /* reset request */
5805 pmboxq->context1 = NULL;
5806 pmboxq->vport = vport;
5808 if ((vport->fc_flag & FC_OFFLINE_MODE) ||
5809 (!(psli->sli_flag & LPFC_SLI_ACTIVE)))
5810 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
5812 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
5814 if (rc != MBX_SUCCESS) {
5815 if (rc != MBX_TIMEOUT)
5816 mempool_free(pmboxq, phba->mbox_mem_pool);
5820 memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
5821 pmb->mbxCommand = MBX_READ_LNK_STAT;
5822 pmb->mbxOwner = OWN_HOST;
5823 pmboxq->context1 = NULL;
5824 pmboxq->vport = vport;
5826 if ((vport->fc_flag & FC_OFFLINE_MODE) ||
5827 (!(psli->sli_flag & LPFC_SLI_ACTIVE)))
5828 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
5830 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
5832 if (rc != MBX_SUCCESS) {
5833 if (rc != MBX_TIMEOUT)
5834 mempool_free( pmboxq, phba->mbox_mem_pool);
5838 lso->link_failure_count = pmb->un.varRdLnk.linkFailureCnt;
5839 lso->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt;
5840 lso->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt;
5841 lso->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt;
5842 lso->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord;
5843 lso->invalid_crc_count = pmb->un.varRdLnk.crcCnt;
5844 lso->error_frames = pmb->un.varRdLnk.crcCnt;
5845 if (phba->hba_flag & HBA_FCOE_MODE)
5846 lso->link_events = (phba->link_events >> 1);
5848 lso->link_events = (phba->fc_eventTag >> 1);
5850 psli->stats_start = get_seconds();
5852 mempool_free(pmboxq, phba->mbox_mem_pool);
5858 * The LPFC driver treats linkdown handling as target loss events so there
5859 * are no sysfs handlers for link_down_tmo.
5863 * lpfc_get_node_by_target - Return the nodelist for a target
5864 * @starget: kernel scsi target pointer.
5867 * address of the node list if found
5868 * NULL target not found
5870 static struct lpfc_nodelist *
5871 lpfc_get_node_by_target(struct scsi_target *starget)
5873 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
5874 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
5875 struct lpfc_nodelist *ndlp;
5877 spin_lock_irq(shost->host_lock);
5878 /* Search for this, mapped, target ID */
5879 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
5880 if (NLP_CHK_NODE_ACT(ndlp) &&
5881 ndlp->nlp_state == NLP_STE_MAPPED_NODE &&
5882 starget->id == ndlp->nlp_sid) {
5883 spin_unlock_irq(shost->host_lock);
5887 spin_unlock_irq(shost->host_lock);
5892 * lpfc_get_starget_port_id - Set the target port id to the ndlp DID or -1
5893 * @starget: kernel scsi target pointer.
5896 lpfc_get_starget_port_id(struct scsi_target *starget)
5898 struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
5900 fc_starget_port_id(starget) = ndlp ? ndlp->nlp_DID : -1;
5904 * lpfc_get_starget_node_name - Set the target node name
5905 * @starget: kernel scsi target pointer.
5907 * Description: Set the target node name to the ndlp node name wwn or zero.
5910 lpfc_get_starget_node_name(struct scsi_target *starget)
5912 struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
5914 fc_starget_node_name(starget) =
5915 ndlp ? wwn_to_u64(ndlp->nlp_nodename.u.wwn) : 0;
5919 * lpfc_get_starget_port_name - Set the target port name
5920 * @starget: kernel scsi target pointer.
5922 * Description: set the target port name to the ndlp port name wwn or zero.
5925 lpfc_get_starget_port_name(struct scsi_target *starget)
5927 struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
5929 fc_starget_port_name(starget) =
5930 ndlp ? wwn_to_u64(ndlp->nlp_portname.u.wwn) : 0;
5934 * lpfc_set_rport_loss_tmo - Set the rport dev loss tmo
5935 * @rport: fc rport address.
5936 * @timeout: new value for dev loss tmo.
5939 * If timeout is non zero set the dev_loss_tmo to timeout, else set
5940 * dev_loss_tmo to one.
5943 lpfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
5946 rport->dev_loss_tmo = timeout;
5948 rport->dev_loss_tmo = 1;
5952 * lpfc_rport_show_function - Return rport target information
5955 * Macro that uses field to generate a function with the name lpfc_show_rport_
5957 * lpfc_show_rport_##field: returns the bytes formatted in buf
5958 * @cdev: class converted to an fc_rport.
5959 * @buf: on return contains the target_field or zero.
5961 * Returns: size of formatted string.
5963 #define lpfc_rport_show_function(field, format_string, sz, cast) \
5965 lpfc_show_rport_##field (struct device *dev, \
5966 struct device_attribute *attr, \
5969 struct fc_rport *rport = transport_class_to_rport(dev); \
5970 struct lpfc_rport_data *rdata = rport->hostdata; \
5971 return snprintf(buf, sz, format_string, \
5972 (rdata->target) ? cast rdata->target->field : 0); \
5975 #define lpfc_rport_rd_attr(field, format_string, sz) \
5976 lpfc_rport_show_function(field, format_string, sz, ) \
5977 static FC_RPORT_ATTR(field, S_IRUGO, lpfc_show_rport_##field, NULL)
5980 * lpfc_set_vport_symbolic_name - Set the vport's symbolic name
5981 * @fc_vport: The fc_vport who's symbolic name has been changed.
5984 * This function is called by the transport after the @fc_vport's symbolic name
5985 * has been changed. This function re-registers the symbolic name with the
5986 * switch to propagate the change into the fabric if the vport is active.
5989 lpfc_set_vport_symbolic_name(struct fc_vport *fc_vport)
5991 struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
5993 if (vport->port_state == LPFC_VPORT_READY)
5994 lpfc_ns_cmd(vport, SLI_CTNS_RSPN_ID, 0, 0);
5998 * lpfc_hba_log_verbose_init - Set hba's log verbose level
5999 * @phba: Pointer to lpfc_hba struct.
6001 * This function is called by the lpfc_get_cfgparam() routine to set the
6002 * module lpfc_log_verbose into the @phba cfg_log_verbose for use with
6003 * log message according to the module's lpfc_log_verbose parameter setting
6004 * before hba port or vport created.
6007 lpfc_hba_log_verbose_init(struct lpfc_hba *phba, uint32_t verbose)
6009 phba->cfg_log_verbose = verbose;
6012 struct fc_function_template lpfc_transport_functions = {
6013 /* fixed attributes the driver supports */
6014 .show_host_node_name = 1,
6015 .show_host_port_name = 1,
6016 .show_host_supported_classes = 1,
6017 .show_host_supported_fc4s = 1,
6018 .show_host_supported_speeds = 1,
6019 .show_host_maxframe_size = 1,
6021 .get_host_symbolic_name = lpfc_get_host_symbolic_name,
6022 .show_host_symbolic_name = 1,
6024 /* dynamic attributes the driver supports */
6025 .get_host_port_id = lpfc_get_host_port_id,
6026 .show_host_port_id = 1,
6028 .get_host_port_type = lpfc_get_host_port_type,
6029 .show_host_port_type = 1,
6031 .get_host_port_state = lpfc_get_host_port_state,
6032 .show_host_port_state = 1,
6034 /* active_fc4s is shown but doesn't change (thus no get function) */
6035 .show_host_active_fc4s = 1,
6037 .get_host_speed = lpfc_get_host_speed,
6038 .show_host_speed = 1,
6040 .get_host_fabric_name = lpfc_get_host_fabric_name,
6041 .show_host_fabric_name = 1,
6044 * The LPFC driver treats linkdown handling as target loss events
6045 * so there are no sysfs handlers for link_down_tmo.
6048 .get_fc_host_stats = lpfc_get_stats,
6049 .reset_fc_host_stats = lpfc_reset_stats,
6051 .dd_fcrport_size = sizeof(struct lpfc_rport_data),
6052 .show_rport_maxframe_size = 1,
6053 .show_rport_supported_classes = 1,
6055 .set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo,
6056 .show_rport_dev_loss_tmo = 1,
6058 .get_starget_port_id = lpfc_get_starget_port_id,
6059 .show_starget_port_id = 1,
6061 .get_starget_node_name = lpfc_get_starget_node_name,
6062 .show_starget_node_name = 1,
6064 .get_starget_port_name = lpfc_get_starget_port_name,
6065 .show_starget_port_name = 1,
6067 .issue_fc_host_lip = lpfc_issue_lip,
6068 .dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk,
6069 .terminate_rport_io = lpfc_terminate_rport_io,
6071 .dd_fcvport_size = sizeof(struct lpfc_vport *),
6073 .vport_disable = lpfc_vport_disable,
6075 .set_vport_symbolic_name = lpfc_set_vport_symbolic_name,
6077 .bsg_request = lpfc_bsg_request,
6078 .bsg_timeout = lpfc_bsg_timeout,
6081 struct fc_function_template lpfc_vport_transport_functions = {
6082 /* fixed attributes the driver supports */
6083 .show_host_node_name = 1,
6084 .show_host_port_name = 1,
6085 .show_host_supported_classes = 1,
6086 .show_host_supported_fc4s = 1,
6087 .show_host_supported_speeds = 1,
6088 .show_host_maxframe_size = 1,
6090 .get_host_symbolic_name = lpfc_get_host_symbolic_name,
6091 .show_host_symbolic_name = 1,
6093 /* dynamic attributes the driver supports */
6094 .get_host_port_id = lpfc_get_host_port_id,
6095 .show_host_port_id = 1,
6097 .get_host_port_type = lpfc_get_host_port_type,
6098 .show_host_port_type = 1,
6100 .get_host_port_state = lpfc_get_host_port_state,
6101 .show_host_port_state = 1,
6103 /* active_fc4s is shown but doesn't change (thus no get function) */
6104 .show_host_active_fc4s = 1,
6106 .get_host_speed = lpfc_get_host_speed,
6107 .show_host_speed = 1,
6109 .get_host_fabric_name = lpfc_get_host_fabric_name,
6110 .show_host_fabric_name = 1,
6113 * The LPFC driver treats linkdown handling as target loss events
6114 * so there are no sysfs handlers for link_down_tmo.
6117 .get_fc_host_stats = lpfc_get_stats,
6118 .reset_fc_host_stats = lpfc_reset_stats,
6120 .dd_fcrport_size = sizeof(struct lpfc_rport_data),
6121 .show_rport_maxframe_size = 1,
6122 .show_rport_supported_classes = 1,
6124 .set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo,
6125 .show_rport_dev_loss_tmo = 1,
6127 .get_starget_port_id = lpfc_get_starget_port_id,
6128 .show_starget_port_id = 1,
6130 .get_starget_node_name = lpfc_get_starget_node_name,
6131 .show_starget_node_name = 1,
6133 .get_starget_port_name = lpfc_get_starget_port_name,
6134 .show_starget_port_name = 1,
6136 .dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk,
6137 .terminate_rport_io = lpfc_terminate_rport_io,
6139 .vport_disable = lpfc_vport_disable,
6141 .set_vport_symbolic_name = lpfc_set_vport_symbolic_name,
6145 * lpfc_get_cfgparam - Used during probe_one to init the adapter structure
6146 * @phba: lpfc_hba pointer.
6149 lpfc_get_cfgparam(struct lpfc_hba *phba)
6151 lpfc_fcp_io_sched_init(phba, lpfc_fcp_io_sched);
6152 lpfc_fcp2_no_tgt_reset_init(phba, lpfc_fcp2_no_tgt_reset);
6153 lpfc_cr_delay_init(phba, lpfc_cr_delay);
6154 lpfc_cr_count_init(phba, lpfc_cr_count);
6155 lpfc_multi_ring_support_init(phba, lpfc_multi_ring_support);
6156 lpfc_multi_ring_rctl_init(phba, lpfc_multi_ring_rctl);
6157 lpfc_multi_ring_type_init(phba, lpfc_multi_ring_type);
6158 lpfc_ack0_init(phba, lpfc_ack0);
6159 lpfc_topology_init(phba, lpfc_topology);
6160 lpfc_link_speed_init(phba, lpfc_link_speed);
6161 lpfc_poll_tmo_init(phba, lpfc_poll_tmo);
6162 lpfc_task_mgmt_tmo_init(phba, lpfc_task_mgmt_tmo);
6163 lpfc_enable_npiv_init(phba, lpfc_enable_npiv);
6164 lpfc_fcf_failover_policy_init(phba, lpfc_fcf_failover_policy);
6165 lpfc_enable_rrq_init(phba, lpfc_enable_rrq);
6166 lpfc_fdmi_on_init(phba, lpfc_fdmi_on);
6167 lpfc_enable_SmartSAN_init(phba, lpfc_enable_SmartSAN);
6168 lpfc_use_msi_init(phba, lpfc_use_msi);
6169 lpfc_nvme_oas_init(phba, lpfc_nvme_oas);
6170 lpfc_fcp_imax_init(phba, lpfc_fcp_imax);
6171 lpfc_fcp_cpu_map_init(phba, lpfc_fcp_cpu_map);
6172 lpfc_enable_hba_reset_init(phba, lpfc_enable_hba_reset);
6173 lpfc_enable_hba_heartbeat_init(phba, lpfc_enable_hba_heartbeat);
6175 lpfc_EnableXLane_init(phba, lpfc_EnableXLane);
6176 if (phba->sli_rev != LPFC_SLI_REV4)
6177 phba->cfg_EnableXLane = 0;
6178 lpfc_XLanePriority_init(phba, lpfc_XLanePriority);
6180 memset(phba->cfg_oas_tgt_wwpn, 0, (8 * sizeof(uint8_t)));
6181 memset(phba->cfg_oas_vpt_wwpn, 0, (8 * sizeof(uint8_t)));
6182 phba->cfg_oas_lun_state = 0;
6183 phba->cfg_oas_lun_status = 0;
6184 phba->cfg_oas_flags = 0;
6185 phba->cfg_oas_priority = 0;
6186 lpfc_enable_bg_init(phba, lpfc_enable_bg);
6187 lpfc_prot_mask_init(phba, lpfc_prot_mask);
6188 lpfc_prot_guard_init(phba, lpfc_prot_guard);
6189 if (phba->sli_rev == LPFC_SLI_REV4)
6192 phba->cfg_poll = lpfc_poll;
6193 lpfc_suppress_rsp_init(phba, lpfc_suppress_rsp);
6195 lpfc_enable_fc4_type_init(phba, lpfc_enable_fc4_type);
6196 lpfc_nvmet_mrq_init(phba, lpfc_nvmet_mrq);
6197 lpfc_nvmet_mrq_post_init(phba, lpfc_nvmet_mrq_post);
6199 /* Initialize first burst. Target vs Initiator are different. */
6200 lpfc_nvme_enable_fb_init(phba, lpfc_nvme_enable_fb);
6201 lpfc_nvmet_fb_size_init(phba, lpfc_nvmet_fb_size);
6202 lpfc_fcp_io_channel_init(phba, lpfc_fcp_io_channel);
6203 lpfc_nvme_io_channel_init(phba, lpfc_nvme_io_channel);
6205 if (phba->sli_rev != LPFC_SLI_REV4) {
6206 /* NVME only supported on SLI4 */
6207 phba->nvmet_support = 0;
6208 phba->cfg_enable_fc4_type = LPFC_ENABLE_FCP;
6210 /* We MUST have FCP support */
6211 if (!(phba->cfg_enable_fc4_type & LPFC_ENABLE_FCP))
6212 phba->cfg_enable_fc4_type |= LPFC_ENABLE_FCP;
6215 /* A value of 0 means use the number of CPUs found in the system */
6216 if (phba->cfg_fcp_io_channel == 0)
6217 phba->cfg_fcp_io_channel = phba->sli4_hba.num_present_cpu;
6218 if (phba->cfg_nvme_io_channel == 0)
6219 phba->cfg_nvme_io_channel = phba->sli4_hba.num_present_cpu;
6221 if (phba->cfg_enable_fc4_type == LPFC_ENABLE_NVME)
6222 phba->cfg_fcp_io_channel = 0;
6224 if (phba->cfg_enable_fc4_type == LPFC_ENABLE_FCP)
6225 phba->cfg_nvme_io_channel = 0;
6227 if (phba->cfg_fcp_io_channel > phba->cfg_nvme_io_channel)
6228 phba->io_channel_irqs = phba->cfg_fcp_io_channel;
6230 phba->io_channel_irqs = phba->cfg_nvme_io_channel;
6232 phba->cfg_soft_wwnn = 0L;
6233 phba->cfg_soft_wwpn = 0L;
6234 lpfc_xri_split_init(phba, lpfc_xri_split);
6235 lpfc_sg_seg_cnt_init(phba, lpfc_sg_seg_cnt);
6236 lpfc_hba_queue_depth_init(phba, lpfc_hba_queue_depth);
6237 lpfc_hba_log_verbose_init(phba, lpfc_log_verbose);
6238 lpfc_aer_support_init(phba, lpfc_aer_support);
6239 lpfc_sriov_nr_virtfn_init(phba, lpfc_sriov_nr_virtfn);
6240 lpfc_request_firmware_upgrade_init(phba, lpfc_req_fw_upgrade);
6241 lpfc_suppress_link_up_init(phba, lpfc_suppress_link_up);
6242 lpfc_iocb_cnt_init(phba, lpfc_iocb_cnt);
6243 lpfc_delay_discovery_init(phba, lpfc_delay_discovery);
6244 lpfc_sli_mode_init(phba, lpfc_sli_mode);
6245 phba->cfg_enable_dss = 1;
6246 lpfc_enable_mds_diags_init(phba, lpfc_enable_mds_diags);
6251 * lpfc_nvme_mod_param_dep - Adjust module parameter value based on
6252 * dependencies between protocols and roles.
6253 * @phba: lpfc_hba pointer.
6256 lpfc_nvme_mod_param_dep(struct lpfc_hba *phba)
6258 if (phba->cfg_nvme_io_channel > phba->sli4_hba.num_present_cpu)
6259 phba->cfg_nvme_io_channel = phba->sli4_hba.num_present_cpu;
6261 if (phba->cfg_fcp_io_channel > phba->sli4_hba.num_present_cpu)
6262 phba->cfg_fcp_io_channel = phba->sli4_hba.num_present_cpu;
6264 if (phba->cfg_enable_fc4_type & LPFC_ENABLE_NVME &&
6265 phba->nvmet_support) {
6266 phba->cfg_enable_fc4_type &= ~LPFC_ENABLE_FCP;
6267 phba->cfg_fcp_io_channel = 0;
6269 lpfc_printf_log(phba, KERN_INFO, LOG_NVME_DISC,
6270 "6013 %s x%x fb_size x%x, fb_max x%x\n",
6271 "NVME Target PRLI ACC enable_fb ",
6272 phba->cfg_nvme_enable_fb,
6273 phba->cfg_nvmet_fb_size,
6274 LPFC_NVMET_FB_SZ_MAX);
6276 if (phba->cfg_nvme_enable_fb == 0)
6277 phba->cfg_nvmet_fb_size = 0;
6279 if (phba->cfg_nvmet_fb_size > LPFC_NVMET_FB_SZ_MAX)
6280 phba->cfg_nvmet_fb_size = LPFC_NVMET_FB_SZ_MAX;
6283 /* Adjust lpfc_nvmet_mrq to avoid running out of WQE slots */
6284 if (phba->cfg_nvmet_mrq > phba->cfg_nvme_io_channel) {
6285 phba->cfg_nvmet_mrq = phba->cfg_nvme_io_channel;
6286 lpfc_printf_log(phba, KERN_ERR, LOG_NVME_DISC,
6287 "6018 Adjust lpfc_nvmet_mrq to %d\n",
6288 phba->cfg_nvmet_mrq);
6291 /* Not NVME Target mode. Turn off Target parameters. */
6292 phba->nvmet_support = 0;
6293 phba->cfg_nvmet_mrq = 0;
6294 phba->cfg_nvmet_mrq_post = 0;
6295 phba->cfg_nvmet_fb_size = 0;
6298 if (phba->cfg_fcp_io_channel > phba->cfg_nvme_io_channel)
6299 phba->io_channel_irqs = phba->cfg_fcp_io_channel;
6301 phba->io_channel_irqs = phba->cfg_nvme_io_channel;
6305 * lpfc_get_vport_cfgparam - Used during port create, init the vport structure
6306 * @vport: lpfc_vport pointer.
6309 lpfc_get_vport_cfgparam(struct lpfc_vport *vport)
6311 lpfc_log_verbose_init(vport, lpfc_log_verbose);
6312 lpfc_lun_queue_depth_init(vport, lpfc_lun_queue_depth);
6313 lpfc_tgt_queue_depth_init(vport, lpfc_tgt_queue_depth);
6314 lpfc_devloss_tmo_init(vport, lpfc_devloss_tmo);
6315 lpfc_nodev_tmo_init(vport, lpfc_nodev_tmo);
6316 lpfc_peer_port_login_init(vport, lpfc_peer_port_login);
6317 lpfc_restrict_login_init(vport, lpfc_restrict_login);
6318 lpfc_fcp_class_init(vport, lpfc_fcp_class);
6319 lpfc_use_adisc_init(vport, lpfc_use_adisc);
6320 lpfc_first_burst_size_init(vport, lpfc_first_burst_size);
6321 lpfc_max_scsicmpl_time_init(vport, lpfc_max_scsicmpl_time);
6322 lpfc_discovery_threads_init(vport, lpfc_discovery_threads);
6323 lpfc_max_luns_init(vport, lpfc_max_luns);
6324 lpfc_scan_down_init(vport, lpfc_scan_down);
6325 lpfc_enable_da_id_init(vport, lpfc_enable_da_id);