2 * Copyright (c) 2005-2010 Brocade Communications Systems, Inc.
6 * Linux driver for Brocade Fibre Channel Host Bus Adapter.
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License (GPL) Version 2 as
10 * published by the Free Software Foundation
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
19 * bfad.c Linux driver PCI interface module.
21 #include <linux/module.h>
22 #include <linux/kthread.h>
23 #include <linux/errno.h>
24 #include <linux/sched.h>
25 #include <linux/init.h>
27 #include <linux/pci.h>
28 #include <linux/firmware.h>
29 #include <asm/uaccess.h>
30 #include <asm/fcntl.h>
38 BFA_TRC_FILE(LDRV
, BFAD
);
39 DEFINE_MUTEX(bfad_mutex
);
43 static int num_sgpgs_parm
;
45 char *host_name
, *os_name
, *os_patch
;
46 int num_rports
, num_ios
, num_tms
;
47 int num_fcxps
, num_ufbufs
;
48 int reqq_size
, rspq_size
, num_sgpgs
;
49 int rport_del_timeout
= BFA_FCS_RPORT_DEF_DEL_TIMEOUT
;
50 int bfa_lun_queue_depth
= BFAD_LUN_QUEUE_DEPTH
;
51 int bfa_io_max_sge
= BFAD_IO_MAX_SGE
;
52 int bfa_log_level
= 3; /* WARNING log level */
53 int ioc_auto_recover
= BFA_TRUE
;
54 int bfa_linkup_delay
= -1;
55 int fdmi_enable
= BFA_TRUE
;
56 int pcie_max_read_reqsz
;
57 int bfa_debugfs_enable
= 1;
58 int msix_disable_cb
= 0, msix_disable_ct
= 0;
59 int max_xfer_size
= BFAD_MAX_SECTORS
>> 1;
60 int max_rport_logins
= BFA_FCS_MAX_RPORT_LOGINS
;
62 /* Firmware releated */
63 u32 bfi_image_cb_size
, bfi_image_ct_size
, bfi_image_ct2_size
;
64 u32
*bfi_image_cb
, *bfi_image_ct
, *bfi_image_ct2
;
66 #define BFAD_FW_FILE_CB "cbfw-3.2.1.0.bin"
67 #define BFAD_FW_FILE_CT "ctfw-3.2.1.0.bin"
68 #define BFAD_FW_FILE_CT2 "ct2fw-3.2.1.0.bin"
70 static u32
*bfad_load_fwimg(struct pci_dev
*pdev
);
71 static void bfad_free_fwimg(void);
72 static void bfad_read_firmware(struct pci_dev
*pdev
, u32
**bfi_image
,
73 u32
*bfi_image_size
, char *fw_name
);
75 static const char *msix_name_ct
[] = {
77 "cpe0", "cpe1", "cpe2", "cpe3",
78 "rme0", "rme1", "rme2", "rme3" };
80 static const char *msix_name_cb
[] = {
81 "cpe0", "cpe1", "cpe2", "cpe3",
82 "rme0", "rme1", "rme2", "rme3",
83 "eemc", "elpu0", "elpu1", "epss", "mlpu" };
85 MODULE_FIRMWARE(BFAD_FW_FILE_CB
);
86 MODULE_FIRMWARE(BFAD_FW_FILE_CT
);
87 MODULE_FIRMWARE(BFAD_FW_FILE_CT2
);
89 module_param(os_name
, charp
, S_IRUGO
| S_IWUSR
);
90 MODULE_PARM_DESC(os_name
, "OS name of the hba host machine");
91 module_param(os_patch
, charp
, S_IRUGO
| S_IWUSR
);
92 MODULE_PARM_DESC(os_patch
, "OS patch level of the hba host machine");
93 module_param(host_name
, charp
, S_IRUGO
| S_IWUSR
);
94 MODULE_PARM_DESC(host_name
, "Hostname of the hba host machine");
95 module_param(num_rports
, int, S_IRUGO
| S_IWUSR
);
96 MODULE_PARM_DESC(num_rports
, "Max number of rports supported per port "
97 "(physical/logical), default=1024");
98 module_param(num_ios
, int, S_IRUGO
| S_IWUSR
);
99 MODULE_PARM_DESC(num_ios
, "Max number of ioim requests, default=2000");
100 module_param(num_tms
, int, S_IRUGO
| S_IWUSR
);
101 MODULE_PARM_DESC(num_tms
, "Max number of task im requests, default=128");
102 module_param(num_fcxps
, int, S_IRUGO
| S_IWUSR
);
103 MODULE_PARM_DESC(num_fcxps
, "Max number of fcxp requests, default=64");
104 module_param(num_ufbufs
, int, S_IRUGO
| S_IWUSR
);
105 MODULE_PARM_DESC(num_ufbufs
, "Max number of unsolicited frame "
106 "buffers, default=64");
107 module_param(reqq_size
, int, S_IRUGO
| S_IWUSR
);
108 MODULE_PARM_DESC(reqq_size
, "Max number of request queue elements, "
110 module_param(rspq_size
, int, S_IRUGO
| S_IWUSR
);
111 MODULE_PARM_DESC(rspq_size
, "Max number of response queue elements, "
113 module_param(num_sgpgs
, int, S_IRUGO
| S_IWUSR
);
114 MODULE_PARM_DESC(num_sgpgs
, "Number of scatter/gather pages, default=2048");
115 module_param(rport_del_timeout
, int, S_IRUGO
| S_IWUSR
);
116 MODULE_PARM_DESC(rport_del_timeout
, "Rport delete timeout, default=90 secs, "
118 module_param(bfa_lun_queue_depth
, int, S_IRUGO
| S_IWUSR
);
119 MODULE_PARM_DESC(bfa_lun_queue_depth
, "Lun queue depth, default=32, Range[>0]");
120 module_param(bfa_io_max_sge
, int, S_IRUGO
| S_IWUSR
);
121 MODULE_PARM_DESC(bfa_io_max_sge
, "Max io scatter/gather elements, default=255");
122 module_param(bfa_log_level
, int, S_IRUGO
| S_IWUSR
);
123 MODULE_PARM_DESC(bfa_log_level
, "Driver log level, default=3, "
124 "Range[Critical:1|Error:2|Warning:3|Info:4]");
125 module_param(ioc_auto_recover
, int, S_IRUGO
| S_IWUSR
);
126 MODULE_PARM_DESC(ioc_auto_recover
, "IOC auto recovery, default=1, "
127 "Range[off:0|on:1]");
128 module_param(bfa_linkup_delay
, int, S_IRUGO
| S_IWUSR
);
129 MODULE_PARM_DESC(bfa_linkup_delay
, "Link up delay, default=30 secs for "
130 "boot port. Otherwise 10 secs in RHEL4 & 0 for "
131 "[RHEL5, SLES10, ESX40] Range[>0]");
132 module_param(msix_disable_cb
, int, S_IRUGO
| S_IWUSR
);
133 MODULE_PARM_DESC(msix_disable_cb
, "Disable Message Signaled Interrupts "
134 "for Brocade-415/425/815/825 cards, default=0, "
135 " Range[false:0|true:1]");
136 module_param(msix_disable_ct
, int, S_IRUGO
| S_IWUSR
);
137 MODULE_PARM_DESC(msix_disable_ct
, "Disable Message Signaled Interrupts "
138 "if possible for Brocade-1010/1020/804/1007/902/1741 "
139 "cards, default=0, Range[false:0|true:1]");
140 module_param(fdmi_enable
, int, S_IRUGO
| S_IWUSR
);
141 MODULE_PARM_DESC(fdmi_enable
, "Enables fdmi registration, default=1, "
142 "Range[false:0|true:1]");
143 module_param(pcie_max_read_reqsz
, int, S_IRUGO
| S_IWUSR
);
144 MODULE_PARM_DESC(pcie_max_read_reqsz
, "PCIe max read request size, default=0 "
145 "(use system setting), Range[128|256|512|1024|2048|4096]");
146 module_param(bfa_debugfs_enable
, int, S_IRUGO
| S_IWUSR
);
147 MODULE_PARM_DESC(bfa_debugfs_enable
, "Enables debugfs feature, default=1,"
148 " Range[false:0|true:1]");
149 module_param(max_xfer_size
, int, S_IRUGO
| S_IWUSR
);
150 MODULE_PARM_DESC(max_xfer_size
, "default=32MB,"
151 " Range[64k|128k|256k|512k|1024k|2048k]");
152 module_param(max_rport_logins
, int, S_IRUGO
| S_IWUSR
);
153 MODULE_PARM_DESC(max_rport_logins
, "Max number of logins to initiator and target rports on a port (physical/logical), default=1024");
156 bfad_sm_uninit(struct bfad_s
*bfad
, enum bfad_sm_event event
);
158 bfad_sm_created(struct bfad_s
*bfad
, enum bfad_sm_event event
);
160 bfad_sm_initializing(struct bfad_s
*bfad
, enum bfad_sm_event event
);
162 bfad_sm_operational(struct bfad_s
*bfad
, enum bfad_sm_event event
);
164 bfad_sm_stopping(struct bfad_s
*bfad
, enum bfad_sm_event event
);
166 bfad_sm_failed(struct bfad_s
*bfad
, enum bfad_sm_event event
);
168 bfad_sm_fcs_exit(struct bfad_s
*bfad
, enum bfad_sm_event event
);
171 * Beginning state for the driver instance, awaiting the pci_probe event
174 bfad_sm_uninit(struct bfad_s
*bfad
, enum bfad_sm_event event
)
176 bfa_trc(bfad
, event
);
180 bfa_sm_set_state(bfad
, bfad_sm_created
);
181 bfad
->bfad_tsk
= kthread_create(bfad_worker
, (void *) bfad
,
182 "%s", "bfad_worker");
183 if (IS_ERR(bfad
->bfad_tsk
)) {
184 printk(KERN_INFO
"bfad[%d]: Kernel thread "
185 "creation failed!\n", bfad
->inst_no
);
186 bfa_sm_send_event(bfad
, BFAD_E_KTHREAD_CREATE_FAILED
);
188 bfa_sm_send_event(bfad
, BFAD_E_INIT
);
192 /* Ignore stop; already in uninit */
196 bfa_sm_fault(bfad
, event
);
201 * Driver Instance is created, awaiting event INIT to initialize the bfad
204 bfad_sm_created(struct bfad_s
*bfad
, enum bfad_sm_event event
)
208 bfa_trc(bfad
, event
);
212 bfa_sm_set_state(bfad
, bfad_sm_initializing
);
214 init_completion(&bfad
->comp
);
216 /* Enable Interrupt and wait bfa_init completion */
217 if (bfad_setup_intr(bfad
)) {
218 printk(KERN_WARNING
"bfad%d: bfad_setup_intr failed\n",
220 bfa_sm_send_event(bfad
, BFAD_E_INTR_INIT_FAILED
);
224 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
225 bfa_iocfc_init(&bfad
->bfa
);
226 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
228 /* Set up interrupt handler for each vectors */
229 if ((bfad
->bfad_flags
& BFAD_MSIX_ON
) &&
230 bfad_install_msix_handler(bfad
)) {
231 printk(KERN_WARNING
"%s: install_msix failed, bfad%d\n",
232 __func__
, bfad
->inst_no
);
235 bfad_init_timer(bfad
);
237 wait_for_completion(&bfad
->comp
);
239 if ((bfad
->bfad_flags
& BFAD_HAL_INIT_DONE
)) {
240 bfa_sm_send_event(bfad
, BFAD_E_INIT_SUCCESS
);
243 "bfa %s: bfa init failed\n",
245 bfad
->bfad_flags
|= BFAD_HAL_INIT_FAIL
;
246 bfa_sm_send_event(bfad
, BFAD_E_INIT_FAILED
);
251 case BFAD_E_KTHREAD_CREATE_FAILED
:
252 bfa_sm_set_state(bfad
, bfad_sm_uninit
);
256 bfa_sm_fault(bfad
, event
);
261 bfad_sm_initializing(struct bfad_s
*bfad
, enum bfad_sm_event event
)
266 bfa_trc(bfad
, event
);
269 case BFAD_E_INIT_SUCCESS
:
270 kthread_stop(bfad
->bfad_tsk
);
271 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
272 bfad
->bfad_tsk
= NULL
;
273 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
275 retval
= bfad_start_ops(bfad
);
276 if (retval
!= BFA_STATUS_OK
)
278 bfa_sm_set_state(bfad
, bfad_sm_operational
);
281 case BFAD_E_INTR_INIT_FAILED
:
282 bfa_sm_set_state(bfad
, bfad_sm_uninit
);
283 kthread_stop(bfad
->bfad_tsk
);
284 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
285 bfad
->bfad_tsk
= NULL
;
286 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
289 case BFAD_E_INIT_FAILED
:
290 bfa_sm_set_state(bfad
, bfad_sm_failed
);
293 bfa_sm_fault(bfad
, event
);
298 bfad_sm_failed(struct bfad_s
*bfad
, enum bfad_sm_event event
)
302 bfa_trc(bfad
, event
);
305 case BFAD_E_INIT_SUCCESS
:
306 retval
= bfad_start_ops(bfad
);
307 if (retval
!= BFA_STATUS_OK
)
309 bfa_sm_set_state(bfad
, bfad_sm_operational
);
313 if (bfad
->bfad_flags
& BFAD_CFG_PPORT_DONE
)
314 bfad_uncfg_pport(bfad
);
315 if (bfad
->bfad_flags
& BFAD_FC4_PROBE_DONE
) {
316 bfad_im_probe_undo(bfad
);
317 bfad
->bfad_flags
&= ~BFAD_FC4_PROBE_DONE
;
322 case BFAD_E_EXIT_COMP
:
323 bfa_sm_set_state(bfad
, bfad_sm_uninit
);
324 bfad_remove_intr(bfad
);
325 del_timer_sync(&bfad
->hal_tmo
);
329 bfa_sm_fault(bfad
, event
);
334 bfad_sm_operational(struct bfad_s
*bfad
, enum bfad_sm_event event
)
336 bfa_trc(bfad
, event
);
340 bfa_sm_set_state(bfad
, bfad_sm_fcs_exit
);
345 bfa_sm_fault(bfad
, event
);
350 bfad_sm_fcs_exit(struct bfad_s
*bfad
, enum bfad_sm_event event
)
352 bfa_trc(bfad
, event
);
355 case BFAD_E_FCS_EXIT_COMP
:
356 bfa_sm_set_state(bfad
, bfad_sm_stopping
);
361 bfa_sm_fault(bfad
, event
);
366 bfad_sm_stopping(struct bfad_s
*bfad
, enum bfad_sm_event event
)
368 bfa_trc(bfad
, event
);
371 case BFAD_E_EXIT_COMP
:
372 bfa_sm_set_state(bfad
, bfad_sm_uninit
);
373 bfad_remove_intr(bfad
);
374 del_timer_sync(&bfad
->hal_tmo
);
375 bfad_im_probe_undo(bfad
);
376 bfad
->bfad_flags
&= ~BFAD_FC4_PROBE_DONE
;
377 bfad_uncfg_pport(bfad
);
381 bfa_sm_fault(bfad
, event
);
390 bfad_hcb_comp(void *arg
, bfa_status_t status
)
392 struct bfad_hal_comp
*fcomp
= (struct bfad_hal_comp
*)arg
;
394 fcomp
->status
= status
;
395 complete(&fcomp
->comp
);
402 bfa_cb_init(void *drv
, bfa_status_t init_status
)
404 struct bfad_s
*bfad
= drv
;
406 if (init_status
== BFA_STATUS_OK
) {
407 bfad
->bfad_flags
|= BFAD_HAL_INIT_DONE
;
410 * If BFAD_HAL_INIT_FAIL flag is set:
411 * Wake up the kernel thread to start
412 * the bfad operations after HAL init done
414 if ((bfad
->bfad_flags
& BFAD_HAL_INIT_FAIL
)) {
415 bfad
->bfad_flags
&= ~BFAD_HAL_INIT_FAIL
;
416 wake_up_process(bfad
->bfad_tsk
);
420 complete(&bfad
->comp
);
427 bfa_fcb_lport_new(struct bfad_s
*bfad
, struct bfa_fcs_lport_s
*port
,
428 enum bfa_lport_role roles
, struct bfad_vf_s
*vf_drv
,
429 struct bfad_vport_s
*vp_drv
)
432 struct bfad_port_s
*port_drv
;
434 if (!vp_drv
&& !vf_drv
) {
435 port_drv
= &bfad
->pport
;
436 port_drv
->pvb_type
= BFAD_PORT_PHYS_BASE
;
437 } else if (!vp_drv
&& vf_drv
) {
438 port_drv
= &vf_drv
->base_port
;
439 port_drv
->pvb_type
= BFAD_PORT_VF_BASE
;
440 } else if (vp_drv
&& !vf_drv
) {
441 port_drv
= &vp_drv
->drv_port
;
442 port_drv
->pvb_type
= BFAD_PORT_PHYS_VPORT
;
444 port_drv
= &vp_drv
->drv_port
;
445 port_drv
->pvb_type
= BFAD_PORT_VF_VPORT
;
448 port_drv
->fcs_port
= port
;
449 port_drv
->roles
= roles
;
451 if (roles
& BFA_LPORT_ROLE_FCP_IM
) {
452 rc
= bfad_im_port_new(bfad
, port_drv
);
453 if (rc
!= BFA_STATUS_OK
) {
454 bfad_im_port_delete(bfad
, port_drv
);
463 * FCS RPORT alloc callback, after successful PLOGI by FCS
466 bfa_fcb_rport_alloc(struct bfad_s
*bfad
, struct bfa_fcs_rport_s
**rport
,
467 struct bfad_rport_s
**rport_drv
)
469 bfa_status_t rc
= BFA_STATUS_OK
;
471 *rport_drv
= kzalloc(sizeof(struct bfad_rport_s
), GFP_ATOMIC
);
472 if (*rport_drv
== NULL
) {
473 rc
= BFA_STATUS_ENOMEM
;
477 *rport
= &(*rport_drv
)->fcs_rport
;
484 * FCS PBC VPORT Create
487 bfa_fcb_pbc_vport_create(struct bfad_s
*bfad
, struct bfi_pbc_vport_s pbc_vport
)
490 struct bfa_lport_cfg_s port_cfg
= {0};
491 struct bfad_vport_s
*vport
;
494 vport
= kzalloc(sizeof(struct bfad_vport_s
), GFP_KERNEL
);
500 vport
->drv_port
.bfad
= bfad
;
501 port_cfg
.roles
= BFA_LPORT_ROLE_FCP_IM
;
502 port_cfg
.pwwn
= pbc_vport
.vp_pwwn
;
503 port_cfg
.nwwn
= pbc_vport
.vp_nwwn
;
504 port_cfg
.preboot_vp
= BFA_TRUE
;
506 rc
= bfa_fcs_pbc_vport_create(&vport
->fcs_vport
, &bfad
->bfa_fcs
, 0,
509 if (rc
!= BFA_STATUS_OK
) {
514 list_add_tail(&vport
->list_entry
, &bfad
->pbc_vport_list
);
518 bfad_hal_mem_release(struct bfad_s
*bfad
)
520 struct bfa_meminfo_s
*hal_meminfo
= &bfad
->meminfo
;
521 struct bfa_mem_dma_s
*dma_info
, *dma_elem
;
522 struct bfa_mem_kva_s
*kva_info
, *kva_elem
;
523 struct list_head
*dm_qe
, *km_qe
;
525 dma_info
= &hal_meminfo
->dma_info
;
526 kva_info
= &hal_meminfo
->kva_info
;
528 /* Iterate through the KVA meminfo queue */
529 list_for_each(km_qe
, &kva_info
->qe
) {
530 kva_elem
= (struct bfa_mem_kva_s
*) km_qe
;
531 vfree(kva_elem
->kva
);
534 /* Iterate through the DMA meminfo queue */
535 list_for_each(dm_qe
, &dma_info
->qe
) {
536 dma_elem
= (struct bfa_mem_dma_s
*) dm_qe
;
537 dma_free_coherent(&bfad
->pcidev
->dev
,
538 dma_elem
->mem_len
, dma_elem
->kva
,
539 (dma_addr_t
) dma_elem
->dma
);
542 memset(hal_meminfo
, 0, sizeof(struct bfa_meminfo_s
));
546 bfad_update_hal_cfg(struct bfa_iocfc_cfg_s
*bfa_cfg
)
549 bfa_cfg
->fwcfg
.num_rports
= num_rports
;
551 bfa_cfg
->fwcfg
.num_ioim_reqs
= num_ios
;
553 bfa_cfg
->fwcfg
.num_tskim_reqs
= num_tms
;
554 if (num_fcxps
> 0 && num_fcxps
<= BFA_FCXP_MAX
)
555 bfa_cfg
->fwcfg
.num_fcxp_reqs
= num_fcxps
;
556 if (num_ufbufs
> 0 && num_ufbufs
<= BFA_UF_MAX
)
557 bfa_cfg
->fwcfg
.num_uf_bufs
= num_ufbufs
;
559 bfa_cfg
->drvcfg
.num_reqq_elems
= reqq_size
;
561 bfa_cfg
->drvcfg
.num_rspq_elems
= rspq_size
;
562 if (num_sgpgs
> 0 && num_sgpgs
<= BFA_SGPG_MAX
)
563 bfa_cfg
->drvcfg
.num_sgpgs
= num_sgpgs
;
566 * populate the hal values back to the driver for sysfs use.
567 * otherwise, the default values will be shown as 0 in sysfs
569 num_rports
= bfa_cfg
->fwcfg
.num_rports
;
570 num_ios
= bfa_cfg
->fwcfg
.num_ioim_reqs
;
571 num_tms
= bfa_cfg
->fwcfg
.num_tskim_reqs
;
572 num_fcxps
= bfa_cfg
->fwcfg
.num_fcxp_reqs
;
573 num_ufbufs
= bfa_cfg
->fwcfg
.num_uf_bufs
;
574 reqq_size
= bfa_cfg
->drvcfg
.num_reqq_elems
;
575 rspq_size
= bfa_cfg
->drvcfg
.num_rspq_elems
;
576 num_sgpgs
= bfa_cfg
->drvcfg
.num_sgpgs
;
580 bfad_hal_mem_alloc(struct bfad_s
*bfad
)
582 struct bfa_meminfo_s
*hal_meminfo
= &bfad
->meminfo
;
583 struct bfa_mem_dma_s
*dma_info
, *dma_elem
;
584 struct bfa_mem_kva_s
*kva_info
, *kva_elem
;
585 struct list_head
*dm_qe
, *km_qe
;
586 bfa_status_t rc
= BFA_STATUS_OK
;
587 dma_addr_t phys_addr
;
589 bfa_cfg_get_default(&bfad
->ioc_cfg
);
590 bfad_update_hal_cfg(&bfad
->ioc_cfg
);
591 bfad
->cfg_data
.ioc_queue_depth
= bfad
->ioc_cfg
.fwcfg
.num_ioim_reqs
;
592 bfa_cfg_get_meminfo(&bfad
->ioc_cfg
, hal_meminfo
, &bfad
->bfa
);
594 dma_info
= &hal_meminfo
->dma_info
;
595 kva_info
= &hal_meminfo
->kva_info
;
597 /* Iterate through the KVA meminfo queue */
598 list_for_each(km_qe
, &kva_info
->qe
) {
599 kva_elem
= (struct bfa_mem_kva_s
*) km_qe
;
600 kva_elem
->kva
= vmalloc(kva_elem
->mem_len
);
601 if (kva_elem
->kva
== NULL
) {
602 bfad_hal_mem_release(bfad
);
603 rc
= BFA_STATUS_ENOMEM
;
606 memset(kva_elem
->kva
, 0, kva_elem
->mem_len
);
609 /* Iterate through the DMA meminfo queue */
610 list_for_each(dm_qe
, &dma_info
->qe
) {
611 dma_elem
= (struct bfa_mem_dma_s
*) dm_qe
;
612 dma_elem
->kva
= dma_alloc_coherent(&bfad
->pcidev
->dev
,
614 &phys_addr
, GFP_KERNEL
);
615 if (dma_elem
->kva
== NULL
) {
616 bfad_hal_mem_release(bfad
);
617 rc
= BFA_STATUS_ENOMEM
;
620 dma_elem
->dma
= phys_addr
;
621 memset(dma_elem
->kva
, 0, dma_elem
->mem_len
);
628 * Create a vport under a vf.
631 bfad_vport_create(struct bfad_s
*bfad
, u16 vf_id
,
632 struct bfa_lport_cfg_s
*port_cfg
, struct device
*dev
)
634 struct bfad_vport_s
*vport
;
635 int rc
= BFA_STATUS_OK
;
637 struct completion fcomp
;
639 vport
= kzalloc(sizeof(struct bfad_vport_s
), GFP_KERNEL
);
641 rc
= BFA_STATUS_ENOMEM
;
645 vport
->drv_port
.bfad
= bfad
;
646 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
647 rc
= bfa_fcs_vport_create(&vport
->fcs_vport
, &bfad
->bfa_fcs
, vf_id
,
649 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
651 if (rc
!= BFA_STATUS_OK
)
654 if (port_cfg
->roles
& BFA_LPORT_ROLE_FCP_IM
) {
655 rc
= bfad_im_scsi_host_alloc(bfad
, vport
->drv_port
.im_port
,
657 if (rc
!= BFA_STATUS_OK
)
658 goto ext_free_fcs_vport
;
661 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
662 bfa_fcs_vport_start(&vport
->fcs_vport
);
663 list_add_tail(&vport
->list_entry
, &bfad
->vport_list
);
664 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
666 return BFA_STATUS_OK
;
669 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
670 vport
->comp_del
= &fcomp
;
671 init_completion(vport
->comp_del
);
672 bfa_fcs_vport_delete(&vport
->fcs_vport
);
673 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
674 wait_for_completion(vport
->comp_del
);
682 bfad_bfa_tmo(unsigned long data
)
684 struct bfad_s
*bfad
= (struct bfad_s
*) data
;
686 struct list_head doneq
;
688 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
690 bfa_timer_beat(&bfad
->bfa
.timer_mod
);
692 bfa_comp_deq(&bfad
->bfa
, &doneq
);
693 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
695 if (!list_empty(&doneq
)) {
696 bfa_comp_process(&bfad
->bfa
, &doneq
);
697 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
698 bfa_comp_free(&bfad
->bfa
, &doneq
);
699 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
702 mod_timer(&bfad
->hal_tmo
,
703 jiffies
+ msecs_to_jiffies(BFA_TIMER_FREQ
));
707 bfad_init_timer(struct bfad_s
*bfad
)
709 init_timer(&bfad
->hal_tmo
);
710 bfad
->hal_tmo
.function
= bfad_bfa_tmo
;
711 bfad
->hal_tmo
.data
= (unsigned long)bfad
;
713 mod_timer(&bfad
->hal_tmo
,
714 jiffies
+ msecs_to_jiffies(BFA_TIMER_FREQ
));
718 bfad_pci_init(struct pci_dev
*pdev
, struct bfad_s
*bfad
)
722 if (pci_enable_device(pdev
)) {
723 printk(KERN_ERR
"pci_enable_device fail %p\n", pdev
);
727 if (pci_request_regions(pdev
, BFAD_DRIVER_NAME
))
728 goto out_disable_device
;
730 pci_set_master(pdev
);
733 if ((pci_set_dma_mask(pdev
, DMA_BIT_MASK(64)) != 0) ||
734 (pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(64)) != 0)) {
735 if ((pci_set_dma_mask(pdev
, DMA_BIT_MASK(32)) != 0) ||
736 (pci_set_consistent_dma_mask(pdev
, DMA_BIT_MASK(32)) != 0)) {
737 printk(KERN_ERR
"pci_set_dma_mask fail %p\n", pdev
);
738 goto out_release_region
;
742 /* Enable PCIE Advanced Error Recovery (AER) if kernel supports */
743 pci_enable_pcie_error_reporting(pdev
);
745 bfad
->pci_bar0_kva
= pci_iomap(pdev
, 0, pci_resource_len(pdev
, 0));
746 bfad
->pci_bar2_kva
= pci_iomap(pdev
, 2, pci_resource_len(pdev
, 2));
748 if (bfad
->pci_bar0_kva
== NULL
) {
749 printk(KERN_ERR
"Fail to map bar0\n");
750 goto out_release_region
;
753 bfad
->hal_pcidev
.pci_slot
= PCI_SLOT(pdev
->devfn
);
754 bfad
->hal_pcidev
.pci_func
= PCI_FUNC(pdev
->devfn
);
755 bfad
->hal_pcidev
.pci_bar_kva
= bfad
->pci_bar0_kva
;
756 bfad
->hal_pcidev
.device_id
= pdev
->device
;
757 bfad
->hal_pcidev
.ssid
= pdev
->subsystem_device
;
758 bfad
->pci_name
= pci_name(pdev
);
760 bfad
->pci_attr
.vendor_id
= pdev
->vendor
;
761 bfad
->pci_attr
.device_id
= pdev
->device
;
762 bfad
->pci_attr
.ssid
= pdev
->subsystem_device
;
763 bfad
->pci_attr
.ssvid
= pdev
->subsystem_vendor
;
764 bfad
->pci_attr
.pcifn
= PCI_FUNC(pdev
->devfn
);
768 /* Adjust PCIe Maximum Read Request Size */
769 if (pcie_max_read_reqsz
> 0) {
774 switch (pcie_max_read_reqsz
) {
797 pcie_cap_reg
= pci_find_capability(pdev
, PCI_CAP_ID_EXP
);
798 if (mask
!= 0xffff && pcie_cap_reg
) {
799 pcie_cap_reg
+= 0x08;
800 pci_read_config_word(pdev
, pcie_cap_reg
, &pcie_dev_ctl
);
801 if ((pcie_dev_ctl
& 0x7000) != mask
) {
802 printk(KERN_WARNING
"BFA[%s]: "
803 "pcie_max_read_request_size is %d, "
804 "reset to %d\n", bfad
->pci_name
,
805 (1 << ((pcie_dev_ctl
& 0x7000) >> 12)) << 7,
806 pcie_max_read_reqsz
);
808 pcie_dev_ctl
&= ~0x7000;
809 pci_write_config_word(pdev
, pcie_cap_reg
,
810 pcie_dev_ctl
| mask
);
815 pci_save_state(pdev
);
820 pci_release_regions(pdev
);
822 pci_disable_device(pdev
);
828 bfad_pci_uninit(struct pci_dev
*pdev
, struct bfad_s
*bfad
)
830 pci_iounmap(pdev
, bfad
->pci_bar0_kva
);
831 pci_iounmap(pdev
, bfad
->pci_bar2_kva
);
832 pci_release_regions(pdev
);
833 /* Disable PCIE Advanced Error Recovery (AER) */
834 pci_disable_pcie_error_reporting(pdev
);
835 pci_disable_device(pdev
);
836 pci_set_drvdata(pdev
, NULL
);
840 bfad_drv_init(struct bfad_s
*bfad
)
845 bfad
->cfg_data
.rport_del_timeout
= rport_del_timeout
;
846 bfad
->cfg_data
.lun_queue_depth
= bfa_lun_queue_depth
;
847 bfad
->cfg_data
.io_max_sge
= bfa_io_max_sge
;
848 bfad
->cfg_data
.binding_method
= FCP_PWWN_BINDING
;
850 rc
= bfad_hal_mem_alloc(bfad
);
851 if (rc
!= BFA_STATUS_OK
) {
852 printk(KERN_WARNING
"bfad%d bfad_hal_mem_alloc failure\n",
855 "Not enough memory to attach all Brocade HBA ports, %s",
856 "System may need more memory.\n");
857 goto out_hal_mem_alloc_failure
;
860 bfad
->bfa
.trcmod
= bfad
->trcmod
;
861 bfad
->bfa
.plog
= &bfad
->plog_buf
;
862 bfa_plog_init(&bfad
->plog_buf
);
863 bfa_plog_str(&bfad
->plog_buf
, BFA_PL_MID_DRVR
, BFA_PL_EID_DRIVER_START
,
866 bfa_attach(&bfad
->bfa
, bfad
, &bfad
->ioc_cfg
, &bfad
->meminfo
,
870 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
871 bfad
->bfa_fcs
.trcmod
= bfad
->trcmod
;
872 bfa_fcs_attach(&bfad
->bfa_fcs
, &bfad
->bfa
, bfad
, BFA_FALSE
);
873 bfad
->bfa_fcs
.fdmi_enabled
= fdmi_enable
;
874 bfa_fcs_init(&bfad
->bfa_fcs
);
875 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
877 bfad
->bfad_flags
|= BFAD_DRV_INIT_DONE
;
879 /* configure base port */
880 rc
= bfad_cfg_pport(bfad
, BFA_LPORT_ROLE_FCP_IM
);
881 if (rc
!= BFA_STATUS_OK
)
882 goto out_cfg_pport_fail
;
884 return BFA_STATUS_OK
;
887 /* fcs exit - on cfg pport failure */
888 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
889 init_completion(&bfad
->comp
);
890 bfad
->pport
.flags
|= BFAD_PORT_DELETE
;
891 bfa_fcs_exit(&bfad
->bfa_fcs
);
892 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
893 wait_for_completion(&bfad
->comp
);
894 /* bfa detach - free hal memory */
895 bfa_detach(&bfad
->bfa
);
896 bfad_hal_mem_release(bfad
);
897 out_hal_mem_alloc_failure
:
898 return BFA_STATUS_FAILED
;
902 bfad_drv_uninit(struct bfad_s
*bfad
)
906 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
907 init_completion(&bfad
->comp
);
908 bfa_iocfc_stop(&bfad
->bfa
);
909 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
910 wait_for_completion(&bfad
->comp
);
912 del_timer_sync(&bfad
->hal_tmo
);
913 bfa_isr_disable(&bfad
->bfa
);
914 bfa_detach(&bfad
->bfa
);
915 bfad_remove_intr(bfad
);
916 bfad_hal_mem_release(bfad
);
918 bfad
->bfad_flags
&= ~BFAD_DRV_INIT_DONE
;
922 bfad_drv_start(struct bfad_s
*bfad
)
926 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
927 bfa_iocfc_start(&bfad
->bfa
);
928 bfa_fcs_pbc_vport_init(&bfad
->bfa_fcs
);
929 bfa_fcs_fabric_modstart(&bfad
->bfa_fcs
);
930 bfad
->bfad_flags
|= BFAD_HAL_START_DONE
;
931 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
934 flush_workqueue(bfad
->im
->drv_workq
);
938 bfad_fcs_stop(struct bfad_s
*bfad
)
942 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
943 init_completion(&bfad
->comp
);
944 bfad
->pport
.flags
|= BFAD_PORT_DELETE
;
945 bfa_fcs_exit(&bfad
->bfa_fcs
);
946 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
947 wait_for_completion(&bfad
->comp
);
949 bfa_sm_send_event(bfad
, BFAD_E_FCS_EXIT_COMP
);
953 bfad_stop(struct bfad_s
*bfad
)
957 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
958 init_completion(&bfad
->comp
);
959 bfa_iocfc_stop(&bfad
->bfa
);
960 bfad
->bfad_flags
&= ~BFAD_HAL_START_DONE
;
961 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
962 wait_for_completion(&bfad
->comp
);
964 bfa_sm_send_event(bfad
, BFAD_E_EXIT_COMP
);
968 bfad_cfg_pport(struct bfad_s
*bfad
, enum bfa_lport_role role
)
970 int rc
= BFA_STATUS_OK
;
972 /* Allocate scsi_host for the physical port */
973 if ((supported_fc4s
& BFA_LPORT_ROLE_FCP_IM
) &&
974 (role
& BFA_LPORT_ROLE_FCP_IM
)) {
975 if (bfad
->pport
.im_port
== NULL
) {
976 rc
= BFA_STATUS_FAILED
;
980 rc
= bfad_im_scsi_host_alloc(bfad
, bfad
->pport
.im_port
,
982 if (rc
!= BFA_STATUS_OK
)
985 bfad
->pport
.roles
|= BFA_LPORT_ROLE_FCP_IM
;
988 bfad
->bfad_flags
|= BFAD_CFG_PPORT_DONE
;
995 bfad_uncfg_pport(struct bfad_s
*bfad
)
997 if ((supported_fc4s
& BFA_LPORT_ROLE_FCP_IM
) &&
998 (bfad
->pport
.roles
& BFA_LPORT_ROLE_FCP_IM
)) {
999 bfad_im_scsi_host_free(bfad
, bfad
->pport
.im_port
);
1000 bfad_im_port_clean(bfad
->pport
.im_port
);
1001 kfree(bfad
->pport
.im_port
);
1002 bfad
->pport
.roles
&= ~BFA_LPORT_ROLE_FCP_IM
;
1005 bfad
->bfad_flags
&= ~BFAD_CFG_PPORT_DONE
;
1009 bfad_start_ops(struct bfad_s
*bfad
) {
1012 unsigned long flags
;
1013 struct bfad_vport_s
*vport
, *vport_new
;
1014 struct bfa_fcs_driver_info_s driver_info
;
1016 /* Limit min/max. xfer size to [64k-32MB] */
1017 if (max_xfer_size
< BFAD_MIN_SECTORS
>> 1)
1018 max_xfer_size
= BFAD_MIN_SECTORS
>> 1;
1019 if (max_xfer_size
> BFAD_MAX_SECTORS
>> 1)
1020 max_xfer_size
= BFAD_MAX_SECTORS
>> 1;
1022 /* Fill the driver_info info to fcs*/
1023 memset(&driver_info
, 0, sizeof(driver_info
));
1024 strncpy(driver_info
.version
, BFAD_DRIVER_VERSION
,
1025 sizeof(driver_info
.version
) - 1);
1027 strncpy(driver_info
.host_machine_name
, host_name
,
1028 sizeof(driver_info
.host_machine_name
) - 1);
1030 strncpy(driver_info
.host_os_name
, os_name
,
1031 sizeof(driver_info
.host_os_name
) - 1);
1033 strncpy(driver_info
.host_os_patch
, os_patch
,
1034 sizeof(driver_info
.host_os_patch
) - 1);
1036 strncpy(driver_info
.os_device_name
, bfad
->pci_name
,
1037 sizeof(driver_info
.os_device_name
) - 1);
1039 /* FCS driver info init */
1040 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1041 bfa_fcs_driver_info_init(&bfad
->bfa_fcs
, &driver_info
);
1042 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1045 * FCS update cfg - reset the pwwn/nwwn of fabric base logical port
1046 * with values learned during bfa_init firmware GETATTR REQ.
1048 bfa_fcs_update_cfg(&bfad
->bfa_fcs
);
1050 /* Setup fc host fixed attribute if the lk supports */
1051 bfad_fc_host_init(bfad
->pport
.im_port
);
1053 /* BFAD level FC4 IM specific resource allocation */
1054 retval
= bfad_im_probe(bfad
);
1055 if (retval
!= BFA_STATUS_OK
) {
1056 printk(KERN_WARNING
"bfad_im_probe failed\n");
1057 if (bfa_sm_cmp_state(bfad
, bfad_sm_initializing
))
1058 bfa_sm_set_state(bfad
, bfad_sm_failed
);
1059 bfad_im_probe_undo(bfad
);
1060 bfad
->bfad_flags
&= ~BFAD_FC4_PROBE_DONE
;
1061 bfad_uncfg_pport(bfad
);
1063 return BFA_STATUS_FAILED
;
1065 bfad
->bfad_flags
|= BFAD_FC4_PROBE_DONE
;
1067 bfad_drv_start(bfad
);
1069 /* Complete pbc vport create */
1070 list_for_each_entry_safe(vport
, vport_new
, &bfad
->pbc_vport_list
,
1072 struct fc_vport_identifiers vid
;
1073 struct fc_vport
*fc_vport
;
1074 char pwwn_buf
[BFA_STRING_32
];
1076 memset(&vid
, 0, sizeof(vid
));
1077 vid
.roles
= FC_PORT_ROLE_FCP_INITIATOR
;
1078 vid
.vport_type
= FC_PORTTYPE_NPIV
;
1079 vid
.disable
= false;
1080 vid
.node_name
= wwn_to_u64((u8
*)
1081 (&((vport
->fcs_vport
).lport
.port_cfg
.nwwn
)));
1082 vid
.port_name
= wwn_to_u64((u8
*)
1083 (&((vport
->fcs_vport
).lport
.port_cfg
.pwwn
)));
1084 fc_vport
= fc_vport_create(bfad
->pport
.im_port
->shost
, 0, &vid
);
1086 wwn2str(pwwn_buf
, vid
.port_name
);
1087 printk(KERN_WARNING
"bfad%d: failed to create pbc vport"
1088 " %s\n", bfad
->inst_no
, pwwn_buf
);
1090 list_del(&vport
->list_entry
);
1095 * If bfa_linkup_delay is set to -1 default; try to retrive the
1096 * value using the bfad_get_linkup_delay(); else use the
1097 * passed in module param value as the bfa_linkup_delay.
1099 if (bfa_linkup_delay
< 0) {
1100 bfa_linkup_delay
= bfad_get_linkup_delay(bfad
);
1101 bfad_rport_online_wait(bfad
);
1102 bfa_linkup_delay
= -1;
1104 bfad_rport_online_wait(bfad
);
1106 BFA_LOG(KERN_INFO
, bfad
, bfa_log_level
, "bfa device claimed\n");
1108 return BFA_STATUS_OK
;
1112 bfad_worker(void *ptr
)
1114 struct bfad_s
*bfad
;
1115 unsigned long flags
;
1117 bfad
= (struct bfad_s
*)ptr
;
1119 while (!kthread_should_stop()) {
1121 /* Send event BFAD_E_INIT_SUCCESS */
1122 bfa_sm_send_event(bfad
, BFAD_E_INIT_SUCCESS
);
1124 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1125 bfad
->bfad_tsk
= NULL
;
1126 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1135 * BFA driver interrupt functions
1138 bfad_intx(int irq
, void *dev_id
)
1140 struct bfad_s
*bfad
= dev_id
;
1141 struct list_head doneq
;
1142 unsigned long flags
;
1145 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1146 rc
= bfa_intx(&bfad
->bfa
);
1148 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1152 bfa_comp_deq(&bfad
->bfa
, &doneq
);
1153 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1155 if (!list_empty(&doneq
)) {
1156 bfa_comp_process(&bfad
->bfa
, &doneq
);
1158 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1159 bfa_comp_free(&bfad
->bfa
, &doneq
);
1160 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1168 bfad_msix(int irq
, void *dev_id
)
1170 struct bfad_msix_s
*vec
= dev_id
;
1171 struct bfad_s
*bfad
= vec
->bfad
;
1172 struct list_head doneq
;
1173 unsigned long flags
;
1175 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1177 bfa_msix(&bfad
->bfa
, vec
->msix
.entry
);
1178 bfa_comp_deq(&bfad
->bfa
, &doneq
);
1179 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1181 if (!list_empty(&doneq
)) {
1182 bfa_comp_process(&bfad
->bfa
, &doneq
);
1184 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1185 bfa_comp_free(&bfad
->bfa
, &doneq
);
1186 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1193 * Initialize the MSIX entry table.
1196 bfad_init_msix_entry(struct bfad_s
*bfad
, struct msix_entry
*msix_entries
,
1197 int mask
, int max_bit
)
1200 int match
= 0x00000001;
1202 for (i
= 0, bfad
->nvec
= 0; i
< MAX_MSIX_ENTRY
; i
++) {
1204 bfad
->msix_tab
[bfad
->nvec
].msix
.entry
= i
;
1205 bfad
->msix_tab
[bfad
->nvec
].bfad
= bfad
;
1206 msix_entries
[bfad
->nvec
].entry
= i
;
1216 bfad_install_msix_handler(struct bfad_s
*bfad
)
1220 for (i
= 0; i
< bfad
->nvec
; i
++) {
1221 sprintf(bfad
->msix_tab
[i
].name
, "bfa-%s-%s",
1223 ((bfa_asic_id_cb(bfad
->hal_pcidev
.device_id
)) ?
1224 msix_name_cb
[i
] : msix_name_ct
[i
]));
1226 error
= request_irq(bfad
->msix_tab
[i
].msix
.vector
,
1227 (irq_handler_t
) bfad_msix
, 0,
1228 bfad
->msix_tab
[i
].name
, &bfad
->msix_tab
[i
]);
1230 bfa_trc(bfad
, bfad
->msix_tab
[i
].msix
.vector
);
1234 for (j
= 0; j
< i
; j
++)
1235 free_irq(bfad
->msix_tab
[j
].msix
.vector
,
1236 &bfad
->msix_tab
[j
]);
1238 bfad
->bfad_flags
&= ~BFAD_MSIX_ON
;
1239 pci_disable_msix(bfad
->pcidev
);
1249 * Setup MSIX based interrupt.
1252 bfad_setup_intr(struct bfad_s
*bfad
)
1255 u32 mask
= 0, i
, num_bit
= 0, max_bit
= 0;
1256 struct msix_entry msix_entries
[MAX_MSIX_ENTRY
];
1257 struct pci_dev
*pdev
= bfad
->pcidev
;
1260 /* Call BFA to get the msix map for this PCI function. */
1261 bfa_msix_getvecs(&bfad
->bfa
, &mask
, &num_bit
, &max_bit
);
1263 /* Set up the msix entry table */
1264 bfad_init_msix_entry(bfad
, msix_entries
, mask
, max_bit
);
1266 if ((bfa_asic_id_ctc(pdev
->device
) && !msix_disable_ct
) ||
1267 (bfa_asic_id_cb(pdev
->device
) && !msix_disable_cb
)) {
1269 error
= pci_enable_msix(bfad
->pcidev
, msix_entries
, bfad
->nvec
);
1271 /* In CT1 & CT2, try to allocate just one vector */
1272 if (bfa_asic_id_ctc(pdev
->device
)) {
1273 printk(KERN_WARNING
"bfa %s: trying one msix "
1274 "vector failed to allocate %d[%d]\n",
1275 bfad
->pci_name
, bfad
->nvec
, error
);
1277 error
= pci_enable_msix(bfad
->pcidev
,
1278 msix_entries
, bfad
->nvec
);
1282 * Only error number of vector is available.
1283 * We don't have a mechanism to map multiple
1284 * interrupts into one vector, so even if we
1285 * can try to request less vectors, we don't
1286 * know how to associate interrupt events to
1287 * vectors. Linux doesn't duplicate vectors
1288 * in the MSIX table for this case.
1291 printk(KERN_WARNING
"bfad%d: "
1292 "pci_enable_msix failed (%d), "
1293 "use line based.\n",
1294 bfad
->inst_no
, error
);
1299 /* Disable INTX in MSI-X mode */
1300 pci_read_config_word(pdev
, PCI_COMMAND
, ®
);
1302 if (!(reg
& PCI_COMMAND_INTX_DISABLE
))
1303 pci_write_config_word(pdev
, PCI_COMMAND
,
1304 reg
| PCI_COMMAND_INTX_DISABLE
);
1306 /* Save the vectors */
1307 for (i
= 0; i
< bfad
->nvec
; i
++) {
1308 bfa_trc(bfad
, msix_entries
[i
].vector
);
1309 bfad
->msix_tab
[i
].msix
.vector
= msix_entries
[i
].vector
;
1312 bfa_msix_init(&bfad
->bfa
, bfad
->nvec
);
1314 bfad
->bfad_flags
|= BFAD_MSIX_ON
;
1322 (bfad
->pcidev
->irq
, (irq_handler_t
) bfad_intx
, BFAD_IRQ_FLAGS
,
1323 BFAD_DRIVER_NAME
, bfad
) != 0) {
1324 /* Enable interrupt handler failed */
1327 bfad
->bfad_flags
|= BFAD_INTX_ON
;
1333 bfad_remove_intr(struct bfad_s
*bfad
)
1337 if (bfad
->bfad_flags
& BFAD_MSIX_ON
) {
1338 for (i
= 0; i
< bfad
->nvec
; i
++)
1339 free_irq(bfad
->msix_tab
[i
].msix
.vector
,
1340 &bfad
->msix_tab
[i
]);
1342 pci_disable_msix(bfad
->pcidev
);
1343 bfad
->bfad_flags
&= ~BFAD_MSIX_ON
;
1344 } else if (bfad
->bfad_flags
& BFAD_INTX_ON
) {
1345 free_irq(bfad
->pcidev
->irq
, bfad
);
1353 bfad_pci_probe(struct pci_dev
*pdev
, const struct pci_device_id
*pid
)
1355 struct bfad_s
*bfad
;
1356 int error
= -ENODEV
, retval
, i
;
1358 /* For single port cards - only claim function 0 */
1359 if ((pdev
->device
== BFA_PCI_DEVICE_ID_FC_8G1P
) &&
1360 (PCI_FUNC(pdev
->devfn
) != 0))
1363 bfad
= kzalloc(sizeof(struct bfad_s
), GFP_KERNEL
);
1369 bfad
->trcmod
= kzalloc(sizeof(struct bfa_trc_mod_s
), GFP_KERNEL
);
1370 if (!bfad
->trcmod
) {
1371 printk(KERN_WARNING
"Error alloc trace buffer!\n");
1373 goto out_alloc_trace_failure
;
1377 bfa_trc_init(bfad
->trcmod
);
1378 bfa_trc(bfad
, bfad_inst
);
1381 INIT_LIST_HEAD(&bfad
->free_aen_q
);
1382 INIT_LIST_HEAD(&bfad
->active_aen_q
);
1383 for (i
= 0; i
< BFA_AEN_MAX_ENTRY
; i
++)
1384 list_add_tail(&bfad
->aen_list
[i
].qe
, &bfad
->free_aen_q
);
1386 if (!(bfad_load_fwimg(pdev
))) {
1387 kfree(bfad
->trcmod
);
1388 goto out_alloc_trace_failure
;
1391 retval
= bfad_pci_init(pdev
, bfad
);
1393 printk(KERN_WARNING
"bfad_pci_init failure!\n");
1395 goto out_pci_init_failure
;
1398 mutex_lock(&bfad_mutex
);
1399 bfad
->inst_no
= bfad_inst
++;
1400 list_add_tail(&bfad
->list_entry
, &bfad_list
);
1401 mutex_unlock(&bfad_mutex
);
1403 /* Initializing the state machine: State set to uninit */
1404 bfa_sm_set_state(bfad
, bfad_sm_uninit
);
1406 spin_lock_init(&bfad
->bfad_lock
);
1407 spin_lock_init(&bfad
->bfad_aen_spinlock
);
1409 pci_set_drvdata(pdev
, bfad
);
1411 bfad
->ref_count
= 0;
1412 bfad
->pport
.bfad
= bfad
;
1413 INIT_LIST_HEAD(&bfad
->pbc_vport_list
);
1414 INIT_LIST_HEAD(&bfad
->vport_list
);
1416 /* Setup the debugfs node for this bfad */
1417 if (bfa_debugfs_enable
)
1418 bfad_debugfs_init(&bfad
->pport
);
1420 retval
= bfad_drv_init(bfad
);
1421 if (retval
!= BFA_STATUS_OK
)
1422 goto out_drv_init_failure
;
1424 bfa_sm_send_event(bfad
, BFAD_E_CREATE
);
1426 if (bfa_sm_cmp_state(bfad
, bfad_sm_uninit
))
1427 goto out_bfad_sm_failure
;
1431 out_bfad_sm_failure
:
1432 bfa_detach(&bfad
->bfa
);
1433 bfad_hal_mem_release(bfad
);
1434 out_drv_init_failure
:
1435 /* Remove the debugfs node for this bfad */
1436 kfree(bfad
->regdata
);
1437 bfad_debugfs_exit(&bfad
->pport
);
1438 mutex_lock(&bfad_mutex
);
1440 list_del(&bfad
->list_entry
);
1441 mutex_unlock(&bfad_mutex
);
1442 bfad_pci_uninit(pdev
, bfad
);
1443 out_pci_init_failure
:
1444 kfree(bfad
->trcmod
);
1445 out_alloc_trace_failure
:
1455 bfad_pci_remove(struct pci_dev
*pdev
)
1457 struct bfad_s
*bfad
= pci_get_drvdata(pdev
);
1458 unsigned long flags
;
1460 bfa_trc(bfad
, bfad
->inst_no
);
1462 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1463 if (bfad
->bfad_tsk
!= NULL
) {
1464 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1465 kthread_stop(bfad
->bfad_tsk
);
1467 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1470 /* Send Event BFAD_E_STOP */
1471 bfa_sm_send_event(bfad
, BFAD_E_STOP
);
1473 /* Driver detach and dealloc mem */
1474 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1475 bfa_detach(&bfad
->bfa
);
1476 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1477 bfad_hal_mem_release(bfad
);
1479 /* Remove the debugfs node for this bfad */
1480 kfree(bfad
->regdata
);
1481 bfad_debugfs_exit(&bfad
->pport
);
1483 /* Cleaning the BFAD instance */
1484 mutex_lock(&bfad_mutex
);
1486 list_del(&bfad
->list_entry
);
1487 mutex_unlock(&bfad_mutex
);
1488 bfad_pci_uninit(pdev
, bfad
);
1490 kfree(bfad
->trcmod
);
1495 * PCI Error Recovery entry, error detected.
1497 static pci_ers_result_t
1498 bfad_pci_error_detected(struct pci_dev
*pdev
, pci_channel_state_t state
)
1500 struct bfad_s
*bfad
= pci_get_drvdata(pdev
);
1501 unsigned long flags
;
1502 pci_ers_result_t ret
= PCI_ERS_RESULT_NONE
;
1504 dev_printk(KERN_ERR
, &pdev
->dev
,
1505 "error detected state: %d - flags: 0x%x\n",
1506 state
, bfad
->bfad_flags
);
1509 case pci_channel_io_normal
: /* non-fatal error */
1510 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1511 bfad
->bfad_flags
&= ~BFAD_EEH_BUSY
;
1512 /* Suspend/fail all bfa operations */
1513 bfa_ioc_suspend(&bfad
->bfa
.ioc
);
1514 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1515 del_timer_sync(&bfad
->hal_tmo
);
1516 ret
= PCI_ERS_RESULT_CAN_RECOVER
;
1518 case pci_channel_io_frozen
: /* fatal error */
1519 init_completion(&bfad
->comp
);
1520 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1521 bfad
->bfad_flags
|= BFAD_EEH_BUSY
;
1522 /* Suspend/fail all bfa operations */
1523 bfa_ioc_suspend(&bfad
->bfa
.ioc
);
1524 bfa_fcs_stop(&bfad
->bfa_fcs
);
1525 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1526 wait_for_completion(&bfad
->comp
);
1528 bfad_remove_intr(bfad
);
1529 del_timer_sync(&bfad
->hal_tmo
);
1530 pci_disable_device(pdev
);
1531 ret
= PCI_ERS_RESULT_NEED_RESET
;
1533 case pci_channel_io_perm_failure
: /* PCI Card is DEAD */
1534 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1535 bfad
->bfad_flags
|= BFAD_EEH_BUSY
|
1536 BFAD_EEH_PCI_CHANNEL_IO_PERM_FAILURE
;
1537 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1539 /* If the error_detected handler is called with the reason
1540 * pci_channel_io_perm_failure - it will subsequently call
1541 * pci_remove() entry point to remove the pci device from the
1542 * system - So defer the cleanup to pci_remove(); cleaning up
1543 * here causes inconsistent state during pci_remove().
1545 ret
= PCI_ERS_RESULT_DISCONNECT
;
1555 restart_bfa(struct bfad_s
*bfad
)
1557 unsigned long flags
;
1558 struct pci_dev
*pdev
= bfad
->pcidev
;
1560 bfa_attach(&bfad
->bfa
, bfad
, &bfad
->ioc_cfg
,
1561 &bfad
->meminfo
, &bfad
->hal_pcidev
);
1563 /* Enable Interrupt and wait bfa_init completion */
1564 if (bfad_setup_intr(bfad
)) {
1565 dev_printk(KERN_WARNING
, &pdev
->dev
,
1566 "%s: bfad_setup_intr failed\n", bfad
->pci_name
);
1567 bfa_sm_send_event(bfad
, BFAD_E_INTR_INIT_FAILED
);
1571 init_completion(&bfad
->comp
);
1572 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1573 bfa_iocfc_init(&bfad
->bfa
);
1574 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1576 /* Set up interrupt handler for each vectors */
1577 if ((bfad
->bfad_flags
& BFAD_MSIX_ON
) &&
1578 bfad_install_msix_handler(bfad
))
1579 dev_printk(KERN_WARNING
, &pdev
->dev
,
1580 "%s: install_msix failed.\n", bfad
->pci_name
);
1582 bfad_init_timer(bfad
);
1583 wait_for_completion(&bfad
->comp
);
1584 bfad_drv_start(bfad
);
1590 * PCI Error Recovery entry, re-initialize the chip.
1592 static pci_ers_result_t
1593 bfad_pci_slot_reset(struct pci_dev
*pdev
)
1595 struct bfad_s
*bfad
= pci_get_drvdata(pdev
);
1598 dev_printk(KERN_ERR
, &pdev
->dev
,
1599 "bfad_pci_slot_reset flags: 0x%x\n", bfad
->bfad_flags
);
1601 if (pci_enable_device(pdev
)) {
1602 dev_printk(KERN_ERR
, &pdev
->dev
, "Cannot re-enable "
1603 "PCI device after reset.\n");
1604 return PCI_ERS_RESULT_DISCONNECT
;
1607 pci_restore_state(pdev
);
1610 * Read some byte (e.g. DMA max. payload size which can't
1611 * be 0xff any time) to make sure - we did not hit another PCI error
1612 * in the middle of recovery. If we did, then declare permanent failure.
1614 pci_read_config_byte(pdev
, 0x68, &byte
);
1616 dev_printk(KERN_ERR
, &pdev
->dev
,
1617 "slot_reset failed ... got another PCI error !\n");
1618 goto out_disable_device
;
1621 pci_save_state(pdev
);
1622 pci_set_master(pdev
);
1624 if (pci_set_dma_mask(bfad
->pcidev
, DMA_BIT_MASK(64)) != 0)
1625 if (pci_set_dma_mask(bfad
->pcidev
, DMA_BIT_MASK(32)) != 0)
1626 goto out_disable_device
;
1628 pci_cleanup_aer_uncorrect_error_status(pdev
);
1630 if (restart_bfa(bfad
) == -1)
1631 goto out_disable_device
;
1633 pci_enable_pcie_error_reporting(pdev
);
1634 dev_printk(KERN_WARNING
, &pdev
->dev
,
1635 "slot_reset completed flags: 0x%x!\n", bfad
->bfad_flags
);
1637 return PCI_ERS_RESULT_RECOVERED
;
1640 pci_disable_device(pdev
);
1641 return PCI_ERS_RESULT_DISCONNECT
;
1644 static pci_ers_result_t
1645 bfad_pci_mmio_enabled(struct pci_dev
*pdev
)
1647 unsigned long flags
;
1648 struct bfad_s
*bfad
= pci_get_drvdata(pdev
);
1650 dev_printk(KERN_INFO
, &pdev
->dev
, "mmio_enabled\n");
1652 /* Fetch FW diagnostic information */
1653 bfa_ioc_debug_save_ftrc(&bfad
->bfa
.ioc
);
1655 /* Cancel all pending IOs */
1656 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1657 init_completion(&bfad
->comp
);
1658 bfa_fcs_stop(&bfad
->bfa_fcs
);
1659 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1660 wait_for_completion(&bfad
->comp
);
1662 bfad_remove_intr(bfad
);
1663 del_timer_sync(&bfad
->hal_tmo
);
1664 pci_disable_device(pdev
);
1666 return PCI_ERS_RESULT_NEED_RESET
;
1670 bfad_pci_resume(struct pci_dev
*pdev
)
1672 unsigned long flags
;
1673 struct bfad_s
*bfad
= pci_get_drvdata(pdev
);
1675 dev_printk(KERN_WARNING
, &pdev
->dev
, "resume\n");
1677 /* wait until the link is online */
1678 bfad_rport_online_wait(bfad
);
1680 spin_lock_irqsave(&bfad
->bfad_lock
, flags
);
1681 bfad
->bfad_flags
&= ~BFAD_EEH_BUSY
;
1682 spin_unlock_irqrestore(&bfad
->bfad_lock
, flags
);
1685 struct pci_device_id bfad_id_table
[] = {
1687 .vendor
= BFA_PCI_VENDOR_ID_BROCADE
,
1688 .device
= BFA_PCI_DEVICE_ID_FC_8G2P
,
1689 .subvendor
= PCI_ANY_ID
,
1690 .subdevice
= PCI_ANY_ID
,
1693 .vendor
= BFA_PCI_VENDOR_ID_BROCADE
,
1694 .device
= BFA_PCI_DEVICE_ID_FC_8G1P
,
1695 .subvendor
= PCI_ANY_ID
,
1696 .subdevice
= PCI_ANY_ID
,
1699 .vendor
= BFA_PCI_VENDOR_ID_BROCADE
,
1700 .device
= BFA_PCI_DEVICE_ID_CT
,
1701 .subvendor
= PCI_ANY_ID
,
1702 .subdevice
= PCI_ANY_ID
,
1703 .class = (PCI_CLASS_SERIAL_FIBER
<< 8),
1707 .vendor
= BFA_PCI_VENDOR_ID_BROCADE
,
1708 .device
= BFA_PCI_DEVICE_ID_CT_FC
,
1709 .subvendor
= PCI_ANY_ID
,
1710 .subdevice
= PCI_ANY_ID
,
1711 .class = (PCI_CLASS_SERIAL_FIBER
<< 8),
1715 .vendor
= BFA_PCI_VENDOR_ID_BROCADE
,
1716 .device
= BFA_PCI_DEVICE_ID_CT2
,
1717 .subvendor
= PCI_ANY_ID
,
1718 .subdevice
= PCI_ANY_ID
,
1719 .class = (PCI_CLASS_SERIAL_FIBER
<< 8),
1724 .vendor
= BFA_PCI_VENDOR_ID_BROCADE
,
1725 .device
= BFA_PCI_DEVICE_ID_CT2_QUAD
,
1726 .subvendor
= PCI_ANY_ID
,
1727 .subdevice
= PCI_ANY_ID
,
1728 .class = (PCI_CLASS_SERIAL_FIBER
<< 8),
1734 MODULE_DEVICE_TABLE(pci
, bfad_id_table
);
1737 * PCI error recovery handlers.
1739 static struct pci_error_handlers bfad_err_handler
= {
1740 .error_detected
= bfad_pci_error_detected
,
1741 .slot_reset
= bfad_pci_slot_reset
,
1742 .mmio_enabled
= bfad_pci_mmio_enabled
,
1743 .resume
= bfad_pci_resume
,
1746 static struct pci_driver bfad_pci_driver
= {
1747 .name
= BFAD_DRIVER_NAME
,
1748 .id_table
= bfad_id_table
,
1749 .probe
= bfad_pci_probe
,
1750 .remove
= bfad_pci_remove
,
1751 .err_handler
= &bfad_err_handler
,
1755 * Driver module init.
1762 printk(KERN_INFO
"Brocade BFA FC/FCOE SCSI driver - version: %s\n",
1763 BFAD_DRIVER_VERSION
);
1766 num_sgpgs_parm
= num_sgpgs
;
1768 error
= bfad_im_module_init();
1771 printk(KERN_WARNING
"bfad_im_module_init failure\n");
1775 if (strcmp(FCPI_NAME
, " fcpim") == 0)
1776 supported_fc4s
|= BFA_LPORT_ROLE_FCP_IM
;
1778 bfa_auto_recover
= ioc_auto_recover
;
1779 bfa_fcs_rport_set_del_timeout(rport_del_timeout
);
1780 bfa_fcs_rport_set_max_logins(max_rport_logins
);
1782 error
= pci_register_driver(&bfad_pci_driver
);
1784 printk(KERN_WARNING
"pci_register_driver failure\n");
1791 bfad_im_module_exit();
1796 * Driver module exit.
1801 pci_unregister_driver(&bfad_pci_driver
);
1802 bfad_im_module_exit();
1806 /* Firmware handling */
1808 bfad_read_firmware(struct pci_dev
*pdev
, u32
**bfi_image
,
1809 u32
*bfi_image_size
, char *fw_name
)
1811 const struct firmware
*fw
;
1813 if (request_firmware(&fw
, fw_name
, &pdev
->dev
)) {
1814 printk(KERN_ALERT
"Can't locate firmware %s\n", fw_name
);
1819 *bfi_image
= vmalloc(fw
->size
);
1820 if (NULL
== *bfi_image
) {
1821 printk(KERN_ALERT
"Fail to allocate buffer for fw image "
1822 "size=%x!\n", (u32
) fw
->size
);
1826 memcpy(*bfi_image
, fw
->data
, fw
->size
);
1827 *bfi_image_size
= fw
->size
/sizeof(u32
);
1829 release_firmware(fw
);
1833 bfad_load_fwimg(struct pci_dev
*pdev
)
1835 if (pdev
->device
== BFA_PCI_DEVICE_ID_CT2
) {
1836 if (bfi_image_ct2_size
== 0)
1837 bfad_read_firmware(pdev
, &bfi_image_ct2
,
1838 &bfi_image_ct2_size
, BFAD_FW_FILE_CT2
);
1839 return bfi_image_ct2
;
1840 } else if (bfa_asic_id_ct(pdev
->device
)) {
1841 if (bfi_image_ct_size
== 0)
1842 bfad_read_firmware(pdev
, &bfi_image_ct
,
1843 &bfi_image_ct_size
, BFAD_FW_FILE_CT
);
1844 return bfi_image_ct
;
1846 if (bfi_image_cb_size
== 0)
1847 bfad_read_firmware(pdev
, &bfi_image_cb
,
1848 &bfi_image_cb_size
, BFAD_FW_FILE_CB
);
1849 return bfi_image_cb
;
1854 bfad_free_fwimg(void)
1856 if (bfi_image_ct2_size
&& bfi_image_ct2
)
1857 vfree(bfi_image_ct2
);
1858 if (bfi_image_ct_size
&& bfi_image_ct
)
1859 vfree(bfi_image_ct
);
1860 if (bfi_image_cb_size
&& bfi_image_cb
)
1861 vfree(bfi_image_cb
);
1864 module_init(bfad_init
);
1865 module_exit(bfad_exit
);
1866 MODULE_LICENSE("GPL");
1867 MODULE_DESCRIPTION("Brocade Fibre Channel HBA Driver" BFAD_PROTO_NAME
);
1868 MODULE_AUTHOR("Brocade Communications Systems, Inc.");
1869 MODULE_VERSION(BFAD_DRIVER_VERSION
);