1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2004-2012 Emulex. All rights reserved. *
5 * EMULEX and SLI are trademarks of Emulex. *
7 * Portions Copyright (C) 2004-2005 Christoph Hellwig *
9 * This program is free software; you can redistribute it and/or *
10 * modify it under the terms of version 2 of the GNU General *
11 * Public License as published by the Free Software Foundation. *
12 * This program is distributed in the hope that it will be useful. *
13 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND *
14 * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, *
15 * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE *
16 * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
17 * TO BE LEGALLY INVALID. See the GNU General Public License for *
18 * more details, a copy of which can be found in the file COPYING *
19 * included with this package. *
20 *******************************************************************/
22 #include <linux/ctype.h>
23 #include <linux/delay.h>
24 #include <linux/pci.h>
25 #include <linux/interrupt.h>
26 #include <linux/module.h>
27 #include <linux/aer.h>
28 #include <linux/gfp.h>
29 #include <linux/kernel.h>
31 #include <scsi/scsi.h>
32 #include <scsi/scsi_device.h>
33 #include <scsi/scsi_host.h>
34 #include <scsi/scsi_tcq.h>
35 #include <scsi/scsi_transport_fc.h>
36 #include <scsi/fc/fc_fs.h>
41 #include "lpfc_sli4.h"
43 #include "lpfc_disc.h"
44 #include "lpfc_scsi.h"
46 #include "lpfc_logmsg.h"
47 #include "lpfc_version.h"
48 #include "lpfc_compat.h"
49 #include "lpfc_crtn.h"
50 #include "lpfc_vport.h"
52 #define LPFC_DEF_DEVLOSS_TMO 30
53 #define LPFC_MIN_DEVLOSS_TMO 1
54 #define LPFC_MAX_DEVLOSS_TMO 255
57 * Write key size should be multiple of 4. If write key is changed
58 * make sure that library write key is also changed.
60 #define LPFC_REG_WRITE_KEY_SIZE 4
61 #define LPFC_REG_WRITE_KEY "EMLX"
64 * lpfc_jedec_to_ascii - Hex to ascii convertor according to JEDEC rules
65 * @incr: integer to convert.
66 * @hdw: ascii string holding converted integer plus a string terminator.
69 * JEDEC Joint Electron Device Engineering Council.
70 * Convert a 32 bit integer composed of 8 nibbles into an 8 byte ascii
71 * character string. The string is then terminated with a NULL in byte 9.
72 * Hex 0-9 becomes ascii '0' to '9'.
73 * Hex a-f becomes ascii '=' to 'B' capital B.
76 * Coded for 32 bit integers only.
79 lpfc_jedec_to_ascii(int incr, char hdw[])
82 for (i = 0; i < 8; i++) {
85 hdw[7 - i] = 0x30 + j;
87 hdw[7 - i] = 0x61 + j - 10;
95 * lpfc_drvr_version_show - Return the Emulex driver string with version number
96 * @dev: class unused variable.
97 * @attr: device attribute, not used.
98 * @buf: on return contains the module description text.
100 * Returns: size of formatted string.
103 lpfc_drvr_version_show(struct device *dev, struct device_attribute *attr,
106 return snprintf(buf, PAGE_SIZE, LPFC_MODULE_DESC "\n");
110 * lpfc_enable_fip_show - Return the fip mode of the HBA
111 * @dev: class unused variable.
112 * @attr: device attribute, not used.
113 * @buf: on return contains the module description text.
115 * Returns: size of formatted string.
118 lpfc_enable_fip_show(struct device *dev, struct device_attribute *attr,
121 struct Scsi_Host *shost = class_to_shost(dev);
122 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
123 struct lpfc_hba *phba = vport->phba;
125 if (phba->hba_flag & HBA_FIP_SUPPORT)
126 return snprintf(buf, PAGE_SIZE, "1\n");
128 return snprintf(buf, PAGE_SIZE, "0\n");
132 lpfc_bg_info_show(struct device *dev, struct device_attribute *attr,
135 struct Scsi_Host *shost = class_to_shost(dev);
136 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
137 struct lpfc_hba *phba = vport->phba;
139 if (phba->cfg_enable_bg)
140 if (phba->sli3_options & LPFC_SLI3_BG_ENABLED)
141 return snprintf(buf, PAGE_SIZE, "BlockGuard Enabled\n");
143 return snprintf(buf, PAGE_SIZE,
144 "BlockGuard Not Supported\n");
146 return snprintf(buf, PAGE_SIZE,
147 "BlockGuard Disabled\n");
151 lpfc_bg_guard_err_show(struct device *dev, struct device_attribute *attr,
154 struct Scsi_Host *shost = class_to_shost(dev);
155 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
156 struct lpfc_hba *phba = vport->phba;
158 return snprintf(buf, PAGE_SIZE, "%llu\n",
159 (unsigned long long)phba->bg_guard_err_cnt);
163 lpfc_bg_apptag_err_show(struct device *dev, struct device_attribute *attr,
166 struct Scsi_Host *shost = class_to_shost(dev);
167 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
168 struct lpfc_hba *phba = vport->phba;
170 return snprintf(buf, PAGE_SIZE, "%llu\n",
171 (unsigned long long)phba->bg_apptag_err_cnt);
175 lpfc_bg_reftag_err_show(struct device *dev, struct device_attribute *attr,
178 struct Scsi_Host *shost = class_to_shost(dev);
179 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
180 struct lpfc_hba *phba = vport->phba;
182 return snprintf(buf, PAGE_SIZE, "%llu\n",
183 (unsigned long long)phba->bg_reftag_err_cnt);
187 * lpfc_info_show - Return some pci info about the host in ascii
188 * @dev: class converted to a Scsi_host structure.
189 * @attr: device attribute, not used.
190 * @buf: on return contains the formatted text from lpfc_info().
192 * Returns: size of formatted string.
195 lpfc_info_show(struct device *dev, struct device_attribute *attr,
198 struct Scsi_Host *host = class_to_shost(dev);
200 return snprintf(buf, PAGE_SIZE, "%s\n",lpfc_info(host));
204 * lpfc_serialnum_show - Return the hba serial number in ascii
205 * @dev: class converted to a Scsi_host structure.
206 * @attr: device attribute, not used.
207 * @buf: on return contains the formatted text serial number.
209 * Returns: size of formatted string.
212 lpfc_serialnum_show(struct device *dev, struct device_attribute *attr,
215 struct Scsi_Host *shost = class_to_shost(dev);
216 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
217 struct lpfc_hba *phba = vport->phba;
219 return snprintf(buf, PAGE_SIZE, "%s\n",phba->SerialNumber);
223 * lpfc_temp_sensor_show - Return the temperature sensor level
224 * @dev: class converted to a Scsi_host structure.
225 * @attr: device attribute, not used.
226 * @buf: on return contains the formatted support level.
229 * Returns a number indicating the temperature sensor level currently
230 * supported, zero or one in ascii.
232 * Returns: size of formatted string.
235 lpfc_temp_sensor_show(struct device *dev, struct device_attribute *attr,
238 struct Scsi_Host *shost = class_to_shost(dev);
239 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
240 struct lpfc_hba *phba = vport->phba;
241 return snprintf(buf, PAGE_SIZE, "%d\n",phba->temp_sensor_support);
245 * lpfc_modeldesc_show - Return the model description of the hba
246 * @dev: class converted to a Scsi_host structure.
247 * @attr: device attribute, not used.
248 * @buf: on return contains the scsi vpd model description.
250 * Returns: size of formatted string.
253 lpfc_modeldesc_show(struct device *dev, struct device_attribute *attr,
256 struct Scsi_Host *shost = class_to_shost(dev);
257 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
258 struct lpfc_hba *phba = vport->phba;
260 return snprintf(buf, PAGE_SIZE, "%s\n",phba->ModelDesc);
264 * lpfc_modelname_show - Return the model name of the hba
265 * @dev: class converted to a Scsi_host structure.
266 * @attr: device attribute, not used.
267 * @buf: on return contains the scsi vpd model name.
269 * Returns: size of formatted string.
272 lpfc_modelname_show(struct device *dev, struct device_attribute *attr,
275 struct Scsi_Host *shost = class_to_shost(dev);
276 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
277 struct lpfc_hba *phba = vport->phba;
279 return snprintf(buf, PAGE_SIZE, "%s\n",phba->ModelName);
283 * lpfc_programtype_show - Return the program type of the hba
284 * @dev: class converted to a Scsi_host structure.
285 * @attr: device attribute, not used.
286 * @buf: on return contains the scsi vpd program type.
288 * Returns: size of formatted string.
291 lpfc_programtype_show(struct device *dev, struct device_attribute *attr,
294 struct Scsi_Host *shost = class_to_shost(dev);
295 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
296 struct lpfc_hba *phba = vport->phba;
298 return snprintf(buf, PAGE_SIZE, "%s\n",phba->ProgramType);
302 * lpfc_mlomgmt_show - Return the Menlo Maintenance sli flag
303 * @dev: class converted to a Scsi_host structure.
304 * @attr: device attribute, not used.
305 * @buf: on return contains the Menlo Maintenance sli flag.
307 * Returns: size of formatted string.
310 lpfc_mlomgmt_show(struct device *dev, struct device_attribute *attr, char *buf)
312 struct Scsi_Host *shost = class_to_shost(dev);
313 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
314 struct lpfc_hba *phba = vport->phba;
316 return snprintf(buf, PAGE_SIZE, "%d\n",
317 (phba->sli.sli_flag & LPFC_MENLO_MAINT));
321 * lpfc_vportnum_show - Return the port number in ascii of the hba
322 * @dev: class converted to a Scsi_host structure.
323 * @attr: device attribute, not used.
324 * @buf: on return contains scsi vpd program type.
326 * Returns: size of formatted string.
329 lpfc_vportnum_show(struct device *dev, struct device_attribute *attr,
332 struct Scsi_Host *shost = class_to_shost(dev);
333 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
334 struct lpfc_hba *phba = vport->phba;
336 return snprintf(buf, PAGE_SIZE, "%s\n",phba->Port);
340 * lpfc_fwrev_show - Return the firmware rev running in the hba
341 * @dev: class converted to a Scsi_host structure.
342 * @attr: device attribute, not used.
343 * @buf: on return contains the scsi vpd program type.
345 * Returns: size of formatted string.
348 lpfc_fwrev_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;
356 char fwrev[FW_REV_STR_SIZE];
359 lpfc_decode_firmware_rev(phba, fwrev, 1);
360 if_type = phba->sli4_hba.pc_sli4_params.if_type;
361 sli_family = phba->sli4_hba.pc_sli4_params.sli_family;
363 if (phba->sli_rev < LPFC_SLI_REV4)
364 len = snprintf(buf, PAGE_SIZE, "%s, sli-%d\n",
365 fwrev, phba->sli_rev);
367 len = snprintf(buf, PAGE_SIZE, "%s, sli-%d:%d:%x\n",
368 fwrev, phba->sli_rev, if_type, sli_family);
374 * lpfc_hdw_show - Return the jedec information about the hba
375 * @dev: class converted to a Scsi_host structure.
376 * @attr: device attribute, not used.
377 * @buf: on return contains the scsi vpd program type.
379 * Returns: size of formatted string.
382 lpfc_hdw_show(struct device *dev, struct device_attribute *attr, char *buf)
385 struct Scsi_Host *shost = class_to_shost(dev);
386 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
387 struct lpfc_hba *phba = vport->phba;
388 lpfc_vpd_t *vp = &phba->vpd;
390 lpfc_jedec_to_ascii(vp->rev.biuRev, hdw);
391 return snprintf(buf, PAGE_SIZE, "%s\n", hdw);
395 * lpfc_option_rom_version_show - Return the adapter ROM FCode version
396 * @dev: class converted to a Scsi_host structure.
397 * @attr: device attribute, not used.
398 * @buf: on return contains the ROM and FCode ascii strings.
400 * Returns: size of formatted string.
403 lpfc_option_rom_version_show(struct device *dev, struct device_attribute *attr,
406 struct Scsi_Host *shost = class_to_shost(dev);
407 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
408 struct lpfc_hba *phba = vport->phba;
410 return snprintf(buf, PAGE_SIZE, "%s\n", phba->OptionROMVersion);
414 * lpfc_state_show - Return the link state of the port
415 * @dev: class converted to a Scsi_host structure.
416 * @attr: device attribute, not used.
417 * @buf: on return contains text describing the state of the link.
420 * The switch statement has no default so zero will be returned.
422 * Returns: size of formatted string.
425 lpfc_link_state_show(struct device *dev, struct device_attribute *attr,
428 struct Scsi_Host *shost = class_to_shost(dev);
429 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
430 struct lpfc_hba *phba = vport->phba;
433 switch (phba->link_state) {
434 case LPFC_LINK_UNKNOWN:
435 case LPFC_WARM_START:
436 case LPFC_INIT_START:
437 case LPFC_INIT_MBX_CMDS:
440 if (phba->hba_flag & LINK_DISABLED)
441 len += snprintf(buf + len, PAGE_SIZE-len,
442 "Link Down - User disabled\n");
444 len += snprintf(buf + len, PAGE_SIZE-len,
450 len += snprintf(buf + len, PAGE_SIZE-len, "Link Up - ");
452 switch (vport->port_state) {
453 case LPFC_LOCAL_CFG_LINK:
454 len += snprintf(buf + len, PAGE_SIZE-len,
455 "Configuring Link\n");
459 case LPFC_FABRIC_CFG_LINK:
462 case LPFC_BUILD_DISC_LIST:
464 len += snprintf(buf + len, PAGE_SIZE - len,
467 case LPFC_VPORT_READY:
468 len += snprintf(buf + len, PAGE_SIZE - len, "Ready\n");
471 case LPFC_VPORT_FAILED:
472 len += snprintf(buf + len, PAGE_SIZE - len, "Failed\n");
475 case LPFC_VPORT_UNKNOWN:
476 len += snprintf(buf + len, PAGE_SIZE - len,
480 if (phba->sli.sli_flag & LPFC_MENLO_MAINT)
481 len += snprintf(buf + len, PAGE_SIZE-len,
482 " Menlo Maint Mode\n");
483 else if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
484 if (vport->fc_flag & FC_PUBLIC_LOOP)
485 len += snprintf(buf + len, PAGE_SIZE-len,
488 len += snprintf(buf + len, PAGE_SIZE-len,
491 if (vport->fc_flag & FC_FABRIC)
492 len += snprintf(buf + len, PAGE_SIZE-len,
495 len += snprintf(buf + len, PAGE_SIZE-len,
504 * lpfc_sli4_protocol_show - Return the fip mode of the HBA
505 * @dev: class unused variable.
506 * @attr: device attribute, not used.
507 * @buf: on return contains the module description text.
509 * Returns: size of formatted string.
512 lpfc_sli4_protocol_show(struct device *dev, struct device_attribute *attr,
515 struct Scsi_Host *shost = class_to_shost(dev);
516 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
517 struct lpfc_hba *phba = vport->phba;
519 if (phba->sli_rev < LPFC_SLI_REV4)
520 return snprintf(buf, PAGE_SIZE, "fc\n");
522 if (phba->sli4_hba.lnk_info.lnk_dv == LPFC_LNK_DAT_VAL) {
523 if (phba->sli4_hba.lnk_info.lnk_tp == LPFC_LNK_TYPE_GE)
524 return snprintf(buf, PAGE_SIZE, "fcoe\n");
525 if (phba->sli4_hba.lnk_info.lnk_tp == LPFC_LNK_TYPE_FC)
526 return snprintf(buf, PAGE_SIZE, "fc\n");
528 return snprintf(buf, PAGE_SIZE, "unknown\n");
532 * lpfc_link_state_store - Transition the link_state on an HBA port
533 * @dev: class device that is converted into a Scsi_host.
534 * @attr: device attribute, not used.
535 * @buf: one or more lpfc_polling_flags values.
539 * -EINVAL if the buffer is not "up" or "down"
540 * return from link state change function if non-zero
541 * length of the buf on success
544 lpfc_link_state_store(struct device *dev, struct device_attribute *attr,
545 const char *buf, size_t count)
547 struct Scsi_Host *shost = class_to_shost(dev);
548 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
549 struct lpfc_hba *phba = vport->phba;
551 int status = -EINVAL;
553 if ((strncmp(buf, "up", sizeof("up") - 1) == 0) &&
554 (phba->link_state == LPFC_LINK_DOWN))
555 status = phba->lpfc_hba_init_link(phba, MBX_NOWAIT);
556 else if ((strncmp(buf, "down", sizeof("down") - 1) == 0) &&
557 (phba->link_state >= LPFC_LINK_UP))
558 status = phba->lpfc_hba_down_link(phba, MBX_NOWAIT);
567 * lpfc_num_discovered_ports_show - Return sum of mapped and unmapped vports
568 * @dev: class device that is converted into a Scsi_host.
569 * @attr: device attribute, not used.
570 * @buf: on return contains the sum of fc mapped and unmapped.
573 * Returns the ascii text number of the sum of the fc mapped and unmapped
576 * Returns: size of formatted string.
579 lpfc_num_discovered_ports_show(struct device *dev,
580 struct device_attribute *attr, char *buf)
582 struct Scsi_Host *shost = class_to_shost(dev);
583 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
585 return snprintf(buf, PAGE_SIZE, "%d\n",
586 vport->fc_map_cnt + vport->fc_unmap_cnt);
590 * lpfc_issue_lip - Misnomer, name carried over from long ago
591 * @shost: Scsi_Host pointer.
594 * Bring the link down gracefully then re-init the link. The firmware will
595 * re-init the fiber channel interface as required. Does not issue a LIP.
598 * -EPERM port offline or management commands are being blocked
599 * -ENOMEM cannot allocate memory for the mailbox command
600 * -EIO error sending the mailbox command
604 lpfc_issue_lip(struct Scsi_Host *shost)
606 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
607 struct lpfc_hba *phba = vport->phba;
608 LPFC_MBOXQ_t *pmboxq;
609 int mbxstatus = MBXERR_ERROR;
611 if ((vport->fc_flag & FC_OFFLINE_MODE) ||
612 (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO))
615 pmboxq = mempool_alloc(phba->mbox_mem_pool,GFP_KERNEL);
620 memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t));
621 pmboxq->u.mb.mbxCommand = MBX_DOWN_LINK;
622 pmboxq->u.mb.mbxOwner = OWN_HOST;
624 mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq, LPFC_MBOX_TMO * 2);
626 if ((mbxstatus == MBX_SUCCESS) &&
627 (pmboxq->u.mb.mbxStatus == 0 ||
628 pmboxq->u.mb.mbxStatus == MBXERR_LINK_DOWN)) {
629 memset((void *)pmboxq, 0, sizeof (LPFC_MBOXQ_t));
630 lpfc_init_link(phba, pmboxq, phba->cfg_topology,
631 phba->cfg_link_speed);
632 mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq,
634 if ((mbxstatus == MBX_SUCCESS) &&
635 (pmboxq->u.mb.mbxStatus == MBXERR_SEC_NO_PERMISSION))
636 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
637 "2859 SLI authentication is required "
638 "for INIT_LINK but has not done yet\n");
641 lpfc_set_loopback_flag(phba);
642 if (mbxstatus != MBX_TIMEOUT)
643 mempool_free(pmboxq, phba->mbox_mem_pool);
645 if (mbxstatus == MBXERR_ERROR)
652 * lpfc_do_offline - Issues a mailbox command to bring the link down
653 * @phba: lpfc_hba pointer.
654 * @type: LPFC_EVT_OFFLINE, LPFC_EVT_WARM_START, LPFC_EVT_KILL.
657 * Assumes any error from lpfc_do_offline() will be negative.
658 * Can wait up to 5 seconds for the port ring buffers count
659 * to reach zero, prints a warning if it is not zero and continues.
660 * lpfc_workq_post_event() returns a non-zero return code if call fails.
663 * -EIO error posting the event
667 lpfc_do_offline(struct lpfc_hba *phba, uint32_t type)
669 struct completion online_compl;
670 struct lpfc_sli_ring *pring;
671 struct lpfc_sli *psli;
677 init_completion(&online_compl);
678 rc = lpfc_workq_post_event(phba, &status, &online_compl,
679 LPFC_EVT_OFFLINE_PREP);
683 wait_for_completion(&online_compl);
690 /* Wait a little for things to settle down, but not
691 * long enough for dev loss timeout to expire.
693 for (i = 0; i < psli->num_rings; i++) {
694 pring = &psli->ring[i];
695 while (!list_empty(&pring->txcmplq)) {
697 if (cnt++ > 500) { /* 5 secs */
698 lpfc_printf_log(phba,
699 KERN_WARNING, LOG_INIT,
700 "0466 Outstanding IO when "
701 "bringing Adapter offline\n");
707 init_completion(&online_compl);
708 rc = lpfc_workq_post_event(phba, &status, &online_compl, type);
712 wait_for_completion(&online_compl);
721 * lpfc_selective_reset - Offline then onlines the port
722 * @phba: lpfc_hba pointer.
725 * If the port is configured to allow a reset then the hba is brought
726 * offline then online.
729 * Assumes any error from lpfc_do_offline() will be negative.
730 * Do not make this function static.
733 * lpfc_do_offline() return code if not zero
734 * -EIO reset not configured or error posting the event
738 lpfc_selective_reset(struct lpfc_hba *phba)
740 struct completion online_compl;
744 if (!phba->cfg_enable_hba_reset)
747 status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
752 init_completion(&online_compl);
753 rc = lpfc_workq_post_event(phba, &status, &online_compl,
758 wait_for_completion(&online_compl);
767 * lpfc_issue_reset - Selectively resets an adapter
768 * @dev: class device that is converted into a Scsi_host.
769 * @attr: device attribute, not used.
770 * @buf: containing the string "selective".
771 * @count: unused variable.
774 * If the buf contains the string "selective" then lpfc_selective_reset()
775 * is called to perform the reset.
778 * Assumes any error from lpfc_selective_reset() will be negative.
779 * If lpfc_selective_reset() returns zero then the length of the buffer
780 * is returned which indicates success
783 * -EINVAL if the buffer does not contain the string "selective"
784 * length of buf if lpfc-selective_reset() if the call succeeds
785 * return value of lpfc_selective_reset() if the call fails
788 lpfc_issue_reset(struct device *dev, struct device_attribute *attr,
789 const char *buf, size_t count)
791 struct Scsi_Host *shost = class_to_shost(dev);
792 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
793 struct lpfc_hba *phba = vport->phba;
794 int status = -EINVAL;
796 if (!phba->cfg_enable_hba_reset)
799 if (strncmp(buf, "selective", sizeof("selective") - 1) == 0)
800 status = phba->lpfc_selective_reset(phba);
809 * lpfc_sli4_pdev_status_reg_wait - Wait for pdev status register for readyness
810 * @phba: lpfc_hba pointer.
813 * SLI4 interface type-2 device to wait on the sliport status register for
814 * the readyness after performing a firmware reset.
817 * zero for success, -EPERM when port does not have privilage to perform the
818 * reset, -EIO when port timeout from recovering from the reset.
821 * As the caller will interpret the return code by value, be careful in making
822 * change or addition to return codes.
825 lpfc_sli4_pdev_status_reg_wait(struct lpfc_hba *phba)
827 struct lpfc_register portstat_reg = {0};
831 lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr,
832 &portstat_reg.word0);
834 /* verify if privilaged for the request operation */
835 if (!bf_get(lpfc_sliport_status_rn, &portstat_reg) &&
836 !bf_get(lpfc_sliport_status_err, &portstat_reg))
839 /* wait for the SLI port firmware ready after firmware reset */
840 for (i = 0; i < LPFC_FW_RESET_MAXIMUM_WAIT_10MS_CNT; i++) {
842 lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr,
843 &portstat_reg.word0);
844 if (!bf_get(lpfc_sliport_status_err, &portstat_reg))
846 if (!bf_get(lpfc_sliport_status_rn, &portstat_reg))
848 if (!bf_get(lpfc_sliport_status_rdy, &portstat_reg))
853 if (i < LPFC_FW_RESET_MAXIMUM_WAIT_10MS_CNT)
860 * lpfc_sli4_pdev_reg_request - Request physical dev to perform a register acc
861 * @phba: lpfc_hba pointer.
864 * Request SLI4 interface type-2 device to perform a physical register set
871 lpfc_sli4_pdev_reg_request(struct lpfc_hba *phba, uint32_t opcode)
873 struct completion online_compl;
874 struct pci_dev *pdev = phba->pcidev;
875 uint32_t before_fc_flag;
876 uint32_t sriov_nr_virtfn;
878 int status = 0, rc = 0;
879 int job_posted = 1, sriov_err;
881 if (!phba->cfg_enable_hba_reset)
884 if ((phba->sli_rev < LPFC_SLI_REV4) ||
885 (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
886 LPFC_SLI_INTF_IF_TYPE_2))
889 /* Keep state if we need to restore back */
890 before_fc_flag = phba->pport->fc_flag;
891 sriov_nr_virtfn = phba->cfg_sriov_nr_virtfn;
893 /* Disable SR-IOV virtual functions if enabled */
894 if (phba->cfg_sriov_nr_virtfn) {
895 pci_disable_sriov(pdev);
896 phba->cfg_sriov_nr_virtfn = 0;
898 status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
903 /* wait for the device to be quiesced before firmware reset */
906 reg_val = readl(phba->sli4_hba.conf_regs_memmap_p +
907 LPFC_CTL_PDEV_CTL_OFFSET);
909 if (opcode == LPFC_FW_DUMP)
910 reg_val |= LPFC_FW_DUMP_REQUEST;
911 else if (opcode == LPFC_FW_RESET)
912 reg_val |= LPFC_CTL_PDEV_CTL_FRST;
913 else if (opcode == LPFC_DV_RESET)
914 reg_val |= LPFC_CTL_PDEV_CTL_DRST;
916 writel(reg_val, phba->sli4_hba.conf_regs_memmap_p +
917 LPFC_CTL_PDEV_CTL_OFFSET);
919 readl(phba->sli4_hba.conf_regs_memmap_p + LPFC_CTL_PDEV_CTL_OFFSET);
921 /* delay driver action following IF_TYPE_2 reset */
922 rc = lpfc_sli4_pdev_status_reg_wait(phba);
925 /* no privilage for reset */
926 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
927 "3150 No privilage to perform the requested "
928 "access: x%x\n", reg_val);
929 } else if (rc == -EIO) {
930 /* reset failed, there is nothing more we can do */
931 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
932 "3153 Fail to perform the requested "
933 "access: x%x\n", reg_val);
937 /* keep the original port state */
938 if (before_fc_flag & FC_OFFLINE_MODE)
941 init_completion(&online_compl);
942 job_posted = lpfc_workq_post_event(phba, &status, &online_compl,
947 wait_for_completion(&online_compl);
950 /* in any case, restore the virtual functions enabled as before */
951 if (sriov_nr_virtfn) {
953 lpfc_sli_probe_sriov_nr_virtfn(phba, sriov_nr_virtfn);
955 phba->cfg_sriov_nr_virtfn = sriov_nr_virtfn;
958 /* return proper error code */
969 * lpfc_nport_evt_cnt_show - Return the number of nport events
970 * @dev: class device that is converted into a Scsi_host.
971 * @attr: device attribute, not used.
972 * @buf: on return contains the ascii number of nport events.
974 * Returns: size of formatted string.
977 lpfc_nport_evt_cnt_show(struct device *dev, struct device_attribute *attr,
980 struct Scsi_Host *shost = class_to_shost(dev);
981 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
982 struct lpfc_hba *phba = vport->phba;
984 return snprintf(buf, PAGE_SIZE, "%d\n", phba->nport_event_cnt);
988 * lpfc_board_mode_show - Return the state of the board
989 * @dev: class device that is converted into a Scsi_host.
990 * @attr: device attribute, not used.
991 * @buf: on return contains the state of the adapter.
993 * Returns: size of formatted string.
996 lpfc_board_mode_show(struct device *dev, struct device_attribute *attr,
999 struct Scsi_Host *shost = class_to_shost(dev);
1000 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1001 struct lpfc_hba *phba = vport->phba;
1004 if (phba->link_state == LPFC_HBA_ERROR)
1006 else if (phba->link_state == LPFC_WARM_START)
1007 state = "warm start";
1008 else if (phba->link_state == LPFC_INIT_START)
1013 return snprintf(buf, PAGE_SIZE, "%s\n", state);
1017 * lpfc_board_mode_store - Puts the hba in online, offline, warm or error state
1018 * @dev: class device that is converted into a Scsi_host.
1019 * @attr: device attribute, not used.
1020 * @buf: containing one of the strings "online", "offline", "warm" or "error".
1021 * @count: unused variable.
1024 * -EACCES if enable hba reset not enabled
1025 * -EINVAL if the buffer does not contain a valid string (see above)
1026 * -EIO if lpfc_workq_post_event() or lpfc_do_offline() fails
1027 * buf length greater than zero indicates success
1030 lpfc_board_mode_store(struct device *dev, struct device_attribute *attr,
1031 const char *buf, size_t count)
1033 struct Scsi_Host *shost = class_to_shost(dev);
1034 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1035 struct lpfc_hba *phba = vport->phba;
1036 struct completion online_compl;
1037 char *board_mode_str = NULL;
1041 if (!phba->cfg_enable_hba_reset) {
1043 goto board_mode_out;
1046 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1047 "3050 lpfc_board_mode set to %s\n", buf);
1049 init_completion(&online_compl);
1051 if(strncmp(buf, "online", sizeof("online") - 1) == 0) {
1052 rc = lpfc_workq_post_event(phba, &status, &online_compl,
1056 goto board_mode_out;
1058 wait_for_completion(&online_compl);
1059 } else if (strncmp(buf, "offline", sizeof("offline") - 1) == 0)
1060 status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
1061 else if (strncmp(buf, "warm", sizeof("warm") - 1) == 0)
1062 if (phba->sli_rev == LPFC_SLI_REV4)
1065 status = lpfc_do_offline(phba, LPFC_EVT_WARM_START);
1066 else if (strncmp(buf, "error", sizeof("error") - 1) == 0)
1067 if (phba->sli_rev == LPFC_SLI_REV4)
1070 status = lpfc_do_offline(phba, LPFC_EVT_KILL);
1071 else if (strncmp(buf, "dump", sizeof("dump") - 1) == 0)
1072 status = lpfc_sli4_pdev_reg_request(phba, LPFC_FW_DUMP);
1073 else if (strncmp(buf, "fw_reset", sizeof("fw_reset") - 1) == 0)
1074 status = lpfc_sli4_pdev_reg_request(phba, LPFC_FW_RESET);
1075 else if (strncmp(buf, "dv_reset", sizeof("dv_reset") - 1) == 0)
1076 status = lpfc_sli4_pdev_reg_request(phba, LPFC_DV_RESET);
1084 board_mode_str = strchr(buf, '\n');
1086 *board_mode_str = '\0';
1087 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1088 "3097 Failed \"%s\", status(%d), "
1090 buf, status, phba->pport->fc_flag);
1096 * lpfc_get_hba_info - Return various bits of informaton about the adapter
1097 * @phba: pointer to the adapter structure.
1098 * @mxri: max xri count.
1099 * @axri: available xri count.
1100 * @mrpi: max rpi count.
1101 * @arpi: available rpi count.
1102 * @mvpi: max vpi count.
1103 * @avpi: available vpi count.
1106 * If an integer pointer for an count is not null then the value for the
1107 * count is returned.
1114 lpfc_get_hba_info(struct lpfc_hba *phba,
1115 uint32_t *mxri, uint32_t *axri,
1116 uint32_t *mrpi, uint32_t *arpi,
1117 uint32_t *mvpi, uint32_t *avpi)
1119 struct lpfc_mbx_read_config *rd_config;
1120 LPFC_MBOXQ_t *pmboxq;
1126 * prevent udev from issuing mailbox commands until the port is
1129 if (phba->link_state < LPFC_LINK_DOWN ||
1130 !phba->mbox_mem_pool ||
1131 (phba->sli.sli_flag & LPFC_SLI_ACTIVE) == 0)
1134 if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
1137 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
1140 memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
1142 pmb = &pmboxq->u.mb;
1143 pmb->mbxCommand = MBX_READ_CONFIG;
1144 pmb->mbxOwner = OWN_HOST;
1145 pmboxq->context1 = NULL;
1147 if (phba->pport->fc_flag & FC_OFFLINE_MODE)
1148 rc = MBX_NOT_FINISHED;
1150 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
1152 if (rc != MBX_SUCCESS) {
1153 if (rc != MBX_TIMEOUT)
1154 mempool_free(pmboxq, phba->mbox_mem_pool);
1158 if (phba->sli_rev == LPFC_SLI_REV4) {
1159 rd_config = &pmboxq->u.mqe.un.rd_config;
1161 *mrpi = bf_get(lpfc_mbx_rd_conf_rpi_count, rd_config);
1163 *arpi = bf_get(lpfc_mbx_rd_conf_rpi_count, rd_config) -
1164 phba->sli4_hba.max_cfg_param.rpi_used;
1166 *mxri = bf_get(lpfc_mbx_rd_conf_xri_count, rd_config);
1168 *axri = bf_get(lpfc_mbx_rd_conf_xri_count, rd_config) -
1169 phba->sli4_hba.max_cfg_param.xri_used;
1171 /* Account for differences with SLI-3. Get vpi count from
1172 * mailbox data and subtract one for max vpi value.
1174 max_vpi = (bf_get(lpfc_mbx_rd_conf_vpi_count, rd_config) > 0) ?
1175 (bf_get(lpfc_mbx_rd_conf_vpi_count, rd_config) - 1) : 0;
1180 *avpi = max_vpi - phba->sli4_hba.max_cfg_param.vpi_used;
1183 *mrpi = pmb->un.varRdConfig.max_rpi;
1185 *arpi = pmb->un.varRdConfig.avail_rpi;
1187 *mxri = pmb->un.varRdConfig.max_xri;
1189 *axri = pmb->un.varRdConfig.avail_xri;
1191 *mvpi = pmb->un.varRdConfig.max_vpi;
1193 *avpi = pmb->un.varRdConfig.avail_vpi;
1196 mempool_free(pmboxq, phba->mbox_mem_pool);
1201 * lpfc_max_rpi_show - Return maximum rpi
1202 * @dev: class device that is converted into a Scsi_host.
1203 * @attr: device attribute, not used.
1204 * @buf: on return contains the maximum rpi count in decimal or "Unknown".
1207 * Calls lpfc_get_hba_info() asking for just the mrpi count.
1208 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1209 * to "Unknown" and the buffer length is returned, therefore the caller
1210 * must check for "Unknown" in the buffer to detect a failure.
1212 * Returns: size of formatted string.
1215 lpfc_max_rpi_show(struct device *dev, struct device_attribute *attr,
1218 struct Scsi_Host *shost = class_to_shost(dev);
1219 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1220 struct lpfc_hba *phba = vport->phba;
1223 if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, NULL, NULL, NULL))
1224 return snprintf(buf, PAGE_SIZE, "%d\n", cnt);
1225 return snprintf(buf, PAGE_SIZE, "Unknown\n");
1229 * lpfc_used_rpi_show - Return maximum rpi minus available rpi
1230 * @dev: class device that is converted into a Scsi_host.
1231 * @attr: device attribute, not used.
1232 * @buf: containing the used rpi count in decimal or "Unknown".
1235 * Calls lpfc_get_hba_info() asking for just the mrpi and arpi counts.
1236 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1237 * to "Unknown" and the buffer length is returned, therefore the caller
1238 * must check for "Unknown" in the buffer to detect a failure.
1240 * Returns: size of formatted string.
1243 lpfc_used_rpi_show(struct device *dev, struct device_attribute *attr,
1246 struct Scsi_Host *shost = class_to_shost(dev);
1247 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1248 struct lpfc_hba *phba = vport->phba;
1251 if (lpfc_get_hba_info(phba, NULL, NULL, &cnt, &acnt, NULL, NULL))
1252 return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
1253 return snprintf(buf, PAGE_SIZE, "Unknown\n");
1257 * lpfc_max_xri_show - Return maximum xri
1258 * @dev: class device that is converted into a Scsi_host.
1259 * @attr: device attribute, not used.
1260 * @buf: on return contains the maximum xri count in decimal or "Unknown".
1263 * Calls lpfc_get_hba_info() asking for just the mrpi count.
1264 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1265 * to "Unknown" and the buffer length is returned, therefore the caller
1266 * must check for "Unknown" in the buffer to detect a failure.
1268 * Returns: size of formatted string.
1271 lpfc_max_xri_show(struct device *dev, struct device_attribute *attr,
1274 struct Scsi_Host *shost = class_to_shost(dev);
1275 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1276 struct lpfc_hba *phba = vport->phba;
1279 if (lpfc_get_hba_info(phba, &cnt, NULL, NULL, NULL, NULL, NULL))
1280 return snprintf(buf, PAGE_SIZE, "%d\n", cnt);
1281 return snprintf(buf, PAGE_SIZE, "Unknown\n");
1285 * lpfc_used_xri_show - Return maximum xpi minus the available xpi
1286 * @dev: class device that is converted into a Scsi_host.
1287 * @attr: device attribute, not used.
1288 * @buf: on return contains the used xri count in decimal or "Unknown".
1291 * Calls lpfc_get_hba_info() asking for just the mxri and axri counts.
1292 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1293 * to "Unknown" and the buffer length is returned, therefore the caller
1294 * must check for "Unknown" in the buffer to detect a failure.
1296 * Returns: size of formatted string.
1299 lpfc_used_xri_show(struct device *dev, struct device_attribute *attr,
1302 struct Scsi_Host *shost = class_to_shost(dev);
1303 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1304 struct lpfc_hba *phba = vport->phba;
1307 if (lpfc_get_hba_info(phba, &cnt, &acnt, NULL, NULL, NULL, NULL))
1308 return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
1309 return snprintf(buf, PAGE_SIZE, "Unknown\n");
1313 * lpfc_max_vpi_show - Return maximum vpi
1314 * @dev: class device that is converted into a Scsi_host.
1315 * @attr: device attribute, not used.
1316 * @buf: on return contains the maximum vpi count in decimal or "Unknown".
1319 * Calls lpfc_get_hba_info() asking for just the mvpi count.
1320 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1321 * to "Unknown" and the buffer length is returned, therefore the caller
1322 * must check for "Unknown" in the buffer to detect a failure.
1324 * Returns: size of formatted string.
1327 lpfc_max_vpi_show(struct device *dev, struct device_attribute *attr,
1330 struct Scsi_Host *shost = class_to_shost(dev);
1331 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1332 struct lpfc_hba *phba = vport->phba;
1335 if (lpfc_get_hba_info(phba, NULL, NULL, NULL, NULL, &cnt, NULL))
1336 return snprintf(buf, PAGE_SIZE, "%d\n", cnt);
1337 return snprintf(buf, PAGE_SIZE, "Unknown\n");
1341 * lpfc_used_vpi_show - Return maximum vpi minus the available vpi
1342 * @dev: class device that is converted into a Scsi_host.
1343 * @attr: device attribute, not used.
1344 * @buf: on return contains the used vpi count in decimal or "Unknown".
1347 * Calls lpfc_get_hba_info() asking for just the mvpi and avpi counts.
1348 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1349 * to "Unknown" and the buffer length is returned, therefore the caller
1350 * must check for "Unknown" in the buffer to detect a failure.
1352 * Returns: size of formatted string.
1355 lpfc_used_vpi_show(struct device *dev, struct device_attribute *attr,
1358 struct Scsi_Host *shost = class_to_shost(dev);
1359 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1360 struct lpfc_hba *phba = vport->phba;
1363 if (lpfc_get_hba_info(phba, NULL, NULL, NULL, NULL, &cnt, &acnt))
1364 return snprintf(buf, PAGE_SIZE, "%d\n", (cnt - acnt));
1365 return snprintf(buf, PAGE_SIZE, "Unknown\n");
1369 * lpfc_npiv_info_show - Return text about NPIV support for the adapter
1370 * @dev: class device that is converted into a Scsi_host.
1371 * @attr: device attribute, not used.
1372 * @buf: text that must be interpreted to determine if npiv is supported.
1375 * Buffer will contain text indicating npiv is not suppoerted on the port,
1376 * the port is an NPIV physical port, or it is an npiv virtual port with
1377 * the id of the vport.
1379 * Returns: size of formatted string.
1382 lpfc_npiv_info_show(struct device *dev, struct device_attribute *attr,
1385 struct Scsi_Host *shost = class_to_shost(dev);
1386 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1387 struct lpfc_hba *phba = vport->phba;
1389 if (!(phba->max_vpi))
1390 return snprintf(buf, PAGE_SIZE, "NPIV Not Supported\n");
1391 if (vport->port_type == LPFC_PHYSICAL_PORT)
1392 return snprintf(buf, PAGE_SIZE, "NPIV Physical\n");
1393 return snprintf(buf, PAGE_SIZE, "NPIV Virtual (VPI %d)\n", vport->vpi);
1397 * lpfc_poll_show - Return text about poll support for the adapter
1398 * @dev: class device that is converted into a Scsi_host.
1399 * @attr: device attribute, not used.
1400 * @buf: on return contains the cfg_poll in hex.
1403 * cfg_poll should be a lpfc_polling_flags type.
1405 * Returns: size of formatted string.
1408 lpfc_poll_show(struct device *dev, struct device_attribute *attr,
1411 struct Scsi_Host *shost = class_to_shost(dev);
1412 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1413 struct lpfc_hba *phba = vport->phba;
1415 return snprintf(buf, PAGE_SIZE, "%#x\n", phba->cfg_poll);
1419 * lpfc_poll_store - Set the value of cfg_poll for the adapter
1420 * @dev: class device that is converted into a Scsi_host.
1421 * @attr: device attribute, not used.
1422 * @buf: one or more lpfc_polling_flags values.
1426 * buf contents converted to integer and checked for a valid value.
1429 * -EINVAL if the buffer connot be converted or is out of range
1430 * length of the buf on success
1433 lpfc_poll_store(struct device *dev, struct device_attribute *attr,
1434 const char *buf, size_t count)
1436 struct Scsi_Host *shost = class_to_shost(dev);
1437 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1438 struct lpfc_hba *phba = vport->phba;
1443 if (!isdigit(buf[0]))
1446 if (sscanf(buf, "%i", &val) != 1)
1449 if ((val & 0x3) != val)
1452 if (phba->sli_rev == LPFC_SLI_REV4)
1455 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
1456 "3051 lpfc_poll changed from %d to %d\n",
1457 phba->cfg_poll, val);
1459 spin_lock_irq(&phba->hbalock);
1461 old_val = phba->cfg_poll;
1463 if (val & ENABLE_FCP_RING_POLLING) {
1464 if ((val & DISABLE_FCP_RING_INT) &&
1465 !(old_val & DISABLE_FCP_RING_INT)) {
1466 if (lpfc_readl(phba->HCregaddr, &creg_val)) {
1467 spin_unlock_irq(&phba->hbalock);
1470 creg_val &= ~(HC_R0INT_ENA << LPFC_FCP_RING);
1471 writel(creg_val, phba->HCregaddr);
1472 readl(phba->HCregaddr); /* flush */
1474 lpfc_poll_start_timer(phba);
1476 } else if (val != 0x0) {
1477 spin_unlock_irq(&phba->hbalock);
1481 if (!(val & DISABLE_FCP_RING_INT) &&
1482 (old_val & DISABLE_FCP_RING_INT))
1484 spin_unlock_irq(&phba->hbalock);
1485 del_timer(&phba->fcp_poll_timer);
1486 spin_lock_irq(&phba->hbalock);
1487 if (lpfc_readl(phba->HCregaddr, &creg_val)) {
1488 spin_unlock_irq(&phba->hbalock);
1491 creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
1492 writel(creg_val, phba->HCregaddr);
1493 readl(phba->HCregaddr); /* flush */
1496 phba->cfg_poll = val;
1498 spin_unlock_irq(&phba->hbalock);
1504 * lpfc_fips_level_show - Return the current FIPS level for the HBA
1505 * @dev: class unused variable.
1506 * @attr: device attribute, not used.
1507 * @buf: on return contains the module description text.
1509 * Returns: size of formatted string.
1512 lpfc_fips_level_show(struct device *dev, struct device_attribute *attr,
1515 struct Scsi_Host *shost = class_to_shost(dev);
1516 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1517 struct lpfc_hba *phba = vport->phba;
1519 return snprintf(buf, PAGE_SIZE, "%d\n", phba->fips_level);
1523 * lpfc_fips_rev_show - Return the FIPS Spec revision for the HBA
1524 * @dev: class unused variable.
1525 * @attr: device attribute, not used.
1526 * @buf: on return contains the module description text.
1528 * Returns: size of formatted string.
1531 lpfc_fips_rev_show(struct device *dev, struct device_attribute *attr,
1534 struct Scsi_Host *shost = class_to_shost(dev);
1535 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1536 struct lpfc_hba *phba = vport->phba;
1538 return snprintf(buf, PAGE_SIZE, "%d\n", phba->fips_spec_rev);
1542 * lpfc_dss_show - Return the current state of dss and the configured state
1543 * @dev: class converted to a Scsi_host structure.
1544 * @attr: device attribute, not used.
1545 * @buf: on return contains the formatted text.
1547 * Returns: size of formatted string.
1550 lpfc_dss_show(struct device *dev, struct device_attribute *attr,
1553 struct Scsi_Host *shost = class_to_shost(dev);
1554 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1555 struct lpfc_hba *phba = vport->phba;
1557 return snprintf(buf, PAGE_SIZE, "%s - %sOperational\n",
1558 (phba->cfg_enable_dss) ? "Enabled" : "Disabled",
1559 (phba->sli3_options & LPFC_SLI3_DSS_ENABLED) ?
1564 * lpfc_sriov_hw_max_virtfn_show - Return maximum number of virtual functions
1565 * @dev: class converted to a Scsi_host structure.
1566 * @attr: device attribute, not used.
1567 * @buf: on return contains the formatted support level.
1570 * Returns the maximum number of virtual functions a physical function can
1571 * support, 0 will be returned if called on virtual function.
1573 * Returns: size of formatted string.
1576 lpfc_sriov_hw_max_virtfn_show(struct device *dev,
1577 struct device_attribute *attr,
1580 struct Scsi_Host *shost = class_to_shost(dev);
1581 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
1582 struct lpfc_hba *phba = vport->phba;
1583 uint16_t max_nr_virtfn;
1585 max_nr_virtfn = lpfc_sli_sriov_nr_virtfn_get(phba);
1586 return snprintf(buf, PAGE_SIZE, "%d\n", max_nr_virtfn);
1590 * lpfc_param_show - Return a cfg attribute value in decimal
1593 * Macro that given an attr e.g. hba_queue_depth expands
1594 * into a function with the name lpfc_hba_queue_depth_show.
1596 * lpfc_##attr##_show: Return the decimal value of an adapters cfg_xxx field.
1597 * @dev: class device that is converted into a Scsi_host.
1598 * @attr: device attribute, not used.
1599 * @buf: on return contains the attribute value in decimal.
1601 * Returns: size of formatted string.
1603 #define lpfc_param_show(attr) \
1605 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
1608 struct Scsi_Host *shost = class_to_shost(dev);\
1609 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1610 struct lpfc_hba *phba = vport->phba;\
1612 val = phba->cfg_##attr;\
1613 return snprintf(buf, PAGE_SIZE, "%d\n",\
1618 * lpfc_param_hex_show - Return a cfg attribute value in hex
1621 * Macro that given an attr e.g. hba_queue_depth expands
1622 * into a function with the name lpfc_hba_queue_depth_show
1624 * lpfc_##attr##_show: Return the hex value of an adapters cfg_xxx field.
1625 * @dev: class device that is converted into a Scsi_host.
1626 * @attr: device attribute, not used.
1627 * @buf: on return contains the attribute value in hexadecimal.
1629 * Returns: size of formatted string.
1631 #define lpfc_param_hex_show(attr) \
1633 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
1636 struct Scsi_Host *shost = class_to_shost(dev);\
1637 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1638 struct lpfc_hba *phba = vport->phba;\
1640 val = phba->cfg_##attr;\
1641 return snprintf(buf, PAGE_SIZE, "%#x\n",\
1646 * lpfc_param_init - Initializes a cfg attribute
1649 * Macro that given an attr e.g. hba_queue_depth expands
1650 * into a function with the name lpfc_hba_queue_depth_init. The macro also
1651 * takes a default argument, a minimum and maximum argument.
1653 * lpfc_##attr##_init: Initializes an attribute.
1654 * @phba: pointer the the adapter structure.
1655 * @val: integer attribute value.
1657 * Validates the min and max values then sets the adapter config field
1658 * accordingly, or uses the default if out of range and prints an error message.
1662 * -EINVAL if default used
1664 #define lpfc_param_init(attr, default, minval, maxval) \
1666 lpfc_##attr##_init(struct lpfc_hba *phba, uint val) \
1668 if (val >= minval && val <= maxval) {\
1669 phba->cfg_##attr = val;\
1672 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
1673 "0449 lpfc_"#attr" attribute cannot be set to %d, "\
1674 "allowed range is ["#minval", "#maxval"]\n", val); \
1675 phba->cfg_##attr = default;\
1680 * lpfc_param_set - Set a cfg attribute value
1683 * Macro that given an attr e.g. hba_queue_depth expands
1684 * into a function with the name lpfc_hba_queue_depth_set
1686 * lpfc_##attr##_set: Sets an attribute value.
1687 * @phba: pointer the the adapter structure.
1688 * @val: integer attribute value.
1691 * Validates the min and max values then sets the
1692 * adapter config field if in the valid range. prints error message
1693 * and does not set the parameter if invalid.
1697 * -EINVAL if val is invalid
1699 #define lpfc_param_set(attr, default, minval, maxval) \
1701 lpfc_##attr##_set(struct lpfc_hba *phba, uint val) \
1703 if (val >= minval && val <= maxval) {\
1704 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
1705 "3052 lpfc_" #attr " changed from %d to %d\n", \
1706 phba->cfg_##attr, val); \
1707 phba->cfg_##attr = val;\
1710 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
1711 "0450 lpfc_"#attr" attribute cannot be set to %d, "\
1712 "allowed range is ["#minval", "#maxval"]\n", val); \
1717 * lpfc_param_store - Set a vport attribute value
1720 * Macro that given an attr e.g. hba_queue_depth expands
1721 * into a function with the name lpfc_hba_queue_depth_store.
1723 * lpfc_##attr##_store: Set an sttribute value.
1724 * @dev: class device that is converted into a Scsi_host.
1725 * @attr: device attribute, not used.
1726 * @buf: contains the attribute value in ascii.
1730 * Convert the ascii text number to an integer, then
1731 * use the lpfc_##attr##_set function to set the value.
1734 * -EINVAL if val is invalid or lpfc_##attr##_set() fails
1735 * length of buffer upon success.
1737 #define lpfc_param_store(attr) \
1739 lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
1740 const char *buf, size_t count) \
1742 struct Scsi_Host *shost = class_to_shost(dev);\
1743 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1744 struct lpfc_hba *phba = vport->phba;\
1746 if (!isdigit(buf[0]))\
1748 if (sscanf(buf, "%i", &val) != 1)\
1750 if (lpfc_##attr##_set(phba, val) == 0) \
1751 return strlen(buf);\
1757 * lpfc_vport_param_show - Return decimal formatted cfg attribute value
1760 * Macro that given an attr e.g. hba_queue_depth expands
1761 * into a function with the name lpfc_hba_queue_depth_show
1763 * lpfc_##attr##_show: prints the attribute value in decimal.
1764 * @dev: class device that is converted into a Scsi_host.
1765 * @attr: device attribute, not used.
1766 * @buf: on return contains the attribute value in decimal.
1768 * Returns: length of formatted string.
1770 #define lpfc_vport_param_show(attr) \
1772 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
1775 struct Scsi_Host *shost = class_to_shost(dev);\
1776 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1778 val = vport->cfg_##attr;\
1779 return snprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_##attr);\
1783 * lpfc_vport_param_hex_show - Return hex formatted attribute value
1786 * Macro that given an attr e.g.
1787 * hba_queue_depth expands into a function with the name
1788 * lpfc_hba_queue_depth_show
1790 * lpfc_##attr##_show: prints the attribute value in hexadecimal.
1791 * @dev: class device that is converted into a Scsi_host.
1792 * @attr: device attribute, not used.
1793 * @buf: on return contains the attribute value in hexadecimal.
1795 * Returns: length of formatted string.
1797 #define lpfc_vport_param_hex_show(attr) \
1799 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
1802 struct Scsi_Host *shost = class_to_shost(dev);\
1803 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1805 val = vport->cfg_##attr;\
1806 return snprintf(buf, PAGE_SIZE, "%#x\n", vport->cfg_##attr);\
1810 * lpfc_vport_param_init - Initialize a vport cfg attribute
1813 * Macro that given an attr e.g. hba_queue_depth expands
1814 * into a function with the name lpfc_hba_queue_depth_init. The macro also
1815 * takes a default argument, a minimum and maximum argument.
1817 * lpfc_##attr##_init: validates the min and max values then sets the
1818 * adapter config field accordingly, or uses the default if out of range
1819 * and prints an error message.
1820 * @phba: pointer the the adapter structure.
1821 * @val: integer attribute value.
1825 * -EINVAL if default used
1827 #define lpfc_vport_param_init(attr, default, minval, maxval) \
1829 lpfc_##attr##_init(struct lpfc_vport *vport, uint val) \
1831 if (val >= minval && val <= maxval) {\
1832 vport->cfg_##attr = val;\
1835 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
1836 "0423 lpfc_"#attr" attribute cannot be set to %d, "\
1837 "allowed range is ["#minval", "#maxval"]\n", val); \
1838 vport->cfg_##attr = default;\
1843 * lpfc_vport_param_set - Set a vport cfg attribute
1846 * Macro that given an attr e.g. hba_queue_depth expands
1847 * into a function with the name lpfc_hba_queue_depth_set
1849 * lpfc_##attr##_set: validates the min and max values then sets the
1850 * adapter config field if in the valid range. prints error message
1851 * and does not set the parameter if invalid.
1852 * @phba: pointer the the adapter structure.
1853 * @val: integer attribute value.
1857 * -EINVAL if val is invalid
1859 #define lpfc_vport_param_set(attr, default, minval, maxval) \
1861 lpfc_##attr##_set(struct lpfc_vport *vport, uint val) \
1863 if (val >= minval && val <= maxval) {\
1864 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
1865 "3053 lpfc_" #attr " changed from %d to %d\n", \
1866 vport->cfg_##attr, val); \
1867 vport->cfg_##attr = val;\
1870 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
1871 "0424 lpfc_"#attr" attribute cannot be set to %d, "\
1872 "allowed range is ["#minval", "#maxval"]\n", val); \
1877 * lpfc_vport_param_store - Set a vport attribute
1880 * Macro that given an attr e.g. hba_queue_depth
1881 * expands into a function with the name lpfc_hba_queue_depth_store
1883 * lpfc_##attr##_store: convert the ascii text number to an integer, then
1884 * use the lpfc_##attr##_set function to set the value.
1885 * @cdev: class device that is converted into a Scsi_host.
1886 * @buf: contains the attribute value in decimal.
1890 * -EINVAL if val is invalid or lpfc_##attr##_set() fails
1891 * length of buffer upon success.
1893 #define lpfc_vport_param_store(attr) \
1895 lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
1896 const char *buf, size_t count) \
1898 struct Scsi_Host *shost = class_to_shost(dev);\
1899 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1901 if (!isdigit(buf[0]))\
1903 if (sscanf(buf, "%i", &val) != 1)\
1905 if (lpfc_##attr##_set(vport, val) == 0) \
1906 return strlen(buf);\
1912 #define LPFC_ATTR(name, defval, minval, maxval, desc) \
1913 static uint lpfc_##name = defval;\
1914 module_param(lpfc_##name, uint, S_IRUGO);\
1915 MODULE_PARM_DESC(lpfc_##name, desc);\
1916 lpfc_param_init(name, defval, minval, maxval)
1918 #define LPFC_ATTR_R(name, defval, minval, maxval, desc) \
1919 static uint lpfc_##name = defval;\
1920 module_param(lpfc_##name, uint, S_IRUGO);\
1921 MODULE_PARM_DESC(lpfc_##name, desc);\
1922 lpfc_param_show(name)\
1923 lpfc_param_init(name, defval, minval, maxval)\
1924 static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
1926 #define LPFC_ATTR_RW(name, defval, minval, maxval, desc) \
1927 static uint lpfc_##name = defval;\
1928 module_param(lpfc_##name, uint, S_IRUGO);\
1929 MODULE_PARM_DESC(lpfc_##name, desc);\
1930 lpfc_param_show(name)\
1931 lpfc_param_init(name, defval, minval, maxval)\
1932 lpfc_param_set(name, defval, minval, maxval)\
1933 lpfc_param_store(name)\
1934 static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
1935 lpfc_##name##_show, lpfc_##name##_store)
1937 #define LPFC_ATTR_HEX_R(name, defval, minval, maxval, desc) \
1938 static uint lpfc_##name = defval;\
1939 module_param(lpfc_##name, uint, S_IRUGO);\
1940 MODULE_PARM_DESC(lpfc_##name, desc);\
1941 lpfc_param_hex_show(name)\
1942 lpfc_param_init(name, defval, minval, maxval)\
1943 static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
1945 #define LPFC_ATTR_HEX_RW(name, defval, minval, maxval, desc) \
1946 static uint lpfc_##name = defval;\
1947 module_param(lpfc_##name, uint, S_IRUGO);\
1948 MODULE_PARM_DESC(lpfc_##name, desc);\
1949 lpfc_param_hex_show(name)\
1950 lpfc_param_init(name, defval, minval, maxval)\
1951 lpfc_param_set(name, defval, minval, maxval)\
1952 lpfc_param_store(name)\
1953 static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
1954 lpfc_##name##_show, lpfc_##name##_store)
1956 #define LPFC_VPORT_ATTR(name, defval, minval, maxval, desc) \
1957 static uint lpfc_##name = defval;\
1958 module_param(lpfc_##name, uint, S_IRUGO);\
1959 MODULE_PARM_DESC(lpfc_##name, desc);\
1960 lpfc_vport_param_init(name, defval, minval, maxval)
1962 #define LPFC_VPORT_ATTR_R(name, defval, minval, maxval, desc) \
1963 static uint lpfc_##name = defval;\
1964 module_param(lpfc_##name, uint, S_IRUGO);\
1965 MODULE_PARM_DESC(lpfc_##name, desc);\
1966 lpfc_vport_param_show(name)\
1967 lpfc_vport_param_init(name, defval, minval, maxval)\
1968 static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
1970 #define LPFC_VPORT_ATTR_RW(name, defval, minval, maxval, desc) \
1971 static uint lpfc_##name = defval;\
1972 module_param(lpfc_##name, uint, S_IRUGO);\
1973 MODULE_PARM_DESC(lpfc_##name, desc);\
1974 lpfc_vport_param_show(name)\
1975 lpfc_vport_param_init(name, defval, minval, maxval)\
1976 lpfc_vport_param_set(name, defval, minval, maxval)\
1977 lpfc_vport_param_store(name)\
1978 static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
1979 lpfc_##name##_show, lpfc_##name##_store)
1981 #define LPFC_VPORT_ATTR_HEX_R(name, defval, minval, maxval, desc) \
1982 static uint lpfc_##name = defval;\
1983 module_param(lpfc_##name, uint, S_IRUGO);\
1984 MODULE_PARM_DESC(lpfc_##name, desc);\
1985 lpfc_vport_param_hex_show(name)\
1986 lpfc_vport_param_init(name, defval, minval, maxval)\
1987 static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
1989 #define LPFC_VPORT_ATTR_HEX_RW(name, defval, minval, maxval, desc) \
1990 static uint lpfc_##name = defval;\
1991 module_param(lpfc_##name, uint, S_IRUGO);\
1992 MODULE_PARM_DESC(lpfc_##name, desc);\
1993 lpfc_vport_param_hex_show(name)\
1994 lpfc_vport_param_init(name, defval, minval, maxval)\
1995 lpfc_vport_param_set(name, defval, minval, maxval)\
1996 lpfc_vport_param_store(name)\
1997 static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
1998 lpfc_##name##_show, lpfc_##name##_store)
2000 static DEVICE_ATTR(bg_info, S_IRUGO, lpfc_bg_info_show, NULL);
2001 static DEVICE_ATTR(bg_guard_err, S_IRUGO, lpfc_bg_guard_err_show, NULL);
2002 static DEVICE_ATTR(bg_apptag_err, S_IRUGO, lpfc_bg_apptag_err_show, NULL);
2003 static DEVICE_ATTR(bg_reftag_err, S_IRUGO, lpfc_bg_reftag_err_show, NULL);
2004 static DEVICE_ATTR(info, S_IRUGO, lpfc_info_show, NULL);
2005 static DEVICE_ATTR(serialnum, S_IRUGO, lpfc_serialnum_show, NULL);
2006 static DEVICE_ATTR(modeldesc, S_IRUGO, lpfc_modeldesc_show, NULL);
2007 static DEVICE_ATTR(modelname, S_IRUGO, lpfc_modelname_show, NULL);
2008 static DEVICE_ATTR(programtype, S_IRUGO, lpfc_programtype_show, NULL);
2009 static DEVICE_ATTR(portnum, S_IRUGO, lpfc_vportnum_show, NULL);
2010 static DEVICE_ATTR(fwrev, S_IRUGO, lpfc_fwrev_show, NULL);
2011 static DEVICE_ATTR(hdw, S_IRUGO, lpfc_hdw_show, NULL);
2012 static DEVICE_ATTR(link_state, S_IRUGO | S_IWUSR, lpfc_link_state_show,
2013 lpfc_link_state_store);
2014 static DEVICE_ATTR(option_rom_version, S_IRUGO,
2015 lpfc_option_rom_version_show, NULL);
2016 static DEVICE_ATTR(num_discovered_ports, S_IRUGO,
2017 lpfc_num_discovered_ports_show, NULL);
2018 static DEVICE_ATTR(menlo_mgmt_mode, S_IRUGO, lpfc_mlomgmt_show, NULL);
2019 static DEVICE_ATTR(nport_evt_cnt, S_IRUGO, lpfc_nport_evt_cnt_show, NULL);
2020 static DEVICE_ATTR(lpfc_drvr_version, S_IRUGO, lpfc_drvr_version_show, NULL);
2021 static DEVICE_ATTR(lpfc_enable_fip, S_IRUGO, lpfc_enable_fip_show, NULL);
2022 static DEVICE_ATTR(board_mode, S_IRUGO | S_IWUSR,
2023 lpfc_board_mode_show, lpfc_board_mode_store);
2024 static DEVICE_ATTR(issue_reset, S_IWUSR, NULL, lpfc_issue_reset);
2025 static DEVICE_ATTR(max_vpi, S_IRUGO, lpfc_max_vpi_show, NULL);
2026 static DEVICE_ATTR(used_vpi, S_IRUGO, lpfc_used_vpi_show, NULL);
2027 static DEVICE_ATTR(max_rpi, S_IRUGO, lpfc_max_rpi_show, NULL);
2028 static DEVICE_ATTR(used_rpi, S_IRUGO, lpfc_used_rpi_show, NULL);
2029 static DEVICE_ATTR(max_xri, S_IRUGO, lpfc_max_xri_show, NULL);
2030 static DEVICE_ATTR(used_xri, S_IRUGO, lpfc_used_xri_show, NULL);
2031 static DEVICE_ATTR(npiv_info, S_IRUGO, lpfc_npiv_info_show, NULL);
2032 static DEVICE_ATTR(lpfc_temp_sensor, S_IRUGO, lpfc_temp_sensor_show, NULL);
2033 static DEVICE_ATTR(lpfc_fips_level, S_IRUGO, lpfc_fips_level_show, NULL);
2034 static DEVICE_ATTR(lpfc_fips_rev, S_IRUGO, lpfc_fips_rev_show, NULL);
2035 static DEVICE_ATTR(lpfc_dss, S_IRUGO, lpfc_dss_show, NULL);
2036 static DEVICE_ATTR(lpfc_sriov_hw_max_virtfn, S_IRUGO,
2037 lpfc_sriov_hw_max_virtfn_show, NULL);
2038 static DEVICE_ATTR(protocol, S_IRUGO, lpfc_sli4_protocol_show, NULL);
2040 static char *lpfc_soft_wwn_key = "C99G71SL8032A";
2043 * lpfc_soft_wwn_enable_store - Allows setting of the wwn if the key is valid
2044 * @dev: class device that is converted into a Scsi_host.
2045 * @attr: device attribute, not used.
2046 * @buf: containing the string lpfc_soft_wwn_key.
2047 * @count: must be size of lpfc_soft_wwn_key.
2050 * -EINVAL if the buffer does not contain lpfc_soft_wwn_key
2051 * length of buf indicates success
2054 lpfc_soft_wwn_enable_store(struct device *dev, struct device_attribute *attr,
2055 const char *buf, size_t count)
2057 struct Scsi_Host *shost = class_to_shost(dev);
2058 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2059 struct lpfc_hba *phba = vport->phba;
2060 unsigned int cnt = count;
2063 * We're doing a simple sanity check for soft_wwpn setting.
2064 * We require that the user write a specific key to enable
2065 * the soft_wwpn attribute to be settable. Once the attribute
2066 * is written, the enable key resets. If further updates are
2067 * desired, the key must be written again to re-enable the
2070 * The "key" is not secret - it is a hardcoded string shown
2071 * here. The intent is to protect against the random user or
2072 * application that is just writing attributes.
2075 /* count may include a LF at end of string */
2076 if (buf[cnt-1] == '\n')
2079 if ((cnt != strlen(lpfc_soft_wwn_key)) ||
2080 (strncmp(buf, lpfc_soft_wwn_key, strlen(lpfc_soft_wwn_key)) != 0))
2083 phba->soft_wwn_enable = 1;
2086 static DEVICE_ATTR(lpfc_soft_wwn_enable, S_IWUSR, NULL,
2087 lpfc_soft_wwn_enable_store);
2090 * lpfc_soft_wwpn_show - Return the cfg soft ww port name of the adapter
2091 * @dev: class device that is converted into a Scsi_host.
2092 * @attr: device attribute, not used.
2093 * @buf: on return contains the wwpn in hexadecimal.
2095 * Returns: size of formatted string.
2098 lpfc_soft_wwpn_show(struct device *dev, struct device_attribute *attr,
2101 struct Scsi_Host *shost = class_to_shost(dev);
2102 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2103 struct lpfc_hba *phba = vport->phba;
2105 return snprintf(buf, PAGE_SIZE, "0x%llx\n",
2106 (unsigned long long)phba->cfg_soft_wwpn);
2110 * lpfc_soft_wwpn_store - Set the ww port name of the adapter
2111 * @dev class device that is converted into a Scsi_host.
2112 * @attr: device attribute, not used.
2113 * @buf: contains the wwpn in hexadecimal.
2114 * @count: number of wwpn bytes in buf
2117 * -EACCES hba reset not enabled, adapter over temp
2118 * -EINVAL soft wwn not enabled, count is invalid, invalid wwpn byte invalid
2119 * -EIO error taking adapter offline or online
2120 * value of count on success
2123 lpfc_soft_wwpn_store(struct device *dev, struct device_attribute *attr,
2124 const char *buf, size_t count)
2126 struct Scsi_Host *shost = class_to_shost(dev);
2127 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2128 struct lpfc_hba *phba = vport->phba;
2129 struct completion online_compl;
2130 int stat1=0, stat2=0;
2131 unsigned int i, j, cnt=count;
2135 if (!phba->cfg_enable_hba_reset)
2137 spin_lock_irq(&phba->hbalock);
2138 if (phba->over_temp_state == HBA_OVER_TEMP) {
2139 spin_unlock_irq(&phba->hbalock);
2142 spin_unlock_irq(&phba->hbalock);
2143 /* count may include a LF at end of string */
2144 if (buf[cnt-1] == '\n')
2147 if (!phba->soft_wwn_enable || (cnt < 16) || (cnt > 18) ||
2148 ((cnt == 17) && (*buf++ != 'x')) ||
2149 ((cnt == 18) && ((*buf++ != '0') || (*buf++ != 'x'))))
2152 phba->soft_wwn_enable = 0;
2154 memset(wwpn, 0, sizeof(wwpn));
2156 /* Validate and store the new name */
2157 for (i=0, j=0; i < 16; i++) {
2160 value = hex_to_bin(*buf++);
2162 j = (j << 4) | value;
2166 wwpn[i/2] = j & 0xff;
2170 phba->cfg_soft_wwpn = wwn_to_u64(wwpn);
2171 fc_host_port_name(shost) = phba->cfg_soft_wwpn;
2172 if (phba->cfg_soft_wwnn)
2173 fc_host_node_name(shost) = phba->cfg_soft_wwnn;
2175 dev_printk(KERN_NOTICE, &phba->pcidev->dev,
2176 "lpfc%d: Reinitializing to use soft_wwpn\n", phba->brd_no);
2178 stat1 = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
2180 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2181 "0463 lpfc_soft_wwpn attribute set failed to "
2182 "reinit adapter - %d\n", stat1);
2183 init_completion(&online_compl);
2184 rc = lpfc_workq_post_event(phba, &stat2, &online_compl,
2189 wait_for_completion(&online_compl);
2191 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2192 "0464 lpfc_soft_wwpn attribute set failed to "
2193 "reinit adapter - %d\n", stat2);
2194 return (stat1 || stat2) ? -EIO : count;
2196 static DEVICE_ATTR(lpfc_soft_wwpn, S_IRUGO | S_IWUSR,\
2197 lpfc_soft_wwpn_show, lpfc_soft_wwpn_store);
2200 * lpfc_soft_wwnn_show - Return the cfg soft ww node name for the adapter
2201 * @dev: class device that is converted into a Scsi_host.
2202 * @attr: device attribute, not used.
2203 * @buf: on return contains the wwnn in hexadecimal.
2205 * Returns: size of formatted string.
2208 lpfc_soft_wwnn_show(struct device *dev, struct device_attribute *attr,
2211 struct Scsi_Host *shost = class_to_shost(dev);
2212 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2213 return snprintf(buf, PAGE_SIZE, "0x%llx\n",
2214 (unsigned long long)phba->cfg_soft_wwnn);
2218 * lpfc_soft_wwnn_store - sets the ww node name of the adapter
2219 * @cdev: class device that is converted into a Scsi_host.
2220 * @buf: contains the ww node name in hexadecimal.
2221 * @count: number of wwnn bytes in buf.
2224 * -EINVAL soft wwn not enabled, count is invalid, invalid wwnn byte invalid
2225 * value of count on success
2228 lpfc_soft_wwnn_store(struct device *dev, struct device_attribute *attr,
2229 const char *buf, size_t count)
2231 struct Scsi_Host *shost = class_to_shost(dev);
2232 struct lpfc_hba *phba = ((struct lpfc_vport *)shost->hostdata)->phba;
2233 unsigned int i, j, cnt=count;
2236 /* count may include a LF at end of string */
2237 if (buf[cnt-1] == '\n')
2240 if (!phba->soft_wwn_enable || (cnt < 16) || (cnt > 18) ||
2241 ((cnt == 17) && (*buf++ != 'x')) ||
2242 ((cnt == 18) && ((*buf++ != '0') || (*buf++ != 'x'))))
2246 * Allow wwnn to be set many times, as long as the enable is set.
2247 * However, once the wwpn is set, everything locks.
2250 memset(wwnn, 0, sizeof(wwnn));
2252 /* Validate and store the new name */
2253 for (i=0, j=0; i < 16; i++) {
2256 value = hex_to_bin(*buf++);
2258 j = (j << 4) | value;
2262 wwnn[i/2] = j & 0xff;
2266 phba->cfg_soft_wwnn = wwn_to_u64(wwnn);
2268 dev_printk(KERN_NOTICE, &phba->pcidev->dev,
2269 "lpfc%d: soft_wwnn set. Value will take effect upon "
2270 "setting of the soft_wwpn\n", phba->brd_no);
2274 static DEVICE_ATTR(lpfc_soft_wwnn, S_IRUGO | S_IWUSR,\
2275 lpfc_soft_wwnn_show, lpfc_soft_wwnn_store);
2278 static int lpfc_poll = 0;
2279 module_param(lpfc_poll, int, S_IRUGO);
2280 MODULE_PARM_DESC(lpfc_poll, "FCP ring polling mode control:"
2282 " 1 - poll with interrupts enabled"
2283 " 3 - poll and disable FCP ring interrupts");
2285 static DEVICE_ATTR(lpfc_poll, S_IRUGO | S_IWUSR,
2286 lpfc_poll_show, lpfc_poll_store);
2288 int lpfc_sli_mode = 0;
2289 module_param(lpfc_sli_mode, int, S_IRUGO);
2290 MODULE_PARM_DESC(lpfc_sli_mode, "SLI mode selector:"
2291 " 0 - auto (SLI-3 if supported),"
2292 " 2 - select SLI-2 even on SLI-3 capable HBAs,"
2293 " 3 - select SLI-3");
2295 int lpfc_enable_npiv = 1;
2296 module_param(lpfc_enable_npiv, int, S_IRUGO);
2297 MODULE_PARM_DESC(lpfc_enable_npiv, "Enable NPIV functionality");
2298 lpfc_param_show(enable_npiv);
2299 lpfc_param_init(enable_npiv, 1, 0, 1);
2300 static DEVICE_ATTR(lpfc_enable_npiv, S_IRUGO, lpfc_enable_npiv_show, NULL);
2302 LPFC_ATTR_R(fcf_failover_policy, 1, 1, 2,
2303 "FCF Fast failover=1 Priority failover=2");
2305 int lpfc_enable_rrq = 2;
2306 module_param(lpfc_enable_rrq, int, S_IRUGO);
2307 MODULE_PARM_DESC(lpfc_enable_rrq, "Enable RRQ functionality");
2308 lpfc_param_show(enable_rrq);
2310 # lpfc_enable_rrq: Track XRI/OXID reuse after IO failures
2311 # 0x0 = disabled, XRI/OXID use not tracked.
2312 # 0x1 = XRI/OXID reuse is timed with ratov, RRQ sent.
2313 # 0x2 = XRI/OXID reuse is timed with ratov, No RRQ sent.
2315 lpfc_param_init(enable_rrq, 2, 0, 2);
2316 static DEVICE_ATTR(lpfc_enable_rrq, S_IRUGO, lpfc_enable_rrq_show, NULL);
2319 # lpfc_suppress_link_up: Bring link up at initialization
2320 # 0x0 = bring link up (issue MBX_INIT_LINK)
2321 # 0x1 = do NOT bring link up at initialization(MBX_INIT_LINK)
2322 # 0x2 = never bring up link
2323 # Default value is 0.
2325 LPFC_ATTR_R(suppress_link_up, LPFC_INITIALIZE_LINK, LPFC_INITIALIZE_LINK,
2326 LPFC_DELAY_INIT_LINK_INDEFINITELY,
2327 "Suppress Link Up at initialization");
2329 # lpfc_cnt: Number of IOCBs allocated for ELS, CT, and ABTS
2337 lpfc_iocb_hw_show(struct device *dev, struct device_attribute *attr, char *buf)
2339 struct Scsi_Host *shost = class_to_shost(dev);
2340 struct lpfc_hba *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
2342 return snprintf(buf, PAGE_SIZE, "%d\n", phba->iocb_max);
2345 static DEVICE_ATTR(iocb_hw, S_IRUGO,
2346 lpfc_iocb_hw_show, NULL);
2348 lpfc_txq_hw_show(struct device *dev, struct device_attribute *attr, char *buf)
2350 struct Scsi_Host *shost = class_to_shost(dev);
2351 struct lpfc_hba *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
2353 return snprintf(buf, PAGE_SIZE, "%d\n",
2354 phba->sli.ring[LPFC_ELS_RING].txq_max);
2357 static DEVICE_ATTR(txq_hw, S_IRUGO,
2358 lpfc_txq_hw_show, NULL);
2360 lpfc_txcmplq_hw_show(struct device *dev, struct device_attribute *attr,
2363 struct Scsi_Host *shost = class_to_shost(dev);
2364 struct lpfc_hba *phba = ((struct lpfc_vport *) shost->hostdata)->phba;
2366 return snprintf(buf, PAGE_SIZE, "%d\n",
2367 phba->sli.ring[LPFC_ELS_RING].txcmplq_max);
2370 static DEVICE_ATTR(txcmplq_hw, S_IRUGO,
2371 lpfc_txcmplq_hw_show, NULL);
2373 int lpfc_iocb_cnt = 2;
2374 module_param(lpfc_iocb_cnt, int, S_IRUGO);
2375 MODULE_PARM_DESC(lpfc_iocb_cnt,
2376 "Number of IOCBs alloc for ELS, CT, and ABTS: 1k to 5k IOCBs");
2377 lpfc_param_show(iocb_cnt);
2378 lpfc_param_init(iocb_cnt, 2, 1, 5);
2379 static DEVICE_ATTR(lpfc_iocb_cnt, S_IRUGO,
2380 lpfc_iocb_cnt_show, NULL);
2383 # lpfc_nodev_tmo: If set, it will hold all I/O errors on devices that disappear
2384 # until the timer expires. Value range is [0,255]. Default value is 30.
2386 static int lpfc_nodev_tmo = LPFC_DEF_DEVLOSS_TMO;
2387 static int lpfc_devloss_tmo = LPFC_DEF_DEVLOSS_TMO;
2388 module_param(lpfc_nodev_tmo, int, 0);
2389 MODULE_PARM_DESC(lpfc_nodev_tmo,
2390 "Seconds driver will hold I/O waiting "
2391 "for a device to come back");
2394 * lpfc_nodev_tmo_show - Return the hba dev loss timeout value
2395 * @dev: class converted to a Scsi_host structure.
2396 * @attr: device attribute, not used.
2397 * @buf: on return contains the dev loss timeout in decimal.
2399 * Returns: size of formatted string.
2402 lpfc_nodev_tmo_show(struct device *dev, struct device_attribute *attr,
2405 struct Scsi_Host *shost = class_to_shost(dev);
2406 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2408 return snprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_devloss_tmo);
2412 * lpfc_nodev_tmo_init - Set the hba nodev timeout value
2413 * @vport: lpfc vport structure pointer.
2414 * @val: contains the nodev timeout value.
2417 * If the devloss tmo is already set then nodev tmo is set to devloss tmo,
2418 * a kernel error message is printed and zero is returned.
2419 * Else if val is in range then nodev tmo and devloss tmo are set to val.
2420 * Otherwise nodev tmo is set to the default value.
2423 * zero if already set or if val is in range
2424 * -EINVAL val out of range
2427 lpfc_nodev_tmo_init(struct lpfc_vport *vport, int val)
2429 if (vport->cfg_devloss_tmo != LPFC_DEF_DEVLOSS_TMO) {
2430 vport->cfg_nodev_tmo = vport->cfg_devloss_tmo;
2431 if (val != LPFC_DEF_DEVLOSS_TMO)
2432 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2433 "0407 Ignoring nodev_tmo module "
2434 "parameter because devloss_tmo is "
2439 if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
2440 vport->cfg_nodev_tmo = val;
2441 vport->cfg_devloss_tmo = val;
2444 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2445 "0400 lpfc_nodev_tmo attribute cannot be set to"
2446 " %d, allowed range is [%d, %d]\n",
2447 val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
2448 vport->cfg_nodev_tmo = LPFC_DEF_DEVLOSS_TMO;
2453 * lpfc_update_rport_devloss_tmo - Update dev loss tmo value
2454 * @vport: lpfc vport structure pointer.
2457 * Update all the ndlp's dev loss tmo with the vport devloss tmo value.
2460 lpfc_update_rport_devloss_tmo(struct lpfc_vport *vport)
2462 struct Scsi_Host *shost;
2463 struct lpfc_nodelist *ndlp;
2465 shost = lpfc_shost_from_vport(vport);
2466 spin_lock_irq(shost->host_lock);
2467 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp)
2468 if (NLP_CHK_NODE_ACT(ndlp) && ndlp->rport)
2469 ndlp->rport->dev_loss_tmo = vport->cfg_devloss_tmo;
2470 spin_unlock_irq(shost->host_lock);
2474 * lpfc_nodev_tmo_set - Set the vport nodev tmo and devloss tmo values
2475 * @vport: lpfc vport structure pointer.
2476 * @val: contains the tmo value.
2479 * If the devloss tmo is already set or the vport dev loss tmo has changed
2480 * then a kernel error message is printed and zero is returned.
2481 * Else if val is in range then nodev tmo and devloss tmo are set to val.
2482 * Otherwise nodev tmo is set to the default value.
2485 * zero if already set or if val is in range
2486 * -EINVAL val out of range
2489 lpfc_nodev_tmo_set(struct lpfc_vport *vport, int val)
2491 if (vport->dev_loss_tmo_changed ||
2492 (lpfc_devloss_tmo != LPFC_DEF_DEVLOSS_TMO)) {
2493 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2494 "0401 Ignoring change to nodev_tmo "
2495 "because devloss_tmo is set.\n");
2498 if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
2499 vport->cfg_nodev_tmo = val;
2500 vport->cfg_devloss_tmo = val;
2502 * For compat: set the fc_host dev loss so new rports
2503 * will get the value.
2505 fc_host_dev_loss_tmo(lpfc_shost_from_vport(vport)) = val;
2506 lpfc_update_rport_devloss_tmo(vport);
2509 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2510 "0403 lpfc_nodev_tmo attribute cannot be set to"
2511 "%d, allowed range is [%d, %d]\n",
2512 val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
2516 lpfc_vport_param_store(nodev_tmo)
2518 static DEVICE_ATTR(lpfc_nodev_tmo, S_IRUGO | S_IWUSR,
2519 lpfc_nodev_tmo_show, lpfc_nodev_tmo_store);
2522 # lpfc_devloss_tmo: If set, it will hold all I/O errors on devices that
2523 # disappear until the timer expires. Value range is [0,255]. Default
2526 module_param(lpfc_devloss_tmo, int, S_IRUGO);
2527 MODULE_PARM_DESC(lpfc_devloss_tmo,
2528 "Seconds driver will hold I/O waiting "
2529 "for a device to come back");
2530 lpfc_vport_param_init(devloss_tmo, LPFC_DEF_DEVLOSS_TMO,
2531 LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO)
2532 lpfc_vport_param_show(devloss_tmo)
2535 * lpfc_devloss_tmo_set - Sets vport nodev tmo, devloss tmo values, changed bit
2536 * @vport: lpfc vport structure pointer.
2537 * @val: contains the tmo value.
2540 * If val is in a valid range then set the vport nodev tmo,
2541 * devloss tmo, also set the vport dev loss tmo changed flag.
2542 * Else a kernel error message is printed.
2545 * zero if val is in range
2546 * -EINVAL val out of range
2549 lpfc_devloss_tmo_set(struct lpfc_vport *vport, int val)
2551 if (val >= LPFC_MIN_DEVLOSS_TMO && val <= LPFC_MAX_DEVLOSS_TMO) {
2552 vport->cfg_nodev_tmo = val;
2553 vport->cfg_devloss_tmo = val;
2554 vport->dev_loss_tmo_changed = 1;
2555 fc_host_dev_loss_tmo(lpfc_shost_from_vport(vport)) = val;
2556 lpfc_update_rport_devloss_tmo(vport);
2560 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2561 "0404 lpfc_devloss_tmo attribute cannot be set to"
2562 " %d, allowed range is [%d, %d]\n",
2563 val, LPFC_MIN_DEVLOSS_TMO, LPFC_MAX_DEVLOSS_TMO);
2567 lpfc_vport_param_store(devloss_tmo)
2568 static DEVICE_ATTR(lpfc_devloss_tmo, S_IRUGO | S_IWUSR,
2569 lpfc_devloss_tmo_show, lpfc_devloss_tmo_store);
2572 # lpfc_log_verbose: Only turn this flag on if you are willing to risk being
2573 # deluged with LOTS of information.
2574 # You can set a bit mask to record specific types of verbose messages:
2575 # See lpfc_logmsh.h for definitions.
2577 LPFC_VPORT_ATTR_HEX_RW(log_verbose, 0x0, 0x0, 0xffffffff,
2578 "Verbose logging bit-mask");
2581 # lpfc_enable_da_id: This turns on the DA_ID CT command that deregisters
2582 # objects that have been registered with the nameserver after login.
2584 LPFC_VPORT_ATTR_R(enable_da_id, 1, 0, 1,
2585 "Deregister nameserver objects before LOGO");
2588 # lun_queue_depth: This parameter is used to limit the number of outstanding
2589 # commands per FCP LUN. Value range is [1,128]. Default value is 30.
2591 LPFC_VPORT_ATTR_R(lun_queue_depth, 30, 1, 128,
2592 "Max number of FCP commands we can queue to a specific LUN");
2595 # tgt_queue_depth: This parameter is used to limit the number of outstanding
2596 # commands per target port. Value range is [10,65535]. Default value is 65535.
2598 LPFC_VPORT_ATTR_R(tgt_queue_depth, 65535, 10, 65535,
2599 "Max number of FCP commands we can queue to a specific target port");
2602 # hba_queue_depth: This parameter is used to limit the number of outstanding
2603 # commands per lpfc HBA. Value range is [32,8192]. If this parameter
2604 # value is greater than the maximum number of exchanges supported by the HBA,
2605 # then maximum number of exchanges supported by the HBA is used to determine
2606 # the hba_queue_depth.
2608 LPFC_ATTR_R(hba_queue_depth, 8192, 32, 8192,
2609 "Max number of FCP commands we can queue to a lpfc HBA");
2612 # peer_port_login: This parameter allows/prevents logins
2613 # between peer ports hosted on the same physical port.
2614 # When this parameter is set 0 peer ports of same physical port
2615 # are not allowed to login to each other.
2616 # When this parameter is set 1 peer ports of same physical port
2617 # are allowed to login to each other.
2618 # Default value of this parameter is 0.
2620 LPFC_VPORT_ATTR_R(peer_port_login, 0, 0, 1,
2621 "Allow peer ports on the same physical port to login to each "
2625 # restrict_login: This parameter allows/prevents logins
2626 # between Virtual Ports and remote initiators.
2627 # When this parameter is not set (0) Virtual Ports will accept PLOGIs from
2628 # other initiators and will attempt to PLOGI all remote ports.
2629 # When this parameter is set (1) Virtual Ports will reject PLOGIs from
2630 # remote ports and will not attempt to PLOGI to other initiators.
2631 # This parameter does not restrict to the physical port.
2632 # This parameter does not restrict logins to Fabric resident remote ports.
2633 # Default value of this parameter is 1.
2635 static int lpfc_restrict_login = 1;
2636 module_param(lpfc_restrict_login, int, S_IRUGO);
2637 MODULE_PARM_DESC(lpfc_restrict_login,
2638 "Restrict virtual ports login to remote initiators.");
2639 lpfc_vport_param_show(restrict_login);
2642 * lpfc_restrict_login_init - Set the vport restrict login flag
2643 * @vport: lpfc vport structure pointer.
2644 * @val: contains the restrict login value.
2647 * If val is not in a valid range then log a kernel error message and set
2648 * the vport restrict login to one.
2649 * If the port type is physical clear the restrict login flag and return.
2650 * Else set the restrict login flag to val.
2653 * zero if val is in range
2654 * -EINVAL val out of range
2657 lpfc_restrict_login_init(struct lpfc_vport *vport, int val)
2659 if (val < 0 || val > 1) {
2660 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2661 "0422 lpfc_restrict_login attribute cannot "
2662 "be set to %d, allowed range is [0, 1]\n",
2664 vport->cfg_restrict_login = 1;
2667 if (vport->port_type == LPFC_PHYSICAL_PORT) {
2668 vport->cfg_restrict_login = 0;
2671 vport->cfg_restrict_login = val;
2676 * lpfc_restrict_login_set - Set the vport restrict login flag
2677 * @vport: lpfc vport structure pointer.
2678 * @val: contains the restrict login value.
2681 * If val is not in a valid range then log a kernel error message and set
2682 * the vport restrict login to one.
2683 * If the port type is physical and the val is not zero log a kernel
2684 * error message, clear the restrict login flag and return zero.
2685 * Else set the restrict login flag to val.
2688 * zero if val is in range
2689 * -EINVAL val out of range
2692 lpfc_restrict_login_set(struct lpfc_vport *vport, int val)
2694 if (val < 0 || val > 1) {
2695 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2696 "0425 lpfc_restrict_login attribute cannot "
2697 "be set to %d, allowed range is [0, 1]\n",
2699 vport->cfg_restrict_login = 1;
2702 if (vport->port_type == LPFC_PHYSICAL_PORT && val != 0) {
2703 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2704 "0468 lpfc_restrict_login must be 0 for "
2705 "Physical ports.\n");
2706 vport->cfg_restrict_login = 0;
2709 vport->cfg_restrict_login = val;
2712 lpfc_vport_param_store(restrict_login);
2713 static DEVICE_ATTR(lpfc_restrict_login, S_IRUGO | S_IWUSR,
2714 lpfc_restrict_login_show, lpfc_restrict_login_store);
2717 # Some disk devices have a "select ID" or "select Target" capability.
2718 # From a protocol standpoint "select ID" usually means select the
2719 # Fibre channel "ALPA". In the FC-AL Profile there is an "informative
2720 # annex" which contains a table that maps a "select ID" (a number
2721 # between 0 and 7F) to an ALPA. By default, for compatibility with
2722 # older drivers, the lpfc driver scans this table from low ALPA to high
2725 # Turning on the scan-down variable (on = 1, off = 0) will
2726 # cause the lpfc driver to use an inverted table, effectively
2727 # scanning ALPAs from high to low. Value range is [0,1]. Default value is 1.
2729 # (Note: This "select ID" functionality is a LOOP ONLY characteristic
2730 # and will not work across a fabric. Also this parameter will take
2731 # effect only in the case when ALPA map is not available.)
2733 LPFC_VPORT_ATTR_R(scan_down, 1, 0, 1,
2734 "Start scanning for devices from highest ALPA to lowest");
2737 # lpfc_topology: link topology for init link
2738 # 0x0 = attempt loop mode then point-to-point
2739 # 0x01 = internal loopback mode
2740 # 0x02 = attempt point-to-point mode only
2741 # 0x04 = attempt loop mode only
2742 # 0x06 = attempt point-to-point mode then loop
2743 # Set point-to-point mode if you want to run as an N_Port.
2744 # Set loop mode if you want to run as an NL_Port. Value range is [0,0x6].
2745 # Default value is 0.
2749 * lpfc_topology_set - Set the adapters topology field
2750 * @phba: lpfc_hba pointer.
2751 * @val: topology value.
2754 * If val is in a valid range then set the adapter's topology field and
2755 * issue a lip; if the lip fails reset the topology to the old value.
2757 * If the value is not in range log a kernel error message and return an error.
2760 * zero if val is in range and lip okay
2761 * non-zero return value from lpfc_issue_lip()
2762 * -EINVAL val out of range
2765 lpfc_topology_store(struct device *dev, struct device_attribute *attr,
2766 const char *buf, size_t count)
2768 struct Scsi_Host *shost = class_to_shost(dev);
2769 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2770 struct lpfc_hba *phba = vport->phba;
2773 const char *val_buf = buf;
2777 if (!strncmp(buf, "nolip ", strlen("nolip "))) {
2779 val_buf = &buf[strlen("nolip ")];
2782 if (!isdigit(val_buf[0]))
2784 if (sscanf(val_buf, "%i", &val) != 1)
2787 if (val >= 0 && val <= 6) {
2788 prev_val = phba->cfg_topology;
2789 phba->cfg_topology = val;
2790 if (phba->cfg_link_speed == LPFC_USER_LINK_SPEED_16G &&
2792 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2793 "3113 Loop mode not supported at speed %d\n",
2794 phba->cfg_link_speed);
2795 phba->cfg_topology = prev_val;
2801 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
2802 "3054 lpfc_topology changed from %d to %d\n",
2804 err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport));
2806 phba->cfg_topology = prev_val;
2811 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
2812 "%d:0467 lpfc_topology attribute cannot be set to %d, "
2813 "allowed range is [0, 6]\n",
2817 static int lpfc_topology = 0;
2818 module_param(lpfc_topology, int, S_IRUGO);
2819 MODULE_PARM_DESC(lpfc_topology, "Select Fibre Channel topology");
2820 lpfc_param_show(topology)
2821 lpfc_param_init(topology, 0, 0, 6)
2822 static DEVICE_ATTR(lpfc_topology, S_IRUGO | S_IWUSR,
2823 lpfc_topology_show, lpfc_topology_store);
2826 * lpfc_static_vport_show: Read callback function for
2827 * lpfc_static_vport sysfs file.
2828 * @dev: Pointer to class device object.
2829 * @attr: device attribute structure.
2830 * @buf: Data buffer.
2832 * This function is the read call back function for
2833 * lpfc_static_vport sysfs file. The lpfc_static_vport
2834 * sysfs file report the mageability of the vport.
2837 lpfc_static_vport_show(struct device *dev, struct device_attribute *attr,
2840 struct Scsi_Host *shost = class_to_shost(dev);
2841 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2842 if (vport->vport_flag & STATIC_VPORT)
2843 sprintf(buf, "1\n");
2845 sprintf(buf, "0\n");
2851 * Sysfs attribute to control the statistical data collection.
2853 static DEVICE_ATTR(lpfc_static_vport, S_IRUGO,
2854 lpfc_static_vport_show, NULL);
2857 * lpfc_stat_data_ctrl_store - write call back for lpfc_stat_data_ctrl sysfs file
2858 * @dev: Pointer to class device.
2859 * @buf: Data buffer.
2860 * @count: Size of the data buffer.
2862 * This function get called when an user write to the lpfc_stat_data_ctrl
2863 * sysfs file. This function parse the command written to the sysfs file
2864 * and take appropriate action. These commands are used for controlling
2865 * driver statistical data collection.
2866 * Following are the command this function handles.
2868 * setbucket <bucket_type> <base> <step>
2869 * = Set the latency buckets.
2870 * destroybucket = destroy all the buckets.
2871 * start = start data collection
2872 * stop = stop data collection
2873 * reset = reset the collected data
2876 lpfc_stat_data_ctrl_store(struct device *dev, struct device_attribute *attr,
2877 const char *buf, size_t count)
2879 struct Scsi_Host *shost = class_to_shost(dev);
2880 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
2881 struct lpfc_hba *phba = vport->phba;
2882 #define LPFC_MAX_DATA_CTRL_LEN 1024
2883 static char bucket_data[LPFC_MAX_DATA_CTRL_LEN];
2885 char *str_ptr, *token;
2886 struct lpfc_vport **vports;
2887 struct Scsi_Host *v_shost;
2888 char *bucket_type_str, *base_str, *step_str;
2889 unsigned long base, step, bucket_type;
2891 if (!strncmp(buf, "setbucket", strlen("setbucket"))) {
2892 if (strlen(buf) > (LPFC_MAX_DATA_CTRL_LEN - 1))
2895 strcpy(bucket_data, buf);
2896 str_ptr = &bucket_data[0];
2897 /* Ignore this token - this is command token */
2898 token = strsep(&str_ptr, "\t ");
2902 bucket_type_str = strsep(&str_ptr, "\t ");
2903 if (!bucket_type_str)
2906 if (!strncmp(bucket_type_str, "linear", strlen("linear")))
2907 bucket_type = LPFC_LINEAR_BUCKET;
2908 else if (!strncmp(bucket_type_str, "power2", strlen("power2")))
2909 bucket_type = LPFC_POWER2_BUCKET;
2913 base_str = strsep(&str_ptr, "\t ");
2916 base = simple_strtoul(base_str, NULL, 0);
2918 step_str = strsep(&str_ptr, "\t ");
2921 step = simple_strtoul(step_str, NULL, 0);
2925 /* Block the data collection for every vport */
2926 vports = lpfc_create_vport_work_array(phba);
2930 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
2931 v_shost = lpfc_shost_from_vport(vports[i]);
2932 spin_lock_irq(v_shost->host_lock);
2933 /* Block and reset data collection */
2934 vports[i]->stat_data_blocked = 1;
2935 if (vports[i]->stat_data_enabled)
2936 lpfc_vport_reset_stat_data(vports[i]);
2937 spin_unlock_irq(v_shost->host_lock);
2940 /* Set the bucket attributes */
2941 phba->bucket_type = bucket_type;
2942 phba->bucket_base = base;
2943 phba->bucket_step = step;
2945 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
2946 v_shost = lpfc_shost_from_vport(vports[i]);
2948 /* Unblock data collection */
2949 spin_lock_irq(v_shost->host_lock);
2950 vports[i]->stat_data_blocked = 0;
2951 spin_unlock_irq(v_shost->host_lock);
2953 lpfc_destroy_vport_work_array(phba, vports);
2957 if (!strncmp(buf, "destroybucket", strlen("destroybucket"))) {
2958 vports = lpfc_create_vport_work_array(phba);
2962 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
2963 v_shost = lpfc_shost_from_vport(vports[i]);
2964 spin_lock_irq(shost->host_lock);
2965 vports[i]->stat_data_blocked = 1;
2966 lpfc_free_bucket(vport);
2967 vport->stat_data_enabled = 0;
2968 vports[i]->stat_data_blocked = 0;
2969 spin_unlock_irq(shost->host_lock);
2971 lpfc_destroy_vport_work_array(phba, vports);
2972 phba->bucket_type = LPFC_NO_BUCKET;
2973 phba->bucket_base = 0;
2974 phba->bucket_step = 0;
2978 if (!strncmp(buf, "start", strlen("start"))) {
2979 /* If no buckets configured return error */
2980 if (phba->bucket_type == LPFC_NO_BUCKET)
2982 spin_lock_irq(shost->host_lock);
2983 if (vport->stat_data_enabled) {
2984 spin_unlock_irq(shost->host_lock);
2987 lpfc_alloc_bucket(vport);
2988 vport->stat_data_enabled = 1;
2989 spin_unlock_irq(shost->host_lock);
2993 if (!strncmp(buf, "stop", strlen("stop"))) {
2994 spin_lock_irq(shost->host_lock);
2995 if (vport->stat_data_enabled == 0) {
2996 spin_unlock_irq(shost->host_lock);
2999 lpfc_free_bucket(vport);
3000 vport->stat_data_enabled = 0;
3001 spin_unlock_irq(shost->host_lock);
3005 if (!strncmp(buf, "reset", strlen("reset"))) {
3006 if ((phba->bucket_type == LPFC_NO_BUCKET)
3007 || !vport->stat_data_enabled)
3009 spin_lock_irq(shost->host_lock);
3010 vport->stat_data_blocked = 1;
3011 lpfc_vport_reset_stat_data(vport);
3012 vport->stat_data_blocked = 0;
3013 spin_unlock_irq(shost->host_lock);
3021 * lpfc_stat_data_ctrl_show - Read function for lpfc_stat_data_ctrl sysfs file
3022 * @dev: Pointer to class device object.
3023 * @buf: Data buffer.
3025 * This function is the read call back function for
3026 * lpfc_stat_data_ctrl sysfs file. This function report the
3027 * current statistical data collection state.
3030 lpfc_stat_data_ctrl_show(struct device *dev, struct device_attribute *attr,
3033 struct Scsi_Host *shost = class_to_shost(dev);
3034 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
3035 struct lpfc_hba *phba = vport->phba;
3039 unsigned long bucket_value;
3041 switch (phba->bucket_type) {
3042 case LPFC_LINEAR_BUCKET:
3043 bucket_type = "linear";
3045 case LPFC_POWER2_BUCKET:
3046 bucket_type = "power2";
3049 bucket_type = "No Bucket";
3053 sprintf(&buf[index], "Statistical Data enabled :%d, "
3054 "blocked :%d, Bucket type :%s, Bucket base :%d,"
3055 " Bucket step :%d\nLatency Ranges :",
3056 vport->stat_data_enabled, vport->stat_data_blocked,
3057 bucket_type, phba->bucket_base, phba->bucket_step);
3058 index = strlen(buf);
3059 if (phba->bucket_type != LPFC_NO_BUCKET) {
3060 for (i = 0; i < LPFC_MAX_BUCKET_COUNT; i++) {
3061 if (phba->bucket_type == LPFC_LINEAR_BUCKET)
3062 bucket_value = phba->bucket_base +
3063 phba->bucket_step * i;
3065 bucket_value = phba->bucket_base +
3066 (1 << i) * phba->bucket_step;
3068 if (index + 10 > PAGE_SIZE)
3070 sprintf(&buf[index], "%08ld ", bucket_value);
3071 index = strlen(buf);
3074 sprintf(&buf[index], "\n");
3079 * Sysfs attribute to control the statistical data collection.
3081 static DEVICE_ATTR(lpfc_stat_data_ctrl, S_IRUGO | S_IWUSR,
3082 lpfc_stat_data_ctrl_show, lpfc_stat_data_ctrl_store);
3085 * lpfc_drvr_stat_data: sysfs attr to get driver statistical data.
3089 * Each Bucket takes 11 characters and 1 new line + 17 bytes WWN
3092 #define STAT_DATA_SIZE_PER_TARGET(NUM_BUCKETS) ((NUM_BUCKETS) * 11 + 18)
3093 #define MAX_STAT_DATA_SIZE_PER_TARGET \
3094 STAT_DATA_SIZE_PER_TARGET(LPFC_MAX_BUCKET_COUNT)
3098 * sysfs_drvr_stat_data_read - Read function for lpfc_drvr_stat_data attribute
3100 * @kobj: Pointer to the kernel object
3101 * @bin_attr: Attribute object
3102 * @buff: Buffer pointer
3104 * @count: Buffer size
3106 * This function is the read call back function for lpfc_drvr_stat_data
3107 * sysfs file. This function export the statistical data to user
3111 sysfs_drvr_stat_data_read(struct file *filp, struct kobject *kobj,
3112 struct bin_attribute *bin_attr,
3113 char *buf, loff_t off, size_t count)
3115 struct device *dev = container_of(kobj, struct device,
3117 struct Scsi_Host *shost = class_to_shost(dev);
3118 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
3119 struct lpfc_hba *phba = vport->phba;
3120 int i = 0, index = 0;
3121 unsigned long nport_index;
3122 struct lpfc_nodelist *ndlp = NULL;
3123 nport_index = (unsigned long)off /
3124 MAX_STAT_DATA_SIZE_PER_TARGET;
3126 if (!vport->stat_data_enabled || vport->stat_data_blocked
3127 || (phba->bucket_type == LPFC_NO_BUCKET))
3130 spin_lock_irq(shost->host_lock);
3131 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
3132 if (!NLP_CHK_NODE_ACT(ndlp) || !ndlp->lat_data)
3135 if (nport_index > 0) {
3140 if ((index + MAX_STAT_DATA_SIZE_PER_TARGET)
3144 if (!ndlp->lat_data)
3148 sprintf(&buf[index], "%02x%02x%02x%02x%02x%02x%02x%02x:",
3149 ndlp->nlp_portname.u.wwn[0],
3150 ndlp->nlp_portname.u.wwn[1],
3151 ndlp->nlp_portname.u.wwn[2],
3152 ndlp->nlp_portname.u.wwn[3],
3153 ndlp->nlp_portname.u.wwn[4],
3154 ndlp->nlp_portname.u.wwn[5],
3155 ndlp->nlp_portname.u.wwn[6],
3156 ndlp->nlp_portname.u.wwn[7]);
3158 index = strlen(buf);
3160 for (i = 0; i < LPFC_MAX_BUCKET_COUNT; i++) {
3161 sprintf(&buf[index], "%010u,",
3162 ndlp->lat_data[i].cmd_count);
3163 index = strlen(buf);
3165 sprintf(&buf[index], "\n");
3166 index = strlen(buf);
3168 spin_unlock_irq(shost->host_lock);
3172 static struct bin_attribute sysfs_drvr_stat_data_attr = {
3174 .name = "lpfc_drvr_stat_data",
3177 .size = LPFC_MAX_TARGET * MAX_STAT_DATA_SIZE_PER_TARGET,
3178 .read = sysfs_drvr_stat_data_read,
3183 # lpfc_link_speed: Link speed selection for initializing the Fibre Channel
3185 # Value range is [0,16]. Default value is 0.
3188 * lpfc_link_speed_set - Set the adapters link speed
3189 * @phba: lpfc_hba pointer.
3190 * @val: link speed value.
3193 * If val is in a valid range then set the adapter's link speed field and
3194 * issue a lip; if the lip fails reset the link speed to the old value.
3197 * If the value is not in range log a kernel error message and return an error.
3200 * zero if val is in range and lip okay.
3201 * non-zero return value from lpfc_issue_lip()
3202 * -EINVAL val out of range
3205 lpfc_link_speed_store(struct device *dev, struct device_attribute *attr,
3206 const char *buf, size_t count)
3208 struct Scsi_Host *shost = class_to_shost(dev);
3209 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
3210 struct lpfc_hba *phba = vport->phba;
3211 int val = LPFC_USER_LINK_SPEED_AUTO;
3213 const char *val_buf = buf;
3217 if (!strncmp(buf, "nolip ", strlen("nolip "))) {
3219 val_buf = &buf[strlen("nolip ")];
3222 if (!isdigit(val_buf[0]))
3224 if (sscanf(val_buf, "%i", &val) != 1)
3227 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
3228 "3055 lpfc_link_speed changed from %d to %d %s\n",
3229 phba->cfg_link_speed, val, nolip ? "(nolip)" : "(lip)");
3231 if (((val == LPFC_USER_LINK_SPEED_1G) && !(phba->lmt & LMT_1Gb)) ||
3232 ((val == LPFC_USER_LINK_SPEED_2G) && !(phba->lmt & LMT_2Gb)) ||
3233 ((val == LPFC_USER_LINK_SPEED_4G) && !(phba->lmt & LMT_4Gb)) ||
3234 ((val == LPFC_USER_LINK_SPEED_8G) && !(phba->lmt & LMT_8Gb)) ||
3235 ((val == LPFC_USER_LINK_SPEED_10G) && !(phba->lmt & LMT_10Gb)) ||
3236 ((val == LPFC_USER_LINK_SPEED_16G) && !(phba->lmt & LMT_16Gb))) {
3237 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3238 "2879 lpfc_link_speed attribute cannot be set "
3239 "to %d. Speed is not supported by this port.\n",
3243 if (val == LPFC_USER_LINK_SPEED_16G &&
3244 phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
3245 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3246 "3112 lpfc_link_speed attribute cannot be set "
3247 "to %d. Speed is not supported in loop mode.\n",
3251 if ((val >= 0) && (val <= LPFC_USER_LINK_SPEED_MAX) &&
3252 (LPFC_USER_LINK_SPEED_BITMAP & (1 << val))) {
3253 prev_val = phba->cfg_link_speed;
3254 phba->cfg_link_speed = val;
3258 err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport));
3260 phba->cfg_link_speed = prev_val;
3265 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3266 "0469 lpfc_link_speed attribute cannot be set to %d, "
3267 "allowed values are ["LPFC_LINK_SPEED_STRING"]\n", val);
3271 static int lpfc_link_speed = 0;
3272 module_param(lpfc_link_speed, int, S_IRUGO);
3273 MODULE_PARM_DESC(lpfc_link_speed, "Select link speed");
3274 lpfc_param_show(link_speed)
3277 * lpfc_link_speed_init - Set the adapters link speed
3278 * @phba: lpfc_hba pointer.
3279 * @val: link speed value.
3282 * If val is in a valid range then set the adapter's link speed field.
3285 * If the value is not in range log a kernel error message, clear the link
3286 * speed and return an error.
3289 * zero if val saved.
3290 * -EINVAL val out of range
3293 lpfc_link_speed_init(struct lpfc_hba *phba, int val)
3295 if (val == LPFC_USER_LINK_SPEED_16G && phba->cfg_topology == 4) {
3296 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3297 "3111 lpfc_link_speed of %d cannot "
3298 "support loop mode, setting topology to default.\n",
3300 phba->cfg_topology = 0;
3302 if ((val >= 0) && (val <= LPFC_USER_LINK_SPEED_MAX) &&
3303 (LPFC_USER_LINK_SPEED_BITMAP & (1 << val))) {
3304 phba->cfg_link_speed = val;
3307 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3308 "0405 lpfc_link_speed attribute cannot "
3309 "be set to %d, allowed values are "
3310 "["LPFC_LINK_SPEED_STRING"]\n", val);
3311 phba->cfg_link_speed = LPFC_USER_LINK_SPEED_AUTO;
3315 static DEVICE_ATTR(lpfc_link_speed, S_IRUGO | S_IWUSR,
3316 lpfc_link_speed_show, lpfc_link_speed_store);
3319 # lpfc_aer_support: Support PCIe device Advanced Error Reporting (AER)
3320 # 0 = aer disabled or not supported
3321 # 1 = aer supported and enabled (default)
3322 # Value range is [0,1]. Default value is 1.
3326 * lpfc_aer_support_store - Set the adapter for aer support
3328 * @dev: class device that is converted into a Scsi_host.
3329 * @attr: device attribute, not used.
3330 * @buf: containing enable or disable aer flag.
3331 * @count: unused variable.
3334 * If the val is 1 and currently the device's AER capability was not
3335 * enabled, invoke the kernel's enable AER helper routine, trying to
3336 * enable the device's AER capability. If the helper routine enabling
3337 * AER returns success, update the device's cfg_aer_support flag to
3338 * indicate AER is supported by the device; otherwise, if the device
3339 * AER capability is already enabled to support AER, then do nothing.
3341 * If the val is 0 and currently the device's AER support was enabled,
3342 * invoke the kernel's disable AER helper routine. After that, update
3343 * the device's cfg_aer_support flag to indicate AER is not supported
3344 * by the device; otherwise, if the device AER capability is already
3345 * disabled from supporting AER, then do nothing.
3348 * length of the buf on success if val is in range the intended mode
3350 * -EINVAL if val out of range or intended mode is not supported.
3353 lpfc_aer_support_store(struct device *dev, struct device_attribute *attr,
3354 const char *buf, size_t count)
3356 struct Scsi_Host *shost = class_to_shost(dev);
3357 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
3358 struct lpfc_hba *phba = vport->phba;
3359 int val = 0, rc = -EINVAL;
3361 if (!isdigit(buf[0]))
3363 if (sscanf(buf, "%i", &val) != 1)
3368 if (phba->hba_flag & HBA_AER_ENABLED) {
3369 rc = pci_disable_pcie_error_reporting(phba->pcidev);
3371 spin_lock_irq(&phba->hbalock);
3372 phba->hba_flag &= ~HBA_AER_ENABLED;
3373 spin_unlock_irq(&phba->hbalock);
3374 phba->cfg_aer_support = 0;
3379 phba->cfg_aer_support = 0;
3384 if (!(phba->hba_flag & HBA_AER_ENABLED)) {
3385 rc = pci_enable_pcie_error_reporting(phba->pcidev);
3387 spin_lock_irq(&phba->hbalock);
3388 phba->hba_flag |= HBA_AER_ENABLED;
3389 spin_unlock_irq(&phba->hbalock);
3390 phba->cfg_aer_support = 1;
3395 phba->cfg_aer_support = 1;
3406 static int lpfc_aer_support = 1;
3407 module_param(lpfc_aer_support, int, S_IRUGO);
3408 MODULE_PARM_DESC(lpfc_aer_support, "Enable PCIe device AER support");
3409 lpfc_param_show(aer_support)
3412 * lpfc_aer_support_init - Set the initial adapters aer support flag
3413 * @phba: lpfc_hba pointer.
3414 * @val: enable aer or disable aer flag.
3417 * If val is in a valid range [0,1], then set the adapter's initial
3418 * cfg_aer_support field. It will be up to the driver's probe_one
3419 * routine to determine whether the device's AER support can be set
3423 * If the value is not in range log a kernel error message, and
3424 * choose the default value of setting AER support and return.
3427 * zero if val saved.
3428 * -EINVAL val out of range
3431 lpfc_aer_support_init(struct lpfc_hba *phba, int val)
3433 if (val == 0 || val == 1) {
3434 phba->cfg_aer_support = val;
3437 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3438 "2712 lpfc_aer_support attribute value %d out "
3439 "of range, allowed values are 0|1, setting it "
3440 "to default value of 1\n", val);
3441 /* By default, try to enable AER on a device */
3442 phba->cfg_aer_support = 1;
3446 static DEVICE_ATTR(lpfc_aer_support, S_IRUGO | S_IWUSR,
3447 lpfc_aer_support_show, lpfc_aer_support_store);
3450 * lpfc_aer_cleanup_state - Clean up aer state to the aer enabled device
3451 * @dev: class device that is converted into a Scsi_host.
3452 * @attr: device attribute, not used.
3453 * @buf: containing flag 1 for aer cleanup state.
3454 * @count: unused variable.
3457 * If the @buf contains 1 and the device currently has the AER support
3458 * enabled, then invokes the kernel AER helper routine
3459 * pci_cleanup_aer_uncorrect_error_status to clean up the uncorrectable
3460 * error status register.
3465 * -EINVAL if the buf does not contain the 1 or the device is not currently
3466 * enabled with the AER support.
3469 lpfc_aer_cleanup_state(struct device *dev, struct device_attribute *attr,
3470 const char *buf, size_t count)
3472 struct Scsi_Host *shost = class_to_shost(dev);
3473 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
3474 struct lpfc_hba *phba = vport->phba;
3477 if (!isdigit(buf[0]))
3479 if (sscanf(buf, "%i", &val) != 1)
3484 if (phba->hba_flag & HBA_AER_ENABLED)
3485 rc = pci_cleanup_aer_uncorrect_error_status(phba->pcidev);
3493 static DEVICE_ATTR(lpfc_aer_state_cleanup, S_IWUSR, NULL,
3494 lpfc_aer_cleanup_state);
3497 * lpfc_sriov_nr_virtfn_store - Enable the adapter for sr-iov virtual functions
3499 * @dev: class device that is converted into a Scsi_host.
3500 * @attr: device attribute, not used.
3501 * @buf: containing the string the number of vfs to be enabled.
3502 * @count: unused variable.
3505 * When this api is called either through user sysfs, the driver shall
3506 * try to enable or disable SR-IOV virtual functions according to the
3509 * If zero virtual function has been enabled to the physical function,
3510 * the driver shall invoke the pci enable virtual function api trying
3511 * to enable the virtual functions. If the nr_vfn provided is greater
3512 * than the maximum supported, the maximum virtual function number will
3513 * be used for invoking the api; otherwise, the nr_vfn provided shall
3514 * be used for invoking the api. If the api call returned success, the
3515 * actual number of virtual functions enabled will be set to the driver
3516 * cfg_sriov_nr_virtfn; otherwise, -EINVAL shall be returned and driver
3517 * cfg_sriov_nr_virtfn remains zero.
3519 * If none-zero virtual functions have already been enabled to the
3520 * physical function, as reflected by the driver's cfg_sriov_nr_virtfn,
3521 * -EINVAL will be returned and the driver does nothing;
3523 * If the nr_vfn provided is zero and none-zero virtual functions have
3524 * been enabled, as indicated by the driver's cfg_sriov_nr_virtfn, the
3525 * disabling virtual function api shall be invoded to disable all the
3526 * virtual functions and driver's cfg_sriov_nr_virtfn shall be set to
3527 * zero. Otherwise, if zero virtual function has been enabled, do
3531 * length of the buf on success if val is in range the intended mode
3533 * -EINVAL if val out of range or intended mode is not supported.
3536 lpfc_sriov_nr_virtfn_store(struct device *dev, struct device_attribute *attr,
3537 const char *buf, size_t count)
3539 struct Scsi_Host *shost = class_to_shost(dev);
3540 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
3541 struct lpfc_hba *phba = vport->phba;
3542 struct pci_dev *pdev = phba->pcidev;
3543 int val = 0, rc = -EINVAL;
3545 /* Sanity check on user data */
3546 if (!isdigit(buf[0]))
3548 if (sscanf(buf, "%i", &val) != 1)
3553 /* Request disabling virtual functions */
3555 if (phba->cfg_sriov_nr_virtfn > 0) {
3556 pci_disable_sriov(pdev);
3557 phba->cfg_sriov_nr_virtfn = 0;
3562 /* Request enabling virtual functions */
3563 if (phba->cfg_sriov_nr_virtfn > 0) {
3564 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3565 "3018 There are %d virtual functions "
3566 "enabled on physical function.\n",
3567 phba->cfg_sriov_nr_virtfn);
3571 if (val <= LPFC_MAX_VFN_PER_PFN)
3572 phba->cfg_sriov_nr_virtfn = val;
3574 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3575 "3019 Enabling %d virtual functions is not "
3580 rc = lpfc_sli_probe_sriov_nr_virtfn(phba, phba->cfg_sriov_nr_virtfn);
3582 phba->cfg_sriov_nr_virtfn = 0;
3590 static int lpfc_sriov_nr_virtfn = LPFC_DEF_VFN_PER_PFN;
3591 module_param(lpfc_sriov_nr_virtfn, int, S_IRUGO|S_IWUSR);
3592 MODULE_PARM_DESC(lpfc_sriov_nr_virtfn, "Enable PCIe device SR-IOV virtual fn");
3593 lpfc_param_show(sriov_nr_virtfn)
3596 * lpfc_sriov_nr_virtfn_init - Set the initial sr-iov virtual function enable
3597 * @phba: lpfc_hba pointer.
3598 * @val: link speed value.
3601 * If val is in a valid range [0,255], then set the adapter's initial
3602 * cfg_sriov_nr_virtfn field. If it's greater than the maximum, the maximum
3603 * number shall be used instead. It will be up to the driver's probe_one
3604 * routine to determine whether the device's SR-IOV is supported or not.
3607 * zero if val saved.
3608 * -EINVAL val out of range
3611 lpfc_sriov_nr_virtfn_init(struct lpfc_hba *phba, int val)
3613 if (val >= 0 && val <= LPFC_MAX_VFN_PER_PFN) {
3614 phba->cfg_sriov_nr_virtfn = val;
3618 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3619 "3017 Enabling %d virtual functions is not "
3623 static DEVICE_ATTR(lpfc_sriov_nr_virtfn, S_IRUGO | S_IWUSR,
3624 lpfc_sriov_nr_virtfn_show, lpfc_sriov_nr_virtfn_store);
3627 * lpfc_request_firmware_store - Request for Linux generic firmware upgrade
3629 * @dev: class device that is converted into a Scsi_host.
3630 * @attr: device attribute, not used.
3631 * @buf: containing the string the number of vfs to be enabled.
3632 * @count: unused variable.
3637 * length of the buf on success if val is in range the intended mode
3639 * -EINVAL if val out of range or intended mode is not supported.
3642 lpfc_request_firmware_upgrade_store(struct device *dev,
3643 struct device_attribute *attr,
3644 const char *buf, size_t count)
3646 struct Scsi_Host *shost = class_to_shost(dev);
3647 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
3648 struct lpfc_hba *phba = vport->phba;
3649 int val = 0, rc = -EINVAL;
3651 /* Sanity check on user data */
3652 if (!isdigit(buf[0]))
3654 if (sscanf(buf, "%i", &val) != 1)
3659 rc = lpfc_sli4_request_firmware_update(phba, RUN_FW_UPGRADE);
3667 static int lpfc_req_fw_upgrade;
3668 module_param(lpfc_req_fw_upgrade, int, S_IRUGO|S_IWUSR);
3669 MODULE_PARM_DESC(lpfc_req_fw_upgrade, "Enable Linux generic firmware upgrade");
3670 lpfc_param_show(request_firmware_upgrade)
3673 * lpfc_request_firmware_upgrade_init - Enable initial linux generic fw upgrade
3674 * @phba: lpfc_hba pointer.
3678 * Set the initial Linux generic firmware upgrade enable or disable flag.
3681 * zero if val saved.
3682 * -EINVAL val out of range
3685 lpfc_request_firmware_upgrade_init(struct lpfc_hba *phba, int val)
3687 if (val >= 0 && val <= 1) {
3688 phba->cfg_request_firmware_upgrade = val;
3693 static DEVICE_ATTR(lpfc_req_fw_upgrade, S_IRUGO | S_IWUSR,
3694 lpfc_request_firmware_upgrade_show,
3695 lpfc_request_firmware_upgrade_store);
3698 * lpfc_fcp_imax_store
3700 * @dev: class device that is converted into a Scsi_host.
3701 * @attr: device attribute, not used.
3702 * @buf: string with the number of fast-path FCP interrupts per second.
3703 * @count: unused variable.
3706 * If val is in a valid range [636,651042], then set the adapter's
3707 * maximum number of fast-path FCP interrupts per second.
3710 * length of the buf on success if val is in range the intended mode
3712 * -EINVAL if val out of range or intended mode is not supported.
3715 lpfc_fcp_imax_store(struct device *dev, struct device_attribute *attr,
3716 const char *buf, size_t count)
3718 struct Scsi_Host *shost = class_to_shost(dev);
3719 struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
3720 struct lpfc_hba *phba = vport->phba;
3723 /* fcp_imax is only valid for SLI4 */
3724 if (phba->sli_rev != LPFC_SLI_REV4)
3727 /* Sanity check on user data */
3728 if (!isdigit(buf[0]))
3730 if (sscanf(buf, "%i", &val) != 1)
3734 * Value range for the HBA is [5000,5000000]
3735 * The value for each EQ depends on how many EQs are configured.
3737 if (val < LPFC_MIN_IMAX || val > LPFC_MAX_IMAX)
3740 phba->cfg_fcp_imax = (uint32_t)val;
3741 for (i = 0; i < phba->cfg_fcp_io_channel; i += LPFC_MAX_EQ_DELAY)
3742 lpfc_modify_fcp_eq_delay(phba, i);
3748 # lpfc_fcp_imax: The maximum number of fast-path FCP interrupts per second
3751 # Value range is [5,000 to 5,000,000]. Default value is 50,000.
3753 static int lpfc_fcp_imax = LPFC_DEF_IMAX;
3754 module_param(lpfc_fcp_imax, int, S_IRUGO|S_IWUSR);
3755 MODULE_PARM_DESC(lpfc_fcp_imax,
3756 "Set the maximum number of FCP interrupts per second per HBA");
3757 lpfc_param_show(fcp_imax)
3760 * lpfc_fcp_imax_init - Set the initial sr-iov virtual function enable
3761 * @phba: lpfc_hba pointer.
3762 * @val: link speed value.
3765 * If val is in a valid range [636,651042], then initialize the adapter's
3766 * maximum number of fast-path FCP interrupts per second.
3769 * zero if val saved.
3770 * -EINVAL val out of range
3773 lpfc_fcp_imax_init(struct lpfc_hba *phba, int val)
3775 if (phba->sli_rev != LPFC_SLI_REV4) {
3776 phba->cfg_fcp_imax = 0;
3780 if (val >= LPFC_MIN_IMAX && val <= LPFC_MAX_IMAX) {
3781 phba->cfg_fcp_imax = val;
3785 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
3786 "3016 fcp_imax: %d out of range, using default\n", val);
3787 phba->cfg_fcp_imax = LPFC_DEF_IMAX;
3792 static DEVICE_ATTR(lpfc_fcp_imax, S_IRUGO | S_IWUSR,
3793 lpfc_fcp_imax_show, lpfc_fcp_imax_store);
3796 # lpfc_fcp_class: Determines FC class to use for the FCP protocol.
3797 # Value range is [2,3]. Default value is 3.
3799 LPFC_VPORT_ATTR_R(fcp_class, 3, 2, 3,
3800 "Select Fibre Channel class of service for FCP sequences");
3803 # lpfc_use_adisc: Use ADISC for FCP rediscovery instead of PLOGI. Value range
3804 # is [0,1]. Default value is 0.
3806 LPFC_VPORT_ATTR_RW(use_adisc, 0, 0, 1,
3807 "Use ADISC on rediscovery to authenticate FCP devices");
3810 # lpfc_max_scsicmpl_time: Use scsi command completion time to control I/O queue
3811 # depth. Default value is 0. When the value of this parameter is zero the
3812 # SCSI command completion time is not used for controlling I/O queue depth. When
3813 # the parameter is set to a non-zero value, the I/O queue depth is controlled
3814 # to limit the I/O completion time to the parameter value.
3815 # The value is set in milliseconds.
3817 static int lpfc_max_scsicmpl_time;
3818 module_param(lpfc_max_scsicmpl_time, int, S_IRUGO);
3819 MODULE_PARM_DESC(lpfc_max_scsicmpl_time,
3820 "Use command completion time to control queue depth");
3821 lpfc_vport_param_show(max_scsicmpl_time);
3822 lpfc_vport_param_init(max_scsicmpl_time, 0, 0, 60000);
3824 lpfc_max_scsicmpl_time_set(struct lpfc_vport *vport, int val)
3826 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
3827 struct lpfc_nodelist *ndlp, *next_ndlp;
3829 if (val == vport->cfg_max_scsicmpl_time)
3831 if ((val < 0) || (val > 60000))
3833 vport->cfg_max_scsicmpl_time = val;
3835 spin_lock_irq(shost->host_lock);
3836 list_for_each_entry_safe(ndlp, next_ndlp, &vport->fc_nodes, nlp_listp) {
3837 if (!NLP_CHK_NODE_ACT(ndlp))
3839 if (ndlp->nlp_state == NLP_STE_UNUSED_NODE)
3841 ndlp->cmd_qdepth = vport->cfg_tgt_queue_depth;
3843 spin_unlock_irq(shost->host_lock);
3846 lpfc_vport_param_store(max_scsicmpl_time);
3847 static DEVICE_ATTR(lpfc_max_scsicmpl_time, S_IRUGO | S_IWUSR,
3848 lpfc_max_scsicmpl_time_show,
3849 lpfc_max_scsicmpl_time_store);
3852 # lpfc_ack0: Use ACK0, instead of ACK1 for class 2 acknowledgement. Value
3853 # range is [0,1]. Default value is 0.
3855 LPFC_ATTR_R(ack0, 0, 0, 1, "Enable ACK0 support");
3858 # lpfc_fcp_io_sched: Determine scheduling algrithmn for issuing FCP cmds
3859 # range is [0,1]. Default value is 0.
3860 # For [0], FCP commands are issued to Work Queues ina round robin fashion.
3861 # For [1], FCP commands are issued to a Work Queue associated with the
3864 LPFC_ATTR_RW(fcp_io_sched, 0, 0, 1, "Determine scheduling algrithmn for "
3865 "issuing commands [0] - Round Robin, [1] - Current CPU");
3868 # lpfc_fcp2_no_tgt_reset: Determine bus reset behavior
3869 # range is [0,1]. Default value is 0.
3870 # For [0], bus reset issues target reset to ALL devices
3871 # For [1], bus reset issues target reset to non-FCP2 devices
3873 LPFC_ATTR_RW(fcp2_no_tgt_reset, 0, 0, 1, "Determine bus reset behavior for "
3874 "FCP2 devices [0] - issue tgt reset, [1] - no tgt reset");
3878 # lpfc_cr_delay & lpfc_cr_count: Default values for I/O colaesing
3879 # cr_delay (msec) or cr_count outstanding commands. cr_delay can take
3880 # value [0,63]. cr_count can take value [1,255]. Default value of cr_delay
3881 # is 0. Default value of cr_count is 1. The cr_count feature is disabled if
3882 # cr_delay is set to 0.
3884 LPFC_ATTR_RW(cr_delay, 0, 0, 63, "A count of milliseconds after which an "
3885 "interrupt response is generated");
3887 LPFC_ATTR_RW(cr_count, 1, 1, 255, "A count of I/O completions after which an "
3888 "interrupt response is generated");
3891 # lpfc_multi_ring_support: Determines how many rings to spread available
3892 # cmd/rsp IOCB entries across.
3893 # Value range is [1,2]. Default value is 1.
3895 LPFC_ATTR_R(multi_ring_support, 1, 1, 2, "Determines number of primary "
3896 "SLI rings to spread IOCB entries across");
3899 # lpfc_multi_ring_rctl: If lpfc_multi_ring_support is enabled, this
3900 # identifies what rctl value to configure the additional ring for.
3901 # Value range is [1,0xff]. Default value is 4 (Unsolicated Data).
3903 LPFC_ATTR_R(multi_ring_rctl, FC_RCTL_DD_UNSOL_DATA, 1,
3904 255, "Identifies RCTL for additional ring configuration");
3907 # lpfc_multi_ring_type: If lpfc_multi_ring_support is enabled, this
3908 # identifies what type value to configure the additional ring for.
3909 # Value range is [1,0xff]. Default value is 5 (LLC/SNAP).
3911 LPFC_ATTR_R(multi_ring_type, FC_TYPE_IP, 1,
3912 255, "Identifies TYPE for additional ring configuration");
3915 # lpfc_fdmi_on: controls FDMI support.
3916 # 0 = no FDMI support
3917 # 1 = support FDMI without attribute of hostname
3918 # 2 = support FDMI with attribute of hostname
3919 # Value range [0,2]. Default value is 0.
3921 LPFC_VPORT_ATTR_RW(fdmi_on, 0, 0, 2, "Enable FDMI support");
3924 # Specifies the maximum number of ELS cmds we can have outstanding (for
3925 # discovery). Value range is [1,64]. Default value = 32.
3927 LPFC_VPORT_ATTR(discovery_threads, 32, 1, 64, "Maximum number of ELS commands "
3928 "during discovery");
3931 # lpfc_max_luns: maximum allowed LUN.
3932 # Value range is [0,65535]. Default value is 255.
3933 # NOTE: The SCSI layer might probe all allowed LUN on some old targets.
3935 LPFC_VPORT_ATTR_R(max_luns, 255, 0, 65535, "Maximum allowed LUN");
3938 # lpfc_poll_tmo: .Milliseconds driver will wait between polling FCP ring.
3939 # Value range is [1,255], default value is 10.
3941 LPFC_ATTR_RW(poll_tmo, 10, 1, 255,
3942 "Milliseconds driver will wait between polling FCP ring");
3945 # lpfc_use_msi: Use MSI (Message Signaled Interrupts) in systems that
3946 # support this feature
3949 # 2 = MSI-X enabled (default)
3950 # Value range is [0,2]. Default value is 2.
3952 LPFC_ATTR_R(use_msi, 2, 0, 2, "Use Message Signaled Interrupts (1) or "
3953 "MSI-X (2), if possible");
3956 # lpfc_fcp_wq_count: Set the number of fast-path FCP work queues
3957 # This parameter is ignored and will eventually be depricated
3959 # Value range is [1,7]. Default value is 4.
3961 LPFC_ATTR_R(fcp_wq_count, LPFC_FCP_IO_CHAN_DEF, LPFC_FCP_IO_CHAN_MIN,
3962 LPFC_FCP_IO_CHAN_MAX,
3963 "Set the number of fast-path FCP work queues, if possible");
3966 # lpfc_fcp_eq_count: Set the number of FCP EQ/CQ/WQ IO channels
3968 # Value range is [1,7]. Default value is 4.
3970 LPFC_ATTR_R(fcp_eq_count, LPFC_FCP_IO_CHAN_DEF, LPFC_FCP_IO_CHAN_MIN,
3971 LPFC_FCP_IO_CHAN_MAX,
3972 "Set the number of fast-path FCP event queues, if possible");
3975 # lpfc_fcp_io_channel: Set the number of FCP EQ/CQ/WQ IO channels
3977 # Value range is [1,7]. Default value is 4.
3979 LPFC_ATTR_R(fcp_io_channel, LPFC_FCP_IO_CHAN_DEF, LPFC_FCP_IO_CHAN_MIN,
3980 LPFC_FCP_IO_CHAN_MAX,
3981 "Set the number of FCP I/O channels");
3984 # lpfc_enable_hba_reset: Allow or prevent HBA resets to the hardware.
3985 # 0 = HBA resets disabled
3986 # 1 = HBA resets enabled (default)
3987 # Value range is [0,1]. Default value is 1.
3989 LPFC_ATTR_R(enable_hba_reset, 1, 0, 1, "Enable HBA resets from the driver.");
3992 # lpfc_enable_hba_heartbeat: Disable HBA heartbeat timer..
3993 # 0 = HBA Heartbeat disabled
3994 # 1 = HBA Heartbeat enabled (default)
3995 # Value range is [0,1]. Default value is 1.
3997 LPFC_ATTR_R(enable_hba_heartbeat, 0, 0, 1, "Enable HBA Heartbeat.");
4000 # lpfc_enable_bg: Enable BlockGuard (Emulex's Implementation of T10-DIF)
4001 # 0 = BlockGuard disabled (default)
4002 # 1 = BlockGuard enabled
4003 # Value range is [0,1]. Default value is 0.
4005 LPFC_ATTR_R(enable_bg, 0, 0, 1, "Enable BlockGuard Support");
4008 # lpfc_fcp_look_ahead: Look ahead for completions in FCP start routine
4009 # 0 = disabled (default)
4011 # Value range is [0,1]. Default value is 0.
4013 unsigned int lpfc_fcp_look_ahead = LPFC_LOOK_AHEAD_OFF;
4015 module_param(lpfc_fcp_look_ahead, uint, S_IRUGO);
4016 MODULE_PARM_DESC(lpfc_fcp_look_ahead, "Look ahead for completions");
4020 # - Bit mask of host protection capabilities used to register with the
4022 # - Only meaningful if BG is turned on (lpfc_enable_bg=1).
4023 # - Allows you to ultimately specify which profiles to use
4024 # - Default will result in registering capabilities for all profiles.
4025 # - SHOST_DIF_TYPE1_PROTECTION 1
4026 # HBA supports T10 DIF Type 1: HBA to Target Type 1 Protection
4027 # - SHOST_DIX_TYPE0_PROTECTION 8
4028 # HBA supports DIX Type 0: Host to HBA protection only
4029 # - SHOST_DIX_TYPE1_PROTECTION 16
4030 # HBA supports DIX Type 1: Host to HBA Type 1 protection
4033 unsigned int lpfc_prot_mask = SHOST_DIF_TYPE1_PROTECTION |
4034 SHOST_DIX_TYPE0_PROTECTION |
4035 SHOST_DIX_TYPE1_PROTECTION;
4037 module_param(lpfc_prot_mask, uint, S_IRUGO);
4038 MODULE_PARM_DESC(lpfc_prot_mask, "host protection mask");
4041 # lpfc_prot_guard: i
4042 # - Bit mask of protection guard types to register with the SCSI mid-layer
4043 # - Guard types are currently either 1) T10-DIF CRC 2) IP checksum
4044 # - Allows you to ultimately specify which profiles to use
4045 # - Default will result in registering capabilities for all guard types
4048 unsigned char lpfc_prot_guard = SHOST_DIX_GUARD_IP;
4049 module_param(lpfc_prot_guard, byte, S_IRUGO);
4050 MODULE_PARM_DESC(lpfc_prot_guard, "host protection guard type");
4053 * Delay initial NPort discovery when Clean Address bit is cleared in
4054 * FLOGI/FDISC accept and FCID/Fabric name/Fabric portname is changed.
4055 * This parameter can have value 0 or 1.
4056 * When this parameter is set to 0, no delay is added to the initial
4058 * When this parameter is set to non-zero value, initial Nport discovery is
4059 * delayed by ra_tov seconds when Clean Address bit is cleared in FLOGI/FDISC
4060 * accept and FCID/Fabric name/Fabric portname is changed.
4061 * Driver always delay Nport discovery for subsequent FLOGI/FDISC completion
4062 * when Clean Address bit is cleared in FLOGI/FDISC
4063 * accept and FCID/Fabric name/Fabric portname is changed.
4064 * Default value is 0.
4066 int lpfc_delay_discovery;
4067 module_param(lpfc_delay_discovery, int, S_IRUGO);
4068 MODULE_PARM_DESC(lpfc_delay_discovery,
4069 "Delay NPort discovery when Clean Address bit is cleared. "
4070 "Allowed values: 0,1.");
4073 * lpfc_sg_seg_cnt - Initial Maximum DMA Segment Count
4074 * This value can be set to values between 64 and 256. The default value is
4075 * 64, but may be increased to allow for larger Max I/O sizes. The scsi layer
4076 * will be allowed to request I/Os of sizes up to (MAX_SEG_COUNT * SEG_SIZE).
4078 LPFC_ATTR_R(sg_seg_cnt, LPFC_DEFAULT_SG_SEG_CNT, LPFC_DEFAULT_SG_SEG_CNT,
4079 LPFC_MAX_SG_SEG_CNT, "Max Scatter Gather Segment Count");
4081 LPFC_ATTR_R(prot_sg_seg_cnt, LPFC_DEFAULT_PROT_SG_SEG_CNT,
4082 LPFC_DEFAULT_PROT_SG_SEG_CNT, LPFC_MAX_PROT_SG_SEG_CNT,
4083 "Max Protection Scatter Gather Segment Count");
4085 struct device_attribute *lpfc_hba_attrs[] = {
4087 &dev_attr_bg_guard_err,
4088 &dev_attr_bg_apptag_err,
4089 &dev_attr_bg_reftag_err,
4091 &dev_attr_serialnum,
4092 &dev_attr_modeldesc,
4093 &dev_attr_modelname,
4094 &dev_attr_programtype,
4098 &dev_attr_option_rom_version,
4099 &dev_attr_link_state,
4100 &dev_attr_num_discovered_ports,
4101 &dev_attr_menlo_mgmt_mode,
4102 &dev_attr_lpfc_drvr_version,
4103 &dev_attr_lpfc_enable_fip,
4104 &dev_attr_lpfc_temp_sensor,
4105 &dev_attr_lpfc_log_verbose,
4106 &dev_attr_lpfc_lun_queue_depth,
4107 &dev_attr_lpfc_tgt_queue_depth,
4108 &dev_attr_lpfc_hba_queue_depth,
4109 &dev_attr_lpfc_peer_port_login,
4110 &dev_attr_lpfc_nodev_tmo,
4111 &dev_attr_lpfc_devloss_tmo,
4112 &dev_attr_lpfc_fcp_class,
4113 &dev_attr_lpfc_use_adisc,
4114 &dev_attr_lpfc_ack0,
4115 &dev_attr_lpfc_topology,
4116 &dev_attr_lpfc_scan_down,
4117 &dev_attr_lpfc_link_speed,
4118 &dev_attr_lpfc_fcp_io_sched,
4119 &dev_attr_lpfc_fcp2_no_tgt_reset,
4120 &dev_attr_lpfc_cr_delay,
4121 &dev_attr_lpfc_cr_count,
4122 &dev_attr_lpfc_multi_ring_support,
4123 &dev_attr_lpfc_multi_ring_rctl,
4124 &dev_attr_lpfc_multi_ring_type,
4125 &dev_attr_lpfc_fdmi_on,
4126 &dev_attr_lpfc_max_luns,
4127 &dev_attr_lpfc_enable_npiv,
4128 &dev_attr_lpfc_fcf_failover_policy,
4129 &dev_attr_lpfc_enable_rrq,
4130 &dev_attr_nport_evt_cnt,
4131 &dev_attr_board_mode,
4138 &dev_attr_npiv_info,
4139 &dev_attr_issue_reset,
4140 &dev_attr_lpfc_poll,
4141 &dev_attr_lpfc_poll_tmo,
4142 &dev_attr_lpfc_use_msi,
4143 &dev_attr_lpfc_fcp_imax,
4144 &dev_attr_lpfc_fcp_wq_count,
4145 &dev_attr_lpfc_fcp_eq_count,
4146 &dev_attr_lpfc_fcp_io_channel,
4147 &dev_attr_lpfc_enable_bg,
4148 &dev_attr_lpfc_soft_wwnn,
4149 &dev_attr_lpfc_soft_wwpn,
4150 &dev_attr_lpfc_soft_wwn_enable,
4151 &dev_attr_lpfc_enable_hba_reset,
4152 &dev_attr_lpfc_enable_hba_heartbeat,
4153 &dev_attr_lpfc_sg_seg_cnt,
4154 &dev_attr_lpfc_max_scsicmpl_time,
4155 &dev_attr_lpfc_stat_data_ctrl,
4156 &dev_attr_lpfc_prot_sg_seg_cnt,
4157 &dev_attr_lpfc_aer_support,
4158 &dev_attr_lpfc_aer_state_cleanup,
4159 &dev_attr_lpfc_sriov_nr_virtfn,
4160 &dev_attr_lpfc_req_fw_upgrade,
4161 &dev_attr_lpfc_suppress_link_up,
4162 &dev_attr_lpfc_iocb_cnt,
4165 &dev_attr_txcmplq_hw,
4166 &dev_attr_lpfc_fips_level,
4167 &dev_attr_lpfc_fips_rev,
4169 &dev_attr_lpfc_sriov_hw_max_virtfn,
4174 struct device_attribute *lpfc_vport_attrs[] = {
4176 &dev_attr_link_state,
4177 &dev_attr_num_discovered_ports,
4178 &dev_attr_lpfc_drvr_version,
4179 &dev_attr_lpfc_log_verbose,
4180 &dev_attr_lpfc_lun_queue_depth,
4181 &dev_attr_lpfc_tgt_queue_depth,
4182 &dev_attr_lpfc_nodev_tmo,
4183 &dev_attr_lpfc_devloss_tmo,
4184 &dev_attr_lpfc_hba_queue_depth,
4185 &dev_attr_lpfc_peer_port_login,
4186 &dev_attr_lpfc_restrict_login,
4187 &dev_attr_lpfc_fcp_class,
4188 &dev_attr_lpfc_use_adisc,
4189 &dev_attr_lpfc_fdmi_on,
4190 &dev_attr_lpfc_max_luns,
4191 &dev_attr_nport_evt_cnt,
4192 &dev_attr_npiv_info,
4193 &dev_attr_lpfc_enable_da_id,
4194 &dev_attr_lpfc_max_scsicmpl_time,
4195 &dev_attr_lpfc_stat_data_ctrl,
4196 &dev_attr_lpfc_static_vport,
4197 &dev_attr_lpfc_fips_level,
4198 &dev_attr_lpfc_fips_rev,
4203 * sysfs_ctlreg_write - Write method for writing to ctlreg
4204 * @filp: open sysfs file
4205 * @kobj: kernel kobject that contains the kernel class device.
4206 * @bin_attr: kernel attributes passed to us.
4207 * @buf: contains the data to be written to the adapter IOREG space.
4208 * @off: offset into buffer to beginning of data.
4209 * @count: bytes to transfer.
4212 * Accessed via /sys/class/scsi_host/hostxxx/ctlreg.
4213 * Uses the adapter io control registers to send buf contents to the adapter.
4216 * -ERANGE off and count combo out of range
4217 * -EINVAL off, count or buff address invalid
4218 * -EPERM adapter is offline
4219 * value of count, buf contents written
4222 sysfs_ctlreg_write(struct file *filp, struct kobject *kobj,
4223 struct bin_attribute *bin_attr,
4224 char *buf, loff_t off, size_t count)
4227 struct device *dev = container_of(kobj, struct device, kobj);
4228 struct Scsi_Host *shost = class_to_shost(dev);
4229 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4230 struct lpfc_hba *phba = vport->phba;
4232 if (phba->sli_rev >= LPFC_SLI_REV4)
4235 if ((off + count) > FF_REG_AREA_SIZE)
4238 if (count <= LPFC_REG_WRITE_KEY_SIZE)
4241 if (off % 4 || count % 4 || (unsigned long)buf % 4)
4244 /* This is to protect HBA registers from accidental writes. */
4245 if (memcmp(buf, LPFC_REG_WRITE_KEY, LPFC_REG_WRITE_KEY_SIZE))
4248 if (!(vport->fc_flag & FC_OFFLINE_MODE))
4251 spin_lock_irq(&phba->hbalock);
4252 for (buf_off = 0; buf_off < count - LPFC_REG_WRITE_KEY_SIZE;
4253 buf_off += sizeof(uint32_t))
4254 writel(*((uint32_t *)(buf + buf_off + LPFC_REG_WRITE_KEY_SIZE)),
4255 phba->ctrl_regs_memmap_p + off + buf_off);
4257 spin_unlock_irq(&phba->hbalock);
4263 * sysfs_ctlreg_read - Read method for reading from ctlreg
4264 * @filp: open sysfs file
4265 * @kobj: kernel kobject that contains the kernel class device.
4266 * @bin_attr: kernel attributes passed to us.
4267 * @buf: if successful contains the data from the adapter IOREG space.
4268 * @off: offset into buffer to beginning of data.
4269 * @count: bytes to transfer.
4272 * Accessed via /sys/class/scsi_host/hostxxx/ctlreg.
4273 * Uses the adapter io control registers to read data into buf.
4276 * -ERANGE off and count combo out of range
4277 * -EINVAL off, count or buff address invalid
4278 * value of count, buf contents read
4281 sysfs_ctlreg_read(struct file *filp, struct kobject *kobj,
4282 struct bin_attribute *bin_attr,
4283 char *buf, loff_t off, size_t count)
4287 struct device *dev = container_of(kobj, struct device, kobj);
4288 struct Scsi_Host *shost = class_to_shost(dev);
4289 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4290 struct lpfc_hba *phba = vport->phba;
4292 if (phba->sli_rev >= LPFC_SLI_REV4)
4295 if (off > FF_REG_AREA_SIZE)
4298 if ((off + count) > FF_REG_AREA_SIZE)
4299 count = FF_REG_AREA_SIZE - off;
4301 if (count == 0) return 0;
4303 if (off % 4 || count % 4 || (unsigned long)buf % 4)
4306 spin_lock_irq(&phba->hbalock);
4308 for (buf_off = 0; buf_off < count; buf_off += sizeof(uint32_t)) {
4309 tmp_ptr = (uint32_t *)(buf + buf_off);
4310 *tmp_ptr = readl(phba->ctrl_regs_memmap_p + off + buf_off);
4313 spin_unlock_irq(&phba->hbalock);
4318 static struct bin_attribute sysfs_ctlreg_attr = {
4321 .mode = S_IRUSR | S_IWUSR,
4324 .read = sysfs_ctlreg_read,
4325 .write = sysfs_ctlreg_write,
4329 * sysfs_mbox_write - Write method for writing information via mbox
4330 * @filp: open sysfs file
4331 * @kobj: kernel kobject that contains the kernel class device.
4332 * @bin_attr: kernel attributes passed to us.
4333 * @buf: contains the data to be written to sysfs mbox.
4334 * @off: offset into buffer to beginning of data.
4335 * @count: bytes to transfer.
4338 * Deprecated function. All mailbox access from user space is performed via the
4342 * -EPERM operation not permitted
4345 sysfs_mbox_write(struct file *filp, struct kobject *kobj,
4346 struct bin_attribute *bin_attr,
4347 char *buf, loff_t off, size_t count)
4353 * sysfs_mbox_read - Read method for reading information via mbox
4354 * @filp: open sysfs file
4355 * @kobj: kernel kobject that contains the kernel class device.
4356 * @bin_attr: kernel attributes passed to us.
4357 * @buf: contains the data to be read from sysfs mbox.
4358 * @off: offset into buffer to beginning of data.
4359 * @count: bytes to transfer.
4362 * Deprecated function. All mailbox access from user space is performed via the
4366 * -EPERM operation not permitted
4369 sysfs_mbox_read(struct file *filp, struct kobject *kobj,
4370 struct bin_attribute *bin_attr,
4371 char *buf, loff_t off, size_t count)
4376 static struct bin_attribute sysfs_mbox_attr = {
4379 .mode = S_IRUSR | S_IWUSR,
4381 .size = MAILBOX_SYSFS_MAX,
4382 .read = sysfs_mbox_read,
4383 .write = sysfs_mbox_write,
4387 * lpfc_alloc_sysfs_attr - Creates the ctlreg and mbox entries
4388 * @vport: address of lpfc vport structure.
4392 * error return code from sysfs_create_bin_file()
4395 lpfc_alloc_sysfs_attr(struct lpfc_vport *vport)
4397 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
4400 error = sysfs_create_bin_file(&shost->shost_dev.kobj,
4401 &sysfs_drvr_stat_data_attr);
4403 /* Virtual ports do not need ctrl_reg and mbox */
4404 if (error || vport->port_type == LPFC_NPIV_PORT)
4407 error = sysfs_create_bin_file(&shost->shost_dev.kobj,
4408 &sysfs_ctlreg_attr);
4410 goto out_remove_stat_attr;
4412 error = sysfs_create_bin_file(&shost->shost_dev.kobj,
4415 goto out_remove_ctlreg_attr;
4418 out_remove_ctlreg_attr:
4419 sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr);
4420 out_remove_stat_attr:
4421 sysfs_remove_bin_file(&shost->shost_dev.kobj,
4422 &sysfs_drvr_stat_data_attr);
4428 * lpfc_free_sysfs_attr - Removes the ctlreg and mbox entries
4429 * @vport: address of lpfc vport structure.
4432 lpfc_free_sysfs_attr(struct lpfc_vport *vport)
4434 struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
4435 sysfs_remove_bin_file(&shost->shost_dev.kobj,
4436 &sysfs_drvr_stat_data_attr);
4437 /* Virtual ports do not need ctrl_reg and mbox */
4438 if (vport->port_type == LPFC_NPIV_PORT)
4440 sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_mbox_attr);
4441 sysfs_remove_bin_file(&shost->shost_dev.kobj, &sysfs_ctlreg_attr);
4446 * Dynamic FC Host Attributes Support
4450 * lpfc_get_host_port_id - Copy the vport DID into the scsi host port id
4451 * @shost: kernel scsi host pointer.
4454 lpfc_get_host_port_id(struct Scsi_Host *shost)
4456 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4458 /* note: fc_myDID already in cpu endianness */
4459 fc_host_port_id(shost) = vport->fc_myDID;
4463 * lpfc_get_host_port_type - Set the value of the scsi host port type
4464 * @shost: kernel scsi host pointer.
4467 lpfc_get_host_port_type(struct Scsi_Host *shost)
4469 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4470 struct lpfc_hba *phba = vport->phba;
4472 spin_lock_irq(shost->host_lock);
4474 if (vport->port_type == LPFC_NPIV_PORT) {
4475 fc_host_port_type(shost) = FC_PORTTYPE_NPIV;
4476 } else if (lpfc_is_link_up(phba)) {
4477 if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
4478 if (vport->fc_flag & FC_PUBLIC_LOOP)
4479 fc_host_port_type(shost) = FC_PORTTYPE_NLPORT;
4481 fc_host_port_type(shost) = FC_PORTTYPE_LPORT;
4483 if (vport->fc_flag & FC_FABRIC)
4484 fc_host_port_type(shost) = FC_PORTTYPE_NPORT;
4486 fc_host_port_type(shost) = FC_PORTTYPE_PTP;
4489 fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN;
4491 spin_unlock_irq(shost->host_lock);
4495 * lpfc_get_host_port_state - Set the value of the scsi host port state
4496 * @shost: kernel scsi host pointer.
4499 lpfc_get_host_port_state(struct Scsi_Host *shost)
4501 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4502 struct lpfc_hba *phba = vport->phba;
4504 spin_lock_irq(shost->host_lock);
4506 if (vport->fc_flag & FC_OFFLINE_MODE)
4507 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
4509 switch (phba->link_state) {
4510 case LPFC_LINK_UNKNOWN:
4511 case LPFC_LINK_DOWN:
4512 fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
4516 case LPFC_HBA_READY:
4517 /* Links up, reports port state accordingly */
4518 if (vport->port_state < LPFC_VPORT_READY)
4519 fc_host_port_state(shost) =
4520 FC_PORTSTATE_BYPASSED;
4522 fc_host_port_state(shost) =
4523 FC_PORTSTATE_ONLINE;
4525 case LPFC_HBA_ERROR:
4526 fc_host_port_state(shost) = FC_PORTSTATE_ERROR;
4529 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN;
4534 spin_unlock_irq(shost->host_lock);
4538 * lpfc_get_host_speed - Set the value of the scsi host speed
4539 * @shost: kernel scsi host pointer.
4542 lpfc_get_host_speed(struct Scsi_Host *shost)
4544 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4545 struct lpfc_hba *phba = vport->phba;
4547 spin_lock_irq(shost->host_lock);
4549 if (lpfc_is_link_up(phba)) {
4550 switch(phba->fc_linkspeed) {
4551 case LPFC_LINK_SPEED_1GHZ:
4552 fc_host_speed(shost) = FC_PORTSPEED_1GBIT;
4554 case LPFC_LINK_SPEED_2GHZ:
4555 fc_host_speed(shost) = FC_PORTSPEED_2GBIT;
4557 case LPFC_LINK_SPEED_4GHZ:
4558 fc_host_speed(shost) = FC_PORTSPEED_4GBIT;
4560 case LPFC_LINK_SPEED_8GHZ:
4561 fc_host_speed(shost) = FC_PORTSPEED_8GBIT;
4563 case LPFC_LINK_SPEED_10GHZ:
4564 fc_host_speed(shost) = FC_PORTSPEED_10GBIT;
4566 case LPFC_LINK_SPEED_16GHZ:
4567 fc_host_speed(shost) = FC_PORTSPEED_16GBIT;
4570 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
4574 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
4576 spin_unlock_irq(shost->host_lock);
4580 * lpfc_get_host_fabric_name - Set the value of the scsi host fabric name
4581 * @shost: kernel scsi host pointer.
4584 lpfc_get_host_fabric_name (struct Scsi_Host *shost)
4586 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4587 struct lpfc_hba *phba = vport->phba;
4590 spin_lock_irq(shost->host_lock);
4592 if ((vport->port_state > LPFC_FLOGI) &&
4593 ((vport->fc_flag & FC_FABRIC) ||
4594 ((phba->fc_topology == LPFC_TOPOLOGY_LOOP) &&
4595 (vport->fc_flag & FC_PUBLIC_LOOP))))
4596 node_name = wwn_to_u64(phba->fc_fabparam.nodeName.u.wwn);
4598 /* fabric is local port if there is no F/FL_Port */
4601 spin_unlock_irq(shost->host_lock);
4603 fc_host_fabric_name(shost) = node_name;
4607 * lpfc_get_stats - Return statistical information about the adapter
4608 * @shost: kernel scsi host pointer.
4611 * NULL on error for link down, no mbox pool, sli2 active,
4612 * management not allowed, memory allocation error, or mbox error.
4616 * address of the adapter host statistics
4618 static struct fc_host_statistics *
4619 lpfc_get_stats(struct Scsi_Host *shost)
4621 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4622 struct lpfc_hba *phba = vport->phba;
4623 struct lpfc_sli *psli = &phba->sli;
4624 struct fc_host_statistics *hs = &phba->link_stats;
4625 struct lpfc_lnk_stat * lso = &psli->lnk_stat_offsets;
4626 LPFC_MBOXQ_t *pmboxq;
4628 unsigned long seconds;
4632 * prevent udev from issuing mailbox commands until the port is
4635 if (phba->link_state < LPFC_LINK_DOWN ||
4636 !phba->mbox_mem_pool ||
4637 (phba->sli.sli_flag & LPFC_SLI_ACTIVE) == 0)
4640 if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
4643 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
4646 memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
4648 pmb = &pmboxq->u.mb;
4649 pmb->mbxCommand = MBX_READ_STATUS;
4650 pmb->mbxOwner = OWN_HOST;
4651 pmboxq->context1 = NULL;
4652 pmboxq->vport = vport;
4654 if (vport->fc_flag & FC_OFFLINE_MODE)
4655 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
4657 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
4659 if (rc != MBX_SUCCESS) {
4660 if (rc != MBX_TIMEOUT)
4661 mempool_free(pmboxq, phba->mbox_mem_pool);
4665 memset(hs, 0, sizeof (struct fc_host_statistics));
4667 hs->tx_frames = pmb->un.varRdStatus.xmitFrameCnt;
4669 * The MBX_READ_STATUS returns tx_k_bytes which has to
4670 * converted to words
4672 hs->tx_words = (uint64_t)
4673 ((uint64_t)pmb->un.varRdStatus.xmitByteCnt
4675 hs->rx_frames = pmb->un.varRdStatus.rcvFrameCnt;
4676 hs->rx_words = (uint64_t)
4677 ((uint64_t)pmb->un.varRdStatus.rcvByteCnt
4680 memset(pmboxq, 0, sizeof (LPFC_MBOXQ_t));
4681 pmb->mbxCommand = MBX_READ_LNK_STAT;
4682 pmb->mbxOwner = OWN_HOST;
4683 pmboxq->context1 = NULL;
4684 pmboxq->vport = vport;
4686 if (vport->fc_flag & FC_OFFLINE_MODE)
4687 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
4689 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
4691 if (rc != MBX_SUCCESS) {
4692 if (rc != MBX_TIMEOUT)
4693 mempool_free(pmboxq, phba->mbox_mem_pool);
4697 hs->link_failure_count = pmb->un.varRdLnk.linkFailureCnt;
4698 hs->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt;
4699 hs->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt;
4700 hs->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt;
4701 hs->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord;
4702 hs->invalid_crc_count = pmb->un.varRdLnk.crcCnt;
4703 hs->error_frames = pmb->un.varRdLnk.crcCnt;
4705 hs->link_failure_count -= lso->link_failure_count;
4706 hs->loss_of_sync_count -= lso->loss_of_sync_count;
4707 hs->loss_of_signal_count -= lso->loss_of_signal_count;
4708 hs->prim_seq_protocol_err_count -= lso->prim_seq_protocol_err_count;
4709 hs->invalid_tx_word_count -= lso->invalid_tx_word_count;
4710 hs->invalid_crc_count -= lso->invalid_crc_count;
4711 hs->error_frames -= lso->error_frames;
4713 if (phba->hba_flag & HBA_FCOE_MODE) {
4715 hs->nos_count = (phba->link_events >> 1);
4716 hs->nos_count -= lso->link_events;
4717 } else if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
4718 hs->lip_count = (phba->fc_eventTag >> 1);
4719 hs->lip_count -= lso->link_events;
4723 hs->nos_count = (phba->fc_eventTag >> 1);
4724 hs->nos_count -= lso->link_events;
4727 hs->dumped_frames = -1;
4729 seconds = get_seconds();
4730 if (seconds < psli->stats_start)
4731 hs->seconds_since_last_reset = seconds +
4732 ((unsigned long)-1 - psli->stats_start);
4734 hs->seconds_since_last_reset = seconds - psli->stats_start;
4736 mempool_free(pmboxq, phba->mbox_mem_pool);
4742 * lpfc_reset_stats - Copy the adapter link stats information
4743 * @shost: kernel scsi host pointer.
4746 lpfc_reset_stats(struct Scsi_Host *shost)
4748 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4749 struct lpfc_hba *phba = vport->phba;
4750 struct lpfc_sli *psli = &phba->sli;
4751 struct lpfc_lnk_stat *lso = &psli->lnk_stat_offsets;
4752 LPFC_MBOXQ_t *pmboxq;
4756 if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO)
4759 pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
4762 memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
4764 pmb = &pmboxq->u.mb;
4765 pmb->mbxCommand = MBX_READ_STATUS;
4766 pmb->mbxOwner = OWN_HOST;
4767 pmb->un.varWords[0] = 0x1; /* reset request */
4768 pmboxq->context1 = NULL;
4769 pmboxq->vport = vport;
4771 if ((vport->fc_flag & FC_OFFLINE_MODE) ||
4772 (!(psli->sli_flag & LPFC_SLI_ACTIVE)))
4773 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
4775 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
4777 if (rc != MBX_SUCCESS) {
4778 if (rc != MBX_TIMEOUT)
4779 mempool_free(pmboxq, phba->mbox_mem_pool);
4783 memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
4784 pmb->mbxCommand = MBX_READ_LNK_STAT;
4785 pmb->mbxOwner = OWN_HOST;
4786 pmboxq->context1 = NULL;
4787 pmboxq->vport = vport;
4789 if ((vport->fc_flag & FC_OFFLINE_MODE) ||
4790 (!(psli->sli_flag & LPFC_SLI_ACTIVE)))
4791 rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
4793 rc = lpfc_sli_issue_mbox_wait(phba, pmboxq, phba->fc_ratov * 2);
4795 if (rc != MBX_SUCCESS) {
4796 if (rc != MBX_TIMEOUT)
4797 mempool_free( pmboxq, phba->mbox_mem_pool);
4801 lso->link_failure_count = pmb->un.varRdLnk.linkFailureCnt;
4802 lso->loss_of_sync_count = pmb->un.varRdLnk.lossSyncCnt;
4803 lso->loss_of_signal_count = pmb->un.varRdLnk.lossSignalCnt;
4804 lso->prim_seq_protocol_err_count = pmb->un.varRdLnk.primSeqErrCnt;
4805 lso->invalid_tx_word_count = pmb->un.varRdLnk.invalidXmitWord;
4806 lso->invalid_crc_count = pmb->un.varRdLnk.crcCnt;
4807 lso->error_frames = pmb->un.varRdLnk.crcCnt;
4808 if (phba->hba_flag & HBA_FCOE_MODE)
4809 lso->link_events = (phba->link_events >> 1);
4811 lso->link_events = (phba->fc_eventTag >> 1);
4813 psli->stats_start = get_seconds();
4815 mempool_free(pmboxq, phba->mbox_mem_pool);
4821 * The LPFC driver treats linkdown handling as target loss events so there
4822 * are no sysfs handlers for link_down_tmo.
4826 * lpfc_get_node_by_target - Return the nodelist for a target
4827 * @starget: kernel scsi target pointer.
4830 * address of the node list if found
4831 * NULL target not found
4833 static struct lpfc_nodelist *
4834 lpfc_get_node_by_target(struct scsi_target *starget)
4836 struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
4837 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
4838 struct lpfc_nodelist *ndlp;
4840 spin_lock_irq(shost->host_lock);
4841 /* Search for this, mapped, target ID */
4842 list_for_each_entry(ndlp, &vport->fc_nodes, nlp_listp) {
4843 if (NLP_CHK_NODE_ACT(ndlp) &&
4844 ndlp->nlp_state == NLP_STE_MAPPED_NODE &&
4845 starget->id == ndlp->nlp_sid) {
4846 spin_unlock_irq(shost->host_lock);
4850 spin_unlock_irq(shost->host_lock);
4855 * lpfc_get_starget_port_id - Set the target port id to the ndlp DID or -1
4856 * @starget: kernel scsi target pointer.
4859 lpfc_get_starget_port_id(struct scsi_target *starget)
4861 struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
4863 fc_starget_port_id(starget) = ndlp ? ndlp->nlp_DID : -1;
4867 * lpfc_get_starget_node_name - Set the target node name
4868 * @starget: kernel scsi target pointer.
4870 * Description: Set the target node name to the ndlp node name wwn or zero.
4873 lpfc_get_starget_node_name(struct scsi_target *starget)
4875 struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
4877 fc_starget_node_name(starget) =
4878 ndlp ? wwn_to_u64(ndlp->nlp_nodename.u.wwn) : 0;
4882 * lpfc_get_starget_port_name - Set the target port name
4883 * @starget: kernel scsi target pointer.
4885 * Description: set the target port name to the ndlp port name wwn or zero.
4888 lpfc_get_starget_port_name(struct scsi_target *starget)
4890 struct lpfc_nodelist *ndlp = lpfc_get_node_by_target(starget);
4892 fc_starget_port_name(starget) =
4893 ndlp ? wwn_to_u64(ndlp->nlp_portname.u.wwn) : 0;
4897 * lpfc_set_rport_loss_tmo - Set the rport dev loss tmo
4898 * @rport: fc rport address.
4899 * @timeout: new value for dev loss tmo.
4902 * If timeout is non zero set the dev_loss_tmo to timeout, else set
4903 * dev_loss_tmo to one.
4906 lpfc_set_rport_loss_tmo(struct fc_rport *rport, uint32_t timeout)
4909 rport->dev_loss_tmo = timeout;
4911 rport->dev_loss_tmo = 1;
4915 * lpfc_rport_show_function - Return rport target information
4918 * Macro that uses field to generate a function with the name lpfc_show_rport_
4920 * lpfc_show_rport_##field: returns the bytes formatted in buf
4921 * @cdev: class converted to an fc_rport.
4922 * @buf: on return contains the target_field or zero.
4924 * Returns: size of formatted string.
4926 #define lpfc_rport_show_function(field, format_string, sz, cast) \
4928 lpfc_show_rport_##field (struct device *dev, \
4929 struct device_attribute *attr, \
4932 struct fc_rport *rport = transport_class_to_rport(dev); \
4933 struct lpfc_rport_data *rdata = rport->hostdata; \
4934 return snprintf(buf, sz, format_string, \
4935 (rdata->target) ? cast rdata->target->field : 0); \
4938 #define lpfc_rport_rd_attr(field, format_string, sz) \
4939 lpfc_rport_show_function(field, format_string, sz, ) \
4940 static FC_RPORT_ATTR(field, S_IRUGO, lpfc_show_rport_##field, NULL)
4943 * lpfc_set_vport_symbolic_name - Set the vport's symbolic name
4944 * @fc_vport: The fc_vport who's symbolic name has been changed.
4947 * This function is called by the transport after the @fc_vport's symbolic name
4948 * has been changed. This function re-registers the symbolic name with the
4949 * switch to propagate the change into the fabric if the vport is active.
4952 lpfc_set_vport_symbolic_name(struct fc_vport *fc_vport)
4954 struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
4956 if (vport->port_state == LPFC_VPORT_READY)
4957 lpfc_ns_cmd(vport, SLI_CTNS_RSPN_ID, 0, 0);
4961 * lpfc_hba_log_verbose_init - Set hba's log verbose level
4962 * @phba: Pointer to lpfc_hba struct.
4964 * This function is called by the lpfc_get_cfgparam() routine to set the
4965 * module lpfc_log_verbose into the @phba cfg_log_verbose for use with
4966 * log message according to the module's lpfc_log_verbose parameter setting
4967 * before hba port or vport created.
4970 lpfc_hba_log_verbose_init(struct lpfc_hba *phba, uint32_t verbose)
4972 phba->cfg_log_verbose = verbose;
4975 struct fc_function_template lpfc_transport_functions = {
4976 /* fixed attributes the driver supports */
4977 .show_host_node_name = 1,
4978 .show_host_port_name = 1,
4979 .show_host_supported_classes = 1,
4980 .show_host_supported_fc4s = 1,
4981 .show_host_supported_speeds = 1,
4982 .show_host_maxframe_size = 1,
4983 .show_host_symbolic_name = 1,
4985 /* dynamic attributes the driver supports */
4986 .get_host_port_id = lpfc_get_host_port_id,
4987 .show_host_port_id = 1,
4989 .get_host_port_type = lpfc_get_host_port_type,
4990 .show_host_port_type = 1,
4992 .get_host_port_state = lpfc_get_host_port_state,
4993 .show_host_port_state = 1,
4995 /* active_fc4s is shown but doesn't change (thus no get function) */
4996 .show_host_active_fc4s = 1,
4998 .get_host_speed = lpfc_get_host_speed,
4999 .show_host_speed = 1,
5001 .get_host_fabric_name = lpfc_get_host_fabric_name,
5002 .show_host_fabric_name = 1,
5005 * The LPFC driver treats linkdown handling as target loss events
5006 * so there are no sysfs handlers for link_down_tmo.
5009 .get_fc_host_stats = lpfc_get_stats,
5010 .reset_fc_host_stats = lpfc_reset_stats,
5012 .dd_fcrport_size = sizeof(struct lpfc_rport_data),
5013 .show_rport_maxframe_size = 1,
5014 .show_rport_supported_classes = 1,
5016 .set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo,
5017 .show_rport_dev_loss_tmo = 1,
5019 .get_starget_port_id = lpfc_get_starget_port_id,
5020 .show_starget_port_id = 1,
5022 .get_starget_node_name = lpfc_get_starget_node_name,
5023 .show_starget_node_name = 1,
5025 .get_starget_port_name = lpfc_get_starget_port_name,
5026 .show_starget_port_name = 1,
5028 .issue_fc_host_lip = lpfc_issue_lip,
5029 .dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk,
5030 .terminate_rport_io = lpfc_terminate_rport_io,
5032 .dd_fcvport_size = sizeof(struct lpfc_vport *),
5034 .vport_disable = lpfc_vport_disable,
5036 .set_vport_symbolic_name = lpfc_set_vport_symbolic_name,
5038 .bsg_request = lpfc_bsg_request,
5039 .bsg_timeout = lpfc_bsg_timeout,
5042 struct fc_function_template lpfc_vport_transport_functions = {
5043 /* fixed attributes the driver supports */
5044 .show_host_node_name = 1,
5045 .show_host_port_name = 1,
5046 .show_host_supported_classes = 1,
5047 .show_host_supported_fc4s = 1,
5048 .show_host_supported_speeds = 1,
5049 .show_host_maxframe_size = 1,
5050 .show_host_symbolic_name = 1,
5052 /* dynamic attributes the driver supports */
5053 .get_host_port_id = lpfc_get_host_port_id,
5054 .show_host_port_id = 1,
5056 .get_host_port_type = lpfc_get_host_port_type,
5057 .show_host_port_type = 1,
5059 .get_host_port_state = lpfc_get_host_port_state,
5060 .show_host_port_state = 1,
5062 /* active_fc4s is shown but doesn't change (thus no get function) */
5063 .show_host_active_fc4s = 1,
5065 .get_host_speed = lpfc_get_host_speed,
5066 .show_host_speed = 1,
5068 .get_host_fabric_name = lpfc_get_host_fabric_name,
5069 .show_host_fabric_name = 1,
5072 * The LPFC driver treats linkdown handling as target loss events
5073 * so there are no sysfs handlers for link_down_tmo.
5076 .get_fc_host_stats = lpfc_get_stats,
5077 .reset_fc_host_stats = lpfc_reset_stats,
5079 .dd_fcrport_size = sizeof(struct lpfc_rport_data),
5080 .show_rport_maxframe_size = 1,
5081 .show_rport_supported_classes = 1,
5083 .set_rport_dev_loss_tmo = lpfc_set_rport_loss_tmo,
5084 .show_rport_dev_loss_tmo = 1,
5086 .get_starget_port_id = lpfc_get_starget_port_id,
5087 .show_starget_port_id = 1,
5089 .get_starget_node_name = lpfc_get_starget_node_name,
5090 .show_starget_node_name = 1,
5092 .get_starget_port_name = lpfc_get_starget_port_name,
5093 .show_starget_port_name = 1,
5095 .dev_loss_tmo_callbk = lpfc_dev_loss_tmo_callbk,
5096 .terminate_rport_io = lpfc_terminate_rport_io,
5098 .vport_disable = lpfc_vport_disable,
5100 .set_vport_symbolic_name = lpfc_set_vport_symbolic_name,
5104 * lpfc_get_cfgparam - Used during probe_one to init the adapter structure
5105 * @phba: lpfc_hba pointer.
5108 lpfc_get_cfgparam(struct lpfc_hba *phba)
5110 lpfc_fcp_io_sched_init(phba, lpfc_fcp_io_sched);
5111 lpfc_fcp2_no_tgt_reset_init(phba, lpfc_fcp2_no_tgt_reset);
5112 lpfc_cr_delay_init(phba, lpfc_cr_delay);
5113 lpfc_cr_count_init(phba, lpfc_cr_count);
5114 lpfc_multi_ring_support_init(phba, lpfc_multi_ring_support);
5115 lpfc_multi_ring_rctl_init(phba, lpfc_multi_ring_rctl);
5116 lpfc_multi_ring_type_init(phba, lpfc_multi_ring_type);
5117 lpfc_ack0_init(phba, lpfc_ack0);
5118 lpfc_topology_init(phba, lpfc_topology);
5119 lpfc_link_speed_init(phba, lpfc_link_speed);
5120 lpfc_poll_tmo_init(phba, lpfc_poll_tmo);
5121 lpfc_enable_npiv_init(phba, lpfc_enable_npiv);
5122 lpfc_fcf_failover_policy_init(phba, lpfc_fcf_failover_policy);
5123 lpfc_enable_rrq_init(phba, lpfc_enable_rrq);
5124 lpfc_use_msi_init(phba, lpfc_use_msi);
5125 lpfc_fcp_imax_init(phba, lpfc_fcp_imax);
5126 lpfc_fcp_wq_count_init(phba, lpfc_fcp_wq_count);
5127 lpfc_fcp_eq_count_init(phba, lpfc_fcp_eq_count);
5128 lpfc_fcp_io_channel_init(phba, lpfc_fcp_io_channel);
5129 lpfc_enable_hba_reset_init(phba, lpfc_enable_hba_reset);
5130 lpfc_enable_hba_heartbeat_init(phba, lpfc_enable_hba_heartbeat);
5131 lpfc_enable_bg_init(phba, lpfc_enable_bg);
5132 if (phba->sli_rev == LPFC_SLI_REV4)
5135 phba->cfg_poll = lpfc_poll;
5136 phba->cfg_soft_wwnn = 0L;
5137 phba->cfg_soft_wwpn = 0L;
5138 lpfc_sg_seg_cnt_init(phba, lpfc_sg_seg_cnt);
5139 lpfc_prot_sg_seg_cnt_init(phba, lpfc_prot_sg_seg_cnt);
5140 lpfc_hba_queue_depth_init(phba, lpfc_hba_queue_depth);
5141 lpfc_hba_log_verbose_init(phba, lpfc_log_verbose);
5142 lpfc_aer_support_init(phba, lpfc_aer_support);
5143 lpfc_sriov_nr_virtfn_init(phba, lpfc_sriov_nr_virtfn);
5144 lpfc_request_firmware_upgrade_init(phba, lpfc_req_fw_upgrade);
5145 lpfc_suppress_link_up_init(phba, lpfc_suppress_link_up);
5146 lpfc_iocb_cnt_init(phba, lpfc_iocb_cnt);
5147 phba->cfg_enable_dss = 1;
5152 * lpfc_get_vport_cfgparam - Used during port create, init the vport structure
5153 * @vport: lpfc_vport pointer.
5156 lpfc_get_vport_cfgparam(struct lpfc_vport *vport)
5158 lpfc_log_verbose_init(vport, lpfc_log_verbose);
5159 lpfc_lun_queue_depth_init(vport, lpfc_lun_queue_depth);
5160 lpfc_tgt_queue_depth_init(vport, lpfc_tgt_queue_depth);
5161 lpfc_devloss_tmo_init(vport, lpfc_devloss_tmo);
5162 lpfc_nodev_tmo_init(vport, lpfc_nodev_tmo);
5163 lpfc_peer_port_login_init(vport, lpfc_peer_port_login);
5164 lpfc_restrict_login_init(vport, lpfc_restrict_login);
5165 lpfc_fcp_class_init(vport, lpfc_fcp_class);
5166 lpfc_use_adisc_init(vport, lpfc_use_adisc);
5167 lpfc_max_scsicmpl_time_init(vport, lpfc_max_scsicmpl_time);
5168 lpfc_fdmi_on_init(vport, lpfc_fdmi_on);
5169 lpfc_discovery_threads_init(vport, lpfc_discovery_threads);
5170 lpfc_max_luns_init(vport, lpfc_max_luns);
5171 lpfc_scan_down_init(vport, lpfc_scan_down);
5172 lpfc_enable_da_id_init(vport, lpfc_enable_da_id);