1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2004-2011 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
;
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 (pring
->txcmplq_cnt
) {
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, restore if needed */
926 if (before_fc_flag
& FC_OFFLINE_MODE
)
928 } else if (rc
== -EIO
) {
929 /* reset failed, there is nothing more we can do */
933 /* keep the original port state */
934 if (before_fc_flag
& FC_OFFLINE_MODE
)
937 init_completion(&online_compl
);
938 job_posted
= lpfc_workq_post_event(phba
, &status
, &online_compl
,
943 wait_for_completion(&online_compl
);
946 /* in any case, restore the virtual functions enabled as before */
947 if (sriov_nr_virtfn
) {
949 lpfc_sli_probe_sriov_nr_virtfn(phba
, sriov_nr_virtfn
);
951 phba
->cfg_sriov_nr_virtfn
= sriov_nr_virtfn
;
954 /* return proper error code */
965 * lpfc_nport_evt_cnt_show - Return the number of nport events
966 * @dev: class device that is converted into a Scsi_host.
967 * @attr: device attribute, not used.
968 * @buf: on return contains the ascii number of nport events.
970 * Returns: size of formatted string.
973 lpfc_nport_evt_cnt_show(struct device
*dev
, struct device_attribute
*attr
,
976 struct Scsi_Host
*shost
= class_to_shost(dev
);
977 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
978 struct lpfc_hba
*phba
= vport
->phba
;
980 return snprintf(buf
, PAGE_SIZE
, "%d\n", phba
->nport_event_cnt
);
984 * lpfc_board_mode_show - Return the state of the board
985 * @dev: class device that is converted into a Scsi_host.
986 * @attr: device attribute, not used.
987 * @buf: on return contains the state of the adapter.
989 * Returns: size of formatted string.
992 lpfc_board_mode_show(struct device
*dev
, struct device_attribute
*attr
,
995 struct Scsi_Host
*shost
= class_to_shost(dev
);
996 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
997 struct lpfc_hba
*phba
= vport
->phba
;
1000 if (phba
->link_state
== LPFC_HBA_ERROR
)
1002 else if (phba
->link_state
== LPFC_WARM_START
)
1003 state
= "warm start";
1004 else if (phba
->link_state
== LPFC_INIT_START
)
1009 return snprintf(buf
, PAGE_SIZE
, "%s\n", state
);
1013 * lpfc_board_mode_store - Puts the hba in online, offline, warm or error state
1014 * @dev: class device that is converted into a Scsi_host.
1015 * @attr: device attribute, not used.
1016 * @buf: containing one of the strings "online", "offline", "warm" or "error".
1017 * @count: unused variable.
1020 * -EACCES if enable hba reset not enabled
1021 * -EINVAL if the buffer does not contain a valid string (see above)
1022 * -EIO if lpfc_workq_post_event() or lpfc_do_offline() fails
1023 * buf length greater than zero indicates success
1026 lpfc_board_mode_store(struct device
*dev
, struct device_attribute
*attr
,
1027 const char *buf
, size_t count
)
1029 struct Scsi_Host
*shost
= class_to_shost(dev
);
1030 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
1031 struct lpfc_hba
*phba
= vport
->phba
;
1032 struct completion online_compl
;
1033 char *board_mode_str
= NULL
;
1037 if (!phba
->cfg_enable_hba_reset
) {
1039 goto board_mode_out
;
1042 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_INIT
,
1043 "3050 lpfc_board_mode set to %s\n", buf
);
1045 init_completion(&online_compl
);
1047 if(strncmp(buf
, "online", sizeof("online") - 1) == 0) {
1048 rc
= lpfc_workq_post_event(phba
, &status
, &online_compl
,
1052 goto board_mode_out
;
1054 wait_for_completion(&online_compl
);
1055 } else if (strncmp(buf
, "offline", sizeof("offline") - 1) == 0)
1056 status
= lpfc_do_offline(phba
, LPFC_EVT_OFFLINE
);
1057 else if (strncmp(buf
, "warm", sizeof("warm") - 1) == 0)
1058 if (phba
->sli_rev
== LPFC_SLI_REV4
)
1061 status
= lpfc_do_offline(phba
, LPFC_EVT_WARM_START
);
1062 else if (strncmp(buf
, "error", sizeof("error") - 1) == 0)
1063 if (phba
->sli_rev
== LPFC_SLI_REV4
)
1066 status
= lpfc_do_offline(phba
, LPFC_EVT_KILL
);
1067 else if (strncmp(buf
, "dump", sizeof("dump") - 1) == 0)
1068 status
= lpfc_sli4_pdev_reg_request(phba
, LPFC_FW_DUMP
);
1069 else if (strncmp(buf
, "fw_reset", sizeof("fw_reset") - 1) == 0)
1070 status
= lpfc_sli4_pdev_reg_request(phba
, LPFC_FW_RESET
);
1071 else if (strncmp(buf
, "dv_reset", sizeof("dv_reset") - 1) == 0)
1072 status
= lpfc_sli4_pdev_reg_request(phba
, LPFC_DV_RESET
);
1080 board_mode_str
= strchr(buf
, '\n');
1082 *board_mode_str
= '\0';
1083 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_INIT
,
1084 "3097 Failed \"%s\", status(%d), "
1086 buf
, status
, phba
->pport
->fc_flag
);
1092 * lpfc_get_hba_info - Return various bits of informaton about the adapter
1093 * @phba: pointer to the adapter structure.
1094 * @mxri: max xri count.
1095 * @axri: available xri count.
1096 * @mrpi: max rpi count.
1097 * @arpi: available rpi count.
1098 * @mvpi: max vpi count.
1099 * @avpi: available vpi count.
1102 * If an integer pointer for an count is not null then the value for the
1103 * count is returned.
1110 lpfc_get_hba_info(struct lpfc_hba
*phba
,
1111 uint32_t *mxri
, uint32_t *axri
,
1112 uint32_t *mrpi
, uint32_t *arpi
,
1113 uint32_t *mvpi
, uint32_t *avpi
)
1115 struct lpfc_mbx_read_config
*rd_config
;
1116 LPFC_MBOXQ_t
*pmboxq
;
1122 * prevent udev from issuing mailbox commands until the port is
1125 if (phba
->link_state
< LPFC_LINK_DOWN
||
1126 !phba
->mbox_mem_pool
||
1127 (phba
->sli
.sli_flag
& LPFC_SLI_ACTIVE
) == 0)
1130 if (phba
->sli
.sli_flag
& LPFC_BLOCK_MGMT_IO
)
1133 pmboxq
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
1136 memset(pmboxq
, 0, sizeof (LPFC_MBOXQ_t
));
1138 pmb
= &pmboxq
->u
.mb
;
1139 pmb
->mbxCommand
= MBX_READ_CONFIG
;
1140 pmb
->mbxOwner
= OWN_HOST
;
1141 pmboxq
->context1
= NULL
;
1143 if (phba
->pport
->fc_flag
& FC_OFFLINE_MODE
)
1144 rc
= MBX_NOT_FINISHED
;
1146 rc
= lpfc_sli_issue_mbox_wait(phba
, pmboxq
, phba
->fc_ratov
* 2);
1148 if (rc
!= MBX_SUCCESS
) {
1149 if (rc
!= MBX_TIMEOUT
)
1150 mempool_free(pmboxq
, phba
->mbox_mem_pool
);
1154 if (phba
->sli_rev
== LPFC_SLI_REV4
) {
1155 rd_config
= &pmboxq
->u
.mqe
.un
.rd_config
;
1157 *mrpi
= bf_get(lpfc_mbx_rd_conf_rpi_count
, rd_config
);
1159 *arpi
= bf_get(lpfc_mbx_rd_conf_rpi_count
, rd_config
) -
1160 phba
->sli4_hba
.max_cfg_param
.rpi_used
;
1162 *mxri
= bf_get(lpfc_mbx_rd_conf_xri_count
, rd_config
);
1164 *axri
= bf_get(lpfc_mbx_rd_conf_xri_count
, rd_config
) -
1165 phba
->sli4_hba
.max_cfg_param
.xri_used
;
1167 /* Account for differences with SLI-3. Get vpi count from
1168 * mailbox data and subtract one for max vpi value.
1170 max_vpi
= (bf_get(lpfc_mbx_rd_conf_vpi_count
, rd_config
) > 0) ?
1171 (bf_get(lpfc_mbx_rd_conf_vpi_count
, rd_config
) - 1) : 0;
1176 *avpi
= max_vpi
- phba
->sli4_hba
.max_cfg_param
.vpi_used
;
1179 *mrpi
= pmb
->un
.varRdConfig
.max_rpi
;
1181 *arpi
= pmb
->un
.varRdConfig
.avail_rpi
;
1183 *mxri
= pmb
->un
.varRdConfig
.max_xri
;
1185 *axri
= pmb
->un
.varRdConfig
.avail_xri
;
1187 *mvpi
= pmb
->un
.varRdConfig
.max_vpi
;
1189 *avpi
= pmb
->un
.varRdConfig
.avail_vpi
;
1192 mempool_free(pmboxq
, phba
->mbox_mem_pool
);
1197 * lpfc_max_rpi_show - Return maximum rpi
1198 * @dev: class device that is converted into a Scsi_host.
1199 * @attr: device attribute, not used.
1200 * @buf: on return contains the maximum rpi count in decimal or "Unknown".
1203 * Calls lpfc_get_hba_info() asking for just the mrpi count.
1204 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1205 * to "Unknown" and the buffer length is returned, therefore the caller
1206 * must check for "Unknown" in the buffer to detect a failure.
1208 * Returns: size of formatted string.
1211 lpfc_max_rpi_show(struct device
*dev
, struct device_attribute
*attr
,
1214 struct Scsi_Host
*shost
= class_to_shost(dev
);
1215 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
1216 struct lpfc_hba
*phba
= vport
->phba
;
1219 if (lpfc_get_hba_info(phba
, NULL
, NULL
, &cnt
, NULL
, NULL
, NULL
))
1220 return snprintf(buf
, PAGE_SIZE
, "%d\n", cnt
);
1221 return snprintf(buf
, PAGE_SIZE
, "Unknown\n");
1225 * lpfc_used_rpi_show - Return maximum rpi minus available rpi
1226 * @dev: class device that is converted into a Scsi_host.
1227 * @attr: device attribute, not used.
1228 * @buf: containing the used rpi count in decimal or "Unknown".
1231 * Calls lpfc_get_hba_info() asking for just the mrpi and arpi counts.
1232 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1233 * to "Unknown" and the buffer length is returned, therefore the caller
1234 * must check for "Unknown" in the buffer to detect a failure.
1236 * Returns: size of formatted string.
1239 lpfc_used_rpi_show(struct device
*dev
, struct device_attribute
*attr
,
1242 struct Scsi_Host
*shost
= class_to_shost(dev
);
1243 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
1244 struct lpfc_hba
*phba
= vport
->phba
;
1247 if (lpfc_get_hba_info(phba
, NULL
, NULL
, &cnt
, &acnt
, NULL
, NULL
))
1248 return snprintf(buf
, PAGE_SIZE
, "%d\n", (cnt
- acnt
));
1249 return snprintf(buf
, PAGE_SIZE
, "Unknown\n");
1253 * lpfc_max_xri_show - Return maximum xri
1254 * @dev: class device that is converted into a Scsi_host.
1255 * @attr: device attribute, not used.
1256 * @buf: on return contains the maximum xri count in decimal or "Unknown".
1259 * Calls lpfc_get_hba_info() asking for just the mrpi count.
1260 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1261 * to "Unknown" and the buffer length is returned, therefore the caller
1262 * must check for "Unknown" in the buffer to detect a failure.
1264 * Returns: size of formatted string.
1267 lpfc_max_xri_show(struct device
*dev
, struct device_attribute
*attr
,
1270 struct Scsi_Host
*shost
= class_to_shost(dev
);
1271 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
1272 struct lpfc_hba
*phba
= vport
->phba
;
1275 if (lpfc_get_hba_info(phba
, &cnt
, NULL
, NULL
, NULL
, NULL
, NULL
))
1276 return snprintf(buf
, PAGE_SIZE
, "%d\n", cnt
);
1277 return snprintf(buf
, PAGE_SIZE
, "Unknown\n");
1281 * lpfc_used_xri_show - Return maximum xpi minus the available xpi
1282 * @dev: class device that is converted into a Scsi_host.
1283 * @attr: device attribute, not used.
1284 * @buf: on return contains the used xri count in decimal or "Unknown".
1287 * Calls lpfc_get_hba_info() asking for just the mxri and axri counts.
1288 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1289 * to "Unknown" and the buffer length is returned, therefore the caller
1290 * must check for "Unknown" in the buffer to detect a failure.
1292 * Returns: size of formatted string.
1295 lpfc_used_xri_show(struct device
*dev
, struct device_attribute
*attr
,
1298 struct Scsi_Host
*shost
= class_to_shost(dev
);
1299 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
1300 struct lpfc_hba
*phba
= vport
->phba
;
1303 if (lpfc_get_hba_info(phba
, &cnt
, &acnt
, NULL
, NULL
, NULL
, NULL
))
1304 return snprintf(buf
, PAGE_SIZE
, "%d\n", (cnt
- acnt
));
1305 return snprintf(buf
, PAGE_SIZE
, "Unknown\n");
1309 * lpfc_max_vpi_show - Return maximum vpi
1310 * @dev: class device that is converted into a Scsi_host.
1311 * @attr: device attribute, not used.
1312 * @buf: on return contains the maximum vpi count in decimal or "Unknown".
1315 * Calls lpfc_get_hba_info() asking for just the mvpi count.
1316 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1317 * to "Unknown" and the buffer length is returned, therefore the caller
1318 * must check for "Unknown" in the buffer to detect a failure.
1320 * Returns: size of formatted string.
1323 lpfc_max_vpi_show(struct device
*dev
, struct device_attribute
*attr
,
1326 struct Scsi_Host
*shost
= class_to_shost(dev
);
1327 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
1328 struct lpfc_hba
*phba
= vport
->phba
;
1331 if (lpfc_get_hba_info(phba
, NULL
, NULL
, NULL
, NULL
, &cnt
, NULL
))
1332 return snprintf(buf
, PAGE_SIZE
, "%d\n", cnt
);
1333 return snprintf(buf
, PAGE_SIZE
, "Unknown\n");
1337 * lpfc_used_vpi_show - Return maximum vpi minus the available vpi
1338 * @dev: class device that is converted into a Scsi_host.
1339 * @attr: device attribute, not used.
1340 * @buf: on return contains the used vpi count in decimal or "Unknown".
1343 * Calls lpfc_get_hba_info() asking for just the mvpi and avpi counts.
1344 * If lpfc_get_hba_info() returns zero (failure) the buffer text is set
1345 * to "Unknown" and the buffer length is returned, therefore the caller
1346 * must check for "Unknown" in the buffer to detect a failure.
1348 * Returns: size of formatted string.
1351 lpfc_used_vpi_show(struct device
*dev
, struct device_attribute
*attr
,
1354 struct Scsi_Host
*shost
= class_to_shost(dev
);
1355 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
1356 struct lpfc_hba
*phba
= vport
->phba
;
1359 if (lpfc_get_hba_info(phba
, NULL
, NULL
, NULL
, NULL
, &cnt
, &acnt
))
1360 return snprintf(buf
, PAGE_SIZE
, "%d\n", (cnt
- acnt
));
1361 return snprintf(buf
, PAGE_SIZE
, "Unknown\n");
1365 * lpfc_npiv_info_show - Return text about NPIV support for the adapter
1366 * @dev: class device that is converted into a Scsi_host.
1367 * @attr: device attribute, not used.
1368 * @buf: text that must be interpreted to determine if npiv is supported.
1371 * Buffer will contain text indicating npiv is not suppoerted on the port,
1372 * the port is an NPIV physical port, or it is an npiv virtual port with
1373 * the id of the vport.
1375 * Returns: size of formatted string.
1378 lpfc_npiv_info_show(struct device
*dev
, struct device_attribute
*attr
,
1381 struct Scsi_Host
*shost
= class_to_shost(dev
);
1382 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
1383 struct lpfc_hba
*phba
= vport
->phba
;
1385 if (!(phba
->max_vpi
))
1386 return snprintf(buf
, PAGE_SIZE
, "NPIV Not Supported\n");
1387 if (vport
->port_type
== LPFC_PHYSICAL_PORT
)
1388 return snprintf(buf
, PAGE_SIZE
, "NPIV Physical\n");
1389 return snprintf(buf
, PAGE_SIZE
, "NPIV Virtual (VPI %d)\n", vport
->vpi
);
1393 * lpfc_poll_show - Return text about poll support for the adapter
1394 * @dev: class device that is converted into a Scsi_host.
1395 * @attr: device attribute, not used.
1396 * @buf: on return contains the cfg_poll in hex.
1399 * cfg_poll should be a lpfc_polling_flags type.
1401 * Returns: size of formatted string.
1404 lpfc_poll_show(struct device
*dev
, struct device_attribute
*attr
,
1407 struct Scsi_Host
*shost
= class_to_shost(dev
);
1408 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
1409 struct lpfc_hba
*phba
= vport
->phba
;
1411 return snprintf(buf
, PAGE_SIZE
, "%#x\n", phba
->cfg_poll
);
1415 * lpfc_poll_store - Set the value of cfg_poll for the adapter
1416 * @dev: class device that is converted into a Scsi_host.
1417 * @attr: device attribute, not used.
1418 * @buf: one or more lpfc_polling_flags values.
1422 * buf contents converted to integer and checked for a valid value.
1425 * -EINVAL if the buffer connot be converted or is out of range
1426 * length of the buf on success
1429 lpfc_poll_store(struct device
*dev
, struct device_attribute
*attr
,
1430 const char *buf
, size_t count
)
1432 struct Scsi_Host
*shost
= class_to_shost(dev
);
1433 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
1434 struct lpfc_hba
*phba
= vport
->phba
;
1439 if (!isdigit(buf
[0]))
1442 if (sscanf(buf
, "%i", &val
) != 1)
1445 if ((val
& 0x3) != val
)
1448 if (phba
->sli_rev
== LPFC_SLI_REV4
)
1451 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_INIT
,
1452 "3051 lpfc_poll changed from %d to %d\n",
1453 phba
->cfg_poll
, val
);
1455 spin_lock_irq(&phba
->hbalock
);
1457 old_val
= phba
->cfg_poll
;
1459 if (val
& ENABLE_FCP_RING_POLLING
) {
1460 if ((val
& DISABLE_FCP_RING_INT
) &&
1461 !(old_val
& DISABLE_FCP_RING_INT
)) {
1462 if (lpfc_readl(phba
->HCregaddr
, &creg_val
)) {
1463 spin_unlock_irq(&phba
->hbalock
);
1466 creg_val
&= ~(HC_R0INT_ENA
<< LPFC_FCP_RING
);
1467 writel(creg_val
, phba
->HCregaddr
);
1468 readl(phba
->HCregaddr
); /* flush */
1470 lpfc_poll_start_timer(phba
);
1472 } else if (val
!= 0x0) {
1473 spin_unlock_irq(&phba
->hbalock
);
1477 if (!(val
& DISABLE_FCP_RING_INT
) &&
1478 (old_val
& DISABLE_FCP_RING_INT
))
1480 spin_unlock_irq(&phba
->hbalock
);
1481 del_timer(&phba
->fcp_poll_timer
);
1482 spin_lock_irq(&phba
->hbalock
);
1483 if (lpfc_readl(phba
->HCregaddr
, &creg_val
)) {
1484 spin_unlock_irq(&phba
->hbalock
);
1487 creg_val
|= (HC_R0INT_ENA
<< LPFC_FCP_RING
);
1488 writel(creg_val
, phba
->HCregaddr
);
1489 readl(phba
->HCregaddr
); /* flush */
1492 phba
->cfg_poll
= val
;
1494 spin_unlock_irq(&phba
->hbalock
);
1500 * lpfc_fips_level_show - Return the current FIPS level for the HBA
1501 * @dev: class unused variable.
1502 * @attr: device attribute, not used.
1503 * @buf: on return contains the module description text.
1505 * Returns: size of formatted string.
1508 lpfc_fips_level_show(struct device
*dev
, struct device_attribute
*attr
,
1511 struct Scsi_Host
*shost
= class_to_shost(dev
);
1512 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
1513 struct lpfc_hba
*phba
= vport
->phba
;
1515 return snprintf(buf
, PAGE_SIZE
, "%d\n", phba
->fips_level
);
1519 * lpfc_fips_rev_show - Return the FIPS Spec revision for the HBA
1520 * @dev: class unused variable.
1521 * @attr: device attribute, not used.
1522 * @buf: on return contains the module description text.
1524 * Returns: size of formatted string.
1527 lpfc_fips_rev_show(struct device
*dev
, struct device_attribute
*attr
,
1530 struct Scsi_Host
*shost
= class_to_shost(dev
);
1531 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
1532 struct lpfc_hba
*phba
= vport
->phba
;
1534 return snprintf(buf
, PAGE_SIZE
, "%d\n", phba
->fips_spec_rev
);
1538 * lpfc_dss_show - Return the current state of dss and the configured state
1539 * @dev: class converted to a Scsi_host structure.
1540 * @attr: device attribute, not used.
1541 * @buf: on return contains the formatted text.
1543 * Returns: size of formatted string.
1546 lpfc_dss_show(struct device
*dev
, struct device_attribute
*attr
,
1549 struct Scsi_Host
*shost
= class_to_shost(dev
);
1550 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
1551 struct lpfc_hba
*phba
= vport
->phba
;
1553 return snprintf(buf
, PAGE_SIZE
, "%s - %sOperational\n",
1554 (phba
->cfg_enable_dss
) ? "Enabled" : "Disabled",
1555 (phba
->sli3_options
& LPFC_SLI3_DSS_ENABLED
) ?
1560 * lpfc_sriov_hw_max_virtfn_show - Return maximum number of virtual functions
1561 * @dev: class converted to a Scsi_host structure.
1562 * @attr: device attribute, not used.
1563 * @buf: on return contains the formatted support level.
1566 * Returns the maximum number of virtual functions a physical function can
1567 * support, 0 will be returned if called on virtual function.
1569 * Returns: size of formatted string.
1572 lpfc_sriov_hw_max_virtfn_show(struct device
*dev
,
1573 struct device_attribute
*attr
,
1576 struct Scsi_Host
*shost
= class_to_shost(dev
);
1577 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
1578 struct lpfc_hba
*phba
= vport
->phba
;
1579 uint16_t max_nr_virtfn
;
1581 max_nr_virtfn
= lpfc_sli_sriov_nr_virtfn_get(phba
);
1582 return snprintf(buf
, PAGE_SIZE
, "%d\n", max_nr_virtfn
);
1586 * lpfc_param_show - Return a cfg attribute value in decimal
1589 * Macro that given an attr e.g. hba_queue_depth expands
1590 * into a function with the name lpfc_hba_queue_depth_show.
1592 * lpfc_##attr##_show: Return the decimal value of an adapters cfg_xxx field.
1593 * @dev: class device that is converted into a Scsi_host.
1594 * @attr: device attribute, not used.
1595 * @buf: on return contains the attribute value in decimal.
1597 * Returns: size of formatted string.
1599 #define lpfc_param_show(attr) \
1601 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
1604 struct Scsi_Host *shost = class_to_shost(dev);\
1605 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1606 struct lpfc_hba *phba = vport->phba;\
1608 val = phba->cfg_##attr;\
1609 return snprintf(buf, PAGE_SIZE, "%d\n",\
1614 * lpfc_param_hex_show - Return a cfg attribute value in hex
1617 * Macro that given an attr e.g. hba_queue_depth expands
1618 * into a function with the name lpfc_hba_queue_depth_show
1620 * lpfc_##attr##_show: Return the hex value of an adapters cfg_xxx field.
1621 * @dev: class device that is converted into a Scsi_host.
1622 * @attr: device attribute, not used.
1623 * @buf: on return contains the attribute value in hexadecimal.
1625 * Returns: size of formatted string.
1627 #define lpfc_param_hex_show(attr) \
1629 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
1632 struct Scsi_Host *shost = class_to_shost(dev);\
1633 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1634 struct lpfc_hba *phba = vport->phba;\
1636 val = phba->cfg_##attr;\
1637 return snprintf(buf, PAGE_SIZE, "%#x\n",\
1642 * lpfc_param_init - Initializes a cfg attribute
1645 * Macro that given an attr e.g. hba_queue_depth expands
1646 * into a function with the name lpfc_hba_queue_depth_init. The macro also
1647 * takes a default argument, a minimum and maximum argument.
1649 * lpfc_##attr##_init: Initializes an attribute.
1650 * @phba: pointer the the adapter structure.
1651 * @val: integer attribute value.
1653 * Validates the min and max values then sets the adapter config field
1654 * accordingly, or uses the default if out of range and prints an error message.
1658 * -EINVAL if default used
1660 #define lpfc_param_init(attr, default, minval, maxval) \
1662 lpfc_##attr##_init(struct lpfc_hba *phba, uint val) \
1664 if (val >= minval && val <= maxval) {\
1665 phba->cfg_##attr = val;\
1668 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
1669 "0449 lpfc_"#attr" attribute cannot be set to %d, "\
1670 "allowed range is ["#minval", "#maxval"]\n", val); \
1671 phba->cfg_##attr = default;\
1676 * lpfc_param_set - Set a cfg attribute value
1679 * Macro that given an attr e.g. hba_queue_depth expands
1680 * into a function with the name lpfc_hba_queue_depth_set
1682 * lpfc_##attr##_set: Sets an attribute value.
1683 * @phba: pointer the the adapter structure.
1684 * @val: integer attribute value.
1687 * Validates the min and max values then sets the
1688 * adapter config field if in the valid range. prints error message
1689 * and does not set the parameter if invalid.
1693 * -EINVAL if val is invalid
1695 #define lpfc_param_set(attr, default, minval, maxval) \
1697 lpfc_##attr##_set(struct lpfc_hba *phba, uint val) \
1699 if (val >= minval && val <= maxval) {\
1700 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
1701 "3052 lpfc_" #attr " changed from %d to %d\n", \
1702 phba->cfg_##attr, val); \
1703 phba->cfg_##attr = val;\
1706 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
1707 "0450 lpfc_"#attr" attribute cannot be set to %d, "\
1708 "allowed range is ["#minval", "#maxval"]\n", val); \
1713 * lpfc_param_store - Set a vport attribute value
1716 * Macro that given an attr e.g. hba_queue_depth expands
1717 * into a function with the name lpfc_hba_queue_depth_store.
1719 * lpfc_##attr##_store: Set an sttribute value.
1720 * @dev: class device that is converted into a Scsi_host.
1721 * @attr: device attribute, not used.
1722 * @buf: contains the attribute value in ascii.
1726 * Convert the ascii text number to an integer, then
1727 * use the lpfc_##attr##_set function to set the value.
1730 * -EINVAL if val is invalid or lpfc_##attr##_set() fails
1731 * length of buffer upon success.
1733 #define lpfc_param_store(attr) \
1735 lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
1736 const char *buf, size_t count) \
1738 struct Scsi_Host *shost = class_to_shost(dev);\
1739 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1740 struct lpfc_hba *phba = vport->phba;\
1742 if (!isdigit(buf[0]))\
1744 if (sscanf(buf, "%i", &val) != 1)\
1746 if (lpfc_##attr##_set(phba, val) == 0) \
1747 return strlen(buf);\
1753 * lpfc_vport_param_show - Return decimal formatted cfg attribute value
1756 * Macro that given an attr e.g. hba_queue_depth expands
1757 * into a function with the name lpfc_hba_queue_depth_show
1759 * lpfc_##attr##_show: prints the attribute value in decimal.
1760 * @dev: class device that is converted into a Scsi_host.
1761 * @attr: device attribute, not used.
1762 * @buf: on return contains the attribute value in decimal.
1764 * Returns: length of formatted string.
1766 #define lpfc_vport_param_show(attr) \
1768 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
1771 struct Scsi_Host *shost = class_to_shost(dev);\
1772 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1774 val = vport->cfg_##attr;\
1775 return snprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_##attr);\
1779 * lpfc_vport_param_hex_show - Return hex formatted attribute value
1782 * Macro that given an attr e.g.
1783 * hba_queue_depth expands into a function with the name
1784 * lpfc_hba_queue_depth_show
1786 * lpfc_##attr##_show: prints the attribute value in hexadecimal.
1787 * @dev: class device that is converted into a Scsi_host.
1788 * @attr: device attribute, not used.
1789 * @buf: on return contains the attribute value in hexadecimal.
1791 * Returns: length of formatted string.
1793 #define lpfc_vport_param_hex_show(attr) \
1795 lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
1798 struct Scsi_Host *shost = class_to_shost(dev);\
1799 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1801 val = vport->cfg_##attr;\
1802 return snprintf(buf, PAGE_SIZE, "%#x\n", vport->cfg_##attr);\
1806 * lpfc_vport_param_init - Initialize a vport cfg attribute
1809 * Macro that given an attr e.g. hba_queue_depth expands
1810 * into a function with the name lpfc_hba_queue_depth_init. The macro also
1811 * takes a default argument, a minimum and maximum argument.
1813 * lpfc_##attr##_init: validates the min and max values then sets the
1814 * adapter config field accordingly, or uses the default if out of range
1815 * and prints an error message.
1816 * @phba: pointer the the adapter structure.
1817 * @val: integer attribute value.
1821 * -EINVAL if default used
1823 #define lpfc_vport_param_init(attr, default, minval, maxval) \
1825 lpfc_##attr##_init(struct lpfc_vport *vport, uint val) \
1827 if (val >= minval && val <= maxval) {\
1828 vport->cfg_##attr = val;\
1831 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
1832 "0423 lpfc_"#attr" attribute cannot be set to %d, "\
1833 "allowed range is ["#minval", "#maxval"]\n", val); \
1834 vport->cfg_##attr = default;\
1839 * lpfc_vport_param_set - Set a vport cfg attribute
1842 * Macro that given an attr e.g. hba_queue_depth expands
1843 * into a function with the name lpfc_hba_queue_depth_set
1845 * lpfc_##attr##_set: validates the min and max values then sets the
1846 * adapter config field if in the valid range. prints error message
1847 * and does not set the parameter if invalid.
1848 * @phba: pointer the the adapter structure.
1849 * @val: integer attribute value.
1853 * -EINVAL if val is invalid
1855 #define lpfc_vport_param_set(attr, default, minval, maxval) \
1857 lpfc_##attr##_set(struct lpfc_vport *vport, uint val) \
1859 if (val >= minval && val <= maxval) {\
1860 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
1861 "3053 lpfc_" #attr " changed from %d to %d\n", \
1862 vport->cfg_##attr, val); \
1863 vport->cfg_##attr = val;\
1866 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
1867 "0424 lpfc_"#attr" attribute cannot be set to %d, "\
1868 "allowed range is ["#minval", "#maxval"]\n", val); \
1873 * lpfc_vport_param_store - Set a vport attribute
1876 * Macro that given an attr e.g. hba_queue_depth
1877 * expands into a function with the name lpfc_hba_queue_depth_store
1879 * lpfc_##attr##_store: convert the ascii text number to an integer, then
1880 * use the lpfc_##attr##_set function to set the value.
1881 * @cdev: class device that is converted into a Scsi_host.
1882 * @buf: contains the attribute value in decimal.
1886 * -EINVAL if val is invalid or lpfc_##attr##_set() fails
1887 * length of buffer upon success.
1889 #define lpfc_vport_param_store(attr) \
1891 lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
1892 const char *buf, size_t count) \
1894 struct Scsi_Host *shost = class_to_shost(dev);\
1895 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
1897 if (!isdigit(buf[0]))\
1899 if (sscanf(buf, "%i", &val) != 1)\
1901 if (lpfc_##attr##_set(vport, val) == 0) \
1902 return strlen(buf);\
1908 #define LPFC_ATTR(name, defval, minval, maxval, desc) \
1909 static uint lpfc_##name = defval;\
1910 module_param(lpfc_##name, uint, S_IRUGO);\
1911 MODULE_PARM_DESC(lpfc_##name, desc);\
1912 lpfc_param_init(name, defval, minval, maxval)
1914 #define LPFC_ATTR_R(name, defval, minval, maxval, desc) \
1915 static uint lpfc_##name = defval;\
1916 module_param(lpfc_##name, uint, S_IRUGO);\
1917 MODULE_PARM_DESC(lpfc_##name, desc);\
1918 lpfc_param_show(name)\
1919 lpfc_param_init(name, defval, minval, maxval)\
1920 static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
1922 #define LPFC_ATTR_RW(name, defval, minval, maxval, desc) \
1923 static uint lpfc_##name = defval;\
1924 module_param(lpfc_##name, uint, S_IRUGO);\
1925 MODULE_PARM_DESC(lpfc_##name, desc);\
1926 lpfc_param_show(name)\
1927 lpfc_param_init(name, defval, minval, maxval)\
1928 lpfc_param_set(name, defval, minval, maxval)\
1929 lpfc_param_store(name)\
1930 static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
1931 lpfc_##name##_show, lpfc_##name##_store)
1933 #define LPFC_ATTR_HEX_R(name, defval, minval, maxval, desc) \
1934 static uint lpfc_##name = defval;\
1935 module_param(lpfc_##name, uint, S_IRUGO);\
1936 MODULE_PARM_DESC(lpfc_##name, desc);\
1937 lpfc_param_hex_show(name)\
1938 lpfc_param_init(name, defval, minval, maxval)\
1939 static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
1941 #define LPFC_ATTR_HEX_RW(name, defval, minval, maxval, desc) \
1942 static uint lpfc_##name = defval;\
1943 module_param(lpfc_##name, uint, S_IRUGO);\
1944 MODULE_PARM_DESC(lpfc_##name, desc);\
1945 lpfc_param_hex_show(name)\
1946 lpfc_param_init(name, defval, minval, maxval)\
1947 lpfc_param_set(name, defval, minval, maxval)\
1948 lpfc_param_store(name)\
1949 static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
1950 lpfc_##name##_show, lpfc_##name##_store)
1952 #define LPFC_VPORT_ATTR(name, defval, minval, maxval, desc) \
1953 static uint lpfc_##name = defval;\
1954 module_param(lpfc_##name, uint, S_IRUGO);\
1955 MODULE_PARM_DESC(lpfc_##name, desc);\
1956 lpfc_vport_param_init(name, defval, minval, maxval)
1958 #define LPFC_VPORT_ATTR_R(name, defval, minval, maxval, desc) \
1959 static uint lpfc_##name = defval;\
1960 module_param(lpfc_##name, uint, S_IRUGO);\
1961 MODULE_PARM_DESC(lpfc_##name, desc);\
1962 lpfc_vport_param_show(name)\
1963 lpfc_vport_param_init(name, defval, minval, maxval)\
1964 static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
1966 #define LPFC_VPORT_ATTR_RW(name, defval, minval, maxval, desc) \
1967 static uint lpfc_##name = defval;\
1968 module_param(lpfc_##name, uint, S_IRUGO);\
1969 MODULE_PARM_DESC(lpfc_##name, desc);\
1970 lpfc_vport_param_show(name)\
1971 lpfc_vport_param_init(name, defval, minval, maxval)\
1972 lpfc_vport_param_set(name, defval, minval, maxval)\
1973 lpfc_vport_param_store(name)\
1974 static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
1975 lpfc_##name##_show, lpfc_##name##_store)
1977 #define LPFC_VPORT_ATTR_HEX_R(name, defval, minval, maxval, desc) \
1978 static uint lpfc_##name = defval;\
1979 module_param(lpfc_##name, uint, S_IRUGO);\
1980 MODULE_PARM_DESC(lpfc_##name, desc);\
1981 lpfc_vport_param_hex_show(name)\
1982 lpfc_vport_param_init(name, defval, minval, maxval)\
1983 static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
1985 #define LPFC_VPORT_ATTR_HEX_RW(name, defval, minval, maxval, desc) \
1986 static uint lpfc_##name = defval;\
1987 module_param(lpfc_##name, uint, S_IRUGO);\
1988 MODULE_PARM_DESC(lpfc_##name, desc);\
1989 lpfc_vport_param_hex_show(name)\
1990 lpfc_vport_param_init(name, defval, minval, maxval)\
1991 lpfc_vport_param_set(name, defval, minval, maxval)\
1992 lpfc_vport_param_store(name)\
1993 static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
1994 lpfc_##name##_show, lpfc_##name##_store)
1996 static DEVICE_ATTR(bg_info
, S_IRUGO
, lpfc_bg_info_show
, NULL
);
1997 static DEVICE_ATTR(bg_guard_err
, S_IRUGO
, lpfc_bg_guard_err_show
, NULL
);
1998 static DEVICE_ATTR(bg_apptag_err
, S_IRUGO
, lpfc_bg_apptag_err_show
, NULL
);
1999 static DEVICE_ATTR(bg_reftag_err
, S_IRUGO
, lpfc_bg_reftag_err_show
, NULL
);
2000 static DEVICE_ATTR(info
, S_IRUGO
, lpfc_info_show
, NULL
);
2001 static DEVICE_ATTR(serialnum
, S_IRUGO
, lpfc_serialnum_show
, NULL
);
2002 static DEVICE_ATTR(modeldesc
, S_IRUGO
, lpfc_modeldesc_show
, NULL
);
2003 static DEVICE_ATTR(modelname
, S_IRUGO
, lpfc_modelname_show
, NULL
);
2004 static DEVICE_ATTR(programtype
, S_IRUGO
, lpfc_programtype_show
, NULL
);
2005 static DEVICE_ATTR(portnum
, S_IRUGO
, lpfc_vportnum_show
, NULL
);
2006 static DEVICE_ATTR(fwrev
, S_IRUGO
, lpfc_fwrev_show
, NULL
);
2007 static DEVICE_ATTR(hdw
, S_IRUGO
, lpfc_hdw_show
, NULL
);
2008 static DEVICE_ATTR(link_state
, S_IRUGO
| S_IWUSR
, lpfc_link_state_show
,
2009 lpfc_link_state_store
);
2010 static DEVICE_ATTR(option_rom_version
, S_IRUGO
,
2011 lpfc_option_rom_version_show
, NULL
);
2012 static DEVICE_ATTR(num_discovered_ports
, S_IRUGO
,
2013 lpfc_num_discovered_ports_show
, NULL
);
2014 static DEVICE_ATTR(menlo_mgmt_mode
, S_IRUGO
, lpfc_mlomgmt_show
, NULL
);
2015 static DEVICE_ATTR(nport_evt_cnt
, S_IRUGO
, lpfc_nport_evt_cnt_show
, NULL
);
2016 static DEVICE_ATTR(lpfc_drvr_version
, S_IRUGO
, lpfc_drvr_version_show
, NULL
);
2017 static DEVICE_ATTR(lpfc_enable_fip
, S_IRUGO
, lpfc_enable_fip_show
, NULL
);
2018 static DEVICE_ATTR(board_mode
, S_IRUGO
| S_IWUSR
,
2019 lpfc_board_mode_show
, lpfc_board_mode_store
);
2020 static DEVICE_ATTR(issue_reset
, S_IWUSR
, NULL
, lpfc_issue_reset
);
2021 static DEVICE_ATTR(max_vpi
, S_IRUGO
, lpfc_max_vpi_show
, NULL
);
2022 static DEVICE_ATTR(used_vpi
, S_IRUGO
, lpfc_used_vpi_show
, NULL
);
2023 static DEVICE_ATTR(max_rpi
, S_IRUGO
, lpfc_max_rpi_show
, NULL
);
2024 static DEVICE_ATTR(used_rpi
, S_IRUGO
, lpfc_used_rpi_show
, NULL
);
2025 static DEVICE_ATTR(max_xri
, S_IRUGO
, lpfc_max_xri_show
, NULL
);
2026 static DEVICE_ATTR(used_xri
, S_IRUGO
, lpfc_used_xri_show
, NULL
);
2027 static DEVICE_ATTR(npiv_info
, S_IRUGO
, lpfc_npiv_info_show
, NULL
);
2028 static DEVICE_ATTR(lpfc_temp_sensor
, S_IRUGO
, lpfc_temp_sensor_show
, NULL
);
2029 static DEVICE_ATTR(lpfc_fips_level
, S_IRUGO
, lpfc_fips_level_show
, NULL
);
2030 static DEVICE_ATTR(lpfc_fips_rev
, S_IRUGO
, lpfc_fips_rev_show
, NULL
);
2031 static DEVICE_ATTR(lpfc_dss
, S_IRUGO
, lpfc_dss_show
, NULL
);
2032 static DEVICE_ATTR(lpfc_sriov_hw_max_virtfn
, S_IRUGO
,
2033 lpfc_sriov_hw_max_virtfn_show
, NULL
);
2034 static DEVICE_ATTR(protocol
, S_IRUGO
, lpfc_sli4_protocol_show
, NULL
);
2036 static char *lpfc_soft_wwn_key
= "C99G71SL8032A";
2039 * lpfc_soft_wwn_enable_store - Allows setting of the wwn if the key is valid
2040 * @dev: class device that is converted into a Scsi_host.
2041 * @attr: device attribute, not used.
2042 * @buf: containing the string lpfc_soft_wwn_key.
2043 * @count: must be size of lpfc_soft_wwn_key.
2046 * -EINVAL if the buffer does not contain lpfc_soft_wwn_key
2047 * length of buf indicates success
2050 lpfc_soft_wwn_enable_store(struct device
*dev
, struct device_attribute
*attr
,
2051 const char *buf
, size_t count
)
2053 struct Scsi_Host
*shost
= class_to_shost(dev
);
2054 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
2055 struct lpfc_hba
*phba
= vport
->phba
;
2056 unsigned int cnt
= count
;
2059 * We're doing a simple sanity check for soft_wwpn setting.
2060 * We require that the user write a specific key to enable
2061 * the soft_wwpn attribute to be settable. Once the attribute
2062 * is written, the enable key resets. If further updates are
2063 * desired, the key must be written again to re-enable the
2066 * The "key" is not secret - it is a hardcoded string shown
2067 * here. The intent is to protect against the random user or
2068 * application that is just writing attributes.
2071 /* count may include a LF at end of string */
2072 if (buf
[cnt
-1] == '\n')
2075 if ((cnt
!= strlen(lpfc_soft_wwn_key
)) ||
2076 (strncmp(buf
, lpfc_soft_wwn_key
, strlen(lpfc_soft_wwn_key
)) != 0))
2079 phba
->soft_wwn_enable
= 1;
2082 static DEVICE_ATTR(lpfc_soft_wwn_enable
, S_IWUSR
, NULL
,
2083 lpfc_soft_wwn_enable_store
);
2086 * lpfc_soft_wwpn_show - Return the cfg soft ww port name of the adapter
2087 * @dev: class device that is converted into a Scsi_host.
2088 * @attr: device attribute, not used.
2089 * @buf: on return contains the wwpn in hexadecimal.
2091 * Returns: size of formatted string.
2094 lpfc_soft_wwpn_show(struct device
*dev
, struct device_attribute
*attr
,
2097 struct Scsi_Host
*shost
= class_to_shost(dev
);
2098 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
2099 struct lpfc_hba
*phba
= vport
->phba
;
2101 return snprintf(buf
, PAGE_SIZE
, "0x%llx\n",
2102 (unsigned long long)phba
->cfg_soft_wwpn
);
2106 * lpfc_soft_wwpn_store - Set the ww port name of the adapter
2107 * @dev class device that is converted into a Scsi_host.
2108 * @attr: device attribute, not used.
2109 * @buf: contains the wwpn in hexadecimal.
2110 * @count: number of wwpn bytes in buf
2113 * -EACCES hba reset not enabled, adapter over temp
2114 * -EINVAL soft wwn not enabled, count is invalid, invalid wwpn byte invalid
2115 * -EIO error taking adapter offline or online
2116 * value of count on success
2119 lpfc_soft_wwpn_store(struct device
*dev
, struct device_attribute
*attr
,
2120 const char *buf
, size_t count
)
2122 struct Scsi_Host
*shost
= class_to_shost(dev
);
2123 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
2124 struct lpfc_hba
*phba
= vport
->phba
;
2125 struct completion online_compl
;
2126 int stat1
=0, stat2
=0;
2127 unsigned int i
, j
, cnt
=count
;
2131 if (!phba
->cfg_enable_hba_reset
)
2133 spin_lock_irq(&phba
->hbalock
);
2134 if (phba
->over_temp_state
== HBA_OVER_TEMP
) {
2135 spin_unlock_irq(&phba
->hbalock
);
2138 spin_unlock_irq(&phba
->hbalock
);
2139 /* count may include a LF at end of string */
2140 if (buf
[cnt
-1] == '\n')
2143 if (!phba
->soft_wwn_enable
|| (cnt
< 16) || (cnt
> 18) ||
2144 ((cnt
== 17) && (*buf
++ != 'x')) ||
2145 ((cnt
== 18) && ((*buf
++ != '0') || (*buf
++ != 'x'))))
2148 phba
->soft_wwn_enable
= 0;
2150 memset(wwpn
, 0, sizeof(wwpn
));
2152 /* Validate and store the new name */
2153 for (i
=0, j
=0; i
< 16; i
++) {
2156 value
= hex_to_bin(*buf
++);
2158 j
= (j
<< 4) | value
;
2162 wwpn
[i
/2] = j
& 0xff;
2166 phba
->cfg_soft_wwpn
= wwn_to_u64(wwpn
);
2167 fc_host_port_name(shost
) = phba
->cfg_soft_wwpn
;
2168 if (phba
->cfg_soft_wwnn
)
2169 fc_host_node_name(shost
) = phba
->cfg_soft_wwnn
;
2171 dev_printk(KERN_NOTICE
, &phba
->pcidev
->dev
,
2172 "lpfc%d: Reinitializing to use soft_wwpn\n", phba
->brd_no
);
2174 stat1
= lpfc_do_offline(phba
, LPFC_EVT_OFFLINE
);
2176 lpfc_printf_log(phba
, KERN_ERR
, LOG_INIT
,
2177 "0463 lpfc_soft_wwpn attribute set failed to "
2178 "reinit adapter - %d\n", stat1
);
2179 init_completion(&online_compl
);
2180 rc
= lpfc_workq_post_event(phba
, &stat2
, &online_compl
,
2185 wait_for_completion(&online_compl
);
2187 lpfc_printf_log(phba
, KERN_ERR
, LOG_INIT
,
2188 "0464 lpfc_soft_wwpn attribute set failed to "
2189 "reinit adapter - %d\n", stat2
);
2190 return (stat1
|| stat2
) ? -EIO
: count
;
2192 static DEVICE_ATTR(lpfc_soft_wwpn
, S_IRUGO
| S_IWUSR
,\
2193 lpfc_soft_wwpn_show
, lpfc_soft_wwpn_store
);
2196 * lpfc_soft_wwnn_show - Return the cfg soft ww node name for the adapter
2197 * @dev: class device that is converted into a Scsi_host.
2198 * @attr: device attribute, not used.
2199 * @buf: on return contains the wwnn in hexadecimal.
2201 * Returns: size of formatted string.
2204 lpfc_soft_wwnn_show(struct device
*dev
, struct device_attribute
*attr
,
2207 struct Scsi_Host
*shost
= class_to_shost(dev
);
2208 struct lpfc_hba
*phba
= ((struct lpfc_vport
*)shost
->hostdata
)->phba
;
2209 return snprintf(buf
, PAGE_SIZE
, "0x%llx\n",
2210 (unsigned long long)phba
->cfg_soft_wwnn
);
2214 * lpfc_soft_wwnn_store - sets the ww node name of the adapter
2215 * @cdev: class device that is converted into a Scsi_host.
2216 * @buf: contains the ww node name in hexadecimal.
2217 * @count: number of wwnn bytes in buf.
2220 * -EINVAL soft wwn not enabled, count is invalid, invalid wwnn byte invalid
2221 * value of count on success
2224 lpfc_soft_wwnn_store(struct device
*dev
, struct device_attribute
*attr
,
2225 const char *buf
, size_t count
)
2227 struct Scsi_Host
*shost
= class_to_shost(dev
);
2228 struct lpfc_hba
*phba
= ((struct lpfc_vport
*)shost
->hostdata
)->phba
;
2229 unsigned int i
, j
, cnt
=count
;
2232 /* count may include a LF at end of string */
2233 if (buf
[cnt
-1] == '\n')
2236 if (!phba
->soft_wwn_enable
|| (cnt
< 16) || (cnt
> 18) ||
2237 ((cnt
== 17) && (*buf
++ != 'x')) ||
2238 ((cnt
== 18) && ((*buf
++ != '0') || (*buf
++ != 'x'))))
2242 * Allow wwnn to be set many times, as long as the enable is set.
2243 * However, once the wwpn is set, everything locks.
2246 memset(wwnn
, 0, sizeof(wwnn
));
2248 /* Validate and store the new name */
2249 for (i
=0, j
=0; i
< 16; i
++) {
2252 value
= hex_to_bin(*buf
++);
2254 j
= (j
<< 4) | value
;
2258 wwnn
[i
/2] = j
& 0xff;
2262 phba
->cfg_soft_wwnn
= wwn_to_u64(wwnn
);
2264 dev_printk(KERN_NOTICE
, &phba
->pcidev
->dev
,
2265 "lpfc%d: soft_wwnn set. Value will take effect upon "
2266 "setting of the soft_wwpn\n", phba
->brd_no
);
2270 static DEVICE_ATTR(lpfc_soft_wwnn
, S_IRUGO
| S_IWUSR
,\
2271 lpfc_soft_wwnn_show
, lpfc_soft_wwnn_store
);
2274 static int lpfc_poll
= 0;
2275 module_param(lpfc_poll
, int, S_IRUGO
);
2276 MODULE_PARM_DESC(lpfc_poll
, "FCP ring polling mode control:"
2278 " 1 - poll with interrupts enabled"
2279 " 3 - poll and disable FCP ring interrupts");
2281 static DEVICE_ATTR(lpfc_poll
, S_IRUGO
| S_IWUSR
,
2282 lpfc_poll_show
, lpfc_poll_store
);
2284 int lpfc_sli_mode
= 0;
2285 module_param(lpfc_sli_mode
, int, S_IRUGO
);
2286 MODULE_PARM_DESC(lpfc_sli_mode
, "SLI mode selector:"
2287 " 0 - auto (SLI-3 if supported),"
2288 " 2 - select SLI-2 even on SLI-3 capable HBAs,"
2289 " 3 - select SLI-3");
2291 int lpfc_enable_npiv
= 1;
2292 module_param(lpfc_enable_npiv
, int, S_IRUGO
);
2293 MODULE_PARM_DESC(lpfc_enable_npiv
, "Enable NPIV functionality");
2294 lpfc_param_show(enable_npiv
);
2295 lpfc_param_init(enable_npiv
, 1, 0, 1);
2296 static DEVICE_ATTR(lpfc_enable_npiv
, S_IRUGO
, lpfc_enable_npiv_show
, NULL
);
2298 LPFC_ATTR_R(fcf_failover_policy
, 1, 1, 2,
2299 "FCF Fast failover=1 Priority failover=2");
2301 int lpfc_enable_rrq
;
2302 module_param(lpfc_enable_rrq
, int, S_IRUGO
);
2303 MODULE_PARM_DESC(lpfc_enable_rrq
, "Enable RRQ functionality");
2304 lpfc_param_show(enable_rrq
);
2305 lpfc_param_init(enable_rrq
, 0, 0, 1);
2306 static DEVICE_ATTR(lpfc_enable_rrq
, S_IRUGO
, lpfc_enable_rrq_show
, NULL
);
2309 # lpfc_suppress_link_up: Bring link up at initialization
2310 # 0x0 = bring link up (issue MBX_INIT_LINK)
2311 # 0x1 = do NOT bring link up at initialization(MBX_INIT_LINK)
2312 # 0x2 = never bring up link
2313 # Default value is 0.
2315 LPFC_ATTR_R(suppress_link_up
, LPFC_INITIALIZE_LINK
, LPFC_INITIALIZE_LINK
,
2316 LPFC_DELAY_INIT_LINK_INDEFINITELY
,
2317 "Suppress Link Up at initialization");
2319 # lpfc_cnt: Number of IOCBs allocated for ELS, CT, and ABTS
2327 lpfc_iocb_hw_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
2329 struct Scsi_Host
*shost
= class_to_shost(dev
);
2330 struct lpfc_hba
*phba
= ((struct lpfc_vport
*) shost
->hostdata
)->phba
;
2332 return snprintf(buf
, PAGE_SIZE
, "%d\n", phba
->iocb_max
);
2335 static DEVICE_ATTR(iocb_hw
, S_IRUGO
,
2336 lpfc_iocb_hw_show
, NULL
);
2338 lpfc_txq_hw_show(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
2340 struct Scsi_Host
*shost
= class_to_shost(dev
);
2341 struct lpfc_hba
*phba
= ((struct lpfc_vport
*) shost
->hostdata
)->phba
;
2343 return snprintf(buf
, PAGE_SIZE
, "%d\n",
2344 phba
->sli
.ring
[LPFC_ELS_RING
].txq_max
);
2347 static DEVICE_ATTR(txq_hw
, S_IRUGO
,
2348 lpfc_txq_hw_show
, NULL
);
2350 lpfc_txcmplq_hw_show(struct device
*dev
, struct device_attribute
*attr
,
2353 struct Scsi_Host
*shost
= class_to_shost(dev
);
2354 struct lpfc_hba
*phba
= ((struct lpfc_vport
*) shost
->hostdata
)->phba
;
2356 return snprintf(buf
, PAGE_SIZE
, "%d\n",
2357 phba
->sli
.ring
[LPFC_ELS_RING
].txcmplq_max
);
2360 static DEVICE_ATTR(txcmplq_hw
, S_IRUGO
,
2361 lpfc_txcmplq_hw_show
, NULL
);
2363 int lpfc_iocb_cnt
= 2;
2364 module_param(lpfc_iocb_cnt
, int, S_IRUGO
);
2365 MODULE_PARM_DESC(lpfc_iocb_cnt
,
2366 "Number of IOCBs alloc for ELS, CT, and ABTS: 1k to 5k IOCBs");
2367 lpfc_param_show(iocb_cnt
);
2368 lpfc_param_init(iocb_cnt
, 2, 1, 5);
2369 static DEVICE_ATTR(lpfc_iocb_cnt
, S_IRUGO
,
2370 lpfc_iocb_cnt_show
, NULL
);
2373 # lpfc_nodev_tmo: If set, it will hold all I/O errors on devices that disappear
2374 # until the timer expires. Value range is [0,255]. Default value is 30.
2376 static int lpfc_nodev_tmo
= LPFC_DEF_DEVLOSS_TMO
;
2377 static int lpfc_devloss_tmo
= LPFC_DEF_DEVLOSS_TMO
;
2378 module_param(lpfc_nodev_tmo
, int, 0);
2379 MODULE_PARM_DESC(lpfc_nodev_tmo
,
2380 "Seconds driver will hold I/O waiting "
2381 "for a device to come back");
2384 * lpfc_nodev_tmo_show - Return the hba dev loss timeout value
2385 * @dev: class converted to a Scsi_host structure.
2386 * @attr: device attribute, not used.
2387 * @buf: on return contains the dev loss timeout in decimal.
2389 * Returns: size of formatted string.
2392 lpfc_nodev_tmo_show(struct device
*dev
, struct device_attribute
*attr
,
2395 struct Scsi_Host
*shost
= class_to_shost(dev
);
2396 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
2398 return snprintf(buf
, PAGE_SIZE
, "%d\n", vport
->cfg_devloss_tmo
);
2402 * lpfc_nodev_tmo_init - Set the hba nodev timeout value
2403 * @vport: lpfc vport structure pointer.
2404 * @val: contains the nodev timeout value.
2407 * If the devloss tmo is already set then nodev tmo is set to devloss tmo,
2408 * a kernel error message is printed and zero is returned.
2409 * Else if val is in range then nodev tmo and devloss tmo are set to val.
2410 * Otherwise nodev tmo is set to the default value.
2413 * zero if already set or if val is in range
2414 * -EINVAL val out of range
2417 lpfc_nodev_tmo_init(struct lpfc_vport
*vport
, int val
)
2419 if (vport
->cfg_devloss_tmo
!= LPFC_DEF_DEVLOSS_TMO
) {
2420 vport
->cfg_nodev_tmo
= vport
->cfg_devloss_tmo
;
2421 if (val
!= LPFC_DEF_DEVLOSS_TMO
)
2422 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_INIT
,
2423 "0407 Ignoring nodev_tmo module "
2424 "parameter because devloss_tmo is "
2429 if (val
>= LPFC_MIN_DEVLOSS_TMO
&& val
<= LPFC_MAX_DEVLOSS_TMO
) {
2430 vport
->cfg_nodev_tmo
= val
;
2431 vport
->cfg_devloss_tmo
= val
;
2434 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_INIT
,
2435 "0400 lpfc_nodev_tmo attribute cannot be set to"
2436 " %d, allowed range is [%d, %d]\n",
2437 val
, LPFC_MIN_DEVLOSS_TMO
, LPFC_MAX_DEVLOSS_TMO
);
2438 vport
->cfg_nodev_tmo
= LPFC_DEF_DEVLOSS_TMO
;
2443 * lpfc_update_rport_devloss_tmo - Update dev loss tmo value
2444 * @vport: lpfc vport structure pointer.
2447 * Update all the ndlp's dev loss tmo with the vport devloss tmo value.
2450 lpfc_update_rport_devloss_tmo(struct lpfc_vport
*vport
)
2452 struct Scsi_Host
*shost
;
2453 struct lpfc_nodelist
*ndlp
;
2455 shost
= lpfc_shost_from_vport(vport
);
2456 spin_lock_irq(shost
->host_lock
);
2457 list_for_each_entry(ndlp
, &vport
->fc_nodes
, nlp_listp
)
2458 if (NLP_CHK_NODE_ACT(ndlp
) && ndlp
->rport
)
2459 ndlp
->rport
->dev_loss_tmo
= vport
->cfg_devloss_tmo
;
2460 spin_unlock_irq(shost
->host_lock
);
2464 * lpfc_nodev_tmo_set - Set the vport nodev tmo and devloss tmo values
2465 * @vport: lpfc vport structure pointer.
2466 * @val: contains the tmo value.
2469 * If the devloss tmo is already set or the vport dev loss tmo has changed
2470 * then a kernel error message is printed and zero is returned.
2471 * Else if val is in range then nodev tmo and devloss tmo are set to val.
2472 * Otherwise nodev tmo is set to the default value.
2475 * zero if already set or if val is in range
2476 * -EINVAL val out of range
2479 lpfc_nodev_tmo_set(struct lpfc_vport
*vport
, int val
)
2481 if (vport
->dev_loss_tmo_changed
||
2482 (lpfc_devloss_tmo
!= LPFC_DEF_DEVLOSS_TMO
)) {
2483 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_INIT
,
2484 "0401 Ignoring change to nodev_tmo "
2485 "because devloss_tmo is set.\n");
2488 if (val
>= LPFC_MIN_DEVLOSS_TMO
&& val
<= LPFC_MAX_DEVLOSS_TMO
) {
2489 vport
->cfg_nodev_tmo
= val
;
2490 vport
->cfg_devloss_tmo
= val
;
2492 * For compat: set the fc_host dev loss so new rports
2493 * will get the value.
2495 fc_host_dev_loss_tmo(lpfc_shost_from_vport(vport
)) = val
;
2496 lpfc_update_rport_devloss_tmo(vport
);
2499 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_INIT
,
2500 "0403 lpfc_nodev_tmo attribute cannot be set to"
2501 "%d, allowed range is [%d, %d]\n",
2502 val
, LPFC_MIN_DEVLOSS_TMO
, LPFC_MAX_DEVLOSS_TMO
);
2506 lpfc_vport_param_store(nodev_tmo
)
2508 static DEVICE_ATTR(lpfc_nodev_tmo
, S_IRUGO
| S_IWUSR
,
2509 lpfc_nodev_tmo_show
, lpfc_nodev_tmo_store
);
2512 # lpfc_devloss_tmo: If set, it will hold all I/O errors on devices that
2513 # disappear until the timer expires. Value range is [0,255]. Default
2516 module_param(lpfc_devloss_tmo
, int, S_IRUGO
);
2517 MODULE_PARM_DESC(lpfc_devloss_tmo
,
2518 "Seconds driver will hold I/O waiting "
2519 "for a device to come back");
2520 lpfc_vport_param_init(devloss_tmo
, LPFC_DEF_DEVLOSS_TMO
,
2521 LPFC_MIN_DEVLOSS_TMO
, LPFC_MAX_DEVLOSS_TMO
)
2522 lpfc_vport_param_show(devloss_tmo
)
2525 * lpfc_devloss_tmo_set - Sets vport nodev tmo, devloss tmo values, changed bit
2526 * @vport: lpfc vport structure pointer.
2527 * @val: contains the tmo value.
2530 * If val is in a valid range then set the vport nodev tmo,
2531 * devloss tmo, also set the vport dev loss tmo changed flag.
2532 * Else a kernel error message is printed.
2535 * zero if val is in range
2536 * -EINVAL val out of range
2539 lpfc_devloss_tmo_set(struct lpfc_vport
*vport
, int val
)
2541 if (val
>= LPFC_MIN_DEVLOSS_TMO
&& val
<= LPFC_MAX_DEVLOSS_TMO
) {
2542 vport
->cfg_nodev_tmo
= val
;
2543 vport
->cfg_devloss_tmo
= val
;
2544 vport
->dev_loss_tmo_changed
= 1;
2545 fc_host_dev_loss_tmo(lpfc_shost_from_vport(vport
)) = val
;
2546 lpfc_update_rport_devloss_tmo(vport
);
2550 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_INIT
,
2551 "0404 lpfc_devloss_tmo attribute cannot be set to"
2552 " %d, allowed range is [%d, %d]\n",
2553 val
, LPFC_MIN_DEVLOSS_TMO
, LPFC_MAX_DEVLOSS_TMO
);
2557 lpfc_vport_param_store(devloss_tmo
)
2558 static DEVICE_ATTR(lpfc_devloss_tmo
, S_IRUGO
| S_IWUSR
,
2559 lpfc_devloss_tmo_show
, lpfc_devloss_tmo_store
);
2562 # lpfc_log_verbose: Only turn this flag on if you are willing to risk being
2563 # deluged with LOTS of information.
2564 # You can set a bit mask to record specific types of verbose messages:
2565 # See lpfc_logmsh.h for definitions.
2567 LPFC_VPORT_ATTR_HEX_RW(log_verbose
, 0x0, 0x0, 0xffffffff,
2568 "Verbose logging bit-mask");
2571 # lpfc_enable_da_id: This turns on the DA_ID CT command that deregisters
2572 # objects that have been registered with the nameserver after login.
2574 LPFC_VPORT_ATTR_R(enable_da_id
, 0, 0, 1,
2575 "Deregister nameserver objects before LOGO");
2578 # lun_queue_depth: This parameter is used to limit the number of outstanding
2579 # commands per FCP LUN. Value range is [1,128]. Default value is 30.
2581 LPFC_VPORT_ATTR_R(lun_queue_depth
, 30, 1, 128,
2582 "Max number of FCP commands we can queue to a specific LUN");
2585 # tgt_queue_depth: This parameter is used to limit the number of outstanding
2586 # commands per target port. Value range is [10,65535]. Default value is 65535.
2588 LPFC_VPORT_ATTR_R(tgt_queue_depth
, 65535, 10, 65535,
2589 "Max number of FCP commands we can queue to a specific target port");
2592 # hba_queue_depth: This parameter is used to limit the number of outstanding
2593 # commands per lpfc HBA. Value range is [32,8192]. If this parameter
2594 # value is greater than the maximum number of exchanges supported by the HBA,
2595 # then maximum number of exchanges supported by the HBA is used to determine
2596 # the hba_queue_depth.
2598 LPFC_ATTR_R(hba_queue_depth
, 8192, 32, 8192,
2599 "Max number of FCP commands we can queue to a lpfc HBA");
2602 # peer_port_login: This parameter allows/prevents logins
2603 # between peer ports hosted on the same physical port.
2604 # When this parameter is set 0 peer ports of same physical port
2605 # are not allowed to login to each other.
2606 # When this parameter is set 1 peer ports of same physical port
2607 # are allowed to login to each other.
2608 # Default value of this parameter is 0.
2610 LPFC_VPORT_ATTR_R(peer_port_login
, 0, 0, 1,
2611 "Allow peer ports on the same physical port to login to each "
2615 # restrict_login: This parameter allows/prevents logins
2616 # between Virtual Ports and remote initiators.
2617 # When this parameter is not set (0) Virtual Ports will accept PLOGIs from
2618 # other initiators and will attempt to PLOGI all remote ports.
2619 # When this parameter is set (1) Virtual Ports will reject PLOGIs from
2620 # remote ports and will not attempt to PLOGI to other initiators.
2621 # This parameter does not restrict to the physical port.
2622 # This parameter does not restrict logins to Fabric resident remote ports.
2623 # Default value of this parameter is 1.
2625 static int lpfc_restrict_login
= 1;
2626 module_param(lpfc_restrict_login
, int, S_IRUGO
);
2627 MODULE_PARM_DESC(lpfc_restrict_login
,
2628 "Restrict virtual ports login to remote initiators.");
2629 lpfc_vport_param_show(restrict_login
);
2632 * lpfc_restrict_login_init - Set the vport restrict login flag
2633 * @vport: lpfc vport structure pointer.
2634 * @val: contains the restrict login value.
2637 * If val is not in a valid range then log a kernel error message and set
2638 * the vport restrict login to one.
2639 * If the port type is physical clear the restrict login flag and return.
2640 * Else set the restrict login flag to val.
2643 * zero if val is in range
2644 * -EINVAL val out of range
2647 lpfc_restrict_login_init(struct lpfc_vport
*vport
, int val
)
2649 if (val
< 0 || val
> 1) {
2650 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_INIT
,
2651 "0422 lpfc_restrict_login attribute cannot "
2652 "be set to %d, allowed range is [0, 1]\n",
2654 vport
->cfg_restrict_login
= 1;
2657 if (vport
->port_type
== LPFC_PHYSICAL_PORT
) {
2658 vport
->cfg_restrict_login
= 0;
2661 vport
->cfg_restrict_login
= val
;
2666 * lpfc_restrict_login_set - Set the vport restrict login flag
2667 * @vport: lpfc vport structure pointer.
2668 * @val: contains the restrict login value.
2671 * If val is not in a valid range then log a kernel error message and set
2672 * the vport restrict login to one.
2673 * If the port type is physical and the val is not zero log a kernel
2674 * error message, clear the restrict login flag and return zero.
2675 * Else set the restrict login flag to val.
2678 * zero if val is in range
2679 * -EINVAL val out of range
2682 lpfc_restrict_login_set(struct lpfc_vport
*vport
, int val
)
2684 if (val
< 0 || val
> 1) {
2685 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_INIT
,
2686 "0425 lpfc_restrict_login attribute cannot "
2687 "be set to %d, allowed range is [0, 1]\n",
2689 vport
->cfg_restrict_login
= 1;
2692 if (vport
->port_type
== LPFC_PHYSICAL_PORT
&& val
!= 0) {
2693 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_INIT
,
2694 "0468 lpfc_restrict_login must be 0 for "
2695 "Physical ports.\n");
2696 vport
->cfg_restrict_login
= 0;
2699 vport
->cfg_restrict_login
= val
;
2702 lpfc_vport_param_store(restrict_login
);
2703 static DEVICE_ATTR(lpfc_restrict_login
, S_IRUGO
| S_IWUSR
,
2704 lpfc_restrict_login_show
, lpfc_restrict_login_store
);
2707 # Some disk devices have a "select ID" or "select Target" capability.
2708 # From a protocol standpoint "select ID" usually means select the
2709 # Fibre channel "ALPA". In the FC-AL Profile there is an "informative
2710 # annex" which contains a table that maps a "select ID" (a number
2711 # between 0 and 7F) to an ALPA. By default, for compatibility with
2712 # older drivers, the lpfc driver scans this table from low ALPA to high
2715 # Turning on the scan-down variable (on = 1, off = 0) will
2716 # cause the lpfc driver to use an inverted table, effectively
2717 # scanning ALPAs from high to low. Value range is [0,1]. Default value is 1.
2719 # (Note: This "select ID" functionality is a LOOP ONLY characteristic
2720 # and will not work across a fabric. Also this parameter will take
2721 # effect only in the case when ALPA map is not available.)
2723 LPFC_VPORT_ATTR_R(scan_down
, 1, 0, 1,
2724 "Start scanning for devices from highest ALPA to lowest");
2727 # lpfc_topology: link topology for init link
2728 # 0x0 = attempt loop mode then point-to-point
2729 # 0x01 = internal loopback mode
2730 # 0x02 = attempt point-to-point mode only
2731 # 0x04 = attempt loop mode only
2732 # 0x06 = attempt point-to-point mode then loop
2733 # Set point-to-point mode if you want to run as an N_Port.
2734 # Set loop mode if you want to run as an NL_Port. Value range is [0,0x6].
2735 # Default value is 0.
2739 * lpfc_topology_set - Set the adapters topology field
2740 * @phba: lpfc_hba pointer.
2741 * @val: topology value.
2744 * If val is in a valid range then set the adapter's topology field and
2745 * issue a lip; if the lip fails reset the topology to the old value.
2747 * If the value is not in range log a kernel error message and return an error.
2750 * zero if val is in range and lip okay
2751 * non-zero return value from lpfc_issue_lip()
2752 * -EINVAL val out of range
2755 lpfc_topology_store(struct device
*dev
, struct device_attribute
*attr
,
2756 const char *buf
, size_t count
)
2758 struct Scsi_Host
*shost
= class_to_shost(dev
);
2759 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
2760 struct lpfc_hba
*phba
= vport
->phba
;
2763 const char *val_buf
= buf
;
2767 if (!strncmp(buf
, "nolip ", strlen("nolip "))) {
2769 val_buf
= &buf
[strlen("nolip ")];
2772 if (!isdigit(val_buf
[0]))
2774 if (sscanf(val_buf
, "%i", &val
) != 1)
2777 if (val
>= 0 && val
<= 6) {
2778 prev_val
= phba
->cfg_topology
;
2779 phba
->cfg_topology
= val
;
2783 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_INIT
,
2784 "3054 lpfc_topology changed from %d to %d\n",
2786 err
= lpfc_issue_lip(lpfc_shost_from_vport(phba
->pport
));
2788 phba
->cfg_topology
= prev_val
;
2793 lpfc_printf_log(phba
, KERN_ERR
, LOG_INIT
,
2794 "%d:0467 lpfc_topology attribute cannot be set to %d, "
2795 "allowed range is [0, 6]\n",
2799 static int lpfc_topology
= 0;
2800 module_param(lpfc_topology
, int, S_IRUGO
);
2801 MODULE_PARM_DESC(lpfc_topology
, "Select Fibre Channel topology");
2802 lpfc_param_show(topology
)
2803 lpfc_param_init(topology
, 0, 0, 6)
2804 static DEVICE_ATTR(lpfc_topology
, S_IRUGO
| S_IWUSR
,
2805 lpfc_topology_show
, lpfc_topology_store
);
2808 * lpfc_static_vport_show: Read callback function for
2809 * lpfc_static_vport sysfs file.
2810 * @dev: Pointer to class device object.
2811 * @attr: device attribute structure.
2812 * @buf: Data buffer.
2814 * This function is the read call back function for
2815 * lpfc_static_vport sysfs file. The lpfc_static_vport
2816 * sysfs file report the mageability of the vport.
2819 lpfc_static_vport_show(struct device
*dev
, struct device_attribute
*attr
,
2822 struct Scsi_Host
*shost
= class_to_shost(dev
);
2823 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
2824 if (vport
->vport_flag
& STATIC_VPORT
)
2825 sprintf(buf
, "1\n");
2827 sprintf(buf
, "0\n");
2833 * Sysfs attribute to control the statistical data collection.
2835 static DEVICE_ATTR(lpfc_static_vport
, S_IRUGO
,
2836 lpfc_static_vport_show
, NULL
);
2839 * lpfc_stat_data_ctrl_store - write call back for lpfc_stat_data_ctrl sysfs file
2840 * @dev: Pointer to class device.
2841 * @buf: Data buffer.
2842 * @count: Size of the data buffer.
2844 * This function get called when an user write to the lpfc_stat_data_ctrl
2845 * sysfs file. This function parse the command written to the sysfs file
2846 * and take appropriate action. These commands are used for controlling
2847 * driver statistical data collection.
2848 * Following are the command this function handles.
2850 * setbucket <bucket_type> <base> <step>
2851 * = Set the latency buckets.
2852 * destroybucket = destroy all the buckets.
2853 * start = start data collection
2854 * stop = stop data collection
2855 * reset = reset the collected data
2858 lpfc_stat_data_ctrl_store(struct device
*dev
, struct device_attribute
*attr
,
2859 const char *buf
, size_t count
)
2861 struct Scsi_Host
*shost
= class_to_shost(dev
);
2862 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
2863 struct lpfc_hba
*phba
= vport
->phba
;
2864 #define LPFC_MAX_DATA_CTRL_LEN 1024
2865 static char bucket_data
[LPFC_MAX_DATA_CTRL_LEN
];
2867 char *str_ptr
, *token
;
2868 struct lpfc_vport
**vports
;
2869 struct Scsi_Host
*v_shost
;
2870 char *bucket_type_str
, *base_str
, *step_str
;
2871 unsigned long base
, step
, bucket_type
;
2873 if (!strncmp(buf
, "setbucket", strlen("setbucket"))) {
2874 if (strlen(buf
) > (LPFC_MAX_DATA_CTRL_LEN
- 1))
2877 strcpy(bucket_data
, buf
);
2878 str_ptr
= &bucket_data
[0];
2879 /* Ignore this token - this is command token */
2880 token
= strsep(&str_ptr
, "\t ");
2884 bucket_type_str
= strsep(&str_ptr
, "\t ");
2885 if (!bucket_type_str
)
2888 if (!strncmp(bucket_type_str
, "linear", strlen("linear")))
2889 bucket_type
= LPFC_LINEAR_BUCKET
;
2890 else if (!strncmp(bucket_type_str
, "power2", strlen("power2")))
2891 bucket_type
= LPFC_POWER2_BUCKET
;
2895 base_str
= strsep(&str_ptr
, "\t ");
2898 base
= simple_strtoul(base_str
, NULL
, 0);
2900 step_str
= strsep(&str_ptr
, "\t ");
2903 step
= simple_strtoul(step_str
, NULL
, 0);
2907 /* Block the data collection for every vport */
2908 vports
= lpfc_create_vport_work_array(phba
);
2912 for (i
= 0; i
<= phba
->max_vports
&& vports
[i
] != NULL
; i
++) {
2913 v_shost
= lpfc_shost_from_vport(vports
[i
]);
2914 spin_lock_irq(v_shost
->host_lock
);
2915 /* Block and reset data collection */
2916 vports
[i
]->stat_data_blocked
= 1;
2917 if (vports
[i
]->stat_data_enabled
)
2918 lpfc_vport_reset_stat_data(vports
[i
]);
2919 spin_unlock_irq(v_shost
->host_lock
);
2922 /* Set the bucket attributes */
2923 phba
->bucket_type
= bucket_type
;
2924 phba
->bucket_base
= base
;
2925 phba
->bucket_step
= step
;
2927 for (i
= 0; i
<= phba
->max_vports
&& vports
[i
] != NULL
; i
++) {
2928 v_shost
= lpfc_shost_from_vport(vports
[i
]);
2930 /* Unblock data collection */
2931 spin_lock_irq(v_shost
->host_lock
);
2932 vports
[i
]->stat_data_blocked
= 0;
2933 spin_unlock_irq(v_shost
->host_lock
);
2935 lpfc_destroy_vport_work_array(phba
, vports
);
2939 if (!strncmp(buf
, "destroybucket", strlen("destroybucket"))) {
2940 vports
= lpfc_create_vport_work_array(phba
);
2944 for (i
= 0; i
<= phba
->max_vports
&& vports
[i
] != NULL
; i
++) {
2945 v_shost
= lpfc_shost_from_vport(vports
[i
]);
2946 spin_lock_irq(shost
->host_lock
);
2947 vports
[i
]->stat_data_blocked
= 1;
2948 lpfc_free_bucket(vport
);
2949 vport
->stat_data_enabled
= 0;
2950 vports
[i
]->stat_data_blocked
= 0;
2951 spin_unlock_irq(shost
->host_lock
);
2953 lpfc_destroy_vport_work_array(phba
, vports
);
2954 phba
->bucket_type
= LPFC_NO_BUCKET
;
2955 phba
->bucket_base
= 0;
2956 phba
->bucket_step
= 0;
2960 if (!strncmp(buf
, "start", strlen("start"))) {
2961 /* If no buckets configured return error */
2962 if (phba
->bucket_type
== LPFC_NO_BUCKET
)
2964 spin_lock_irq(shost
->host_lock
);
2965 if (vport
->stat_data_enabled
) {
2966 spin_unlock_irq(shost
->host_lock
);
2969 lpfc_alloc_bucket(vport
);
2970 vport
->stat_data_enabled
= 1;
2971 spin_unlock_irq(shost
->host_lock
);
2975 if (!strncmp(buf
, "stop", strlen("stop"))) {
2976 spin_lock_irq(shost
->host_lock
);
2977 if (vport
->stat_data_enabled
== 0) {
2978 spin_unlock_irq(shost
->host_lock
);
2981 lpfc_free_bucket(vport
);
2982 vport
->stat_data_enabled
= 0;
2983 spin_unlock_irq(shost
->host_lock
);
2987 if (!strncmp(buf
, "reset", strlen("reset"))) {
2988 if ((phba
->bucket_type
== LPFC_NO_BUCKET
)
2989 || !vport
->stat_data_enabled
)
2991 spin_lock_irq(shost
->host_lock
);
2992 vport
->stat_data_blocked
= 1;
2993 lpfc_vport_reset_stat_data(vport
);
2994 vport
->stat_data_blocked
= 0;
2995 spin_unlock_irq(shost
->host_lock
);
3003 * lpfc_stat_data_ctrl_show - Read function for lpfc_stat_data_ctrl sysfs file
3004 * @dev: Pointer to class device object.
3005 * @buf: Data buffer.
3007 * This function is the read call back function for
3008 * lpfc_stat_data_ctrl sysfs file. This function report the
3009 * current statistical data collection state.
3012 lpfc_stat_data_ctrl_show(struct device
*dev
, struct device_attribute
*attr
,
3015 struct Scsi_Host
*shost
= class_to_shost(dev
);
3016 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
3017 struct lpfc_hba
*phba
= vport
->phba
;
3021 unsigned long bucket_value
;
3023 switch (phba
->bucket_type
) {
3024 case LPFC_LINEAR_BUCKET
:
3025 bucket_type
= "linear";
3027 case LPFC_POWER2_BUCKET
:
3028 bucket_type
= "power2";
3031 bucket_type
= "No Bucket";
3035 sprintf(&buf
[index
], "Statistical Data enabled :%d, "
3036 "blocked :%d, Bucket type :%s, Bucket base :%d,"
3037 " Bucket step :%d\nLatency Ranges :",
3038 vport
->stat_data_enabled
, vport
->stat_data_blocked
,
3039 bucket_type
, phba
->bucket_base
, phba
->bucket_step
);
3040 index
= strlen(buf
);
3041 if (phba
->bucket_type
!= LPFC_NO_BUCKET
) {
3042 for (i
= 0; i
< LPFC_MAX_BUCKET_COUNT
; i
++) {
3043 if (phba
->bucket_type
== LPFC_LINEAR_BUCKET
)
3044 bucket_value
= phba
->bucket_base
+
3045 phba
->bucket_step
* i
;
3047 bucket_value
= phba
->bucket_base
+
3048 (1 << i
) * phba
->bucket_step
;
3050 if (index
+ 10 > PAGE_SIZE
)
3052 sprintf(&buf
[index
], "%08ld ", bucket_value
);
3053 index
= strlen(buf
);
3056 sprintf(&buf
[index
], "\n");
3061 * Sysfs attribute to control the statistical data collection.
3063 static DEVICE_ATTR(lpfc_stat_data_ctrl
, S_IRUGO
| S_IWUSR
,
3064 lpfc_stat_data_ctrl_show
, lpfc_stat_data_ctrl_store
);
3067 * lpfc_drvr_stat_data: sysfs attr to get driver statistical data.
3071 * Each Bucket takes 11 characters and 1 new line + 17 bytes WWN
3074 #define STAT_DATA_SIZE_PER_TARGET(NUM_BUCKETS) ((NUM_BUCKETS) * 11 + 18)
3075 #define MAX_STAT_DATA_SIZE_PER_TARGET \
3076 STAT_DATA_SIZE_PER_TARGET(LPFC_MAX_BUCKET_COUNT)
3080 * sysfs_drvr_stat_data_read - Read function for lpfc_drvr_stat_data attribute
3082 * @kobj: Pointer to the kernel object
3083 * @bin_attr: Attribute object
3084 * @buff: Buffer pointer
3086 * @count: Buffer size
3088 * This function is the read call back function for lpfc_drvr_stat_data
3089 * sysfs file. This function export the statistical data to user
3093 sysfs_drvr_stat_data_read(struct file
*filp
, struct kobject
*kobj
,
3094 struct bin_attribute
*bin_attr
,
3095 char *buf
, loff_t off
, size_t count
)
3097 struct device
*dev
= container_of(kobj
, struct device
,
3099 struct Scsi_Host
*shost
= class_to_shost(dev
);
3100 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
3101 struct lpfc_hba
*phba
= vport
->phba
;
3102 int i
= 0, index
= 0;
3103 unsigned long nport_index
;
3104 struct lpfc_nodelist
*ndlp
= NULL
;
3105 nport_index
= (unsigned long)off
/
3106 MAX_STAT_DATA_SIZE_PER_TARGET
;
3108 if (!vport
->stat_data_enabled
|| vport
->stat_data_blocked
3109 || (phba
->bucket_type
== LPFC_NO_BUCKET
))
3112 spin_lock_irq(shost
->host_lock
);
3113 list_for_each_entry(ndlp
, &vport
->fc_nodes
, nlp_listp
) {
3114 if (!NLP_CHK_NODE_ACT(ndlp
) || !ndlp
->lat_data
)
3117 if (nport_index
> 0) {
3122 if ((index
+ MAX_STAT_DATA_SIZE_PER_TARGET
)
3126 if (!ndlp
->lat_data
)
3130 sprintf(&buf
[index
], "%02x%02x%02x%02x%02x%02x%02x%02x:",
3131 ndlp
->nlp_portname
.u
.wwn
[0],
3132 ndlp
->nlp_portname
.u
.wwn
[1],
3133 ndlp
->nlp_portname
.u
.wwn
[2],
3134 ndlp
->nlp_portname
.u
.wwn
[3],
3135 ndlp
->nlp_portname
.u
.wwn
[4],
3136 ndlp
->nlp_portname
.u
.wwn
[5],
3137 ndlp
->nlp_portname
.u
.wwn
[6],
3138 ndlp
->nlp_portname
.u
.wwn
[7]);
3140 index
= strlen(buf
);
3142 for (i
= 0; i
< LPFC_MAX_BUCKET_COUNT
; i
++) {
3143 sprintf(&buf
[index
], "%010u,",
3144 ndlp
->lat_data
[i
].cmd_count
);
3145 index
= strlen(buf
);
3147 sprintf(&buf
[index
], "\n");
3148 index
= strlen(buf
);
3150 spin_unlock_irq(shost
->host_lock
);
3154 static struct bin_attribute sysfs_drvr_stat_data_attr
= {
3156 .name
= "lpfc_drvr_stat_data",
3159 .size
= LPFC_MAX_TARGET
* MAX_STAT_DATA_SIZE_PER_TARGET
,
3160 .read
= sysfs_drvr_stat_data_read
,
3165 # lpfc_link_speed: Link speed selection for initializing the Fibre Channel
3167 # Value range is [0,16]. Default value is 0.
3170 * lpfc_link_speed_set - Set the adapters link speed
3171 * @phba: lpfc_hba pointer.
3172 * @val: link speed value.
3175 * If val is in a valid range then set the adapter's link speed field and
3176 * issue a lip; if the lip fails reset the link speed to the old value.
3179 * If the value is not in range log a kernel error message and return an error.
3182 * zero if val is in range and lip okay.
3183 * non-zero return value from lpfc_issue_lip()
3184 * -EINVAL val out of range
3187 lpfc_link_speed_store(struct device
*dev
, struct device_attribute
*attr
,
3188 const char *buf
, size_t count
)
3190 struct Scsi_Host
*shost
= class_to_shost(dev
);
3191 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
3192 struct lpfc_hba
*phba
= vport
->phba
;
3193 int val
= LPFC_USER_LINK_SPEED_AUTO
;
3195 const char *val_buf
= buf
;
3199 if (!strncmp(buf
, "nolip ", strlen("nolip "))) {
3201 val_buf
= &buf
[strlen("nolip ")];
3204 if (!isdigit(val_buf
[0]))
3206 if (sscanf(val_buf
, "%i", &val
) != 1)
3209 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_INIT
,
3210 "3055 lpfc_link_speed changed from %d to %d %s\n",
3211 phba
->cfg_link_speed
, val
, nolip
? "(nolip)" : "(lip)");
3213 if (((val
== LPFC_USER_LINK_SPEED_1G
) && !(phba
->lmt
& LMT_1Gb
)) ||
3214 ((val
== LPFC_USER_LINK_SPEED_2G
) && !(phba
->lmt
& LMT_2Gb
)) ||
3215 ((val
== LPFC_USER_LINK_SPEED_4G
) && !(phba
->lmt
& LMT_4Gb
)) ||
3216 ((val
== LPFC_USER_LINK_SPEED_8G
) && !(phba
->lmt
& LMT_8Gb
)) ||
3217 ((val
== LPFC_USER_LINK_SPEED_10G
) && !(phba
->lmt
& LMT_10Gb
)) ||
3218 ((val
== LPFC_USER_LINK_SPEED_16G
) && !(phba
->lmt
& LMT_16Gb
))) {
3219 lpfc_printf_log(phba
, KERN_ERR
, LOG_INIT
,
3220 "2879 lpfc_link_speed attribute cannot be set "
3221 "to %d. Speed is not supported by this port.\n",
3225 if ((val
>= 0) && (val
<= LPFC_USER_LINK_SPEED_MAX
) &&
3226 (LPFC_USER_LINK_SPEED_BITMAP
& (1 << val
))) {
3227 prev_val
= phba
->cfg_link_speed
;
3228 phba
->cfg_link_speed
= val
;
3232 err
= lpfc_issue_lip(lpfc_shost_from_vport(phba
->pport
));
3234 phba
->cfg_link_speed
= prev_val
;
3239 lpfc_printf_log(phba
, KERN_ERR
, LOG_INIT
,
3240 "0469 lpfc_link_speed attribute cannot be set to %d, "
3241 "allowed values are ["LPFC_LINK_SPEED_STRING
"]\n", val
);
3245 static int lpfc_link_speed
= 0;
3246 module_param(lpfc_link_speed
, int, S_IRUGO
);
3247 MODULE_PARM_DESC(lpfc_link_speed
, "Select link speed");
3248 lpfc_param_show(link_speed
)
3251 * lpfc_link_speed_init - Set the adapters link speed
3252 * @phba: lpfc_hba pointer.
3253 * @val: link speed value.
3256 * If val is in a valid range then set the adapter's link speed field.
3259 * If the value is not in range log a kernel error message, clear the link
3260 * speed and return an error.
3263 * zero if val saved.
3264 * -EINVAL val out of range
3267 lpfc_link_speed_init(struct lpfc_hba
*phba
, int val
)
3269 if ((val
>= 0) && (val
<= LPFC_USER_LINK_SPEED_MAX
) &&
3270 (LPFC_USER_LINK_SPEED_BITMAP
& (1 << val
))) {
3271 phba
->cfg_link_speed
= val
;
3274 lpfc_printf_log(phba
, KERN_ERR
, LOG_INIT
,
3275 "0405 lpfc_link_speed attribute cannot "
3276 "be set to %d, allowed values are "
3277 "["LPFC_LINK_SPEED_STRING
"]\n", val
);
3278 phba
->cfg_link_speed
= LPFC_USER_LINK_SPEED_AUTO
;
3282 static DEVICE_ATTR(lpfc_link_speed
, S_IRUGO
| S_IWUSR
,
3283 lpfc_link_speed_show
, lpfc_link_speed_store
);
3286 # lpfc_aer_support: Support PCIe device Advanced Error Reporting (AER)
3287 # 0 = aer disabled or not supported
3288 # 1 = aer supported and enabled (default)
3289 # Value range is [0,1]. Default value is 1.
3293 * lpfc_aer_support_store - Set the adapter for aer support
3295 * @dev: class device that is converted into a Scsi_host.
3296 * @attr: device attribute, not used.
3297 * @buf: containing enable or disable aer flag.
3298 * @count: unused variable.
3301 * If the val is 1 and currently the device's AER capability was not
3302 * enabled, invoke the kernel's enable AER helper routine, trying to
3303 * enable the device's AER capability. If the helper routine enabling
3304 * AER returns success, update the device's cfg_aer_support flag to
3305 * indicate AER is supported by the device; otherwise, if the device
3306 * AER capability is already enabled to support AER, then do nothing.
3308 * If the val is 0 and currently the device's AER support was enabled,
3309 * invoke the kernel's disable AER helper routine. After that, update
3310 * the device's cfg_aer_support flag to indicate AER is not supported
3311 * by the device; otherwise, if the device AER capability is already
3312 * disabled from supporting AER, then do nothing.
3315 * length of the buf on success if val is in range the intended mode
3317 * -EINVAL if val out of range or intended mode is not supported.
3320 lpfc_aer_support_store(struct device
*dev
, struct device_attribute
*attr
,
3321 const char *buf
, size_t count
)
3323 struct Scsi_Host
*shost
= class_to_shost(dev
);
3324 struct lpfc_vport
*vport
= (struct lpfc_vport
*)shost
->hostdata
;
3325 struct lpfc_hba
*phba
= vport
->phba
;
3326 int val
= 0, rc
= -EINVAL
;
3328 if (!isdigit(buf
[0]))
3330 if (sscanf(buf
, "%i", &val
) != 1)
3335 if (phba
->hba_flag
& HBA_AER_ENABLED
) {
3336 rc
= pci_disable_pcie_error_reporting(phba
->pcidev
);
3338 spin_lock_irq(&phba
->hbalock
);
3339 phba
->hba_flag
&= ~HBA_AER_ENABLED
;
3340 spin_unlock_irq(&phba
->hbalock
);
3341 phba
->cfg_aer_support
= 0;
3346 phba
->cfg_aer_support
= 0;
3351 if (!(phba
->hba_flag
& HBA_AER_ENABLED
)) {
3352 rc
= pci_enable_pcie_error_reporting(phba
->pcidev
);
3354 spin_lock_irq(&phba
->hbalock
);
3355 phba
->hba_flag
|= HBA_AER_ENABLED
;
3356 spin_unlock_irq(&phba
->hbalock
);
3357 phba
->cfg_aer_support
= 1;
3362 phba
->cfg_aer_support
= 1;
3373 static int lpfc_aer_support
= 1;
3374 module_param(lpfc_aer_support
, int, S_IRUGO
);
3375 MODULE_PARM_DESC(lpfc_aer_support
, "Enable PCIe device AER support");
3376 lpfc_param_show(aer_support
)
3379 * lpfc_aer_support_init - Set the initial adapters aer support flag
3380 * @phba: lpfc_hba pointer.
3381 * @val: enable aer or disable aer flag.
3384 * If val is in a valid range [0,1], then set the adapter's initial
3385 * cfg_aer_support field. It will be up to the driver's probe_one
3386 * routine to determine whether the device's AER support can be set
3390 * If the value is not in range log a kernel error message, and
3391 * choose the default value of setting AER support and return.
3394 * zero if val saved.
3395 * -EINVAL val out of range
3398 lpfc_aer_support_init(struct lpfc_hba
*phba
, int val
)
3400 if (val
== 0 || val
== 1) {
3401 phba
->cfg_aer_support
= val
;
3404 lpfc_printf_log(phba
, KERN_ERR
, LOG_INIT
,
3405 "2712 lpfc_aer_support attribute value %d out "
3406 "of range, allowed values are 0|1, setting it "
3407 "to default value of 1\n", val
);
3408 /* By default, try to enable AER on a device */
3409 phba
->cfg_aer_support
= 1;
3413 static DEVICE_ATTR(lpfc_aer_support
, S_IRUGO
| S_IWUSR
,
3414 lpfc_aer_support_show
, lpfc_aer_support_store
);
3417 * lpfc_aer_cleanup_state - Clean up aer state to the aer enabled device
3418 * @dev: class device that is converted into a Scsi_host.
3419 * @attr: device attribute, not used.
3420 * @buf: containing flag 1 for aer cleanup state.
3421 * @count: unused variable.
3424 * If the @buf contains 1 and the device currently has the AER support
3425 * enabled, then invokes the kernel AER helper routine
3426 * pci_cleanup_aer_uncorrect_error_status to clean up the uncorrectable
3427 * error status register.
3432 * -EINVAL if the buf does not contain the 1 or the device is not currently
3433 * enabled with the AER support.
3436 lpfc_aer_cleanup_state(struct device
*dev
, struct device_attribute
*attr
,
3437 const char *buf
, size_t count
)
3439 struct Scsi_Host
*shost
= class_to_shost(dev
);
3440 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
3441 struct lpfc_hba
*phba
= vport
->phba
;
3444 if (!isdigit(buf
[0]))
3446 if (sscanf(buf
, "%i", &val
) != 1)
3451 if (phba
->hba_flag
& HBA_AER_ENABLED
)
3452 rc
= pci_cleanup_aer_uncorrect_error_status(phba
->pcidev
);
3460 static DEVICE_ATTR(lpfc_aer_state_cleanup
, S_IWUSR
, NULL
,
3461 lpfc_aer_cleanup_state
);
3464 * lpfc_sriov_nr_virtfn_store - Enable the adapter for sr-iov virtual functions
3466 * @dev: class device that is converted into a Scsi_host.
3467 * @attr: device attribute, not used.
3468 * @buf: containing the string the number of vfs to be enabled.
3469 * @count: unused variable.
3472 * When this api is called either through user sysfs, the driver shall
3473 * try to enable or disable SR-IOV virtual functions according to the
3476 * If zero virtual function has been enabled to the physical function,
3477 * the driver shall invoke the pci enable virtual function api trying
3478 * to enable the virtual functions. If the nr_vfn provided is greater
3479 * than the maximum supported, the maximum virtual function number will
3480 * be used for invoking the api; otherwise, the nr_vfn provided shall
3481 * be used for invoking the api. If the api call returned success, the
3482 * actual number of virtual functions enabled will be set to the driver
3483 * cfg_sriov_nr_virtfn; otherwise, -EINVAL shall be returned and driver
3484 * cfg_sriov_nr_virtfn remains zero.
3486 * If none-zero virtual functions have already been enabled to the
3487 * physical function, as reflected by the driver's cfg_sriov_nr_virtfn,
3488 * -EINVAL will be returned and the driver does nothing;
3490 * If the nr_vfn provided is zero and none-zero virtual functions have
3491 * been enabled, as indicated by the driver's cfg_sriov_nr_virtfn, the
3492 * disabling virtual function api shall be invoded to disable all the
3493 * virtual functions and driver's cfg_sriov_nr_virtfn shall be set to
3494 * zero. Otherwise, if zero virtual function has been enabled, do
3498 * length of the buf on success if val is in range the intended mode
3500 * -EINVAL if val out of range or intended mode is not supported.
3503 lpfc_sriov_nr_virtfn_store(struct device
*dev
, struct device_attribute
*attr
,
3504 const char *buf
, size_t count
)
3506 struct Scsi_Host
*shost
= class_to_shost(dev
);
3507 struct lpfc_vport
*vport
= (struct lpfc_vport
*)shost
->hostdata
;
3508 struct lpfc_hba
*phba
= vport
->phba
;
3509 struct pci_dev
*pdev
= phba
->pcidev
;
3510 int val
= 0, rc
= -EINVAL
;
3512 /* Sanity check on user data */
3513 if (!isdigit(buf
[0]))
3515 if (sscanf(buf
, "%i", &val
) != 1)
3520 /* Request disabling virtual functions */
3522 if (phba
->cfg_sriov_nr_virtfn
> 0) {
3523 pci_disable_sriov(pdev
);
3524 phba
->cfg_sriov_nr_virtfn
= 0;
3529 /* Request enabling virtual functions */
3530 if (phba
->cfg_sriov_nr_virtfn
> 0) {
3531 lpfc_printf_log(phba
, KERN_ERR
, LOG_INIT
,
3532 "3018 There are %d virtual functions "
3533 "enabled on physical function.\n",
3534 phba
->cfg_sriov_nr_virtfn
);
3538 if (val
<= LPFC_MAX_VFN_PER_PFN
)
3539 phba
->cfg_sriov_nr_virtfn
= val
;
3541 lpfc_printf_log(phba
, KERN_ERR
, LOG_INIT
,
3542 "3019 Enabling %d virtual functions is not "
3547 rc
= lpfc_sli_probe_sriov_nr_virtfn(phba
, phba
->cfg_sriov_nr_virtfn
);
3549 phba
->cfg_sriov_nr_virtfn
= 0;
3557 static int lpfc_sriov_nr_virtfn
= LPFC_DEF_VFN_PER_PFN
;
3558 module_param(lpfc_sriov_nr_virtfn
, int, S_IRUGO
|S_IWUSR
);
3559 MODULE_PARM_DESC(lpfc_sriov_nr_virtfn
, "Enable PCIe device SR-IOV virtual fn");
3560 lpfc_param_show(sriov_nr_virtfn
)
3563 * lpfc_sriov_nr_virtfn_init - Set the initial sr-iov virtual function enable
3564 * @phba: lpfc_hba pointer.
3565 * @val: link speed value.
3568 * If val is in a valid range [0,255], then set the adapter's initial
3569 * cfg_sriov_nr_virtfn field. If it's greater than the maximum, the maximum
3570 * number shall be used instead. It will be up to the driver's probe_one
3571 * routine to determine whether the device's SR-IOV is supported or not.
3574 * zero if val saved.
3575 * -EINVAL val out of range
3578 lpfc_sriov_nr_virtfn_init(struct lpfc_hba
*phba
, int val
)
3580 if (val
>= 0 && val
<= LPFC_MAX_VFN_PER_PFN
) {
3581 phba
->cfg_sriov_nr_virtfn
= val
;
3585 lpfc_printf_log(phba
, KERN_ERR
, LOG_INIT
,
3586 "3017 Enabling %d virtual functions is not "
3590 static DEVICE_ATTR(lpfc_sriov_nr_virtfn
, S_IRUGO
| S_IWUSR
,
3591 lpfc_sriov_nr_virtfn_show
, lpfc_sriov_nr_virtfn_store
);
3594 # lpfc_fcp_class: Determines FC class to use for the FCP protocol.
3595 # Value range is [2,3]. Default value is 3.
3597 LPFC_VPORT_ATTR_R(fcp_class
, 3, 2, 3,
3598 "Select Fibre Channel class of service for FCP sequences");
3601 # lpfc_use_adisc: Use ADISC for FCP rediscovery instead of PLOGI. Value range
3602 # is [0,1]. Default value is 0.
3604 LPFC_VPORT_ATTR_RW(use_adisc
, 0, 0, 1,
3605 "Use ADISC on rediscovery to authenticate FCP devices");
3608 # lpfc_max_scsicmpl_time: Use scsi command completion time to control I/O queue
3609 # depth. Default value is 0. When the value of this parameter is zero the
3610 # SCSI command completion time is not used for controlling I/O queue depth. When
3611 # the parameter is set to a non-zero value, the I/O queue depth is controlled
3612 # to limit the I/O completion time to the parameter value.
3613 # The value is set in milliseconds.
3615 static int lpfc_max_scsicmpl_time
;
3616 module_param(lpfc_max_scsicmpl_time
, int, S_IRUGO
);
3617 MODULE_PARM_DESC(lpfc_max_scsicmpl_time
,
3618 "Use command completion time to control queue depth");
3619 lpfc_vport_param_show(max_scsicmpl_time
);
3620 lpfc_vport_param_init(max_scsicmpl_time
, 0, 0, 60000);
3622 lpfc_max_scsicmpl_time_set(struct lpfc_vport
*vport
, int val
)
3624 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
3625 struct lpfc_nodelist
*ndlp
, *next_ndlp
;
3627 if (val
== vport
->cfg_max_scsicmpl_time
)
3629 if ((val
< 0) || (val
> 60000))
3631 vport
->cfg_max_scsicmpl_time
= val
;
3633 spin_lock_irq(shost
->host_lock
);
3634 list_for_each_entry_safe(ndlp
, next_ndlp
, &vport
->fc_nodes
, nlp_listp
) {
3635 if (!NLP_CHK_NODE_ACT(ndlp
))
3637 if (ndlp
->nlp_state
== NLP_STE_UNUSED_NODE
)
3639 ndlp
->cmd_qdepth
= vport
->cfg_tgt_queue_depth
;
3641 spin_unlock_irq(shost
->host_lock
);
3644 lpfc_vport_param_store(max_scsicmpl_time
);
3645 static DEVICE_ATTR(lpfc_max_scsicmpl_time
, S_IRUGO
| S_IWUSR
,
3646 lpfc_max_scsicmpl_time_show
,
3647 lpfc_max_scsicmpl_time_store
);
3650 # lpfc_ack0: Use ACK0, instead of ACK1 for class 2 acknowledgement. Value
3651 # range is [0,1]. Default value is 0.
3653 LPFC_ATTR_R(ack0
, 0, 0, 1, "Enable ACK0 support");
3656 # lpfc_cr_delay & lpfc_cr_count: Default values for I/O colaesing
3657 # cr_delay (msec) or cr_count outstanding commands. cr_delay can take
3658 # value [0,63]. cr_count can take value [1,255]. Default value of cr_delay
3659 # is 0. Default value of cr_count is 1. The cr_count feature is disabled if
3660 # cr_delay is set to 0.
3662 LPFC_ATTR_RW(cr_delay
, 0, 0, 63, "A count of milliseconds after which an "
3663 "interrupt response is generated");
3665 LPFC_ATTR_RW(cr_count
, 1, 1, 255, "A count of I/O completions after which an "
3666 "interrupt response is generated");
3669 # lpfc_multi_ring_support: Determines how many rings to spread available
3670 # cmd/rsp IOCB entries across.
3671 # Value range is [1,2]. Default value is 1.
3673 LPFC_ATTR_R(multi_ring_support
, 1, 1, 2, "Determines number of primary "
3674 "SLI rings to spread IOCB entries across");
3677 # lpfc_multi_ring_rctl: If lpfc_multi_ring_support is enabled, this
3678 # identifies what rctl value to configure the additional ring for.
3679 # Value range is [1,0xff]. Default value is 4 (Unsolicated Data).
3681 LPFC_ATTR_R(multi_ring_rctl
, FC_RCTL_DD_UNSOL_DATA
, 1,
3682 255, "Identifies RCTL for additional ring configuration");
3685 # lpfc_multi_ring_type: If lpfc_multi_ring_support is enabled, this
3686 # identifies what type value to configure the additional ring for.
3687 # Value range is [1,0xff]. Default value is 5 (LLC/SNAP).
3689 LPFC_ATTR_R(multi_ring_type
, FC_TYPE_IP
, 1,
3690 255, "Identifies TYPE for additional ring configuration");
3693 # lpfc_fdmi_on: controls FDMI support.
3694 # 0 = no FDMI support
3695 # 1 = support FDMI without attribute of hostname
3696 # 2 = support FDMI with attribute of hostname
3697 # Value range [0,2]. Default value is 0.
3699 LPFC_VPORT_ATTR_RW(fdmi_on
, 0, 0, 2, "Enable FDMI support");
3702 # Specifies the maximum number of ELS cmds we can have outstanding (for
3703 # discovery). Value range is [1,64]. Default value = 32.
3705 LPFC_VPORT_ATTR(discovery_threads
, 32, 1, 64, "Maximum number of ELS commands "
3706 "during discovery");
3709 # lpfc_max_luns: maximum allowed LUN.
3710 # Value range is [0,65535]. Default value is 255.
3711 # NOTE: The SCSI layer might probe all allowed LUN on some old targets.
3713 LPFC_VPORT_ATTR_R(max_luns
, 255, 0, 65535, "Maximum allowed LUN");
3716 # lpfc_poll_tmo: .Milliseconds driver will wait between polling FCP ring.
3717 # Value range is [1,255], default value is 10.
3719 LPFC_ATTR_RW(poll_tmo
, 10, 1, 255,
3720 "Milliseconds driver will wait between polling FCP ring");
3723 # lpfc_use_msi: Use MSI (Message Signaled Interrupts) in systems that
3724 # support this feature
3727 # 2 = MSI-X enabled (default)
3728 # Value range is [0,2]. Default value is 2.
3730 LPFC_ATTR_R(use_msi
, 2, 0, 2, "Use Message Signaled Interrupts (1) or "
3731 "MSI-X (2), if possible");
3734 # lpfc_fcp_imax: Set the maximum number of fast-path FCP interrupts per second
3736 # Value range is [636,651042]. Default value is 10000.
3738 LPFC_ATTR_R(fcp_imax
, LPFC_FP_DEF_IMAX
, LPFC_MIM_IMAX
, LPFC_DMULT_CONST
,
3739 "Set the maximum number of fast-path FCP interrupts per second");
3742 # lpfc_fcp_wq_count: Set the number of fast-path FCP work queues
3744 # Value range is [1,31]. Default value is 4.
3746 LPFC_ATTR_R(fcp_wq_count
, LPFC_FP_WQN_DEF
, LPFC_FP_WQN_MIN
, LPFC_FP_WQN_MAX
,
3747 "Set the number of fast-path FCP work queues, if possible");
3750 # lpfc_fcp_eq_count: Set the number of fast-path FCP event queues
3752 # Value range is [1,7]. Default value is 1.
3754 LPFC_ATTR_R(fcp_eq_count
, LPFC_FP_EQN_DEF
, LPFC_FP_EQN_MIN
, LPFC_FP_EQN_MAX
,
3755 "Set the number of fast-path FCP event queues, if possible");
3758 # lpfc_enable_hba_reset: Allow or prevent HBA resets to the hardware.
3759 # 0 = HBA resets disabled
3760 # 1 = HBA resets enabled (default)
3761 # Value range is [0,1]. Default value is 1.
3763 LPFC_ATTR_R(enable_hba_reset
, 1, 0, 1, "Enable HBA resets from the driver.");
3766 # lpfc_enable_hba_heartbeat: Disable HBA heartbeat timer..
3767 # 0 = HBA Heartbeat disabled
3768 # 1 = HBA Heartbeat enabled (default)
3769 # Value range is [0,1]. Default value is 1.
3771 LPFC_ATTR_R(enable_hba_heartbeat
, 0, 0, 1, "Enable HBA Heartbeat.");
3774 # lpfc_enable_bg: Enable BlockGuard (Emulex's Implementation of T10-DIF)
3775 # 0 = BlockGuard disabled (default)
3776 # 1 = BlockGuard enabled
3777 # Value range is [0,1]. Default value is 0.
3779 LPFC_ATTR_R(enable_bg
, 0, 0, 1, "Enable BlockGuard Support");
3783 # - Bit mask of host protection capabilities used to register with the
3785 # - Only meaningful if BG is turned on (lpfc_enable_bg=1).
3786 # - Allows you to ultimately specify which profiles to use
3787 # - Default will result in registering capabilities for all profiles.
3790 unsigned int lpfc_prot_mask
= SHOST_DIF_TYPE1_PROTECTION
|
3791 SHOST_DIX_TYPE0_PROTECTION
|
3792 SHOST_DIX_TYPE1_PROTECTION
;
3794 module_param(lpfc_prot_mask
, uint
, S_IRUGO
);
3795 MODULE_PARM_DESC(lpfc_prot_mask
, "host protection mask");
3798 # lpfc_prot_guard: i
3799 # - Bit mask of protection guard types to register with the SCSI mid-layer
3800 # - Guard types are currently either 1) IP checksum 2) T10-DIF CRC
3801 # - Allows you to ultimately specify which profiles to use
3802 # - Default will result in registering capabilities for all guard types
3805 unsigned char lpfc_prot_guard
= SHOST_DIX_GUARD_IP
;
3806 module_param(lpfc_prot_guard
, byte
, S_IRUGO
);
3807 MODULE_PARM_DESC(lpfc_prot_guard
, "host protection guard type");
3810 * Delay initial NPort discovery when Clean Address bit is cleared in
3811 * FLOGI/FDISC accept and FCID/Fabric name/Fabric portname is changed.
3812 * This parameter can have value 0 or 1.
3813 * When this parameter is set to 0, no delay is added to the initial
3815 * When this parameter is set to non-zero value, initial Nport discovery is
3816 * delayed by ra_tov seconds when Clean Address bit is cleared in FLOGI/FDISC
3817 * accept and FCID/Fabric name/Fabric portname is changed.
3818 * Driver always delay Nport discovery for subsequent FLOGI/FDISC completion
3819 * when Clean Address bit is cleared in FLOGI/FDISC
3820 * accept and FCID/Fabric name/Fabric portname is changed.
3821 * Default value is 0.
3823 int lpfc_delay_discovery
;
3824 module_param(lpfc_delay_discovery
, int, S_IRUGO
);
3825 MODULE_PARM_DESC(lpfc_delay_discovery
,
3826 "Delay NPort discovery when Clean Address bit is cleared. "
3827 "Allowed values: 0,1.");
3830 * lpfc_sg_seg_cnt - Initial Maximum DMA Segment Count
3831 * This value can be set to values between 64 and 256. The default value is
3832 * 64, but may be increased to allow for larger Max I/O sizes. The scsi layer
3833 * will be allowed to request I/Os of sizes up to (MAX_SEG_COUNT * SEG_SIZE).
3835 LPFC_ATTR_R(sg_seg_cnt
, LPFC_DEFAULT_SG_SEG_CNT
, LPFC_DEFAULT_SG_SEG_CNT
,
3836 LPFC_MAX_SG_SEG_CNT
, "Max Scatter Gather Segment Count");
3838 LPFC_ATTR_R(prot_sg_seg_cnt
, LPFC_DEFAULT_PROT_SG_SEG_CNT
,
3839 LPFC_DEFAULT_PROT_SG_SEG_CNT
, LPFC_MAX_PROT_SG_SEG_CNT
,
3840 "Max Protection Scatter Gather Segment Count");
3842 struct device_attribute
*lpfc_hba_attrs
[] = {
3844 &dev_attr_bg_guard_err
,
3845 &dev_attr_bg_apptag_err
,
3846 &dev_attr_bg_reftag_err
,
3848 &dev_attr_serialnum
,
3849 &dev_attr_modeldesc
,
3850 &dev_attr_modelname
,
3851 &dev_attr_programtype
,
3855 &dev_attr_option_rom_version
,
3856 &dev_attr_link_state
,
3857 &dev_attr_num_discovered_ports
,
3858 &dev_attr_menlo_mgmt_mode
,
3859 &dev_attr_lpfc_drvr_version
,
3860 &dev_attr_lpfc_enable_fip
,
3861 &dev_attr_lpfc_temp_sensor
,
3862 &dev_attr_lpfc_log_verbose
,
3863 &dev_attr_lpfc_lun_queue_depth
,
3864 &dev_attr_lpfc_tgt_queue_depth
,
3865 &dev_attr_lpfc_hba_queue_depth
,
3866 &dev_attr_lpfc_peer_port_login
,
3867 &dev_attr_lpfc_nodev_tmo
,
3868 &dev_attr_lpfc_devloss_tmo
,
3869 &dev_attr_lpfc_fcp_class
,
3870 &dev_attr_lpfc_use_adisc
,
3871 &dev_attr_lpfc_ack0
,
3872 &dev_attr_lpfc_topology
,
3873 &dev_attr_lpfc_scan_down
,
3874 &dev_attr_lpfc_link_speed
,
3875 &dev_attr_lpfc_cr_delay
,
3876 &dev_attr_lpfc_cr_count
,
3877 &dev_attr_lpfc_multi_ring_support
,
3878 &dev_attr_lpfc_multi_ring_rctl
,
3879 &dev_attr_lpfc_multi_ring_type
,
3880 &dev_attr_lpfc_fdmi_on
,
3881 &dev_attr_lpfc_max_luns
,
3882 &dev_attr_lpfc_enable_npiv
,
3883 &dev_attr_lpfc_fcf_failover_policy
,
3884 &dev_attr_lpfc_enable_rrq
,
3885 &dev_attr_nport_evt_cnt
,
3886 &dev_attr_board_mode
,
3893 &dev_attr_npiv_info
,
3894 &dev_attr_issue_reset
,
3895 &dev_attr_lpfc_poll
,
3896 &dev_attr_lpfc_poll_tmo
,
3897 &dev_attr_lpfc_use_msi
,
3898 &dev_attr_lpfc_fcp_imax
,
3899 &dev_attr_lpfc_fcp_wq_count
,
3900 &dev_attr_lpfc_fcp_eq_count
,
3901 &dev_attr_lpfc_enable_bg
,
3902 &dev_attr_lpfc_soft_wwnn
,
3903 &dev_attr_lpfc_soft_wwpn
,
3904 &dev_attr_lpfc_soft_wwn_enable
,
3905 &dev_attr_lpfc_enable_hba_reset
,
3906 &dev_attr_lpfc_enable_hba_heartbeat
,
3907 &dev_attr_lpfc_sg_seg_cnt
,
3908 &dev_attr_lpfc_max_scsicmpl_time
,
3909 &dev_attr_lpfc_stat_data_ctrl
,
3910 &dev_attr_lpfc_prot_sg_seg_cnt
,
3911 &dev_attr_lpfc_aer_support
,
3912 &dev_attr_lpfc_aer_state_cleanup
,
3913 &dev_attr_lpfc_sriov_nr_virtfn
,
3914 &dev_attr_lpfc_suppress_link_up
,
3915 &dev_attr_lpfc_iocb_cnt
,
3918 &dev_attr_txcmplq_hw
,
3919 &dev_attr_lpfc_fips_level
,
3920 &dev_attr_lpfc_fips_rev
,
3922 &dev_attr_lpfc_sriov_hw_max_virtfn
,
3927 struct device_attribute
*lpfc_vport_attrs
[] = {
3929 &dev_attr_link_state
,
3930 &dev_attr_num_discovered_ports
,
3931 &dev_attr_lpfc_drvr_version
,
3932 &dev_attr_lpfc_log_verbose
,
3933 &dev_attr_lpfc_lun_queue_depth
,
3934 &dev_attr_lpfc_tgt_queue_depth
,
3935 &dev_attr_lpfc_nodev_tmo
,
3936 &dev_attr_lpfc_devloss_tmo
,
3937 &dev_attr_lpfc_hba_queue_depth
,
3938 &dev_attr_lpfc_peer_port_login
,
3939 &dev_attr_lpfc_restrict_login
,
3940 &dev_attr_lpfc_fcp_class
,
3941 &dev_attr_lpfc_use_adisc
,
3942 &dev_attr_lpfc_fdmi_on
,
3943 &dev_attr_lpfc_max_luns
,
3944 &dev_attr_nport_evt_cnt
,
3945 &dev_attr_npiv_info
,
3946 &dev_attr_lpfc_enable_da_id
,
3947 &dev_attr_lpfc_max_scsicmpl_time
,
3948 &dev_attr_lpfc_stat_data_ctrl
,
3949 &dev_attr_lpfc_static_vport
,
3950 &dev_attr_lpfc_fips_level
,
3951 &dev_attr_lpfc_fips_rev
,
3956 * sysfs_ctlreg_write - Write method for writing to ctlreg
3957 * @filp: open sysfs file
3958 * @kobj: kernel kobject that contains the kernel class device.
3959 * @bin_attr: kernel attributes passed to us.
3960 * @buf: contains the data to be written to the adapter IOREG space.
3961 * @off: offset into buffer to beginning of data.
3962 * @count: bytes to transfer.
3965 * Accessed via /sys/class/scsi_host/hostxxx/ctlreg.
3966 * Uses the adapter io control registers to send buf contents to the adapter.
3969 * -ERANGE off and count combo out of range
3970 * -EINVAL off, count or buff address invalid
3971 * -EPERM adapter is offline
3972 * value of count, buf contents written
3975 sysfs_ctlreg_write(struct file
*filp
, struct kobject
*kobj
,
3976 struct bin_attribute
*bin_attr
,
3977 char *buf
, loff_t off
, size_t count
)
3980 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
3981 struct Scsi_Host
*shost
= class_to_shost(dev
);
3982 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
3983 struct lpfc_hba
*phba
= vport
->phba
;
3985 if (phba
->sli_rev
>= LPFC_SLI_REV4
)
3988 if ((off
+ count
) > FF_REG_AREA_SIZE
)
3991 if (count
<= LPFC_REG_WRITE_KEY_SIZE
)
3994 if (off
% 4 || count
% 4 || (unsigned long)buf
% 4)
3997 /* This is to protect HBA registers from accidental writes. */
3998 if (memcmp(buf
, LPFC_REG_WRITE_KEY
, LPFC_REG_WRITE_KEY_SIZE
))
4001 if (!(vport
->fc_flag
& FC_OFFLINE_MODE
))
4004 spin_lock_irq(&phba
->hbalock
);
4005 for (buf_off
= 0; buf_off
< count
- LPFC_REG_WRITE_KEY_SIZE
;
4006 buf_off
+= sizeof(uint32_t))
4007 writel(*((uint32_t *)(buf
+ buf_off
+ LPFC_REG_WRITE_KEY_SIZE
)),
4008 phba
->ctrl_regs_memmap_p
+ off
+ buf_off
);
4010 spin_unlock_irq(&phba
->hbalock
);
4016 * sysfs_ctlreg_read - Read method for reading from ctlreg
4017 * @filp: open sysfs file
4018 * @kobj: kernel kobject that contains the kernel class device.
4019 * @bin_attr: kernel attributes passed to us.
4020 * @buf: if successful contains the data from the adapter IOREG space.
4021 * @off: offset into buffer to beginning of data.
4022 * @count: bytes to transfer.
4025 * Accessed via /sys/class/scsi_host/hostxxx/ctlreg.
4026 * Uses the adapter io control registers to read data into buf.
4029 * -ERANGE off and count combo out of range
4030 * -EINVAL off, count or buff address invalid
4031 * value of count, buf contents read
4034 sysfs_ctlreg_read(struct file
*filp
, struct kobject
*kobj
,
4035 struct bin_attribute
*bin_attr
,
4036 char *buf
, loff_t off
, size_t count
)
4040 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
4041 struct Scsi_Host
*shost
= class_to_shost(dev
);
4042 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
4043 struct lpfc_hba
*phba
= vport
->phba
;
4045 if (phba
->sli_rev
>= LPFC_SLI_REV4
)
4048 if (off
> FF_REG_AREA_SIZE
)
4051 if ((off
+ count
) > FF_REG_AREA_SIZE
)
4052 count
= FF_REG_AREA_SIZE
- off
;
4054 if (count
== 0) return 0;
4056 if (off
% 4 || count
% 4 || (unsigned long)buf
% 4)
4059 spin_lock_irq(&phba
->hbalock
);
4061 for (buf_off
= 0; buf_off
< count
; buf_off
+= sizeof(uint32_t)) {
4062 tmp_ptr
= (uint32_t *)(buf
+ buf_off
);
4063 *tmp_ptr
= readl(phba
->ctrl_regs_memmap_p
+ off
+ buf_off
);
4066 spin_unlock_irq(&phba
->hbalock
);
4071 static struct bin_attribute sysfs_ctlreg_attr
= {
4074 .mode
= S_IRUSR
| S_IWUSR
,
4077 .read
= sysfs_ctlreg_read
,
4078 .write
= sysfs_ctlreg_write
,
4082 * sysfs_mbox_write - Write method for writing information via mbox
4083 * @filp: open sysfs file
4084 * @kobj: kernel kobject that contains the kernel class device.
4085 * @bin_attr: kernel attributes passed to us.
4086 * @buf: contains the data to be written to sysfs mbox.
4087 * @off: offset into buffer to beginning of data.
4088 * @count: bytes to transfer.
4091 * Deprecated function. All mailbox access from user space is performed via the
4095 * -EPERM operation not permitted
4098 sysfs_mbox_write(struct file
*filp
, struct kobject
*kobj
,
4099 struct bin_attribute
*bin_attr
,
4100 char *buf
, loff_t off
, size_t count
)
4106 * sysfs_mbox_read - Read method for reading information via mbox
4107 * @filp: open sysfs file
4108 * @kobj: kernel kobject that contains the kernel class device.
4109 * @bin_attr: kernel attributes passed to us.
4110 * @buf: contains the data to be read from sysfs mbox.
4111 * @off: offset into buffer to beginning of data.
4112 * @count: bytes to transfer.
4115 * Deprecated function. All mailbox access from user space is performed via the
4119 * -EPERM operation not permitted
4122 sysfs_mbox_read(struct file
*filp
, struct kobject
*kobj
,
4123 struct bin_attribute
*bin_attr
,
4124 char *buf
, loff_t off
, size_t count
)
4129 static struct bin_attribute sysfs_mbox_attr
= {
4132 .mode
= S_IRUSR
| S_IWUSR
,
4134 .size
= MAILBOX_SYSFS_MAX
,
4135 .read
= sysfs_mbox_read
,
4136 .write
= sysfs_mbox_write
,
4140 * lpfc_alloc_sysfs_attr - Creates the ctlreg and mbox entries
4141 * @vport: address of lpfc vport structure.
4145 * error return code from sysfs_create_bin_file()
4148 lpfc_alloc_sysfs_attr(struct lpfc_vport
*vport
)
4150 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
4153 error
= sysfs_create_bin_file(&shost
->shost_dev
.kobj
,
4154 &sysfs_drvr_stat_data_attr
);
4156 /* Virtual ports do not need ctrl_reg and mbox */
4157 if (error
|| vport
->port_type
== LPFC_NPIV_PORT
)
4160 error
= sysfs_create_bin_file(&shost
->shost_dev
.kobj
,
4161 &sysfs_ctlreg_attr
);
4163 goto out_remove_stat_attr
;
4165 error
= sysfs_create_bin_file(&shost
->shost_dev
.kobj
,
4168 goto out_remove_ctlreg_attr
;
4171 out_remove_ctlreg_attr
:
4172 sysfs_remove_bin_file(&shost
->shost_dev
.kobj
, &sysfs_ctlreg_attr
);
4173 out_remove_stat_attr
:
4174 sysfs_remove_bin_file(&shost
->shost_dev
.kobj
,
4175 &sysfs_drvr_stat_data_attr
);
4181 * lpfc_free_sysfs_attr - Removes the ctlreg and mbox entries
4182 * @vport: address of lpfc vport structure.
4185 lpfc_free_sysfs_attr(struct lpfc_vport
*vport
)
4187 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
4188 sysfs_remove_bin_file(&shost
->shost_dev
.kobj
,
4189 &sysfs_drvr_stat_data_attr
);
4190 /* Virtual ports do not need ctrl_reg and mbox */
4191 if (vport
->port_type
== LPFC_NPIV_PORT
)
4193 sysfs_remove_bin_file(&shost
->shost_dev
.kobj
, &sysfs_mbox_attr
);
4194 sysfs_remove_bin_file(&shost
->shost_dev
.kobj
, &sysfs_ctlreg_attr
);
4199 * Dynamic FC Host Attributes Support
4203 * lpfc_get_host_port_id - Copy the vport DID into the scsi host port id
4204 * @shost: kernel scsi host pointer.
4207 lpfc_get_host_port_id(struct Scsi_Host
*shost
)
4209 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
4211 /* note: fc_myDID already in cpu endianness */
4212 fc_host_port_id(shost
) = vport
->fc_myDID
;
4216 * lpfc_get_host_port_type - Set the value of the scsi host port type
4217 * @shost: kernel scsi host pointer.
4220 lpfc_get_host_port_type(struct Scsi_Host
*shost
)
4222 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
4223 struct lpfc_hba
*phba
= vport
->phba
;
4225 spin_lock_irq(shost
->host_lock
);
4227 if (vport
->port_type
== LPFC_NPIV_PORT
) {
4228 fc_host_port_type(shost
) = FC_PORTTYPE_NPIV
;
4229 } else if (lpfc_is_link_up(phba
)) {
4230 if (phba
->fc_topology
== LPFC_TOPOLOGY_LOOP
) {
4231 if (vport
->fc_flag
& FC_PUBLIC_LOOP
)
4232 fc_host_port_type(shost
) = FC_PORTTYPE_NLPORT
;
4234 fc_host_port_type(shost
) = FC_PORTTYPE_LPORT
;
4236 if (vport
->fc_flag
& FC_FABRIC
)
4237 fc_host_port_type(shost
) = FC_PORTTYPE_NPORT
;
4239 fc_host_port_type(shost
) = FC_PORTTYPE_PTP
;
4242 fc_host_port_type(shost
) = FC_PORTTYPE_UNKNOWN
;
4244 spin_unlock_irq(shost
->host_lock
);
4248 * lpfc_get_host_port_state - Set the value of the scsi host port state
4249 * @shost: kernel scsi host pointer.
4252 lpfc_get_host_port_state(struct Scsi_Host
*shost
)
4254 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
4255 struct lpfc_hba
*phba
= vport
->phba
;
4257 spin_lock_irq(shost
->host_lock
);
4259 if (vport
->fc_flag
& FC_OFFLINE_MODE
)
4260 fc_host_port_state(shost
) = FC_PORTSTATE_OFFLINE
;
4262 switch (phba
->link_state
) {
4263 case LPFC_LINK_UNKNOWN
:
4264 case LPFC_LINK_DOWN
:
4265 fc_host_port_state(shost
) = FC_PORTSTATE_LINKDOWN
;
4269 case LPFC_HBA_READY
:
4270 /* Links up, reports port state accordingly */
4271 if (vport
->port_state
< LPFC_VPORT_READY
)
4272 fc_host_port_state(shost
) =
4273 FC_PORTSTATE_BYPASSED
;
4275 fc_host_port_state(shost
) =
4276 FC_PORTSTATE_ONLINE
;
4278 case LPFC_HBA_ERROR
:
4279 fc_host_port_state(shost
) = FC_PORTSTATE_ERROR
;
4282 fc_host_port_state(shost
) = FC_PORTSTATE_UNKNOWN
;
4287 spin_unlock_irq(shost
->host_lock
);
4291 * lpfc_get_host_speed - Set the value of the scsi host speed
4292 * @shost: kernel scsi host pointer.
4295 lpfc_get_host_speed(struct Scsi_Host
*shost
)
4297 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
4298 struct lpfc_hba
*phba
= vport
->phba
;
4300 spin_lock_irq(shost
->host_lock
);
4302 if (lpfc_is_link_up(phba
)) {
4303 switch(phba
->fc_linkspeed
) {
4304 case LPFC_LINK_SPEED_1GHZ
:
4305 fc_host_speed(shost
) = FC_PORTSPEED_1GBIT
;
4307 case LPFC_LINK_SPEED_2GHZ
:
4308 fc_host_speed(shost
) = FC_PORTSPEED_2GBIT
;
4310 case LPFC_LINK_SPEED_4GHZ
:
4311 fc_host_speed(shost
) = FC_PORTSPEED_4GBIT
;
4313 case LPFC_LINK_SPEED_8GHZ
:
4314 fc_host_speed(shost
) = FC_PORTSPEED_8GBIT
;
4316 case LPFC_LINK_SPEED_10GHZ
:
4317 fc_host_speed(shost
) = FC_PORTSPEED_10GBIT
;
4319 case LPFC_LINK_SPEED_16GHZ
:
4320 fc_host_speed(shost
) = FC_PORTSPEED_16GBIT
;
4323 fc_host_speed(shost
) = FC_PORTSPEED_UNKNOWN
;
4327 fc_host_speed(shost
) = FC_PORTSPEED_UNKNOWN
;
4329 spin_unlock_irq(shost
->host_lock
);
4333 * lpfc_get_host_fabric_name - Set the value of the scsi host fabric name
4334 * @shost: kernel scsi host pointer.
4337 lpfc_get_host_fabric_name (struct Scsi_Host
*shost
)
4339 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
4340 struct lpfc_hba
*phba
= vport
->phba
;
4343 spin_lock_irq(shost
->host_lock
);
4345 if ((vport
->port_state
> LPFC_FLOGI
) &&
4346 ((vport
->fc_flag
& FC_FABRIC
) ||
4347 ((phba
->fc_topology
== LPFC_TOPOLOGY_LOOP
) &&
4348 (vport
->fc_flag
& FC_PUBLIC_LOOP
))))
4349 node_name
= wwn_to_u64(phba
->fc_fabparam
.nodeName
.u
.wwn
);
4351 /* fabric is local port if there is no F/FL_Port */
4354 spin_unlock_irq(shost
->host_lock
);
4356 fc_host_fabric_name(shost
) = node_name
;
4360 * lpfc_get_stats - Return statistical information about the adapter
4361 * @shost: kernel scsi host pointer.
4364 * NULL on error for link down, no mbox pool, sli2 active,
4365 * management not allowed, memory allocation error, or mbox error.
4369 * address of the adapter host statistics
4371 static struct fc_host_statistics
*
4372 lpfc_get_stats(struct Scsi_Host
*shost
)
4374 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
4375 struct lpfc_hba
*phba
= vport
->phba
;
4376 struct lpfc_sli
*psli
= &phba
->sli
;
4377 struct fc_host_statistics
*hs
= &phba
->link_stats
;
4378 struct lpfc_lnk_stat
* lso
= &psli
->lnk_stat_offsets
;
4379 LPFC_MBOXQ_t
*pmboxq
;
4381 unsigned long seconds
;
4385 * prevent udev from issuing mailbox commands until the port is
4388 if (phba
->link_state
< LPFC_LINK_DOWN
||
4389 !phba
->mbox_mem_pool
||
4390 (phba
->sli
.sli_flag
& LPFC_SLI_ACTIVE
) == 0)
4393 if (phba
->sli
.sli_flag
& LPFC_BLOCK_MGMT_IO
)
4396 pmboxq
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
4399 memset(pmboxq
, 0, sizeof (LPFC_MBOXQ_t
));
4401 pmb
= &pmboxq
->u
.mb
;
4402 pmb
->mbxCommand
= MBX_READ_STATUS
;
4403 pmb
->mbxOwner
= OWN_HOST
;
4404 pmboxq
->context1
= NULL
;
4405 pmboxq
->vport
= vport
;
4407 if (vport
->fc_flag
& FC_OFFLINE_MODE
)
4408 rc
= lpfc_sli_issue_mbox(phba
, pmboxq
, MBX_POLL
);
4410 rc
= lpfc_sli_issue_mbox_wait(phba
, pmboxq
, phba
->fc_ratov
* 2);
4412 if (rc
!= MBX_SUCCESS
) {
4413 if (rc
!= MBX_TIMEOUT
)
4414 mempool_free(pmboxq
, phba
->mbox_mem_pool
);
4418 memset(hs
, 0, sizeof (struct fc_host_statistics
));
4420 hs
->tx_frames
= pmb
->un
.varRdStatus
.xmitFrameCnt
;
4422 * The MBX_READ_STATUS returns tx_k_bytes which has to
4423 * converted to words
4425 hs
->tx_words
= (uint64_t)
4426 ((uint64_t)pmb
->un
.varRdStatus
.xmitByteCnt
4428 hs
->rx_frames
= pmb
->un
.varRdStatus
.rcvFrameCnt
;
4429 hs
->rx_words
= (uint64_t)
4430 ((uint64_t)pmb
->un
.varRdStatus
.rcvByteCnt
4433 memset(pmboxq
, 0, sizeof (LPFC_MBOXQ_t
));
4434 pmb
->mbxCommand
= MBX_READ_LNK_STAT
;
4435 pmb
->mbxOwner
= OWN_HOST
;
4436 pmboxq
->context1
= NULL
;
4437 pmboxq
->vport
= vport
;
4439 if (vport
->fc_flag
& FC_OFFLINE_MODE
)
4440 rc
= lpfc_sli_issue_mbox(phba
, pmboxq
, MBX_POLL
);
4442 rc
= lpfc_sli_issue_mbox_wait(phba
, pmboxq
, phba
->fc_ratov
* 2);
4444 if (rc
!= MBX_SUCCESS
) {
4445 if (rc
!= MBX_TIMEOUT
)
4446 mempool_free(pmboxq
, phba
->mbox_mem_pool
);
4450 hs
->link_failure_count
= pmb
->un
.varRdLnk
.linkFailureCnt
;
4451 hs
->loss_of_sync_count
= pmb
->un
.varRdLnk
.lossSyncCnt
;
4452 hs
->loss_of_signal_count
= pmb
->un
.varRdLnk
.lossSignalCnt
;
4453 hs
->prim_seq_protocol_err_count
= pmb
->un
.varRdLnk
.primSeqErrCnt
;
4454 hs
->invalid_tx_word_count
= pmb
->un
.varRdLnk
.invalidXmitWord
;
4455 hs
->invalid_crc_count
= pmb
->un
.varRdLnk
.crcCnt
;
4456 hs
->error_frames
= pmb
->un
.varRdLnk
.crcCnt
;
4458 hs
->link_failure_count
-= lso
->link_failure_count
;
4459 hs
->loss_of_sync_count
-= lso
->loss_of_sync_count
;
4460 hs
->loss_of_signal_count
-= lso
->loss_of_signal_count
;
4461 hs
->prim_seq_protocol_err_count
-= lso
->prim_seq_protocol_err_count
;
4462 hs
->invalid_tx_word_count
-= lso
->invalid_tx_word_count
;
4463 hs
->invalid_crc_count
-= lso
->invalid_crc_count
;
4464 hs
->error_frames
-= lso
->error_frames
;
4466 if (phba
->hba_flag
& HBA_FCOE_MODE
) {
4468 hs
->nos_count
= (phba
->link_events
>> 1);
4469 hs
->nos_count
-= lso
->link_events
;
4470 } else if (phba
->fc_topology
== LPFC_TOPOLOGY_LOOP
) {
4471 hs
->lip_count
= (phba
->fc_eventTag
>> 1);
4472 hs
->lip_count
-= lso
->link_events
;
4476 hs
->nos_count
= (phba
->fc_eventTag
>> 1);
4477 hs
->nos_count
-= lso
->link_events
;
4480 hs
->dumped_frames
= -1;
4482 seconds
= get_seconds();
4483 if (seconds
< psli
->stats_start
)
4484 hs
->seconds_since_last_reset
= seconds
+
4485 ((unsigned long)-1 - psli
->stats_start
);
4487 hs
->seconds_since_last_reset
= seconds
- psli
->stats_start
;
4489 mempool_free(pmboxq
, phba
->mbox_mem_pool
);
4495 * lpfc_reset_stats - Copy the adapter link stats information
4496 * @shost: kernel scsi host pointer.
4499 lpfc_reset_stats(struct Scsi_Host
*shost
)
4501 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
4502 struct lpfc_hba
*phba
= vport
->phba
;
4503 struct lpfc_sli
*psli
= &phba
->sli
;
4504 struct lpfc_lnk_stat
*lso
= &psli
->lnk_stat_offsets
;
4505 LPFC_MBOXQ_t
*pmboxq
;
4509 if (phba
->sli
.sli_flag
& LPFC_BLOCK_MGMT_IO
)
4512 pmboxq
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
4515 memset(pmboxq
, 0, sizeof(LPFC_MBOXQ_t
));
4517 pmb
= &pmboxq
->u
.mb
;
4518 pmb
->mbxCommand
= MBX_READ_STATUS
;
4519 pmb
->mbxOwner
= OWN_HOST
;
4520 pmb
->un
.varWords
[0] = 0x1; /* reset request */
4521 pmboxq
->context1
= NULL
;
4522 pmboxq
->vport
= vport
;
4524 if ((vport
->fc_flag
& FC_OFFLINE_MODE
) ||
4525 (!(psli
->sli_flag
& LPFC_SLI_ACTIVE
)))
4526 rc
= lpfc_sli_issue_mbox(phba
, pmboxq
, MBX_POLL
);
4528 rc
= lpfc_sli_issue_mbox_wait(phba
, pmboxq
, phba
->fc_ratov
* 2);
4530 if (rc
!= MBX_SUCCESS
) {
4531 if (rc
!= MBX_TIMEOUT
)
4532 mempool_free(pmboxq
, phba
->mbox_mem_pool
);
4536 memset(pmboxq
, 0, sizeof(LPFC_MBOXQ_t
));
4537 pmb
->mbxCommand
= MBX_READ_LNK_STAT
;
4538 pmb
->mbxOwner
= OWN_HOST
;
4539 pmboxq
->context1
= NULL
;
4540 pmboxq
->vport
= vport
;
4542 if ((vport
->fc_flag
& FC_OFFLINE_MODE
) ||
4543 (!(psli
->sli_flag
& LPFC_SLI_ACTIVE
)))
4544 rc
= lpfc_sli_issue_mbox(phba
, pmboxq
, MBX_POLL
);
4546 rc
= lpfc_sli_issue_mbox_wait(phba
, pmboxq
, phba
->fc_ratov
* 2);
4548 if (rc
!= MBX_SUCCESS
) {
4549 if (rc
!= MBX_TIMEOUT
)
4550 mempool_free( pmboxq
, phba
->mbox_mem_pool
);
4554 lso
->link_failure_count
= pmb
->un
.varRdLnk
.linkFailureCnt
;
4555 lso
->loss_of_sync_count
= pmb
->un
.varRdLnk
.lossSyncCnt
;
4556 lso
->loss_of_signal_count
= pmb
->un
.varRdLnk
.lossSignalCnt
;
4557 lso
->prim_seq_protocol_err_count
= pmb
->un
.varRdLnk
.primSeqErrCnt
;
4558 lso
->invalid_tx_word_count
= pmb
->un
.varRdLnk
.invalidXmitWord
;
4559 lso
->invalid_crc_count
= pmb
->un
.varRdLnk
.crcCnt
;
4560 lso
->error_frames
= pmb
->un
.varRdLnk
.crcCnt
;
4561 if (phba
->hba_flag
& HBA_FCOE_MODE
)
4562 lso
->link_events
= (phba
->link_events
>> 1);
4564 lso
->link_events
= (phba
->fc_eventTag
>> 1);
4566 psli
->stats_start
= get_seconds();
4568 mempool_free(pmboxq
, phba
->mbox_mem_pool
);
4574 * The LPFC driver treats linkdown handling as target loss events so there
4575 * are no sysfs handlers for link_down_tmo.
4579 * lpfc_get_node_by_target - Return the nodelist for a target
4580 * @starget: kernel scsi target pointer.
4583 * address of the node list if found
4584 * NULL target not found
4586 static struct lpfc_nodelist
*
4587 lpfc_get_node_by_target(struct scsi_target
*starget
)
4589 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
4590 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
4591 struct lpfc_nodelist
*ndlp
;
4593 spin_lock_irq(shost
->host_lock
);
4594 /* Search for this, mapped, target ID */
4595 list_for_each_entry(ndlp
, &vport
->fc_nodes
, nlp_listp
) {
4596 if (NLP_CHK_NODE_ACT(ndlp
) &&
4597 ndlp
->nlp_state
== NLP_STE_MAPPED_NODE
&&
4598 starget
->id
== ndlp
->nlp_sid
) {
4599 spin_unlock_irq(shost
->host_lock
);
4603 spin_unlock_irq(shost
->host_lock
);
4608 * lpfc_get_starget_port_id - Set the target port id to the ndlp DID or -1
4609 * @starget: kernel scsi target pointer.
4612 lpfc_get_starget_port_id(struct scsi_target
*starget
)
4614 struct lpfc_nodelist
*ndlp
= lpfc_get_node_by_target(starget
);
4616 fc_starget_port_id(starget
) = ndlp
? ndlp
->nlp_DID
: -1;
4620 * lpfc_get_starget_node_name - Set the target node name
4621 * @starget: kernel scsi target pointer.
4623 * Description: Set the target node name to the ndlp node name wwn or zero.
4626 lpfc_get_starget_node_name(struct scsi_target
*starget
)
4628 struct lpfc_nodelist
*ndlp
= lpfc_get_node_by_target(starget
);
4630 fc_starget_node_name(starget
) =
4631 ndlp
? wwn_to_u64(ndlp
->nlp_nodename
.u
.wwn
) : 0;
4635 * lpfc_get_starget_port_name - Set the target port name
4636 * @starget: kernel scsi target pointer.
4638 * Description: set the target port name to the ndlp port name wwn or zero.
4641 lpfc_get_starget_port_name(struct scsi_target
*starget
)
4643 struct lpfc_nodelist
*ndlp
= lpfc_get_node_by_target(starget
);
4645 fc_starget_port_name(starget
) =
4646 ndlp
? wwn_to_u64(ndlp
->nlp_portname
.u
.wwn
) : 0;
4650 * lpfc_set_rport_loss_tmo - Set the rport dev loss tmo
4651 * @rport: fc rport address.
4652 * @timeout: new value for dev loss tmo.
4655 * If timeout is non zero set the dev_loss_tmo to timeout, else set
4656 * dev_loss_tmo to one.
4659 lpfc_set_rport_loss_tmo(struct fc_rport
*rport
, uint32_t timeout
)
4662 rport
->dev_loss_tmo
= timeout
;
4664 rport
->dev_loss_tmo
= 1;
4668 * lpfc_rport_show_function - Return rport target information
4671 * Macro that uses field to generate a function with the name lpfc_show_rport_
4673 * lpfc_show_rport_##field: returns the bytes formatted in buf
4674 * @cdev: class converted to an fc_rport.
4675 * @buf: on return contains the target_field or zero.
4677 * Returns: size of formatted string.
4679 #define lpfc_rport_show_function(field, format_string, sz, cast) \
4681 lpfc_show_rport_##field (struct device *dev, \
4682 struct device_attribute *attr, \
4685 struct fc_rport *rport = transport_class_to_rport(dev); \
4686 struct lpfc_rport_data *rdata = rport->hostdata; \
4687 return snprintf(buf, sz, format_string, \
4688 (rdata->target) ? cast rdata->target->field : 0); \
4691 #define lpfc_rport_rd_attr(field, format_string, sz) \
4692 lpfc_rport_show_function(field, format_string, sz, ) \
4693 static FC_RPORT_ATTR(field, S_IRUGO, lpfc_show_rport_##field, NULL)
4696 * lpfc_set_vport_symbolic_name - Set the vport's symbolic name
4697 * @fc_vport: The fc_vport who's symbolic name has been changed.
4700 * This function is called by the transport after the @fc_vport's symbolic name
4701 * has been changed. This function re-registers the symbolic name with the
4702 * switch to propagate the change into the fabric if the vport is active.
4705 lpfc_set_vport_symbolic_name(struct fc_vport
*fc_vport
)
4707 struct lpfc_vport
*vport
= *(struct lpfc_vport
**)fc_vport
->dd_data
;
4709 if (vport
->port_state
== LPFC_VPORT_READY
)
4710 lpfc_ns_cmd(vport
, SLI_CTNS_RSPN_ID
, 0, 0);
4714 * lpfc_hba_log_verbose_init - Set hba's log verbose level
4715 * @phba: Pointer to lpfc_hba struct.
4717 * This function is called by the lpfc_get_cfgparam() routine to set the
4718 * module lpfc_log_verbose into the @phba cfg_log_verbose for use with
4719 * log message according to the module's lpfc_log_verbose parameter setting
4720 * before hba port or vport created.
4723 lpfc_hba_log_verbose_init(struct lpfc_hba
*phba
, uint32_t verbose
)
4725 phba
->cfg_log_verbose
= verbose
;
4728 struct fc_function_template lpfc_transport_functions
= {
4729 /* fixed attributes the driver supports */
4730 .show_host_node_name
= 1,
4731 .show_host_port_name
= 1,
4732 .show_host_supported_classes
= 1,
4733 .show_host_supported_fc4s
= 1,
4734 .show_host_supported_speeds
= 1,
4735 .show_host_maxframe_size
= 1,
4736 .show_host_symbolic_name
= 1,
4738 /* dynamic attributes the driver supports */
4739 .get_host_port_id
= lpfc_get_host_port_id
,
4740 .show_host_port_id
= 1,
4742 .get_host_port_type
= lpfc_get_host_port_type
,
4743 .show_host_port_type
= 1,
4745 .get_host_port_state
= lpfc_get_host_port_state
,
4746 .show_host_port_state
= 1,
4748 /* active_fc4s is shown but doesn't change (thus no get function) */
4749 .show_host_active_fc4s
= 1,
4751 .get_host_speed
= lpfc_get_host_speed
,
4752 .show_host_speed
= 1,
4754 .get_host_fabric_name
= lpfc_get_host_fabric_name
,
4755 .show_host_fabric_name
= 1,
4758 * The LPFC driver treats linkdown handling as target loss events
4759 * so there are no sysfs handlers for link_down_tmo.
4762 .get_fc_host_stats
= lpfc_get_stats
,
4763 .reset_fc_host_stats
= lpfc_reset_stats
,
4765 .dd_fcrport_size
= sizeof(struct lpfc_rport_data
),
4766 .show_rport_maxframe_size
= 1,
4767 .show_rport_supported_classes
= 1,
4769 .set_rport_dev_loss_tmo
= lpfc_set_rport_loss_tmo
,
4770 .show_rport_dev_loss_tmo
= 1,
4772 .get_starget_port_id
= lpfc_get_starget_port_id
,
4773 .show_starget_port_id
= 1,
4775 .get_starget_node_name
= lpfc_get_starget_node_name
,
4776 .show_starget_node_name
= 1,
4778 .get_starget_port_name
= lpfc_get_starget_port_name
,
4779 .show_starget_port_name
= 1,
4781 .issue_fc_host_lip
= lpfc_issue_lip
,
4782 .dev_loss_tmo_callbk
= lpfc_dev_loss_tmo_callbk
,
4783 .terminate_rport_io
= lpfc_terminate_rport_io
,
4785 .dd_fcvport_size
= sizeof(struct lpfc_vport
*),
4787 .vport_disable
= lpfc_vport_disable
,
4789 .set_vport_symbolic_name
= lpfc_set_vport_symbolic_name
,
4791 .bsg_request
= lpfc_bsg_request
,
4792 .bsg_timeout
= lpfc_bsg_timeout
,
4795 struct fc_function_template lpfc_vport_transport_functions
= {
4796 /* fixed attributes the driver supports */
4797 .show_host_node_name
= 1,
4798 .show_host_port_name
= 1,
4799 .show_host_supported_classes
= 1,
4800 .show_host_supported_fc4s
= 1,
4801 .show_host_supported_speeds
= 1,
4802 .show_host_maxframe_size
= 1,
4803 .show_host_symbolic_name
= 1,
4805 /* dynamic attributes the driver supports */
4806 .get_host_port_id
= lpfc_get_host_port_id
,
4807 .show_host_port_id
= 1,
4809 .get_host_port_type
= lpfc_get_host_port_type
,
4810 .show_host_port_type
= 1,
4812 .get_host_port_state
= lpfc_get_host_port_state
,
4813 .show_host_port_state
= 1,
4815 /* active_fc4s is shown but doesn't change (thus no get function) */
4816 .show_host_active_fc4s
= 1,
4818 .get_host_speed
= lpfc_get_host_speed
,
4819 .show_host_speed
= 1,
4821 .get_host_fabric_name
= lpfc_get_host_fabric_name
,
4822 .show_host_fabric_name
= 1,
4825 * The LPFC driver treats linkdown handling as target loss events
4826 * so there are no sysfs handlers for link_down_tmo.
4829 .get_fc_host_stats
= lpfc_get_stats
,
4830 .reset_fc_host_stats
= lpfc_reset_stats
,
4832 .dd_fcrport_size
= sizeof(struct lpfc_rport_data
),
4833 .show_rport_maxframe_size
= 1,
4834 .show_rport_supported_classes
= 1,
4836 .set_rport_dev_loss_tmo
= lpfc_set_rport_loss_tmo
,
4837 .show_rport_dev_loss_tmo
= 1,
4839 .get_starget_port_id
= lpfc_get_starget_port_id
,
4840 .show_starget_port_id
= 1,
4842 .get_starget_node_name
= lpfc_get_starget_node_name
,
4843 .show_starget_node_name
= 1,
4845 .get_starget_port_name
= lpfc_get_starget_port_name
,
4846 .show_starget_port_name
= 1,
4848 .dev_loss_tmo_callbk
= lpfc_dev_loss_tmo_callbk
,
4849 .terminate_rport_io
= lpfc_terminate_rport_io
,
4851 .vport_disable
= lpfc_vport_disable
,
4853 .set_vport_symbolic_name
= lpfc_set_vport_symbolic_name
,
4857 * lpfc_get_cfgparam - Used during probe_one to init the adapter structure
4858 * @phba: lpfc_hba pointer.
4861 lpfc_get_cfgparam(struct lpfc_hba
*phba
)
4863 lpfc_cr_delay_init(phba
, lpfc_cr_delay
);
4864 lpfc_cr_count_init(phba
, lpfc_cr_count
);
4865 lpfc_multi_ring_support_init(phba
, lpfc_multi_ring_support
);
4866 lpfc_multi_ring_rctl_init(phba
, lpfc_multi_ring_rctl
);
4867 lpfc_multi_ring_type_init(phba
, lpfc_multi_ring_type
);
4868 lpfc_ack0_init(phba
, lpfc_ack0
);
4869 lpfc_topology_init(phba
, lpfc_topology
);
4870 lpfc_link_speed_init(phba
, lpfc_link_speed
);
4871 lpfc_poll_tmo_init(phba
, lpfc_poll_tmo
);
4872 lpfc_enable_npiv_init(phba
, lpfc_enable_npiv
);
4873 lpfc_fcf_failover_policy_init(phba
, lpfc_fcf_failover_policy
);
4874 lpfc_enable_rrq_init(phba
, lpfc_enable_rrq
);
4875 lpfc_use_msi_init(phba
, lpfc_use_msi
);
4876 lpfc_fcp_imax_init(phba
, lpfc_fcp_imax
);
4877 lpfc_fcp_wq_count_init(phba
, lpfc_fcp_wq_count
);
4878 lpfc_fcp_eq_count_init(phba
, lpfc_fcp_eq_count
);
4879 lpfc_enable_hba_reset_init(phba
, lpfc_enable_hba_reset
);
4880 lpfc_enable_hba_heartbeat_init(phba
, lpfc_enable_hba_heartbeat
);
4881 lpfc_enable_bg_init(phba
, lpfc_enable_bg
);
4882 if (phba
->sli_rev
== LPFC_SLI_REV4
)
4885 phba
->cfg_poll
= lpfc_poll
;
4886 phba
->cfg_soft_wwnn
= 0L;
4887 phba
->cfg_soft_wwpn
= 0L;
4888 lpfc_sg_seg_cnt_init(phba
, lpfc_sg_seg_cnt
);
4889 lpfc_prot_sg_seg_cnt_init(phba
, lpfc_prot_sg_seg_cnt
);
4890 lpfc_hba_queue_depth_init(phba
, lpfc_hba_queue_depth
);
4891 lpfc_hba_log_verbose_init(phba
, lpfc_log_verbose
);
4892 lpfc_aer_support_init(phba
, lpfc_aer_support
);
4893 lpfc_sriov_nr_virtfn_init(phba
, lpfc_sriov_nr_virtfn
);
4894 lpfc_suppress_link_up_init(phba
, lpfc_suppress_link_up
);
4895 lpfc_iocb_cnt_init(phba
, lpfc_iocb_cnt
);
4896 phba
->cfg_enable_dss
= 1;
4901 * lpfc_get_vport_cfgparam - Used during port create, init the vport structure
4902 * @vport: lpfc_vport pointer.
4905 lpfc_get_vport_cfgparam(struct lpfc_vport
*vport
)
4907 lpfc_log_verbose_init(vport
, lpfc_log_verbose
);
4908 lpfc_lun_queue_depth_init(vport
, lpfc_lun_queue_depth
);
4909 lpfc_tgt_queue_depth_init(vport
, lpfc_tgt_queue_depth
);
4910 lpfc_devloss_tmo_init(vport
, lpfc_devloss_tmo
);
4911 lpfc_nodev_tmo_init(vport
, lpfc_nodev_tmo
);
4912 lpfc_peer_port_login_init(vport
, lpfc_peer_port_login
);
4913 lpfc_restrict_login_init(vport
, lpfc_restrict_login
);
4914 lpfc_fcp_class_init(vport
, lpfc_fcp_class
);
4915 lpfc_use_adisc_init(vport
, lpfc_use_adisc
);
4916 lpfc_max_scsicmpl_time_init(vport
, lpfc_max_scsicmpl_time
);
4917 lpfc_fdmi_on_init(vport
, lpfc_fdmi_on
);
4918 lpfc_discovery_threads_init(vport
, lpfc_discovery_threads
);
4919 lpfc_max_luns_init(vport
, lpfc_max_luns
);
4920 lpfc_scan_down_init(vport
, lpfc_scan_down
);
4921 lpfc_enable_da_id_init(vport
, lpfc_enable_da_id
);