1 /*******************************************************************
2 * This file is part of the Emulex Linux Device Driver for *
3 * Fibre Channel Host Bus Adapters. *
4 * Copyright (C) 2004-2007 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>
27 #include <scsi/scsi.h>
28 #include <scsi/scsi_device.h>
29 #include <scsi/scsi_host.h>
30 #include <scsi/scsi_tcq.h>
31 #include <scsi/scsi_transport_fc.h>
35 #include "lpfc_disc.h"
36 #include "lpfc_scsi.h"
38 #include "lpfc_logmsg.h"
39 #include "lpfc_version.h"
40 #include "lpfc_compat.h"
41 #include "lpfc_crtn.h"
42 #include "lpfc_vport.h"
44 #define LPFC_DEF_DEVLOSS_TMO 30
45 #define LPFC_MIN_DEVLOSS_TMO 1
46 #define LPFC_MAX_DEVLOSS_TMO 255
49 lpfc_jedec_to_ascii(int incr
, char hdw
[])
52 for (i
= 0; i
< 8; i
++) {
55 hdw
[7 - i
] = 0x30 + j
;
57 hdw
[7 - i
] = 0x61 + j
- 10;
65 lpfc_drvr_version_show(struct class_device
*cdev
, char *buf
)
67 return snprintf(buf
, PAGE_SIZE
, LPFC_MODULE_DESC
"\n");
71 lpfc_info_show(struct class_device
*cdev
, char *buf
)
73 struct Scsi_Host
*host
= class_to_shost(cdev
);
75 return snprintf(buf
, PAGE_SIZE
, "%s\n",lpfc_info(host
));
79 lpfc_serialnum_show(struct class_device
*cdev
, char *buf
)
81 struct Scsi_Host
*shost
= class_to_shost(cdev
);
82 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
83 struct lpfc_hba
*phba
= vport
->phba
;
85 return snprintf(buf
, PAGE_SIZE
, "%s\n",phba
->SerialNumber
);
89 lpfc_temp_sensor_show(struct class_device
*cdev
, char *buf
)
91 struct Scsi_Host
*shost
= class_to_shost(cdev
);
92 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
93 struct lpfc_hba
*phba
= vport
->phba
;
94 return snprintf(buf
, PAGE_SIZE
, "%d\n",phba
->temp_sensor_support
);
98 lpfc_modeldesc_show(struct class_device
*cdev
, char *buf
)
100 struct Scsi_Host
*shost
= class_to_shost(cdev
);
101 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
102 struct lpfc_hba
*phba
= vport
->phba
;
104 return snprintf(buf
, PAGE_SIZE
, "%s\n",phba
->ModelDesc
);
108 lpfc_modelname_show(struct class_device
*cdev
, char *buf
)
110 struct Scsi_Host
*shost
= class_to_shost(cdev
);
111 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
112 struct lpfc_hba
*phba
= vport
->phba
;
114 return snprintf(buf
, PAGE_SIZE
, "%s\n",phba
->ModelName
);
118 lpfc_programtype_show(struct class_device
*cdev
, char *buf
)
120 struct Scsi_Host
*shost
= class_to_shost(cdev
);
121 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
122 struct lpfc_hba
*phba
= vport
->phba
;
124 return snprintf(buf
, PAGE_SIZE
, "%s\n",phba
->ProgramType
);
128 lpfc_vportnum_show(struct class_device
*cdev
, char *buf
)
130 struct Scsi_Host
*shost
= class_to_shost(cdev
);
131 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
132 struct lpfc_hba
*phba
= vport
->phba
;
134 return snprintf(buf
, PAGE_SIZE
, "%s\n",phba
->Port
);
138 lpfc_fwrev_show(struct class_device
*cdev
, char *buf
)
140 struct Scsi_Host
*shost
= class_to_shost(cdev
);
141 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
142 struct lpfc_hba
*phba
= vport
->phba
;
145 lpfc_decode_firmware_rev(phba
, fwrev
, 1);
146 return snprintf(buf
, PAGE_SIZE
, "%s, sli-%d\n", fwrev
, phba
->sli_rev
);
150 lpfc_hdw_show(struct class_device
*cdev
, char *buf
)
153 struct Scsi_Host
*shost
= class_to_shost(cdev
);
154 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
155 struct lpfc_hba
*phba
= vport
->phba
;
156 lpfc_vpd_t
*vp
= &phba
->vpd
;
158 lpfc_jedec_to_ascii(vp
->rev
.biuRev
, hdw
);
159 return snprintf(buf
, PAGE_SIZE
, "%s\n", hdw
);
162 lpfc_option_rom_version_show(struct class_device
*cdev
, char *buf
)
164 struct Scsi_Host
*shost
= class_to_shost(cdev
);
165 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
166 struct lpfc_hba
*phba
= vport
->phba
;
168 return snprintf(buf
, PAGE_SIZE
, "%s\n", phba
->OptionROMVersion
);
171 lpfc_state_show(struct class_device
*cdev
, char *buf
)
173 struct Scsi_Host
*shost
= class_to_shost(cdev
);
174 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
175 struct lpfc_hba
*phba
= vport
->phba
;
178 switch (phba
->link_state
) {
179 case LPFC_LINK_UNKNOWN
:
180 case LPFC_WARM_START
:
181 case LPFC_INIT_START
:
182 case LPFC_INIT_MBX_CMDS
:
185 len
+= snprintf(buf
+ len
, PAGE_SIZE
-len
, "Link Down\n");
190 len
+= snprintf(buf
+ len
, PAGE_SIZE
-len
, "Link Up - \n");
192 switch (vport
->port_state
) {
193 len
+= snprintf(buf
+ len
, PAGE_SIZE
-len
,
196 case LPFC_LOCAL_CFG_LINK
:
197 len
+= snprintf(buf
+ len
, PAGE_SIZE
-len
,
198 "Configuring Link\n");
202 case LPFC_FABRIC_CFG_LINK
:
205 case LPFC_BUILD_DISC_LIST
:
207 len
+= snprintf(buf
+ len
, PAGE_SIZE
- len
,
210 case LPFC_VPORT_READY
:
211 len
+= snprintf(buf
+ len
, PAGE_SIZE
- len
, "Ready\n");
214 case LPFC_VPORT_FAILED
:
215 len
+= snprintf(buf
+ len
, PAGE_SIZE
- len
, "Failed\n");
218 case LPFC_VPORT_UNKNOWN
:
219 len
+= snprintf(buf
+ len
, PAGE_SIZE
- len
,
224 if (phba
->fc_topology
== TOPOLOGY_LOOP
) {
225 if (vport
->fc_flag
& FC_PUBLIC_LOOP
)
226 len
+= snprintf(buf
+ len
, PAGE_SIZE
-len
,
229 len
+= snprintf(buf
+ len
, PAGE_SIZE
-len
,
232 if (vport
->fc_flag
& FC_FABRIC
)
233 len
+= snprintf(buf
+ len
, PAGE_SIZE
-len
,
236 len
+= snprintf(buf
+ len
, PAGE_SIZE
-len
,
245 lpfc_num_discovered_ports_show(struct class_device
*cdev
, char *buf
)
247 struct Scsi_Host
*shost
= class_to_shost(cdev
);
248 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
250 return snprintf(buf
, PAGE_SIZE
, "%d\n",
251 vport
->fc_map_cnt
+ vport
->fc_unmap_cnt
);
256 lpfc_issue_lip(struct Scsi_Host
*shost
)
258 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
259 struct lpfc_hba
*phba
= vport
->phba
;
260 LPFC_MBOXQ_t
*pmboxq
;
261 int mbxstatus
= MBXERR_ERROR
;
263 if ((vport
->fc_flag
& FC_OFFLINE_MODE
) ||
264 (phba
->sli
.sli_flag
& LPFC_BLOCK_MGMT_IO
) ||
265 (vport
->port_state
!= LPFC_VPORT_READY
))
268 pmboxq
= mempool_alloc(phba
->mbox_mem_pool
,GFP_KERNEL
);
273 memset((void *)pmboxq
, 0, sizeof (LPFC_MBOXQ_t
));
274 pmboxq
->mb
.mbxCommand
= MBX_DOWN_LINK
;
275 pmboxq
->mb
.mbxOwner
= OWN_HOST
;
277 mbxstatus
= lpfc_sli_issue_mbox_wait(phba
, pmboxq
, LPFC_MBOX_TMO
* 2);
279 if ((mbxstatus
== MBX_SUCCESS
) && (pmboxq
->mb
.mbxStatus
== 0)) {
280 memset((void *)pmboxq
, 0, sizeof (LPFC_MBOXQ_t
));
281 lpfc_init_link(phba
, pmboxq
, phba
->cfg_topology
,
282 phba
->cfg_link_speed
);
283 mbxstatus
= lpfc_sli_issue_mbox_wait(phba
, pmboxq
,
287 lpfc_set_loopback_flag(phba
);
288 if (mbxstatus
!= MBX_TIMEOUT
)
289 mempool_free(pmboxq
, phba
->mbox_mem_pool
);
291 if (mbxstatus
== MBXERR_ERROR
)
298 lpfc_do_offline(struct lpfc_hba
*phba
, uint32_t type
)
300 struct completion online_compl
;
301 struct lpfc_sli_ring
*pring
;
302 struct lpfc_sli
*psli
;
307 init_completion(&online_compl
);
308 lpfc_workq_post_event(phba
, &status
, &online_compl
,
309 LPFC_EVT_OFFLINE_PREP
);
310 wait_for_completion(&online_compl
);
317 for (i
= 0; i
< psli
->num_rings
; i
++) {
318 pring
= &psli
->ring
[i
];
319 /* The linkdown event takes 30 seconds to timeout. */
320 while (pring
->txcmplq_cnt
) {
323 lpfc_printf_log(phba
,
324 KERN_WARNING
, LOG_INIT
,
325 "0466 Outstanding IO when "
326 "bringing Adapter offline\n");
332 init_completion(&online_compl
);
333 lpfc_workq_post_event(phba
, &status
, &online_compl
, type
);
334 wait_for_completion(&online_compl
);
343 lpfc_selective_reset(struct lpfc_hba
*phba
)
345 struct completion online_compl
;
348 status
= lpfc_do_offline(phba
, LPFC_EVT_OFFLINE
);
353 init_completion(&online_compl
);
354 lpfc_workq_post_event(phba
, &status
, &online_compl
,
356 wait_for_completion(&online_compl
);
365 lpfc_issue_reset(struct class_device
*cdev
, const char *buf
, size_t count
)
367 struct Scsi_Host
*shost
= class_to_shost(cdev
);
368 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
369 struct lpfc_hba
*phba
= vport
->phba
;
371 int status
= -EINVAL
;
373 if (strncmp(buf
, "selective", sizeof("selective") - 1) == 0)
374 status
= lpfc_selective_reset(phba
);
383 lpfc_nport_evt_cnt_show(struct class_device
*cdev
, char *buf
)
385 struct Scsi_Host
*shost
= class_to_shost(cdev
);
386 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
387 struct lpfc_hba
*phba
= vport
->phba
;
389 return snprintf(buf
, PAGE_SIZE
, "%d\n", phba
->nport_event_cnt
);
393 lpfc_board_mode_show(struct class_device
*cdev
, char *buf
)
395 struct Scsi_Host
*shost
= class_to_shost(cdev
);
396 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
397 struct lpfc_hba
*phba
= vport
->phba
;
400 if (phba
->link_state
== LPFC_HBA_ERROR
)
402 else if (phba
->link_state
== LPFC_WARM_START
)
403 state
= "warm start";
404 else if (phba
->link_state
== LPFC_INIT_START
)
409 return snprintf(buf
, PAGE_SIZE
, "%s\n", state
);
413 lpfc_board_mode_store(struct class_device
*cdev
, const char *buf
, size_t count
)
415 struct Scsi_Host
*shost
= class_to_shost(cdev
);
416 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
417 struct lpfc_hba
*phba
= vport
->phba
;
418 struct completion online_compl
;
421 init_completion(&online_compl
);
423 if(strncmp(buf
, "online", sizeof("online") - 1) == 0) {
424 lpfc_workq_post_event(phba
, &status
, &online_compl
,
426 wait_for_completion(&online_compl
);
427 } else if (strncmp(buf
, "offline", sizeof("offline") - 1) == 0)
428 status
= lpfc_do_offline(phba
, LPFC_EVT_OFFLINE
);
429 else if (strncmp(buf
, "warm", sizeof("warm") - 1) == 0)
430 status
= lpfc_do_offline(phba
, LPFC_EVT_WARM_START
);
431 else if (strncmp(buf
, "error", sizeof("error") - 1) == 0)
432 status
= lpfc_do_offline(phba
, LPFC_EVT_KILL
);
443 lpfc_get_hba_info(struct lpfc_hba
*phba
,
444 uint32_t *mxri
, uint32_t *axri
,
445 uint32_t *mrpi
, uint32_t *arpi
,
446 uint32_t *mvpi
, uint32_t *avpi
)
448 struct lpfc_sli
*psli
= &phba
->sli
;
449 LPFC_MBOXQ_t
*pmboxq
;
454 * prevent udev from issuing mailbox commands until the port is
457 if (phba
->link_state
< LPFC_LINK_DOWN
||
458 !phba
->mbox_mem_pool
||
459 (phba
->sli
.sli_flag
& LPFC_SLI2_ACTIVE
) == 0)
462 if (phba
->sli
.sli_flag
& LPFC_BLOCK_MGMT_IO
)
465 pmboxq
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
468 memset(pmboxq
, 0, sizeof (LPFC_MBOXQ_t
));
471 pmb
->mbxCommand
= MBX_READ_CONFIG
;
472 pmb
->mbxOwner
= OWN_HOST
;
473 pmboxq
->context1
= NULL
;
475 if ((phba
->pport
->fc_flag
& FC_OFFLINE_MODE
) ||
476 (!(psli
->sli_flag
& LPFC_SLI2_ACTIVE
)))
477 rc
= MBX_NOT_FINISHED
;
479 rc
= lpfc_sli_issue_mbox_wait(phba
, pmboxq
, phba
->fc_ratov
* 2);
481 if (rc
!= MBX_SUCCESS
) {
482 if (rc
!= MBX_TIMEOUT
)
483 mempool_free(pmboxq
, phba
->mbox_mem_pool
);
488 *mrpi
= pmb
->un
.varRdConfig
.max_rpi
;
490 *arpi
= pmb
->un
.varRdConfig
.avail_rpi
;
492 *mxri
= pmb
->un
.varRdConfig
.max_xri
;
494 *axri
= pmb
->un
.varRdConfig
.avail_xri
;
496 *mvpi
= pmb
->un
.varRdConfig
.max_vpi
;
498 *avpi
= pmb
->un
.varRdConfig
.avail_vpi
;
500 mempool_free(pmboxq
, phba
->mbox_mem_pool
);
505 lpfc_max_rpi_show(struct class_device
*cdev
, char *buf
)
507 struct Scsi_Host
*shost
= class_to_shost(cdev
);
508 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
509 struct lpfc_hba
*phba
= vport
->phba
;
512 if (lpfc_get_hba_info(phba
, NULL
, NULL
, &cnt
, NULL
, NULL
, NULL
))
513 return snprintf(buf
, PAGE_SIZE
, "%d\n", cnt
);
514 return snprintf(buf
, PAGE_SIZE
, "Unknown\n");
518 lpfc_used_rpi_show(struct class_device
*cdev
, char *buf
)
520 struct Scsi_Host
*shost
= class_to_shost(cdev
);
521 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
522 struct lpfc_hba
*phba
= vport
->phba
;
525 if (lpfc_get_hba_info(phba
, NULL
, NULL
, &cnt
, &acnt
, NULL
, NULL
))
526 return snprintf(buf
, PAGE_SIZE
, "%d\n", (cnt
- acnt
));
527 return snprintf(buf
, PAGE_SIZE
, "Unknown\n");
531 lpfc_max_xri_show(struct class_device
*cdev
, char *buf
)
533 struct Scsi_Host
*shost
= class_to_shost(cdev
);
534 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
535 struct lpfc_hba
*phba
= vport
->phba
;
538 if (lpfc_get_hba_info(phba
, &cnt
, NULL
, NULL
, NULL
, NULL
, NULL
))
539 return snprintf(buf
, PAGE_SIZE
, "%d\n", cnt
);
540 return snprintf(buf
, PAGE_SIZE
, "Unknown\n");
544 lpfc_used_xri_show(struct class_device
*cdev
, char *buf
)
546 struct Scsi_Host
*shost
= class_to_shost(cdev
);
547 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
548 struct lpfc_hba
*phba
= vport
->phba
;
551 if (lpfc_get_hba_info(phba
, &cnt
, &acnt
, NULL
, NULL
, NULL
, NULL
))
552 return snprintf(buf
, PAGE_SIZE
, "%d\n", (cnt
- acnt
));
553 return snprintf(buf
, PAGE_SIZE
, "Unknown\n");
557 lpfc_max_vpi_show(struct class_device
*cdev
, char *buf
)
559 struct Scsi_Host
*shost
= class_to_shost(cdev
);
560 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
561 struct lpfc_hba
*phba
= vport
->phba
;
564 if (lpfc_get_hba_info(phba
, NULL
, NULL
, NULL
, NULL
, &cnt
, NULL
))
565 return snprintf(buf
, PAGE_SIZE
, "%d\n", cnt
);
566 return snprintf(buf
, PAGE_SIZE
, "Unknown\n");
570 lpfc_used_vpi_show(struct class_device
*cdev
, char *buf
)
572 struct Scsi_Host
*shost
= class_to_shost(cdev
);
573 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
574 struct lpfc_hba
*phba
= vport
->phba
;
577 if (lpfc_get_hba_info(phba
, NULL
, NULL
, NULL
, NULL
, &cnt
, &acnt
))
578 return snprintf(buf
, PAGE_SIZE
, "%d\n", (cnt
- acnt
));
579 return snprintf(buf
, PAGE_SIZE
, "Unknown\n");
583 lpfc_npiv_info_show(struct class_device
*cdev
, char *buf
)
585 struct Scsi_Host
*shost
= class_to_shost(cdev
);
586 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
587 struct lpfc_hba
*phba
= vport
->phba
;
589 if (!(phba
->max_vpi
))
590 return snprintf(buf
, PAGE_SIZE
, "NPIV Not Supported\n");
591 if (vport
->port_type
== LPFC_PHYSICAL_PORT
)
592 return snprintf(buf
, PAGE_SIZE
, "NPIV Physical\n");
593 return snprintf(buf
, PAGE_SIZE
, "NPIV Virtual (VPI %d)\n", vport
->vpi
);
597 lpfc_poll_show(struct class_device
*cdev
, char *buf
)
599 struct Scsi_Host
*shost
= class_to_shost(cdev
);
600 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
601 struct lpfc_hba
*phba
= vport
->phba
;
603 return snprintf(buf
, PAGE_SIZE
, "%#x\n", phba
->cfg_poll
);
607 lpfc_poll_store(struct class_device
*cdev
, const char *buf
,
610 struct Scsi_Host
*shost
= class_to_shost(cdev
);
611 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
612 struct lpfc_hba
*phba
= vport
->phba
;
617 if (!isdigit(buf
[0]))
620 if (sscanf(buf
, "%i", &val
) != 1)
623 if ((val
& 0x3) != val
)
626 spin_lock_irq(&phba
->hbalock
);
628 old_val
= phba
->cfg_poll
;
630 if (val
& ENABLE_FCP_RING_POLLING
) {
631 if ((val
& DISABLE_FCP_RING_INT
) &&
632 !(old_val
& DISABLE_FCP_RING_INT
)) {
633 creg_val
= readl(phba
->HCregaddr
);
634 creg_val
&= ~(HC_R0INT_ENA
<< LPFC_FCP_RING
);
635 writel(creg_val
, phba
->HCregaddr
);
636 readl(phba
->HCregaddr
); /* flush */
638 lpfc_poll_start_timer(phba
);
640 } else if (val
!= 0x0) {
641 spin_unlock_irq(&phba
->hbalock
);
645 if (!(val
& DISABLE_FCP_RING_INT
) &&
646 (old_val
& DISABLE_FCP_RING_INT
))
648 spin_unlock_irq(&phba
->hbalock
);
649 del_timer(&phba
->fcp_poll_timer
);
650 spin_lock_irq(&phba
->hbalock
);
651 creg_val
= readl(phba
->HCregaddr
);
652 creg_val
|= (HC_R0INT_ENA
<< LPFC_FCP_RING
);
653 writel(creg_val
, phba
->HCregaddr
);
654 readl(phba
->HCregaddr
); /* flush */
657 phba
->cfg_poll
= val
;
659 spin_unlock_irq(&phba
->hbalock
);
664 #define lpfc_param_show(attr) \
666 lpfc_##attr##_show(struct class_device *cdev, char *buf) \
668 struct Scsi_Host *shost = class_to_shost(cdev);\
669 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
670 struct lpfc_hba *phba = vport->phba;\
672 val = phba->cfg_##attr;\
673 return snprintf(buf, PAGE_SIZE, "%d\n",\
677 #define lpfc_param_hex_show(attr) \
679 lpfc_##attr##_show(struct class_device *cdev, char *buf) \
681 struct Scsi_Host *shost = class_to_shost(cdev);\
682 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
683 struct lpfc_hba *phba = vport->phba;\
685 val = phba->cfg_##attr;\
686 return snprintf(buf, PAGE_SIZE, "%#x\n",\
690 #define lpfc_param_init(attr, default, minval, maxval) \
692 lpfc_##attr##_init(struct lpfc_hba *phba, int val) \
694 if (val >= minval && val <= maxval) {\
695 phba->cfg_##attr = val;\
698 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
699 "0449 lpfc_"#attr" attribute cannot be set to %d, "\
700 "allowed range is ["#minval", "#maxval"]\n", val); \
701 phba->cfg_##attr = default;\
705 #define lpfc_param_set(attr, default, minval, maxval) \
707 lpfc_##attr##_set(struct lpfc_hba *phba, int val) \
709 if (val >= minval && val <= maxval) {\
710 phba->cfg_##attr = val;\
713 lpfc_printf_log(phba, KERN_ERR, LOG_INIT, \
714 "0450 lpfc_"#attr" attribute cannot be set to %d, "\
715 "allowed range is ["#minval", "#maxval"]\n", val); \
719 #define lpfc_param_store(attr) \
721 lpfc_##attr##_store(struct class_device *cdev, const char *buf, size_t count) \
723 struct Scsi_Host *shost = class_to_shost(cdev);\
724 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
725 struct lpfc_hba *phba = vport->phba;\
727 if (!isdigit(buf[0]))\
729 if (sscanf(buf, "%i", &val) != 1)\
731 if (lpfc_##attr##_set(phba, val) == 0) \
737 #define lpfc_vport_param_show(attr) \
739 lpfc_##attr##_show(struct class_device *cdev, char *buf) \
741 struct Scsi_Host *shost = class_to_shost(cdev);\
742 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
744 val = vport->cfg_##attr;\
745 return snprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_##attr);\
748 #define lpfc_vport_param_hex_show(attr) \
750 lpfc_##attr##_show(struct class_device *cdev, char *buf) \
752 struct Scsi_Host *shost = class_to_shost(cdev);\
753 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
755 val = vport->cfg_##attr;\
756 return snprintf(buf, PAGE_SIZE, "%#x\n", vport->cfg_##attr);\
759 #define lpfc_vport_param_init(attr, default, minval, maxval) \
761 lpfc_##attr##_init(struct lpfc_vport *vport, int val) \
763 if (val >= minval && val <= maxval) {\
764 vport->cfg_##attr = val;\
767 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
768 "0449 lpfc_"#attr" attribute cannot be set to %d, "\
769 "allowed range is ["#minval", "#maxval"]\n", val); \
770 vport->cfg_##attr = default;\
774 #define lpfc_vport_param_set(attr, default, minval, maxval) \
776 lpfc_##attr##_set(struct lpfc_vport *vport, int val) \
778 if (val >= minval && val <= maxval) {\
779 vport->cfg_##attr = val;\
782 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT, \
783 "0450 lpfc_"#attr" attribute cannot be set to %d, "\
784 "allowed range is ["#minval", "#maxval"]\n", val); \
788 #define lpfc_vport_param_store(attr) \
790 lpfc_##attr##_store(struct class_device *cdev, const char *buf, size_t count) \
792 struct Scsi_Host *shost = class_to_shost(cdev);\
793 struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
795 if (!isdigit(buf[0]))\
797 if (sscanf(buf, "%i", &val) != 1)\
799 if (lpfc_##attr##_set(vport, val) == 0) \
806 #define LPFC_ATTR(name, defval, minval, maxval, desc) \
807 static int lpfc_##name = defval;\
808 module_param(lpfc_##name, int, 0);\
809 MODULE_PARM_DESC(lpfc_##name, desc);\
810 lpfc_param_init(name, defval, minval, maxval)
812 #define LPFC_ATTR_R(name, defval, minval, maxval, desc) \
813 static int lpfc_##name = defval;\
814 module_param(lpfc_##name, int, 0);\
815 MODULE_PARM_DESC(lpfc_##name, desc);\
816 lpfc_param_show(name)\
817 lpfc_param_init(name, defval, minval, maxval)\
818 static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
820 #define LPFC_ATTR_RW(name, defval, minval, maxval, desc) \
821 static int lpfc_##name = defval;\
822 module_param(lpfc_##name, int, 0);\
823 MODULE_PARM_DESC(lpfc_##name, desc);\
824 lpfc_param_show(name)\
825 lpfc_param_init(name, defval, minval, maxval)\
826 lpfc_param_set(name, defval, minval, maxval)\
827 lpfc_param_store(name)\
828 static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
829 lpfc_##name##_show, lpfc_##name##_store)
831 #define LPFC_ATTR_HEX_R(name, defval, minval, maxval, desc) \
832 static int lpfc_##name = defval;\
833 module_param(lpfc_##name, int, 0);\
834 MODULE_PARM_DESC(lpfc_##name, desc);\
835 lpfc_param_hex_show(name)\
836 lpfc_param_init(name, defval, minval, maxval)\
837 static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
839 #define LPFC_ATTR_HEX_RW(name, defval, minval, maxval, desc) \
840 static int lpfc_##name = defval;\
841 module_param(lpfc_##name, int, 0);\
842 MODULE_PARM_DESC(lpfc_##name, desc);\
843 lpfc_param_hex_show(name)\
844 lpfc_param_init(name, defval, minval, maxval)\
845 lpfc_param_set(name, defval, minval, maxval)\
846 lpfc_param_store(name)\
847 static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
848 lpfc_##name##_show, lpfc_##name##_store)
850 #define LPFC_VPORT_ATTR(name, defval, minval, maxval, desc) \
851 static int lpfc_##name = defval;\
852 module_param(lpfc_##name, int, 0);\
853 MODULE_PARM_DESC(lpfc_##name, desc);\
854 lpfc_vport_param_init(name, defval, minval, maxval)
856 #define LPFC_VPORT_ATTR_R(name, defval, minval, maxval, desc) \
857 static int lpfc_##name = defval;\
858 module_param(lpfc_##name, int, 0);\
859 MODULE_PARM_DESC(lpfc_##name, desc);\
860 lpfc_vport_param_show(name)\
861 lpfc_vport_param_init(name, defval, minval, maxval)\
862 static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
864 #define LPFC_VPORT_ATTR_RW(name, defval, minval, maxval, desc) \
865 static int lpfc_##name = defval;\
866 module_param(lpfc_##name, int, 0);\
867 MODULE_PARM_DESC(lpfc_##name, desc);\
868 lpfc_vport_param_show(name)\
869 lpfc_vport_param_init(name, defval, minval, maxval)\
870 lpfc_vport_param_set(name, defval, minval, maxval)\
871 lpfc_vport_param_store(name)\
872 static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
873 lpfc_##name##_show, lpfc_##name##_store)
875 #define LPFC_VPORT_ATTR_HEX_R(name, defval, minval, maxval, desc) \
876 static int lpfc_##name = defval;\
877 module_param(lpfc_##name, int, 0);\
878 MODULE_PARM_DESC(lpfc_##name, desc);\
879 lpfc_vport_param_hex_show(name)\
880 lpfc_vport_param_init(name, defval, minval, maxval)\
881 static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
883 #define LPFC_VPORT_ATTR_HEX_RW(name, defval, minval, maxval, desc) \
884 static int lpfc_##name = defval;\
885 module_param(lpfc_##name, int, 0);\
886 MODULE_PARM_DESC(lpfc_##name, desc);\
887 lpfc_vport_param_hex_show(name)\
888 lpfc_vport_param_init(name, defval, minval, maxval)\
889 lpfc_vport_param_set(name, defval, minval, maxval)\
890 lpfc_vport_param_store(name)\
891 static CLASS_DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
892 lpfc_##name##_show, lpfc_##name##_store)
894 static CLASS_DEVICE_ATTR(info
, S_IRUGO
, lpfc_info_show
, NULL
);
895 static CLASS_DEVICE_ATTR(serialnum
, S_IRUGO
, lpfc_serialnum_show
, NULL
);
896 static CLASS_DEVICE_ATTR(modeldesc
, S_IRUGO
, lpfc_modeldesc_show
, NULL
);
897 static CLASS_DEVICE_ATTR(modelname
, S_IRUGO
, lpfc_modelname_show
, NULL
);
898 static CLASS_DEVICE_ATTR(programtype
, S_IRUGO
, lpfc_programtype_show
, NULL
);
899 static CLASS_DEVICE_ATTR(portnum
, S_IRUGO
, lpfc_vportnum_show
, NULL
);
900 static CLASS_DEVICE_ATTR(fwrev
, S_IRUGO
, lpfc_fwrev_show
, NULL
);
901 static CLASS_DEVICE_ATTR(hdw
, S_IRUGO
, lpfc_hdw_show
, NULL
);
902 static CLASS_DEVICE_ATTR(state
, S_IRUGO
, lpfc_state_show
, NULL
);
903 static CLASS_DEVICE_ATTR(option_rom_version
, S_IRUGO
,
904 lpfc_option_rom_version_show
, NULL
);
905 static CLASS_DEVICE_ATTR(num_discovered_ports
, S_IRUGO
,
906 lpfc_num_discovered_ports_show
, NULL
);
907 static CLASS_DEVICE_ATTR(nport_evt_cnt
, S_IRUGO
, lpfc_nport_evt_cnt_show
, NULL
);
908 static CLASS_DEVICE_ATTR(lpfc_drvr_version
, S_IRUGO
, lpfc_drvr_version_show
,
910 static CLASS_DEVICE_ATTR(board_mode
, S_IRUGO
| S_IWUSR
,
911 lpfc_board_mode_show
, lpfc_board_mode_store
);
912 static CLASS_DEVICE_ATTR(issue_reset
, S_IWUSR
, NULL
, lpfc_issue_reset
);
913 static CLASS_DEVICE_ATTR(max_vpi
, S_IRUGO
, lpfc_max_vpi_show
, NULL
);
914 static CLASS_DEVICE_ATTR(used_vpi
, S_IRUGO
, lpfc_used_vpi_show
, NULL
);
915 static CLASS_DEVICE_ATTR(max_rpi
, S_IRUGO
, lpfc_max_rpi_show
, NULL
);
916 static CLASS_DEVICE_ATTR(used_rpi
, S_IRUGO
, lpfc_used_rpi_show
, NULL
);
917 static CLASS_DEVICE_ATTR(max_xri
, S_IRUGO
, lpfc_max_xri_show
, NULL
);
918 static CLASS_DEVICE_ATTR(used_xri
, S_IRUGO
, lpfc_used_xri_show
, NULL
);
919 static CLASS_DEVICE_ATTR(npiv_info
, S_IRUGO
, lpfc_npiv_info_show
, NULL
);
920 static CLASS_DEVICE_ATTR(lpfc_temp_sensor
, S_IRUGO
, lpfc_temp_sensor_show
,
924 static char *lpfc_soft_wwn_key
= "C99G71SL8032A";
927 lpfc_soft_wwn_enable_store(struct class_device
*cdev
, const char *buf
,
930 struct Scsi_Host
*shost
= class_to_shost(cdev
);
931 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
932 struct lpfc_hba
*phba
= vport
->phba
;
933 unsigned int cnt
= count
;
936 * We're doing a simple sanity check for soft_wwpn setting.
937 * We require that the user write a specific key to enable
938 * the soft_wwpn attribute to be settable. Once the attribute
939 * is written, the enable key resets. If further updates are
940 * desired, the key must be written again to re-enable the
943 * The "key" is not secret - it is a hardcoded string shown
944 * here. The intent is to protect against the random user or
945 * application that is just writing attributes.
948 /* count may include a LF at end of string */
949 if (buf
[cnt
-1] == '\n')
952 if ((cnt
!= strlen(lpfc_soft_wwn_key
)) ||
953 (strncmp(buf
, lpfc_soft_wwn_key
, strlen(lpfc_soft_wwn_key
)) != 0))
956 phba
->soft_wwn_enable
= 1;
959 static CLASS_DEVICE_ATTR(lpfc_soft_wwn_enable
, S_IWUSR
, NULL
,
960 lpfc_soft_wwn_enable_store
);
963 lpfc_soft_wwpn_show(struct class_device
*cdev
, char *buf
)
965 struct Scsi_Host
*shost
= class_to_shost(cdev
);
966 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
967 struct lpfc_hba
*phba
= vport
->phba
;
969 return snprintf(buf
, PAGE_SIZE
, "0x%llx\n",
970 (unsigned long long)phba
->cfg_soft_wwpn
);
975 lpfc_soft_wwpn_store(struct class_device
*cdev
, const char *buf
, size_t count
)
977 struct Scsi_Host
*shost
= class_to_shost(cdev
);
978 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
979 struct lpfc_hba
*phba
= vport
->phba
;
980 struct completion online_compl
;
981 int stat1
=0, stat2
=0;
982 unsigned int i
, j
, cnt
=count
;
985 /* count may include a LF at end of string */
986 if (buf
[cnt
-1] == '\n')
989 if (!phba
->soft_wwn_enable
|| (cnt
< 16) || (cnt
> 18) ||
990 ((cnt
== 17) && (*buf
++ != 'x')) ||
991 ((cnt
== 18) && ((*buf
++ != '0') || (*buf
++ != 'x'))))
994 phba
->soft_wwn_enable
= 0;
996 memset(wwpn
, 0, sizeof(wwpn
));
998 /* Validate and store the new name */
999 for (i
=0, j
=0; i
< 16; i
++) {
1000 if ((*buf
>= 'a') && (*buf
<= 'f'))
1001 j
= ((j
<< 4) | ((*buf
++ -'a') + 10));
1002 else if ((*buf
>= 'A') && (*buf
<= 'F'))
1003 j
= ((j
<< 4) | ((*buf
++ -'A') + 10));
1004 else if ((*buf
>= '0') && (*buf
<= '9'))
1005 j
= ((j
<< 4) | (*buf
++ -'0'));
1009 wwpn
[i
/2] = j
& 0xff;
1013 phba
->cfg_soft_wwpn
= wwn_to_u64(wwpn
);
1014 fc_host_port_name(shost
) = phba
->cfg_soft_wwpn
;
1015 if (phba
->cfg_soft_wwnn
)
1016 fc_host_node_name(shost
) = phba
->cfg_soft_wwnn
;
1018 dev_printk(KERN_NOTICE
, &phba
->pcidev
->dev
,
1019 "lpfc%d: Reinitializing to use soft_wwpn\n", phba
->brd_no
);
1021 stat1
= lpfc_do_offline(phba
, LPFC_EVT_OFFLINE
);
1023 lpfc_printf_log(phba
, KERN_ERR
, LOG_INIT
,
1024 "0463 lpfc_soft_wwpn attribute set failed to "
1025 "reinit adapter - %d\n", stat1
);
1026 init_completion(&online_compl
);
1027 lpfc_workq_post_event(phba
, &stat2
, &online_compl
, LPFC_EVT_ONLINE
);
1028 wait_for_completion(&online_compl
);
1030 lpfc_printf_log(phba
, KERN_ERR
, LOG_INIT
,
1031 "0464 lpfc_soft_wwpn attribute set failed to "
1032 "reinit adapter - %d\n", stat2
);
1033 return (stat1
|| stat2
) ? -EIO
: count
;
1035 static CLASS_DEVICE_ATTR(lpfc_soft_wwpn
, S_IRUGO
| S_IWUSR
,\
1036 lpfc_soft_wwpn_show
, lpfc_soft_wwpn_store
);
1039 lpfc_soft_wwnn_show(struct class_device
*cdev
, char *buf
)
1041 struct Scsi_Host
*shost
= class_to_shost(cdev
);
1042 struct lpfc_hba
*phba
= ((struct lpfc_vport
*)shost
->hostdata
)->phba
;
1043 return snprintf(buf
, PAGE_SIZE
, "0x%llx\n",
1044 (unsigned long long)phba
->cfg_soft_wwnn
);
1049 lpfc_soft_wwnn_store(struct class_device
*cdev
, const char *buf
, size_t count
)
1051 struct Scsi_Host
*shost
= class_to_shost(cdev
);
1052 struct lpfc_hba
*phba
= ((struct lpfc_vport
*)shost
->hostdata
)->phba
;
1053 unsigned int i
, j
, cnt
=count
;
1056 /* count may include a LF at end of string */
1057 if (buf
[cnt
-1] == '\n')
1060 if (!phba
->soft_wwn_enable
|| (cnt
< 16) || (cnt
> 18) ||
1061 ((cnt
== 17) && (*buf
++ != 'x')) ||
1062 ((cnt
== 18) && ((*buf
++ != '0') || (*buf
++ != 'x'))))
1066 * Allow wwnn to be set many times, as long as the enable is set.
1067 * However, once the wwpn is set, everything locks.
1070 memset(wwnn
, 0, sizeof(wwnn
));
1072 /* Validate and store the new name */
1073 for (i
=0, j
=0; i
< 16; i
++) {
1074 if ((*buf
>= 'a') && (*buf
<= 'f'))
1075 j
= ((j
<< 4) | ((*buf
++ -'a') + 10));
1076 else if ((*buf
>= 'A') && (*buf
<= 'F'))
1077 j
= ((j
<< 4) | ((*buf
++ -'A') + 10));
1078 else if ((*buf
>= '0') && (*buf
<= '9'))
1079 j
= ((j
<< 4) | (*buf
++ -'0'));
1083 wwnn
[i
/2] = j
& 0xff;
1087 phba
->cfg_soft_wwnn
= wwn_to_u64(wwnn
);
1089 dev_printk(KERN_NOTICE
, &phba
->pcidev
->dev
,
1090 "lpfc%d: soft_wwnn set. Value will take effect upon "
1091 "setting of the soft_wwpn\n", phba
->brd_no
);
1095 static CLASS_DEVICE_ATTR(lpfc_soft_wwnn
, S_IRUGO
| S_IWUSR
,\
1096 lpfc_soft_wwnn_show
, lpfc_soft_wwnn_store
);
1099 static int lpfc_poll
= 0;
1100 module_param(lpfc_poll
, int, 0);
1101 MODULE_PARM_DESC(lpfc_poll
, "FCP ring polling mode control:"
1103 " 1 - poll with interrupts enabled"
1104 " 3 - poll and disable FCP ring interrupts");
1106 static CLASS_DEVICE_ATTR(lpfc_poll
, S_IRUGO
| S_IWUSR
,
1107 lpfc_poll_show
, lpfc_poll_store
);
1109 int lpfc_sli_mode
= 0;
1110 module_param(lpfc_sli_mode
, int, 0);
1111 MODULE_PARM_DESC(lpfc_sli_mode
, "SLI mode selector:"
1112 " 0 - auto (SLI-3 if supported),"
1113 " 2 - select SLI-2 even on SLI-3 capable HBAs,"
1114 " 3 - select SLI-3");
1116 int lpfc_enable_npiv
= 0;
1117 module_param(lpfc_enable_npiv
, int, 0);
1118 MODULE_PARM_DESC(lpfc_enable_npiv
, "Enable NPIV functionality");
1119 lpfc_param_show(enable_npiv
);
1120 lpfc_param_init(enable_npiv
, 0, 0, 1);
1121 static CLASS_DEVICE_ATTR(lpfc_enable_npiv
, S_IRUGO
,
1122 lpfc_enable_npiv_show
, NULL
);
1125 # lpfc_nodev_tmo: If set, it will hold all I/O errors on devices that disappear
1126 # until the timer expires. Value range is [0,255]. Default value is 30.
1128 static int lpfc_nodev_tmo
= LPFC_DEF_DEVLOSS_TMO
;
1129 static int lpfc_devloss_tmo
= LPFC_DEF_DEVLOSS_TMO
;
1130 module_param(lpfc_nodev_tmo
, int, 0);
1131 MODULE_PARM_DESC(lpfc_nodev_tmo
,
1132 "Seconds driver will hold I/O waiting "
1133 "for a device to come back");
1135 lpfc_nodev_tmo_show(struct class_device
*cdev
, char *buf
)
1137 struct Scsi_Host
*shost
= class_to_shost(cdev
);
1138 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
1140 val
= vport
->cfg_devloss_tmo
;
1141 return snprintf(buf
, PAGE_SIZE
, "%d\n", vport
->cfg_devloss_tmo
);
1145 lpfc_nodev_tmo_init(struct lpfc_vport
*vport
, int val
)
1147 if (vport
->cfg_devloss_tmo
!= LPFC_DEF_DEVLOSS_TMO
) {
1148 vport
->cfg_nodev_tmo
= vport
->cfg_devloss_tmo
;
1149 if (val
!= LPFC_DEF_DEVLOSS_TMO
)
1150 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_INIT
,
1151 "0402 Ignoring nodev_tmo module "
1152 "parameter because devloss_tmo is "
1157 if (val
>= LPFC_MIN_DEVLOSS_TMO
&& val
<= LPFC_MAX_DEVLOSS_TMO
) {
1158 vport
->cfg_nodev_tmo
= val
;
1159 vport
->cfg_devloss_tmo
= val
;
1162 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_INIT
,
1163 "0400 lpfc_nodev_tmo attribute cannot be set to"
1164 " %d, allowed range is [%d, %d]\n",
1165 val
, LPFC_MIN_DEVLOSS_TMO
, LPFC_MAX_DEVLOSS_TMO
);
1166 vport
->cfg_nodev_tmo
= LPFC_DEF_DEVLOSS_TMO
;
1171 lpfc_update_rport_devloss_tmo(struct lpfc_vport
*vport
)
1173 struct Scsi_Host
*shost
;
1174 struct lpfc_nodelist
*ndlp
;
1176 shost
= lpfc_shost_from_vport(vport
);
1177 spin_lock_irq(shost
->host_lock
);
1178 list_for_each_entry(ndlp
, &vport
->fc_nodes
, nlp_listp
)
1180 ndlp
->rport
->dev_loss_tmo
= vport
->cfg_devloss_tmo
;
1181 spin_unlock_irq(shost
->host_lock
);
1185 lpfc_nodev_tmo_set(struct lpfc_vport
*vport
, int val
)
1187 if (vport
->dev_loss_tmo_changed
||
1188 (lpfc_devloss_tmo
!= LPFC_DEF_DEVLOSS_TMO
)) {
1189 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_INIT
,
1190 "0401 Ignoring change to nodev_tmo "
1191 "because devloss_tmo is set.\n");
1194 if (val
>= LPFC_MIN_DEVLOSS_TMO
&& val
<= LPFC_MAX_DEVLOSS_TMO
) {
1195 vport
->cfg_nodev_tmo
= val
;
1196 vport
->cfg_devloss_tmo
= val
;
1197 lpfc_update_rport_devloss_tmo(vport
);
1200 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_INIT
,
1201 "0403 lpfc_nodev_tmo attribute cannot be set to"
1202 "%d, allowed range is [%d, %d]\n",
1203 val
, LPFC_MIN_DEVLOSS_TMO
, LPFC_MAX_DEVLOSS_TMO
);
1207 lpfc_vport_param_store(nodev_tmo
)
1209 static CLASS_DEVICE_ATTR(lpfc_nodev_tmo
, S_IRUGO
| S_IWUSR
,
1210 lpfc_nodev_tmo_show
, lpfc_nodev_tmo_store
);
1213 # lpfc_devloss_tmo: If set, it will hold all I/O errors on devices that
1214 # disappear until the timer expires. Value range is [0,255]. Default
1217 module_param(lpfc_devloss_tmo
, int, 0);
1218 MODULE_PARM_DESC(lpfc_devloss_tmo
,
1219 "Seconds driver will hold I/O waiting "
1220 "for a device to come back");
1221 lpfc_vport_param_init(devloss_tmo
, LPFC_DEF_DEVLOSS_TMO
,
1222 LPFC_MIN_DEVLOSS_TMO
, LPFC_MAX_DEVLOSS_TMO
)
1223 lpfc_vport_param_show(devloss_tmo
)
1225 lpfc_devloss_tmo_set(struct lpfc_vport
*vport
, int val
)
1227 if (val
>= LPFC_MIN_DEVLOSS_TMO
&& val
<= LPFC_MAX_DEVLOSS_TMO
) {
1228 vport
->cfg_nodev_tmo
= val
;
1229 vport
->cfg_devloss_tmo
= val
;
1230 vport
->dev_loss_tmo_changed
= 1;
1231 lpfc_update_rport_devloss_tmo(vport
);
1235 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_INIT
,
1236 "0404 lpfc_devloss_tmo attribute cannot be set to"
1237 " %d, allowed range is [%d, %d]\n",
1238 val
, LPFC_MIN_DEVLOSS_TMO
, LPFC_MAX_DEVLOSS_TMO
);
1242 lpfc_vport_param_store(devloss_tmo
)
1243 static CLASS_DEVICE_ATTR(lpfc_devloss_tmo
, S_IRUGO
| S_IWUSR
,
1244 lpfc_devloss_tmo_show
, lpfc_devloss_tmo_store
);
1247 # lpfc_log_verbose: Only turn this flag on if you are willing to risk being
1248 # deluged with LOTS of information.
1249 # You can set a bit mask to record specific types of verbose messages:
1251 # LOG_ELS 0x1 ELS events
1252 # LOG_DISCOVERY 0x2 Link discovery events
1253 # LOG_MBOX 0x4 Mailbox events
1254 # LOG_INIT 0x8 Initialization events
1255 # LOG_LINK_EVENT 0x10 Link events
1256 # LOG_FCP 0x40 FCP traffic history
1257 # LOG_NODE 0x80 Node table events
1258 # LOG_MISC 0x400 Miscellaneous events
1259 # LOG_SLI 0x800 SLI events
1260 # LOG_FCP_ERROR 0x1000 Only log FCP errors
1261 # LOG_LIBDFC 0x2000 LIBDFC events
1262 # LOG_ALL_MSG 0xffff LOG all messages
1264 LPFC_VPORT_ATTR_HEX_RW(log_verbose
, 0x0, 0x0, 0xffff,
1265 "Verbose logging bit-mask");
1268 # lpfc_enable_da_id: This turns on the DA_ID CT command that deregisters
1269 # objects that have been registered with the nameserver after login.
1271 LPFC_VPORT_ATTR_R(enable_da_id
, 0, 0, 1,
1272 "Deregister nameserver objects before LOGO");
1275 # lun_queue_depth: This parameter is used to limit the number of outstanding
1276 # commands per FCP LUN. Value range is [1,128]. Default value is 30.
1278 LPFC_VPORT_ATTR_R(lun_queue_depth
, 30, 1, 128,
1279 "Max number of FCP commands we can queue to a specific LUN");
1282 # hba_queue_depth: This parameter is used to limit the number of outstanding
1283 # commands per lpfc HBA. Value range is [32,8192]. If this parameter
1284 # value is greater than the maximum number of exchanges supported by the HBA,
1285 # then maximum number of exchanges supported by the HBA is used to determine
1286 # the hba_queue_depth.
1288 LPFC_ATTR_R(hba_queue_depth
, 8192, 32, 8192,
1289 "Max number of FCP commands we can queue to a lpfc HBA");
1292 # peer_port_login: This parameter allows/prevents logins
1293 # between peer ports hosted on the same physical port.
1294 # When this parameter is set 0 peer ports of same physical port
1295 # are not allowed to login to each other.
1296 # When this parameter is set 1 peer ports of same physical port
1297 # are allowed to login to each other.
1298 # Default value of this parameter is 0.
1300 LPFC_VPORT_ATTR_R(peer_port_login
, 0, 0, 1,
1301 "Allow peer ports on the same physical port to login to each "
1305 # restrict_login: This parameter allows/prevents logins
1306 # between Virtual Ports and remote initiators.
1307 # When this parameter is not set (0) Virtual Ports will accept PLOGIs from
1308 # other initiators and will attempt to PLOGI all remote ports.
1309 # When this parameter is set (1) Virtual Ports will reject PLOGIs from
1310 # remote ports and will not attempt to PLOGI to other initiators.
1311 # This parameter does not restrict to the physical port.
1312 # This parameter does not restrict logins to Fabric resident remote ports.
1313 # Default value of this parameter is 1.
1315 static int lpfc_restrict_login
= 1;
1316 module_param(lpfc_restrict_login
, int, 0);
1317 MODULE_PARM_DESC(lpfc_restrict_login
,
1318 "Restrict virtual ports login to remote initiators.");
1319 lpfc_vport_param_show(restrict_login
);
1322 lpfc_restrict_login_init(struct lpfc_vport
*vport
, int val
)
1324 if (val
< 0 || val
> 1) {
1325 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_INIT
,
1326 "0449 lpfc_restrict_login attribute cannot "
1327 "be set to %d, allowed range is [0, 1]\n",
1329 vport
->cfg_restrict_login
= 1;
1332 if (vport
->port_type
== LPFC_PHYSICAL_PORT
) {
1333 vport
->cfg_restrict_login
= 0;
1336 vport
->cfg_restrict_login
= val
;
1341 lpfc_restrict_login_set(struct lpfc_vport
*vport
, int val
)
1343 if (val
< 0 || val
> 1) {
1344 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_INIT
,
1345 "0450 lpfc_restrict_login attribute cannot "
1346 "be set to %d, allowed range is [0, 1]\n",
1348 vport
->cfg_restrict_login
= 1;
1351 if (vport
->port_type
== LPFC_PHYSICAL_PORT
&& val
!= 0) {
1352 lpfc_printf_vlog(vport
, KERN_ERR
, LOG_INIT
,
1353 "0468 lpfc_restrict_login must be 0 for "
1354 "Physical ports.\n");
1355 vport
->cfg_restrict_login
= 0;
1358 vport
->cfg_restrict_login
= val
;
1361 lpfc_vport_param_store(restrict_login
);
1362 static CLASS_DEVICE_ATTR(lpfc_restrict_login
, S_IRUGO
| S_IWUSR
,
1363 lpfc_restrict_login_show
, lpfc_restrict_login_store
);
1366 # Some disk devices have a "select ID" or "select Target" capability.
1367 # From a protocol standpoint "select ID" usually means select the
1368 # Fibre channel "ALPA". In the FC-AL Profile there is an "informative
1369 # annex" which contains a table that maps a "select ID" (a number
1370 # between 0 and 7F) to an ALPA. By default, for compatibility with
1371 # older drivers, the lpfc driver scans this table from low ALPA to high
1374 # Turning on the scan-down variable (on = 1, off = 0) will
1375 # cause the lpfc driver to use an inverted table, effectively
1376 # scanning ALPAs from high to low. Value range is [0,1]. Default value is 1.
1378 # (Note: This "select ID" functionality is a LOOP ONLY characteristic
1379 # and will not work across a fabric. Also this parameter will take
1380 # effect only in the case when ALPA map is not available.)
1382 LPFC_VPORT_ATTR_R(scan_down
, 1, 0, 1,
1383 "Start scanning for devices from highest ALPA to lowest");
1386 # lpfc_topology: link topology for init link
1387 # 0x0 = attempt loop mode then point-to-point
1388 # 0x01 = internal loopback mode
1389 # 0x02 = attempt point-to-point mode only
1390 # 0x04 = attempt loop mode only
1391 # 0x06 = attempt point-to-point mode then loop
1392 # Set point-to-point mode if you want to run as an N_Port.
1393 # Set loop mode if you want to run as an NL_Port. Value range is [0,0x6].
1394 # Default value is 0.
1396 LPFC_ATTR_RW(topology
, 0, 0, 6, "Select Fibre Channel topology");
1399 # lpfc_link_speed: Link speed selection for initializing the Fibre Channel
1401 # 0 = auto select (default)
1406 # Value range is [0,8]. Default value is 0.
1408 LPFC_ATTR_R(link_speed
, 0, 0, 8, "Select link speed");
1411 # lpfc_fcp_class: Determines FC class to use for the FCP protocol.
1412 # Value range is [2,3]. Default value is 3.
1414 LPFC_VPORT_ATTR_R(fcp_class
, 3, 2, 3,
1415 "Select Fibre Channel class of service for FCP sequences");
1418 # lpfc_use_adisc: Use ADISC for FCP rediscovery instead of PLOGI. Value range
1419 # is [0,1]. Default value is 0.
1421 LPFC_VPORT_ATTR_RW(use_adisc
, 0, 0, 1,
1422 "Use ADISC on rediscovery to authenticate FCP devices");
1425 # lpfc_ack0: Use ACK0, instead of ACK1 for class 2 acknowledgement. Value
1426 # range is [0,1]. Default value is 0.
1428 LPFC_ATTR_R(ack0
, 0, 0, 1, "Enable ACK0 support");
1431 # lpfc_cr_delay & lpfc_cr_count: Default values for I/O colaesing
1432 # cr_delay (msec) or cr_count outstanding commands. cr_delay can take
1433 # value [0,63]. cr_count can take value [1,255]. Default value of cr_delay
1434 # is 0. Default value of cr_count is 1. The cr_count feature is disabled if
1435 # cr_delay is set to 0.
1437 LPFC_ATTR_RW(cr_delay
, 0, 0, 63, "A count of milliseconds after which an "
1438 "interrupt response is generated");
1440 LPFC_ATTR_RW(cr_count
, 1, 1, 255, "A count of I/O completions after which an "
1441 "interrupt response is generated");
1444 # lpfc_multi_ring_support: Determines how many rings to spread available
1445 # cmd/rsp IOCB entries across.
1446 # Value range is [1,2]. Default value is 1.
1448 LPFC_ATTR_R(multi_ring_support
, 1, 1, 2, "Determines number of primary "
1449 "SLI rings to spread IOCB entries across");
1452 # lpfc_multi_ring_rctl: If lpfc_multi_ring_support is enabled, this
1453 # identifies what rctl value to configure the additional ring for.
1454 # Value range is [1,0xff]. Default value is 4 (Unsolicated Data).
1456 LPFC_ATTR_R(multi_ring_rctl
, FC_UNSOL_DATA
, 1,
1457 255, "Identifies RCTL for additional ring configuration");
1460 # lpfc_multi_ring_type: If lpfc_multi_ring_support is enabled, this
1461 # identifies what type value to configure the additional ring for.
1462 # Value range is [1,0xff]. Default value is 5 (LLC/SNAP).
1464 LPFC_ATTR_R(multi_ring_type
, FC_LLC_SNAP
, 1,
1465 255, "Identifies TYPE for additional ring configuration");
1468 # lpfc_fdmi_on: controls FDMI support.
1469 # 0 = no FDMI support
1470 # 1 = support FDMI without attribute of hostname
1471 # 2 = support FDMI with attribute of hostname
1472 # Value range [0,2]. Default value is 0.
1474 LPFC_VPORT_ATTR_RW(fdmi_on
, 0, 0, 2, "Enable FDMI support");
1477 # Specifies the maximum number of ELS cmds we can have outstanding (for
1478 # discovery). Value range is [1,64]. Default value = 32.
1480 LPFC_VPORT_ATTR(discovery_threads
, 32, 1, 64, "Maximum number of ELS commands "
1481 "during discovery");
1484 # lpfc_max_luns: maximum allowed LUN.
1485 # Value range is [0,65535]. Default value is 255.
1486 # NOTE: The SCSI layer might probe all allowed LUN on some old targets.
1488 LPFC_VPORT_ATTR_R(max_luns
, 255, 0, 65535, "Maximum allowed LUN");
1491 # lpfc_poll_tmo: .Milliseconds driver will wait between polling FCP ring.
1492 # Value range is [1,255], default value is 10.
1494 LPFC_ATTR_RW(poll_tmo
, 10, 1, 255,
1495 "Milliseconds driver will wait between polling FCP ring");
1498 # lpfc_use_msi: Use MSI (Message Signaled Interrupts) in systems that
1499 # support this feature
1500 # 0 = MSI disabled (default)
1502 # Value range is [0,1]. Default value is 0.
1504 LPFC_ATTR_R(use_msi
, 0, 0, 1, "Use Message Signaled Interrupts, if possible");
1508 struct class_device_attribute
*lpfc_hba_attrs
[] = {
1509 &class_device_attr_info
,
1510 &class_device_attr_serialnum
,
1511 &class_device_attr_modeldesc
,
1512 &class_device_attr_modelname
,
1513 &class_device_attr_programtype
,
1514 &class_device_attr_portnum
,
1515 &class_device_attr_fwrev
,
1516 &class_device_attr_hdw
,
1517 &class_device_attr_option_rom_version
,
1518 &class_device_attr_state
,
1519 &class_device_attr_num_discovered_ports
,
1520 &class_device_attr_lpfc_drvr_version
,
1521 &class_device_attr_lpfc_temp_sensor
,
1522 &class_device_attr_lpfc_log_verbose
,
1523 &class_device_attr_lpfc_lun_queue_depth
,
1524 &class_device_attr_lpfc_hba_queue_depth
,
1525 &class_device_attr_lpfc_peer_port_login
,
1526 &class_device_attr_lpfc_nodev_tmo
,
1527 &class_device_attr_lpfc_devloss_tmo
,
1528 &class_device_attr_lpfc_fcp_class
,
1529 &class_device_attr_lpfc_use_adisc
,
1530 &class_device_attr_lpfc_ack0
,
1531 &class_device_attr_lpfc_topology
,
1532 &class_device_attr_lpfc_scan_down
,
1533 &class_device_attr_lpfc_link_speed
,
1534 &class_device_attr_lpfc_cr_delay
,
1535 &class_device_attr_lpfc_cr_count
,
1536 &class_device_attr_lpfc_multi_ring_support
,
1537 &class_device_attr_lpfc_multi_ring_rctl
,
1538 &class_device_attr_lpfc_multi_ring_type
,
1539 &class_device_attr_lpfc_fdmi_on
,
1540 &class_device_attr_lpfc_max_luns
,
1541 &class_device_attr_lpfc_enable_npiv
,
1542 &class_device_attr_nport_evt_cnt
,
1543 &class_device_attr_board_mode
,
1544 &class_device_attr_max_vpi
,
1545 &class_device_attr_used_vpi
,
1546 &class_device_attr_max_rpi
,
1547 &class_device_attr_used_rpi
,
1548 &class_device_attr_max_xri
,
1549 &class_device_attr_used_xri
,
1550 &class_device_attr_npiv_info
,
1551 &class_device_attr_issue_reset
,
1552 &class_device_attr_lpfc_poll
,
1553 &class_device_attr_lpfc_poll_tmo
,
1554 &class_device_attr_lpfc_use_msi
,
1555 &class_device_attr_lpfc_soft_wwnn
,
1556 &class_device_attr_lpfc_soft_wwpn
,
1557 &class_device_attr_lpfc_soft_wwn_enable
,
1561 struct class_device_attribute
*lpfc_vport_attrs
[] = {
1562 &class_device_attr_info
,
1563 &class_device_attr_state
,
1564 &class_device_attr_num_discovered_ports
,
1565 &class_device_attr_lpfc_drvr_version
,
1567 &class_device_attr_lpfc_log_verbose
,
1568 &class_device_attr_lpfc_lun_queue_depth
,
1569 &class_device_attr_lpfc_nodev_tmo
,
1570 &class_device_attr_lpfc_devloss_tmo
,
1571 &class_device_attr_lpfc_hba_queue_depth
,
1572 &class_device_attr_lpfc_peer_port_login
,
1573 &class_device_attr_lpfc_restrict_login
,
1574 &class_device_attr_lpfc_fcp_class
,
1575 &class_device_attr_lpfc_use_adisc
,
1576 &class_device_attr_lpfc_fdmi_on
,
1577 &class_device_attr_lpfc_max_luns
,
1578 &class_device_attr_nport_evt_cnt
,
1579 &class_device_attr_npiv_info
,
1580 &class_device_attr_lpfc_enable_da_id
,
1585 sysfs_ctlreg_write(struct kobject
*kobj
, struct bin_attribute
*bin_attr
,
1586 char *buf
, loff_t off
, size_t count
)
1589 struct class_device
*cdev
= container_of(kobj
, struct class_device
,
1591 struct Scsi_Host
*shost
= class_to_shost(cdev
);
1592 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
1593 struct lpfc_hba
*phba
= vport
->phba
;
1595 if ((off
+ count
) > FF_REG_AREA_SIZE
)
1598 if (count
== 0) return 0;
1600 if (off
% 4 || count
% 4 || (unsigned long)buf
% 4)
1603 if (!(vport
->fc_flag
& FC_OFFLINE_MODE
)) {
1607 spin_lock_irq(&phba
->hbalock
);
1608 for (buf_off
= 0; buf_off
< count
; buf_off
+= sizeof(uint32_t))
1609 writel(*((uint32_t *)(buf
+ buf_off
)),
1610 phba
->ctrl_regs_memmap_p
+ off
+ buf_off
);
1612 spin_unlock_irq(&phba
->hbalock
);
1618 sysfs_ctlreg_read(struct kobject
*kobj
, struct bin_attribute
*bin_attr
,
1619 char *buf
, loff_t off
, size_t count
)
1623 struct class_device
*cdev
= container_of(kobj
, struct class_device
,
1625 struct Scsi_Host
*shost
= class_to_shost(cdev
);
1626 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
1627 struct lpfc_hba
*phba
= vport
->phba
;
1629 if (off
> FF_REG_AREA_SIZE
)
1632 if ((off
+ count
) > FF_REG_AREA_SIZE
)
1633 count
= FF_REG_AREA_SIZE
- off
;
1635 if (count
== 0) return 0;
1637 if (off
% 4 || count
% 4 || (unsigned long)buf
% 4)
1640 spin_lock_irq(&phba
->hbalock
);
1642 for (buf_off
= 0; buf_off
< count
; buf_off
+= sizeof(uint32_t)) {
1643 tmp_ptr
= (uint32_t *)(buf
+ buf_off
);
1644 *tmp_ptr
= readl(phba
->ctrl_regs_memmap_p
+ off
+ buf_off
);
1647 spin_unlock_irq(&phba
->hbalock
);
1652 static struct bin_attribute sysfs_ctlreg_attr
= {
1655 .mode
= S_IRUSR
| S_IWUSR
,
1658 .read
= sysfs_ctlreg_read
,
1659 .write
= sysfs_ctlreg_write
,
1664 sysfs_mbox_idle(struct lpfc_hba
*phba
)
1666 phba
->sysfs_mbox
.state
= SMBOX_IDLE
;
1667 phba
->sysfs_mbox
.offset
= 0;
1669 if (phba
->sysfs_mbox
.mbox
) {
1670 mempool_free(phba
->sysfs_mbox
.mbox
,
1671 phba
->mbox_mem_pool
);
1672 phba
->sysfs_mbox
.mbox
= NULL
;
1677 sysfs_mbox_write(struct kobject
*kobj
, struct bin_attribute
*bin_attr
,
1678 char *buf
, loff_t off
, size_t count
)
1680 struct class_device
*cdev
= container_of(kobj
, struct class_device
,
1682 struct Scsi_Host
*shost
= class_to_shost(cdev
);
1683 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
1684 struct lpfc_hba
*phba
= vport
->phba
;
1685 struct lpfcMboxq
*mbox
= NULL
;
1687 if ((count
+ off
) > MAILBOX_CMD_SIZE
)
1690 if (off
% 4 || count
% 4 || (unsigned long)buf
% 4)
1697 mbox
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
1700 memset(mbox
, 0, sizeof (LPFC_MBOXQ_t
));
1703 spin_lock_irq(&phba
->hbalock
);
1706 if (phba
->sysfs_mbox
.mbox
)
1707 mempool_free(mbox
, phba
->mbox_mem_pool
);
1709 phba
->sysfs_mbox
.mbox
= mbox
;
1710 phba
->sysfs_mbox
.state
= SMBOX_WRITING
;
1712 if (phba
->sysfs_mbox
.state
!= SMBOX_WRITING
||
1713 phba
->sysfs_mbox
.offset
!= off
||
1714 phba
->sysfs_mbox
.mbox
== NULL
) {
1715 sysfs_mbox_idle(phba
);
1716 spin_unlock_irq(&phba
->hbalock
);
1721 memcpy((uint8_t *) & phba
->sysfs_mbox
.mbox
->mb
+ off
,
1724 phba
->sysfs_mbox
.offset
= off
+ count
;
1726 spin_unlock_irq(&phba
->hbalock
);
1732 sysfs_mbox_read(struct kobject
*kobj
, struct bin_attribute
*bin_attr
,
1733 char *buf
, loff_t off
, size_t count
)
1735 struct class_device
*cdev
= container_of(kobj
, struct class_device
,
1737 struct Scsi_Host
*shost
= class_to_shost(cdev
);
1738 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
1739 struct lpfc_hba
*phba
= vport
->phba
;
1742 if (off
> MAILBOX_CMD_SIZE
)
1745 if ((count
+ off
) > MAILBOX_CMD_SIZE
)
1746 count
= MAILBOX_CMD_SIZE
- off
;
1748 if (off
% 4 || count
% 4 || (unsigned long)buf
% 4)
1751 if (off
&& count
== 0)
1754 spin_lock_irq(&phba
->hbalock
);
1757 phba
->sysfs_mbox
.state
== SMBOX_WRITING
&&
1758 phba
->sysfs_mbox
.offset
>= 2 * sizeof(uint32_t)) {
1760 switch (phba
->sysfs_mbox
.mbox
->mb
.mbxCommand
) {
1765 case MBX_CONFIG_LINK
:
1766 case MBX_CONFIG_RING
:
1767 case MBX_RESET_RING
:
1768 case MBX_UNREG_LOGIN
:
1770 case MBX_DUMP_CONTEXT
:
1773 case MBX_FLASH_WR_ULA
:
1777 if (!(vport
->fc_flag
& FC_OFFLINE_MODE
)) {
1778 printk(KERN_WARNING
"mbox_read:Command 0x%x "
1779 "is illegal in on-line state\n",
1780 phba
->sysfs_mbox
.mbox
->mb
.mbxCommand
);
1781 sysfs_mbox_idle(phba
);
1782 spin_unlock_irq(&phba
->hbalock
);
1787 case MBX_READ_CONFIG
:
1788 case MBX_READ_RCONFIG
:
1789 case MBX_READ_STATUS
:
1792 case MBX_READ_LNK_STAT
:
1793 case MBX_DUMP_MEMORY
:
1795 case MBX_UPDATE_CFG
:
1796 case MBX_KILL_BOARD
:
1798 case MBX_LOAD_EXP_ROM
:
1800 case MBX_DEL_LD_ENTRY
:
1802 case MBX_READ_SPARM64
:
1806 case MBX_REG_LOGIN64
:
1807 case MBX_CONFIG_PORT
:
1808 case MBX_RUN_BIU_DIAG
:
1809 printk(KERN_WARNING
"mbox_read: Illegal Command 0x%x\n",
1810 phba
->sysfs_mbox
.mbox
->mb
.mbxCommand
);
1811 sysfs_mbox_idle(phba
);
1812 spin_unlock_irq(&phba
->hbalock
);
1815 printk(KERN_WARNING
"mbox_read: Unknown Command 0x%x\n",
1816 phba
->sysfs_mbox
.mbox
->mb
.mbxCommand
);
1817 sysfs_mbox_idle(phba
);
1818 spin_unlock_irq(&phba
->hbalock
);
1822 phba
->sysfs_mbox
.mbox
->vport
= vport
;
1824 if (phba
->sli
.sli_flag
& LPFC_BLOCK_MGMT_IO
) {
1825 sysfs_mbox_idle(phba
);
1826 spin_unlock_irq(&phba
->hbalock
);
1830 if ((vport
->fc_flag
& FC_OFFLINE_MODE
) ||
1831 (!(phba
->sli
.sli_flag
& LPFC_SLI2_ACTIVE
))){
1833 spin_unlock_irq(&phba
->hbalock
);
1834 rc
= lpfc_sli_issue_mbox (phba
,
1835 phba
->sysfs_mbox
.mbox
,
1837 spin_lock_irq(&phba
->hbalock
);
1840 spin_unlock_irq(&phba
->hbalock
);
1841 rc
= lpfc_sli_issue_mbox_wait (phba
,
1842 phba
->sysfs_mbox
.mbox
,
1843 lpfc_mbox_tmo_val(phba
,
1844 phba
->sysfs_mbox
.mbox
->mb
.mbxCommand
) * HZ
);
1845 spin_lock_irq(&phba
->hbalock
);
1848 if (rc
!= MBX_SUCCESS
) {
1849 if (rc
== MBX_TIMEOUT
) {
1850 phba
->sysfs_mbox
.mbox
= NULL
;
1852 sysfs_mbox_idle(phba
);
1853 spin_unlock_irq(&phba
->hbalock
);
1854 return (rc
== MBX_TIMEOUT
) ? -ETIME
: -ENODEV
;
1856 phba
->sysfs_mbox
.state
= SMBOX_READING
;
1858 else if (phba
->sysfs_mbox
.offset
!= off
||
1859 phba
->sysfs_mbox
.state
!= SMBOX_READING
) {
1860 printk(KERN_WARNING
"mbox_read: Bad State\n");
1861 sysfs_mbox_idle(phba
);
1862 spin_unlock_irq(&phba
->hbalock
);
1866 memcpy(buf
, (uint8_t *) & phba
->sysfs_mbox
.mbox
->mb
+ off
, count
);
1868 phba
->sysfs_mbox
.offset
= off
+ count
;
1870 if (phba
->sysfs_mbox
.offset
== MAILBOX_CMD_SIZE
)
1871 sysfs_mbox_idle(phba
);
1873 spin_unlock_irq(&phba
->hbalock
);
1878 static struct bin_attribute sysfs_mbox_attr
= {
1881 .mode
= S_IRUSR
| S_IWUSR
,
1883 .size
= MAILBOX_CMD_SIZE
,
1884 .read
= sysfs_mbox_read
,
1885 .write
= sysfs_mbox_write
,
1889 lpfc_alloc_sysfs_attr(struct lpfc_vport
*vport
)
1891 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1894 error
= sysfs_create_bin_file(&shost
->shost_classdev
.kobj
,
1895 &sysfs_ctlreg_attr
);
1899 error
= sysfs_create_bin_file(&shost
->shost_classdev
.kobj
,
1902 goto out_remove_ctlreg_attr
;
1905 out_remove_ctlreg_attr
:
1906 sysfs_remove_bin_file(&shost
->shost_classdev
.kobj
, &sysfs_ctlreg_attr
);
1912 lpfc_free_sysfs_attr(struct lpfc_vport
*vport
)
1914 struct Scsi_Host
*shost
= lpfc_shost_from_vport(vport
);
1916 sysfs_remove_bin_file(&shost
->shost_classdev
.kobj
, &sysfs_mbox_attr
);
1917 sysfs_remove_bin_file(&shost
->shost_classdev
.kobj
, &sysfs_ctlreg_attr
);
1922 * Dynamic FC Host Attributes Support
1926 lpfc_get_host_port_id(struct Scsi_Host
*shost
)
1928 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
1930 /* note: fc_myDID already in cpu endianness */
1931 fc_host_port_id(shost
) = vport
->fc_myDID
;
1935 lpfc_get_host_port_type(struct Scsi_Host
*shost
)
1937 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
1938 struct lpfc_hba
*phba
= vport
->phba
;
1940 spin_lock_irq(shost
->host_lock
);
1942 if (vport
->port_type
== LPFC_NPIV_PORT
) {
1943 fc_host_port_type(shost
) = FC_PORTTYPE_NPIV
;
1944 } else if (lpfc_is_link_up(phba
)) {
1945 if (phba
->fc_topology
== TOPOLOGY_LOOP
) {
1946 if (vport
->fc_flag
& FC_PUBLIC_LOOP
)
1947 fc_host_port_type(shost
) = FC_PORTTYPE_NLPORT
;
1949 fc_host_port_type(shost
) = FC_PORTTYPE_LPORT
;
1951 if (vport
->fc_flag
& FC_FABRIC
)
1952 fc_host_port_type(shost
) = FC_PORTTYPE_NPORT
;
1954 fc_host_port_type(shost
) = FC_PORTTYPE_PTP
;
1957 fc_host_port_type(shost
) = FC_PORTTYPE_UNKNOWN
;
1959 spin_unlock_irq(shost
->host_lock
);
1963 lpfc_get_host_port_state(struct Scsi_Host
*shost
)
1965 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
1966 struct lpfc_hba
*phba
= vport
->phba
;
1968 spin_lock_irq(shost
->host_lock
);
1970 if (vport
->fc_flag
& FC_OFFLINE_MODE
)
1971 fc_host_port_state(shost
) = FC_PORTSTATE_OFFLINE
;
1973 switch (phba
->link_state
) {
1974 case LPFC_LINK_UNKNOWN
:
1975 case LPFC_LINK_DOWN
:
1976 fc_host_port_state(shost
) = FC_PORTSTATE_LINKDOWN
;
1980 case LPFC_HBA_READY
:
1981 /* Links up, beyond this port_type reports state */
1982 fc_host_port_state(shost
) = FC_PORTSTATE_ONLINE
;
1984 case LPFC_HBA_ERROR
:
1985 fc_host_port_state(shost
) = FC_PORTSTATE_ERROR
;
1988 fc_host_port_state(shost
) = FC_PORTSTATE_UNKNOWN
;
1993 spin_unlock_irq(shost
->host_lock
);
1997 lpfc_get_host_speed(struct Scsi_Host
*shost
)
1999 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
2000 struct lpfc_hba
*phba
= vport
->phba
;
2002 spin_lock_irq(shost
->host_lock
);
2004 if (lpfc_is_link_up(phba
)) {
2005 switch(phba
->fc_linkspeed
) {
2007 fc_host_speed(shost
) = FC_PORTSPEED_1GBIT
;
2010 fc_host_speed(shost
) = FC_PORTSPEED_2GBIT
;
2013 fc_host_speed(shost
) = FC_PORTSPEED_4GBIT
;
2016 fc_host_speed(shost
) = FC_PORTSPEED_8GBIT
;
2019 fc_host_speed(shost
) = FC_PORTSPEED_UNKNOWN
;
2024 spin_unlock_irq(shost
->host_lock
);
2028 lpfc_get_host_fabric_name (struct Scsi_Host
*shost
)
2030 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
2031 struct lpfc_hba
*phba
= vport
->phba
;
2034 spin_lock_irq(shost
->host_lock
);
2036 if ((vport
->fc_flag
& FC_FABRIC
) ||
2037 ((phba
->fc_topology
== TOPOLOGY_LOOP
) &&
2038 (vport
->fc_flag
& FC_PUBLIC_LOOP
)))
2039 node_name
= wwn_to_u64(phba
->fc_fabparam
.nodeName
.u
.wwn
);
2041 /* fabric is local port if there is no F/FL_Port */
2042 node_name
= wwn_to_u64(vport
->fc_nodename
.u
.wwn
);
2044 spin_unlock_irq(shost
->host_lock
);
2046 fc_host_fabric_name(shost
) = node_name
;
2049 static struct fc_host_statistics
*
2050 lpfc_get_stats(struct Scsi_Host
*shost
)
2052 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
2053 struct lpfc_hba
*phba
= vport
->phba
;
2054 struct lpfc_sli
*psli
= &phba
->sli
;
2055 struct fc_host_statistics
*hs
= &phba
->link_stats
;
2056 struct lpfc_lnk_stat
* lso
= &psli
->lnk_stat_offsets
;
2057 LPFC_MBOXQ_t
*pmboxq
;
2059 unsigned long seconds
;
2063 * prevent udev from issuing mailbox commands until the port is
2066 if (phba
->link_state
< LPFC_LINK_DOWN
||
2067 !phba
->mbox_mem_pool
||
2068 (phba
->sli
.sli_flag
& LPFC_SLI2_ACTIVE
) == 0)
2071 if (phba
->sli
.sli_flag
& LPFC_BLOCK_MGMT_IO
)
2074 pmboxq
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
2077 memset(pmboxq
, 0, sizeof (LPFC_MBOXQ_t
));
2080 pmb
->mbxCommand
= MBX_READ_STATUS
;
2081 pmb
->mbxOwner
= OWN_HOST
;
2082 pmboxq
->context1
= NULL
;
2083 pmboxq
->vport
= vport
;
2085 if ((vport
->fc_flag
& FC_OFFLINE_MODE
) ||
2086 (!(psli
->sli_flag
& LPFC_SLI2_ACTIVE
)))
2087 rc
= lpfc_sli_issue_mbox(phba
, pmboxq
, MBX_POLL
);
2089 rc
= lpfc_sli_issue_mbox_wait(phba
, pmboxq
, phba
->fc_ratov
* 2);
2091 if (rc
!= MBX_SUCCESS
) {
2092 if (rc
!= MBX_TIMEOUT
)
2093 mempool_free(pmboxq
, phba
->mbox_mem_pool
);
2097 memset(hs
, 0, sizeof (struct fc_host_statistics
));
2099 hs
->tx_frames
= pmb
->un
.varRdStatus
.xmitFrameCnt
;
2100 hs
->tx_words
= (pmb
->un
.varRdStatus
.xmitByteCnt
* 256);
2101 hs
->rx_frames
= pmb
->un
.varRdStatus
.rcvFrameCnt
;
2102 hs
->rx_words
= (pmb
->un
.varRdStatus
.rcvByteCnt
* 256);
2104 memset(pmboxq
, 0, sizeof (LPFC_MBOXQ_t
));
2105 pmb
->mbxCommand
= MBX_READ_LNK_STAT
;
2106 pmb
->mbxOwner
= OWN_HOST
;
2107 pmboxq
->context1
= NULL
;
2108 pmboxq
->vport
= vport
;
2110 if ((vport
->fc_flag
& FC_OFFLINE_MODE
) ||
2111 (!(psli
->sli_flag
& LPFC_SLI2_ACTIVE
)))
2112 rc
= lpfc_sli_issue_mbox(phba
, pmboxq
, MBX_POLL
);
2114 rc
= lpfc_sli_issue_mbox_wait(phba
, pmboxq
, phba
->fc_ratov
* 2);
2116 if (rc
!= MBX_SUCCESS
) {
2117 if (rc
!= MBX_TIMEOUT
)
2118 mempool_free(pmboxq
, phba
->mbox_mem_pool
);
2122 hs
->link_failure_count
= pmb
->un
.varRdLnk
.linkFailureCnt
;
2123 hs
->loss_of_sync_count
= pmb
->un
.varRdLnk
.lossSyncCnt
;
2124 hs
->loss_of_signal_count
= pmb
->un
.varRdLnk
.lossSignalCnt
;
2125 hs
->prim_seq_protocol_err_count
= pmb
->un
.varRdLnk
.primSeqErrCnt
;
2126 hs
->invalid_tx_word_count
= pmb
->un
.varRdLnk
.invalidXmitWord
;
2127 hs
->invalid_crc_count
= pmb
->un
.varRdLnk
.crcCnt
;
2128 hs
->error_frames
= pmb
->un
.varRdLnk
.crcCnt
;
2130 hs
->link_failure_count
-= lso
->link_failure_count
;
2131 hs
->loss_of_sync_count
-= lso
->loss_of_sync_count
;
2132 hs
->loss_of_signal_count
-= lso
->loss_of_signal_count
;
2133 hs
->prim_seq_protocol_err_count
-= lso
->prim_seq_protocol_err_count
;
2134 hs
->invalid_tx_word_count
-= lso
->invalid_tx_word_count
;
2135 hs
->invalid_crc_count
-= lso
->invalid_crc_count
;
2136 hs
->error_frames
-= lso
->error_frames
;
2138 if (phba
->fc_topology
== TOPOLOGY_LOOP
) {
2139 hs
->lip_count
= (phba
->fc_eventTag
>> 1);
2140 hs
->lip_count
-= lso
->link_events
;
2144 hs
->nos_count
= (phba
->fc_eventTag
>> 1);
2145 hs
->nos_count
-= lso
->link_events
;
2148 hs
->dumped_frames
= -1;
2150 seconds
= get_seconds();
2151 if (seconds
< psli
->stats_start
)
2152 hs
->seconds_since_last_reset
= seconds
+
2153 ((unsigned long)-1 - psli
->stats_start
);
2155 hs
->seconds_since_last_reset
= seconds
- psli
->stats_start
;
2157 mempool_free(pmboxq
, phba
->mbox_mem_pool
);
2163 lpfc_reset_stats(struct Scsi_Host
*shost
)
2165 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
2166 struct lpfc_hba
*phba
= vport
->phba
;
2167 struct lpfc_sli
*psli
= &phba
->sli
;
2168 struct lpfc_lnk_stat
*lso
= &psli
->lnk_stat_offsets
;
2169 LPFC_MBOXQ_t
*pmboxq
;
2173 if (phba
->sli
.sli_flag
& LPFC_BLOCK_MGMT_IO
)
2176 pmboxq
= mempool_alloc(phba
->mbox_mem_pool
, GFP_KERNEL
);
2179 memset(pmboxq
, 0, sizeof(LPFC_MBOXQ_t
));
2182 pmb
->mbxCommand
= MBX_READ_STATUS
;
2183 pmb
->mbxOwner
= OWN_HOST
;
2184 pmb
->un
.varWords
[0] = 0x1; /* reset request */
2185 pmboxq
->context1
= NULL
;
2186 pmboxq
->vport
= vport
;
2188 if ((vport
->fc_flag
& FC_OFFLINE_MODE
) ||
2189 (!(psli
->sli_flag
& LPFC_SLI2_ACTIVE
)))
2190 rc
= lpfc_sli_issue_mbox(phba
, pmboxq
, MBX_POLL
);
2192 rc
= lpfc_sli_issue_mbox_wait(phba
, pmboxq
, phba
->fc_ratov
* 2);
2194 if (rc
!= MBX_SUCCESS
) {
2195 if (rc
!= MBX_TIMEOUT
)
2196 mempool_free(pmboxq
, phba
->mbox_mem_pool
);
2200 memset(pmboxq
, 0, sizeof(LPFC_MBOXQ_t
));
2201 pmb
->mbxCommand
= MBX_READ_LNK_STAT
;
2202 pmb
->mbxOwner
= OWN_HOST
;
2203 pmboxq
->context1
= NULL
;
2204 pmboxq
->vport
= vport
;
2206 if ((vport
->fc_flag
& FC_OFFLINE_MODE
) ||
2207 (!(psli
->sli_flag
& LPFC_SLI2_ACTIVE
)))
2208 rc
= lpfc_sli_issue_mbox(phba
, pmboxq
, MBX_POLL
);
2210 rc
= lpfc_sli_issue_mbox_wait(phba
, pmboxq
, phba
->fc_ratov
* 2);
2212 if (rc
!= MBX_SUCCESS
) {
2213 if (rc
!= MBX_TIMEOUT
)
2214 mempool_free( pmboxq
, phba
->mbox_mem_pool
);
2218 lso
->link_failure_count
= pmb
->un
.varRdLnk
.linkFailureCnt
;
2219 lso
->loss_of_sync_count
= pmb
->un
.varRdLnk
.lossSyncCnt
;
2220 lso
->loss_of_signal_count
= pmb
->un
.varRdLnk
.lossSignalCnt
;
2221 lso
->prim_seq_protocol_err_count
= pmb
->un
.varRdLnk
.primSeqErrCnt
;
2222 lso
->invalid_tx_word_count
= pmb
->un
.varRdLnk
.invalidXmitWord
;
2223 lso
->invalid_crc_count
= pmb
->un
.varRdLnk
.crcCnt
;
2224 lso
->error_frames
= pmb
->un
.varRdLnk
.crcCnt
;
2225 lso
->link_events
= (phba
->fc_eventTag
>> 1);
2227 psli
->stats_start
= get_seconds();
2229 mempool_free(pmboxq
, phba
->mbox_mem_pool
);
2235 * The LPFC driver treats linkdown handling as target loss events so there
2236 * are no sysfs handlers for link_down_tmo.
2239 static struct lpfc_nodelist
*
2240 lpfc_get_node_by_target(struct scsi_target
*starget
)
2242 struct Scsi_Host
*shost
= dev_to_shost(starget
->dev
.parent
);
2243 struct lpfc_vport
*vport
= (struct lpfc_vport
*) shost
->hostdata
;
2244 struct lpfc_nodelist
*ndlp
;
2246 spin_lock_irq(shost
->host_lock
);
2247 /* Search for this, mapped, target ID */
2248 list_for_each_entry(ndlp
, &vport
->fc_nodes
, nlp_listp
) {
2249 if (ndlp
->nlp_state
== NLP_STE_MAPPED_NODE
&&
2250 starget
->id
== ndlp
->nlp_sid
) {
2251 spin_unlock_irq(shost
->host_lock
);
2255 spin_unlock_irq(shost
->host_lock
);
2260 lpfc_get_starget_port_id(struct scsi_target
*starget
)
2262 struct lpfc_nodelist
*ndlp
= lpfc_get_node_by_target(starget
);
2264 fc_starget_port_id(starget
) = ndlp
? ndlp
->nlp_DID
: -1;
2268 lpfc_get_starget_node_name(struct scsi_target
*starget
)
2270 struct lpfc_nodelist
*ndlp
= lpfc_get_node_by_target(starget
);
2272 fc_starget_node_name(starget
) =
2273 ndlp
? wwn_to_u64(ndlp
->nlp_nodename
.u
.wwn
) : 0;
2277 lpfc_get_starget_port_name(struct scsi_target
*starget
)
2279 struct lpfc_nodelist
*ndlp
= lpfc_get_node_by_target(starget
);
2281 fc_starget_port_name(starget
) =
2282 ndlp
? wwn_to_u64(ndlp
->nlp_portname
.u
.wwn
) : 0;
2286 lpfc_set_rport_loss_tmo(struct fc_rport
*rport
, uint32_t timeout
)
2289 rport
->dev_loss_tmo
= timeout
;
2291 rport
->dev_loss_tmo
= 1;
2295 #define lpfc_rport_show_function(field, format_string, sz, cast) \
2297 lpfc_show_rport_##field (struct class_device *cdev, char *buf) \
2299 struct fc_rport *rport = transport_class_to_rport(cdev); \
2300 struct lpfc_rport_data *rdata = rport->hostdata; \
2301 return snprintf(buf, sz, format_string, \
2302 (rdata->target) ? cast rdata->target->field : 0); \
2305 #define lpfc_rport_rd_attr(field, format_string, sz) \
2306 lpfc_rport_show_function(field, format_string, sz, ) \
2307 static FC_RPORT_ATTR(field, S_IRUGO, lpfc_show_rport_##field, NULL)
2310 struct fc_function_template lpfc_transport_functions
= {
2311 /* fixed attributes the driver supports */
2312 .show_host_node_name
= 1,
2313 .show_host_port_name
= 1,
2314 .show_host_supported_classes
= 1,
2315 .show_host_supported_fc4s
= 1,
2316 .show_host_supported_speeds
= 1,
2317 .show_host_maxframe_size
= 1,
2319 /* dynamic attributes the driver supports */
2320 .get_host_port_id
= lpfc_get_host_port_id
,
2321 .show_host_port_id
= 1,
2323 .get_host_port_type
= lpfc_get_host_port_type
,
2324 .show_host_port_type
= 1,
2326 .get_host_port_state
= lpfc_get_host_port_state
,
2327 .show_host_port_state
= 1,
2329 /* active_fc4s is shown but doesn't change (thus no get function) */
2330 .show_host_active_fc4s
= 1,
2332 .get_host_speed
= lpfc_get_host_speed
,
2333 .show_host_speed
= 1,
2335 .get_host_fabric_name
= lpfc_get_host_fabric_name
,
2336 .show_host_fabric_name
= 1,
2339 * The LPFC driver treats linkdown handling as target loss events
2340 * so there are no sysfs handlers for link_down_tmo.
2343 .get_fc_host_stats
= lpfc_get_stats
,
2344 .reset_fc_host_stats
= lpfc_reset_stats
,
2346 .dd_fcrport_size
= sizeof(struct lpfc_rport_data
),
2347 .show_rport_maxframe_size
= 1,
2348 .show_rport_supported_classes
= 1,
2350 .set_rport_dev_loss_tmo
= lpfc_set_rport_loss_tmo
,
2351 .show_rport_dev_loss_tmo
= 1,
2353 .get_starget_port_id
= lpfc_get_starget_port_id
,
2354 .show_starget_port_id
= 1,
2356 .get_starget_node_name
= lpfc_get_starget_node_name
,
2357 .show_starget_node_name
= 1,
2359 .get_starget_port_name
= lpfc_get_starget_port_name
,
2360 .show_starget_port_name
= 1,
2362 .issue_fc_host_lip
= lpfc_issue_lip
,
2363 .dev_loss_tmo_callbk
= lpfc_dev_loss_tmo_callbk
,
2364 .terminate_rport_io
= lpfc_terminate_rport_io
,
2366 .dd_fcvport_size
= sizeof(struct lpfc_vport
*),
2369 struct fc_function_template lpfc_vport_transport_functions
= {
2370 /* fixed attributes the driver supports */
2371 .show_host_node_name
= 1,
2372 .show_host_port_name
= 1,
2373 .show_host_supported_classes
= 1,
2374 .show_host_supported_fc4s
= 1,
2375 .show_host_supported_speeds
= 1,
2376 .show_host_maxframe_size
= 1,
2378 /* dynamic attributes the driver supports */
2379 .get_host_port_id
= lpfc_get_host_port_id
,
2380 .show_host_port_id
= 1,
2382 .get_host_port_type
= lpfc_get_host_port_type
,
2383 .show_host_port_type
= 1,
2385 .get_host_port_state
= lpfc_get_host_port_state
,
2386 .show_host_port_state
= 1,
2388 /* active_fc4s is shown but doesn't change (thus no get function) */
2389 .show_host_active_fc4s
= 1,
2391 .get_host_speed
= lpfc_get_host_speed
,
2392 .show_host_speed
= 1,
2394 .get_host_fabric_name
= lpfc_get_host_fabric_name
,
2395 .show_host_fabric_name
= 1,
2398 * The LPFC driver treats linkdown handling as target loss events
2399 * so there are no sysfs handlers for link_down_tmo.
2402 .get_fc_host_stats
= lpfc_get_stats
,
2403 .reset_fc_host_stats
= lpfc_reset_stats
,
2405 .dd_fcrport_size
= sizeof(struct lpfc_rport_data
),
2406 .show_rport_maxframe_size
= 1,
2407 .show_rport_supported_classes
= 1,
2409 .set_rport_dev_loss_tmo
= lpfc_set_rport_loss_tmo
,
2410 .show_rport_dev_loss_tmo
= 1,
2412 .get_starget_port_id
= lpfc_get_starget_port_id
,
2413 .show_starget_port_id
= 1,
2415 .get_starget_node_name
= lpfc_get_starget_node_name
,
2416 .show_starget_node_name
= 1,
2418 .get_starget_port_name
= lpfc_get_starget_port_name
,
2419 .show_starget_port_name
= 1,
2421 .dev_loss_tmo_callbk
= lpfc_dev_loss_tmo_callbk
,
2422 .terminate_rport_io
= lpfc_terminate_rport_io
,
2424 .vport_disable
= lpfc_vport_disable
,
2428 lpfc_get_cfgparam(struct lpfc_hba
*phba
)
2430 lpfc_cr_delay_init(phba
, lpfc_cr_delay
);
2431 lpfc_cr_count_init(phba
, lpfc_cr_count
);
2432 lpfc_multi_ring_support_init(phba
, lpfc_multi_ring_support
);
2433 lpfc_multi_ring_rctl_init(phba
, lpfc_multi_ring_rctl
);
2434 lpfc_multi_ring_type_init(phba
, lpfc_multi_ring_type
);
2435 lpfc_ack0_init(phba
, lpfc_ack0
);
2436 lpfc_topology_init(phba
, lpfc_topology
);
2437 lpfc_link_speed_init(phba
, lpfc_link_speed
);
2438 lpfc_poll_tmo_init(phba
, lpfc_poll_tmo
);
2439 lpfc_enable_npiv_init(phba
, lpfc_enable_npiv
);
2440 lpfc_use_msi_init(phba
, lpfc_use_msi
);
2441 phba
->cfg_poll
= lpfc_poll
;
2442 phba
->cfg_soft_wwnn
= 0L;
2443 phba
->cfg_soft_wwpn
= 0L;
2445 * The total number of segments is the configuration value plus 2
2446 * since the IOCB need a command and response bde.
2448 phba
->cfg_sg_seg_cnt
= LPFC_SG_SEG_CNT
+ 2;
2450 * Since the sg_tablesize is module parameter, the sg_dma_buf_size
2451 * used to create the sg_dma_buf_pool must be dynamically calculated
2453 phba
->cfg_sg_dma_buf_size
= sizeof(struct fcp_cmnd
) +
2454 sizeof(struct fcp_rsp
) +
2455 (phba
->cfg_sg_seg_cnt
* sizeof(struct ulp_bde64
));
2456 lpfc_hba_queue_depth_init(phba
, lpfc_hba_queue_depth
);
2461 lpfc_get_vport_cfgparam(struct lpfc_vport
*vport
)
2463 lpfc_log_verbose_init(vport
, lpfc_log_verbose
);
2464 lpfc_lun_queue_depth_init(vport
, lpfc_lun_queue_depth
);
2465 lpfc_devloss_tmo_init(vport
, lpfc_devloss_tmo
);
2466 lpfc_nodev_tmo_init(vport
, lpfc_nodev_tmo
);
2467 lpfc_peer_port_login_init(vport
, lpfc_peer_port_login
);
2468 lpfc_restrict_login_init(vport
, lpfc_restrict_login
);
2469 lpfc_fcp_class_init(vport
, lpfc_fcp_class
);
2470 lpfc_use_adisc_init(vport
, lpfc_use_adisc
);
2471 lpfc_fdmi_on_init(vport
, lpfc_fdmi_on
);
2472 lpfc_discovery_threads_init(vport
, lpfc_discovery_threads
);
2473 lpfc_max_luns_init(vport
, lpfc_max_luns
);
2474 lpfc_scan_down_init(vport
, lpfc_scan_down
);
2475 lpfc_enable_da_id_init(vport
, lpfc_enable_da_id
);