1 /* 2 * Copyright (c) 2005-2014 Brocade Communications Systems, Inc. 3 * Copyright (c) 2014- QLogic Corporation. 4 * All rights reserved 5 * www.qlogic.com 6 * 7 * Linux driver for QLogic BR-series Fibre Channel Host Bus Adapter. 8 * 9 * This program is free software; you can redistribute it and/or modify it 10 * under the terms of the GNU General Public License (GPL) Version 2 as 11 * published by the Free Software Foundation 12 * 13 * This program is distributed in the hope that it will be useful, but 14 * WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * General Public License for more details. 17 */ 18 19 /* 20 * bfad.c Linux driver PCI interface module. 21 */ 22 #include <linux/module.h> 23 #include <linux/kthread.h> 24 #include <linux/errno.h> 25 #include <linux/sched.h> 26 #include <linux/init.h> 27 #include <linux/fs.h> 28 #include <linux/pci.h> 29 #include <linux/firmware.h> 30 #include <linux/uaccess.h> 31 #include <asm/fcntl.h> 32 33 #include "bfad_drv.h" 34 #include "bfad_im.h" 35 #include "bfa_fcs.h" 36 #include "bfa_defs.h" 37 #include "bfa.h" 38 39 BFA_TRC_FILE(LDRV, BFAD); 40 DEFINE_MUTEX(bfad_mutex); 41 LIST_HEAD(bfad_list); 42 43 static int bfad_inst; 44 static int num_sgpgs_parm; 45 int supported_fc4s; 46 char *host_name, *os_name, *os_patch; 47 int num_rports, num_ios, num_tms; 48 int num_fcxps, num_ufbufs; 49 int reqq_size, rspq_size, num_sgpgs; 50 int rport_del_timeout = BFA_FCS_RPORT_DEF_DEL_TIMEOUT; 51 int bfa_lun_queue_depth = BFAD_LUN_QUEUE_DEPTH; 52 int bfa_io_max_sge = BFAD_IO_MAX_SGE; 53 int bfa_log_level = 3; /* WARNING log level */ 54 int ioc_auto_recover = BFA_TRUE; 55 int bfa_linkup_delay = -1; 56 int fdmi_enable = BFA_TRUE; 57 int pcie_max_read_reqsz; 58 int bfa_debugfs_enable = 1; 59 int msix_disable_cb = 0, msix_disable_ct = 0; 60 int max_xfer_size = BFAD_MAX_SECTORS >> 1; 61 int max_rport_logins = BFA_FCS_MAX_RPORT_LOGINS; 62 63 /* Firmware releated */ 64 u32 bfi_image_cb_size, bfi_image_ct_size, bfi_image_ct2_size; 65 u32 *bfi_image_cb, *bfi_image_ct, *bfi_image_ct2; 66 67 #define BFAD_FW_FILE_CB "cbfw-3.2.5.1.bin" 68 #define BFAD_FW_FILE_CT "ctfw-3.2.5.1.bin" 69 #define BFAD_FW_FILE_CT2 "ct2fw-3.2.5.1.bin" 70 71 static u32 *bfad_load_fwimg(struct pci_dev *pdev); 72 static void bfad_free_fwimg(void); 73 static void bfad_read_firmware(struct pci_dev *pdev, u32 **bfi_image, 74 u32 *bfi_image_size, char *fw_name); 75 76 static const char *msix_name_ct[] = { 77 "ctrl", 78 "cpe0", "cpe1", "cpe2", "cpe3", 79 "rme0", "rme1", "rme2", "rme3" }; 80 81 static const char *msix_name_cb[] = { 82 "cpe0", "cpe1", "cpe2", "cpe3", 83 "rme0", "rme1", "rme2", "rme3", 84 "eemc", "elpu0", "elpu1", "epss", "mlpu" }; 85 86 MODULE_FIRMWARE(BFAD_FW_FILE_CB); 87 MODULE_FIRMWARE(BFAD_FW_FILE_CT); 88 MODULE_FIRMWARE(BFAD_FW_FILE_CT2); 89 90 module_param(os_name, charp, S_IRUGO | S_IWUSR); 91 MODULE_PARM_DESC(os_name, "OS name of the hba host machine"); 92 module_param(os_patch, charp, S_IRUGO | S_IWUSR); 93 MODULE_PARM_DESC(os_patch, "OS patch level of the hba host machine"); 94 module_param(host_name, charp, S_IRUGO | S_IWUSR); 95 MODULE_PARM_DESC(host_name, "Hostname of the hba host machine"); 96 module_param(num_rports, int, S_IRUGO | S_IWUSR); 97 MODULE_PARM_DESC(num_rports, "Max number of rports supported per port " 98 "(physical/logical), default=1024"); 99 module_param(num_ios, int, S_IRUGO | S_IWUSR); 100 MODULE_PARM_DESC(num_ios, "Max number of ioim requests, default=2000"); 101 module_param(num_tms, int, S_IRUGO | S_IWUSR); 102 MODULE_PARM_DESC(num_tms, "Max number of task im requests, default=128"); 103 module_param(num_fcxps, int, S_IRUGO | S_IWUSR); 104 MODULE_PARM_DESC(num_fcxps, "Max number of fcxp requests, default=64"); 105 module_param(num_ufbufs, int, S_IRUGO | S_IWUSR); 106 MODULE_PARM_DESC(num_ufbufs, "Max number of unsolicited frame " 107 "buffers, default=64"); 108 module_param(reqq_size, int, S_IRUGO | S_IWUSR); 109 MODULE_PARM_DESC(reqq_size, "Max number of request queue elements, " 110 "default=256"); 111 module_param(rspq_size, int, S_IRUGO | S_IWUSR); 112 MODULE_PARM_DESC(rspq_size, "Max number of response queue elements, " 113 "default=64"); 114 module_param(num_sgpgs, int, S_IRUGO | S_IWUSR); 115 MODULE_PARM_DESC(num_sgpgs, "Number of scatter/gather pages, default=2048"); 116 module_param(rport_del_timeout, int, S_IRUGO | S_IWUSR); 117 MODULE_PARM_DESC(rport_del_timeout, "Rport delete timeout, default=90 secs, " 118 "Range[>0]"); 119 module_param(bfa_lun_queue_depth, int, S_IRUGO | S_IWUSR); 120 MODULE_PARM_DESC(bfa_lun_queue_depth, "Lun queue depth, default=32, Range[>0]"); 121 module_param(bfa_io_max_sge, int, S_IRUGO | S_IWUSR); 122 MODULE_PARM_DESC(bfa_io_max_sge, "Max io scatter/gather elements, default=255"); 123 module_param(bfa_log_level, int, S_IRUGO | S_IWUSR); 124 MODULE_PARM_DESC(bfa_log_level, "Driver log level, default=3, " 125 "Range[Critical:1|Error:2|Warning:3|Info:4]"); 126 module_param(ioc_auto_recover, int, S_IRUGO | S_IWUSR); 127 MODULE_PARM_DESC(ioc_auto_recover, "IOC auto recovery, default=1, " 128 "Range[off:0|on:1]"); 129 module_param(bfa_linkup_delay, int, S_IRUGO | S_IWUSR); 130 MODULE_PARM_DESC(bfa_linkup_delay, "Link up delay, default=30 secs for " 131 "boot port. Otherwise 10 secs in RHEL4 & 0 for " 132 "[RHEL5, SLES10, ESX40] Range[>0]"); 133 module_param(msix_disable_cb, int, S_IRUGO | S_IWUSR); 134 MODULE_PARM_DESC(msix_disable_cb, "Disable Message Signaled Interrupts for QLogic-415/425/815/825 cards, default=0 Range[false:0|true:1]"); 135 module_param(msix_disable_ct, int, S_IRUGO | S_IWUSR); 136 MODULE_PARM_DESC(msix_disable_ct, "Disable Message Signaled Interrupts if possible for QLogic-1010/1020/804/1007/902/1741 cards, default=0, Range[false:0|true:1]"); 137 module_param(fdmi_enable, int, S_IRUGO | S_IWUSR); 138 MODULE_PARM_DESC(fdmi_enable, "Enables fdmi registration, default=1, " 139 "Range[false:0|true:1]"); 140 module_param(pcie_max_read_reqsz, int, S_IRUGO | S_IWUSR); 141 MODULE_PARM_DESC(pcie_max_read_reqsz, "PCIe max read request size, default=0 " 142 "(use system setting), Range[128|256|512|1024|2048|4096]"); 143 module_param(bfa_debugfs_enable, int, S_IRUGO | S_IWUSR); 144 MODULE_PARM_DESC(bfa_debugfs_enable, "Enables debugfs feature, default=1," 145 " Range[false:0|true:1]"); 146 module_param(max_xfer_size, int, S_IRUGO | S_IWUSR); 147 MODULE_PARM_DESC(max_xfer_size, "default=32MB," 148 " Range[64k|128k|256k|512k|1024k|2048k]"); 149 module_param(max_rport_logins, int, S_IRUGO | S_IWUSR); 150 MODULE_PARM_DESC(max_rport_logins, "Max number of logins to initiator and target rports on a port (physical/logical), default=1024"); 151 152 static void 153 bfad_sm_uninit(struct bfad_s *bfad, enum bfad_sm_event event); 154 static void 155 bfad_sm_created(struct bfad_s *bfad, enum bfad_sm_event event); 156 static void 157 bfad_sm_initializing(struct bfad_s *bfad, enum bfad_sm_event event); 158 static void 159 bfad_sm_operational(struct bfad_s *bfad, enum bfad_sm_event event); 160 static void 161 bfad_sm_stopping(struct bfad_s *bfad, enum bfad_sm_event event); 162 static void 163 bfad_sm_failed(struct bfad_s *bfad, enum bfad_sm_event event); 164 static void 165 bfad_sm_fcs_exit(struct bfad_s *bfad, enum bfad_sm_event event); 166 167 /* 168 * Beginning state for the driver instance, awaiting the pci_probe event 169 */ 170 static void 171 bfad_sm_uninit(struct bfad_s *bfad, enum bfad_sm_event event) 172 { 173 bfa_trc(bfad, event); 174 175 switch (event) { 176 case BFAD_E_CREATE: 177 bfa_sm_set_state(bfad, bfad_sm_created); 178 bfad->bfad_tsk = kthread_create(bfad_worker, (void *) bfad, 179 "%s", "bfad_worker"); 180 if (IS_ERR(bfad->bfad_tsk)) { 181 printk(KERN_INFO "bfad[%d]: Kernel thread " 182 "creation failed!\n", bfad->inst_no); 183 bfa_sm_send_event(bfad, BFAD_E_KTHREAD_CREATE_FAILED); 184 } 185 bfa_sm_send_event(bfad, BFAD_E_INIT); 186 break; 187 188 case BFAD_E_STOP: 189 /* Ignore stop; already in uninit */ 190 break; 191 192 default: 193 bfa_sm_fault(bfad, event); 194 } 195 } 196 197 /* 198 * Driver Instance is created, awaiting event INIT to initialize the bfad 199 */ 200 static void 201 bfad_sm_created(struct bfad_s *bfad, enum bfad_sm_event event) 202 { 203 unsigned long flags; 204 bfa_status_t ret; 205 206 bfa_trc(bfad, event); 207 208 switch (event) { 209 case BFAD_E_INIT: 210 bfa_sm_set_state(bfad, bfad_sm_initializing); 211 212 init_completion(&bfad->comp); 213 214 /* Enable Interrupt and wait bfa_init completion */ 215 if (bfad_setup_intr(bfad)) { 216 printk(KERN_WARNING "bfad%d: bfad_setup_intr failed\n", 217 bfad->inst_no); 218 bfa_sm_send_event(bfad, BFAD_E_INIT_FAILED); 219 break; 220 } 221 222 spin_lock_irqsave(&bfad->bfad_lock, flags); 223 bfa_iocfc_init(&bfad->bfa); 224 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 225 226 /* Set up interrupt handler for each vectors */ 227 if ((bfad->bfad_flags & BFAD_MSIX_ON) && 228 bfad_install_msix_handler(bfad)) { 229 printk(KERN_WARNING "%s: install_msix failed, bfad%d\n", 230 __func__, bfad->inst_no); 231 } 232 233 bfad_init_timer(bfad); 234 235 wait_for_completion(&bfad->comp); 236 237 if ((bfad->bfad_flags & BFAD_HAL_INIT_DONE)) { 238 bfa_sm_send_event(bfad, BFAD_E_INIT_SUCCESS); 239 } else { 240 printk(KERN_WARNING 241 "bfa %s: bfa init failed\n", 242 bfad->pci_name); 243 spin_lock_irqsave(&bfad->bfad_lock, flags); 244 bfa_fcs_init(&bfad->bfa_fcs); 245 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 246 247 ret = bfad_cfg_pport(bfad, BFA_LPORT_ROLE_FCP_IM); 248 if (ret != BFA_STATUS_OK) { 249 init_completion(&bfad->comp); 250 251 spin_lock_irqsave(&bfad->bfad_lock, flags); 252 bfad->pport.flags |= BFAD_PORT_DELETE; 253 bfa_fcs_exit(&bfad->bfa_fcs); 254 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 255 256 wait_for_completion(&bfad->comp); 257 258 bfa_sm_send_event(bfad, BFAD_E_INIT_FAILED); 259 break; 260 } 261 bfad->bfad_flags |= BFAD_HAL_INIT_FAIL; 262 bfa_sm_send_event(bfad, BFAD_E_HAL_INIT_FAILED); 263 } 264 265 break; 266 267 case BFAD_E_KTHREAD_CREATE_FAILED: 268 bfa_sm_set_state(bfad, bfad_sm_uninit); 269 break; 270 271 default: 272 bfa_sm_fault(bfad, event); 273 } 274 } 275 276 static void 277 bfad_sm_initializing(struct bfad_s *bfad, enum bfad_sm_event event) 278 { 279 int retval; 280 unsigned long flags; 281 282 bfa_trc(bfad, event); 283 284 switch (event) { 285 case BFAD_E_INIT_SUCCESS: 286 kthread_stop(bfad->bfad_tsk); 287 spin_lock_irqsave(&bfad->bfad_lock, flags); 288 bfad->bfad_tsk = NULL; 289 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 290 291 retval = bfad_start_ops(bfad); 292 if (retval != BFA_STATUS_OK) { 293 bfa_sm_set_state(bfad, bfad_sm_failed); 294 break; 295 } 296 bfa_sm_set_state(bfad, bfad_sm_operational); 297 break; 298 299 case BFAD_E_INIT_FAILED: 300 bfa_sm_set_state(bfad, bfad_sm_uninit); 301 kthread_stop(bfad->bfad_tsk); 302 spin_lock_irqsave(&bfad->bfad_lock, flags); 303 bfad->bfad_tsk = NULL; 304 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 305 break; 306 307 case BFAD_E_HAL_INIT_FAILED: 308 bfa_sm_set_state(bfad, bfad_sm_failed); 309 break; 310 default: 311 bfa_sm_fault(bfad, event); 312 } 313 } 314 315 static void 316 bfad_sm_failed(struct bfad_s *bfad, enum bfad_sm_event event) 317 { 318 int retval; 319 320 bfa_trc(bfad, event); 321 322 switch (event) { 323 case BFAD_E_INIT_SUCCESS: 324 retval = bfad_start_ops(bfad); 325 if (retval != BFA_STATUS_OK) 326 break; 327 bfa_sm_set_state(bfad, bfad_sm_operational); 328 break; 329 330 case BFAD_E_STOP: 331 bfa_sm_set_state(bfad, bfad_sm_fcs_exit); 332 bfa_sm_send_event(bfad, BFAD_E_FCS_EXIT_COMP); 333 break; 334 335 case BFAD_E_EXIT_COMP: 336 bfa_sm_set_state(bfad, bfad_sm_uninit); 337 bfad_remove_intr(bfad); 338 del_timer_sync(&bfad->hal_tmo); 339 break; 340 341 default: 342 bfa_sm_fault(bfad, event); 343 } 344 } 345 346 static void 347 bfad_sm_operational(struct bfad_s *bfad, enum bfad_sm_event event) 348 { 349 bfa_trc(bfad, event); 350 351 switch (event) { 352 case BFAD_E_STOP: 353 bfa_sm_set_state(bfad, bfad_sm_fcs_exit); 354 bfad_fcs_stop(bfad); 355 break; 356 357 default: 358 bfa_sm_fault(bfad, event); 359 } 360 } 361 362 static void 363 bfad_sm_fcs_exit(struct bfad_s *bfad, enum bfad_sm_event event) 364 { 365 bfa_trc(bfad, event); 366 367 switch (event) { 368 case BFAD_E_FCS_EXIT_COMP: 369 bfa_sm_set_state(bfad, bfad_sm_stopping); 370 bfad_stop(bfad); 371 break; 372 373 default: 374 bfa_sm_fault(bfad, event); 375 } 376 } 377 378 static void 379 bfad_sm_stopping(struct bfad_s *bfad, enum bfad_sm_event event) 380 { 381 bfa_trc(bfad, event); 382 383 switch (event) { 384 case BFAD_E_EXIT_COMP: 385 bfa_sm_set_state(bfad, bfad_sm_uninit); 386 bfad_remove_intr(bfad); 387 del_timer_sync(&bfad->hal_tmo); 388 bfad_im_probe_undo(bfad); 389 bfad->bfad_flags &= ~BFAD_FC4_PROBE_DONE; 390 bfad_uncfg_pport(bfad); 391 break; 392 393 default: 394 bfa_sm_fault(bfad, event); 395 break; 396 } 397 } 398 399 /* 400 * BFA callbacks 401 */ 402 void 403 bfad_hcb_comp(void *arg, bfa_status_t status) 404 { 405 struct bfad_hal_comp *fcomp = (struct bfad_hal_comp *)arg; 406 407 fcomp->status = status; 408 complete(&fcomp->comp); 409 } 410 411 /* 412 * bfa_init callback 413 */ 414 void 415 bfa_cb_init(void *drv, bfa_status_t init_status) 416 { 417 struct bfad_s *bfad = drv; 418 419 if (init_status == BFA_STATUS_OK) { 420 bfad->bfad_flags |= BFAD_HAL_INIT_DONE; 421 422 /* 423 * If BFAD_HAL_INIT_FAIL flag is set: 424 * Wake up the kernel thread to start 425 * the bfad operations after HAL init done 426 */ 427 if ((bfad->bfad_flags & BFAD_HAL_INIT_FAIL)) { 428 bfad->bfad_flags &= ~BFAD_HAL_INIT_FAIL; 429 wake_up_process(bfad->bfad_tsk); 430 } 431 } 432 433 complete(&bfad->comp); 434 } 435 436 /* 437 * BFA_FCS callbacks 438 */ 439 struct bfad_port_s * 440 bfa_fcb_lport_new(struct bfad_s *bfad, struct bfa_fcs_lport_s *port, 441 enum bfa_lport_role roles, struct bfad_vf_s *vf_drv, 442 struct bfad_vport_s *vp_drv) 443 { 444 bfa_status_t rc; 445 struct bfad_port_s *port_drv; 446 447 if (!vp_drv && !vf_drv) { 448 port_drv = &bfad->pport; 449 port_drv->pvb_type = BFAD_PORT_PHYS_BASE; 450 } else if (!vp_drv && vf_drv) { 451 port_drv = &vf_drv->base_port; 452 port_drv->pvb_type = BFAD_PORT_VF_BASE; 453 } else if (vp_drv && !vf_drv) { 454 port_drv = &vp_drv->drv_port; 455 port_drv->pvb_type = BFAD_PORT_PHYS_VPORT; 456 } else { 457 port_drv = &vp_drv->drv_port; 458 port_drv->pvb_type = BFAD_PORT_VF_VPORT; 459 } 460 461 port_drv->fcs_port = port; 462 port_drv->roles = roles; 463 464 if (roles & BFA_LPORT_ROLE_FCP_IM) { 465 rc = bfad_im_port_new(bfad, port_drv); 466 if (rc != BFA_STATUS_OK) { 467 bfad_im_port_delete(bfad, port_drv); 468 port_drv = NULL; 469 } 470 } 471 472 return port_drv; 473 } 474 475 /* 476 * FCS RPORT alloc callback, after successful PLOGI by FCS 477 */ 478 bfa_status_t 479 bfa_fcb_rport_alloc(struct bfad_s *bfad, struct bfa_fcs_rport_s **rport, 480 struct bfad_rport_s **rport_drv) 481 { 482 bfa_status_t rc = BFA_STATUS_OK; 483 484 *rport_drv = kzalloc(sizeof(struct bfad_rport_s), GFP_ATOMIC); 485 if (*rport_drv == NULL) { 486 rc = BFA_STATUS_ENOMEM; 487 goto ext; 488 } 489 490 *rport = &(*rport_drv)->fcs_rport; 491 492 ext: 493 return rc; 494 } 495 496 /* 497 * FCS PBC VPORT Create 498 */ 499 void 500 bfa_fcb_pbc_vport_create(struct bfad_s *bfad, struct bfi_pbc_vport_s pbc_vport) 501 { 502 503 struct bfa_lport_cfg_s port_cfg = {0}; 504 struct bfad_vport_s *vport; 505 int rc; 506 507 vport = kzalloc(sizeof(struct bfad_vport_s), GFP_ATOMIC); 508 if (!vport) { 509 bfa_trc(bfad, 0); 510 return; 511 } 512 513 vport->drv_port.bfad = bfad; 514 port_cfg.roles = BFA_LPORT_ROLE_FCP_IM; 515 port_cfg.pwwn = pbc_vport.vp_pwwn; 516 port_cfg.nwwn = pbc_vport.vp_nwwn; 517 port_cfg.preboot_vp = BFA_TRUE; 518 519 rc = bfa_fcs_pbc_vport_create(&vport->fcs_vport, &bfad->bfa_fcs, 0, 520 &port_cfg, vport); 521 522 if (rc != BFA_STATUS_OK) { 523 bfa_trc(bfad, 0); 524 return; 525 } 526 527 list_add_tail(&vport->list_entry, &bfad->pbc_vport_list); 528 } 529 530 void 531 bfad_hal_mem_release(struct bfad_s *bfad) 532 { 533 struct bfa_meminfo_s *hal_meminfo = &bfad->meminfo; 534 struct bfa_mem_dma_s *dma_info, *dma_elem; 535 struct bfa_mem_kva_s *kva_info, *kva_elem; 536 struct list_head *dm_qe, *km_qe; 537 538 dma_info = &hal_meminfo->dma_info; 539 kva_info = &hal_meminfo->kva_info; 540 541 /* Iterate through the KVA meminfo queue */ 542 list_for_each(km_qe, &kva_info->qe) { 543 kva_elem = (struct bfa_mem_kva_s *) km_qe; 544 vfree(kva_elem->kva); 545 } 546 547 /* Iterate through the DMA meminfo queue */ 548 list_for_each(dm_qe, &dma_info->qe) { 549 dma_elem = (struct bfa_mem_dma_s *) dm_qe; 550 dma_free_coherent(&bfad->pcidev->dev, 551 dma_elem->mem_len, dma_elem->kva, 552 (dma_addr_t) dma_elem->dma); 553 } 554 555 memset(hal_meminfo, 0, sizeof(struct bfa_meminfo_s)); 556 } 557 558 void 559 bfad_update_hal_cfg(struct bfa_iocfc_cfg_s *bfa_cfg) 560 { 561 if (num_rports > 0) 562 bfa_cfg->fwcfg.num_rports = num_rports; 563 if (num_ios > 0) 564 bfa_cfg->fwcfg.num_ioim_reqs = num_ios; 565 if (num_tms > 0) 566 bfa_cfg->fwcfg.num_tskim_reqs = num_tms; 567 if (num_fcxps > 0 && num_fcxps <= BFA_FCXP_MAX) 568 bfa_cfg->fwcfg.num_fcxp_reqs = num_fcxps; 569 if (num_ufbufs > 0 && num_ufbufs <= BFA_UF_MAX) 570 bfa_cfg->fwcfg.num_uf_bufs = num_ufbufs; 571 if (reqq_size > 0) 572 bfa_cfg->drvcfg.num_reqq_elems = reqq_size; 573 if (rspq_size > 0) 574 bfa_cfg->drvcfg.num_rspq_elems = rspq_size; 575 if (num_sgpgs > 0 && num_sgpgs <= BFA_SGPG_MAX) 576 bfa_cfg->drvcfg.num_sgpgs = num_sgpgs; 577 578 /* 579 * populate the hal values back to the driver for sysfs use. 580 * otherwise, the default values will be shown as 0 in sysfs 581 */ 582 num_rports = bfa_cfg->fwcfg.num_rports; 583 num_ios = bfa_cfg->fwcfg.num_ioim_reqs; 584 num_tms = bfa_cfg->fwcfg.num_tskim_reqs; 585 num_fcxps = bfa_cfg->fwcfg.num_fcxp_reqs; 586 num_ufbufs = bfa_cfg->fwcfg.num_uf_bufs; 587 reqq_size = bfa_cfg->drvcfg.num_reqq_elems; 588 rspq_size = bfa_cfg->drvcfg.num_rspq_elems; 589 num_sgpgs = bfa_cfg->drvcfg.num_sgpgs; 590 } 591 592 bfa_status_t 593 bfad_hal_mem_alloc(struct bfad_s *bfad) 594 { 595 struct bfa_meminfo_s *hal_meminfo = &bfad->meminfo; 596 struct bfa_mem_dma_s *dma_info, *dma_elem; 597 struct bfa_mem_kva_s *kva_info, *kva_elem; 598 struct list_head *dm_qe, *km_qe; 599 bfa_status_t rc = BFA_STATUS_OK; 600 dma_addr_t phys_addr; 601 602 bfa_cfg_get_default(&bfad->ioc_cfg); 603 bfad_update_hal_cfg(&bfad->ioc_cfg); 604 bfad->cfg_data.ioc_queue_depth = bfad->ioc_cfg.fwcfg.num_ioim_reqs; 605 bfa_cfg_get_meminfo(&bfad->ioc_cfg, hal_meminfo, &bfad->bfa); 606 607 dma_info = &hal_meminfo->dma_info; 608 kva_info = &hal_meminfo->kva_info; 609 610 /* Iterate through the KVA meminfo queue */ 611 list_for_each(km_qe, &kva_info->qe) { 612 kva_elem = (struct bfa_mem_kva_s *) km_qe; 613 kva_elem->kva = vmalloc(kva_elem->mem_len); 614 if (kva_elem->kva == NULL) { 615 bfad_hal_mem_release(bfad); 616 rc = BFA_STATUS_ENOMEM; 617 goto ext; 618 } 619 memset(kva_elem->kva, 0, kva_elem->mem_len); 620 } 621 622 /* Iterate through the DMA meminfo queue */ 623 list_for_each(dm_qe, &dma_info->qe) { 624 dma_elem = (struct bfa_mem_dma_s *) dm_qe; 625 dma_elem->kva = dma_alloc_coherent(&bfad->pcidev->dev, 626 dma_elem->mem_len, 627 &phys_addr, GFP_KERNEL); 628 if (dma_elem->kva == NULL) { 629 bfad_hal_mem_release(bfad); 630 rc = BFA_STATUS_ENOMEM; 631 goto ext; 632 } 633 dma_elem->dma = phys_addr; 634 memset(dma_elem->kva, 0, dma_elem->mem_len); 635 } 636 ext: 637 return rc; 638 } 639 640 /* 641 * Create a vport under a vf. 642 */ 643 bfa_status_t 644 bfad_vport_create(struct bfad_s *bfad, u16 vf_id, 645 struct bfa_lport_cfg_s *port_cfg, struct device *dev) 646 { 647 struct bfad_vport_s *vport; 648 int rc = BFA_STATUS_OK; 649 unsigned long flags; 650 struct completion fcomp; 651 652 vport = kzalloc(sizeof(struct bfad_vport_s), GFP_KERNEL); 653 if (!vport) { 654 rc = BFA_STATUS_ENOMEM; 655 goto ext; 656 } 657 658 vport->drv_port.bfad = bfad; 659 spin_lock_irqsave(&bfad->bfad_lock, flags); 660 rc = bfa_fcs_vport_create(&vport->fcs_vport, &bfad->bfa_fcs, vf_id, 661 port_cfg, vport); 662 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 663 664 if (rc != BFA_STATUS_OK) 665 goto ext_free_vport; 666 667 if (port_cfg->roles & BFA_LPORT_ROLE_FCP_IM) { 668 rc = bfad_im_scsi_host_alloc(bfad, vport->drv_port.im_port, 669 dev); 670 if (rc != BFA_STATUS_OK) 671 goto ext_free_fcs_vport; 672 } 673 674 spin_lock_irqsave(&bfad->bfad_lock, flags); 675 bfa_fcs_vport_start(&vport->fcs_vport); 676 list_add_tail(&vport->list_entry, &bfad->vport_list); 677 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 678 679 return BFA_STATUS_OK; 680 681 ext_free_fcs_vport: 682 spin_lock_irqsave(&bfad->bfad_lock, flags); 683 vport->comp_del = &fcomp; 684 init_completion(vport->comp_del); 685 bfa_fcs_vport_delete(&vport->fcs_vport); 686 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 687 wait_for_completion(vport->comp_del); 688 ext_free_vport: 689 kfree(vport); 690 ext: 691 return rc; 692 } 693 694 void 695 bfad_bfa_tmo(struct timer_list *t) 696 { 697 struct bfad_s *bfad = from_timer(bfad, t, hal_tmo); 698 unsigned long flags; 699 struct list_head doneq; 700 701 spin_lock_irqsave(&bfad->bfad_lock, flags); 702 703 bfa_timer_beat(&bfad->bfa.timer_mod); 704 705 bfa_comp_deq(&bfad->bfa, &doneq); 706 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 707 708 if (!list_empty(&doneq)) { 709 bfa_comp_process(&bfad->bfa, &doneq); 710 spin_lock_irqsave(&bfad->bfad_lock, flags); 711 bfa_comp_free(&bfad->bfa, &doneq); 712 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 713 } 714 715 mod_timer(&bfad->hal_tmo, 716 jiffies + msecs_to_jiffies(BFA_TIMER_FREQ)); 717 } 718 719 void 720 bfad_init_timer(struct bfad_s *bfad) 721 { 722 timer_setup(&bfad->hal_tmo, bfad_bfa_tmo, 0); 723 724 mod_timer(&bfad->hal_tmo, 725 jiffies + msecs_to_jiffies(BFA_TIMER_FREQ)); 726 } 727 728 int 729 bfad_pci_init(struct pci_dev *pdev, struct bfad_s *bfad) 730 { 731 int rc = -ENODEV; 732 733 if (pci_enable_device(pdev)) { 734 printk(KERN_ERR "pci_enable_device fail %p\n", pdev); 735 goto out; 736 } 737 738 if (pci_request_regions(pdev, BFAD_DRIVER_NAME)) 739 goto out_disable_device; 740 741 pci_set_master(pdev); 742 743 744 if ((pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0) || 745 (pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)) != 0)) { 746 if ((pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0) || 747 (pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)) != 0)) { 748 printk(KERN_ERR "pci_set_dma_mask fail %p\n", pdev); 749 goto out_release_region; 750 } 751 } 752 753 /* Enable PCIE Advanced Error Recovery (AER) if kernel supports */ 754 pci_enable_pcie_error_reporting(pdev); 755 756 bfad->pci_bar0_kva = pci_iomap(pdev, 0, pci_resource_len(pdev, 0)); 757 bfad->pci_bar2_kva = pci_iomap(pdev, 2, pci_resource_len(pdev, 2)); 758 759 if (bfad->pci_bar0_kva == NULL) { 760 printk(KERN_ERR "Fail to map bar0\n"); 761 goto out_release_region; 762 } 763 764 bfad->hal_pcidev.pci_slot = PCI_SLOT(pdev->devfn); 765 bfad->hal_pcidev.pci_func = PCI_FUNC(pdev->devfn); 766 bfad->hal_pcidev.pci_bar_kva = bfad->pci_bar0_kva; 767 bfad->hal_pcidev.device_id = pdev->device; 768 bfad->hal_pcidev.ssid = pdev->subsystem_device; 769 bfad->pci_name = pci_name(pdev); 770 771 bfad->pci_attr.vendor_id = pdev->vendor; 772 bfad->pci_attr.device_id = pdev->device; 773 bfad->pci_attr.ssid = pdev->subsystem_device; 774 bfad->pci_attr.ssvid = pdev->subsystem_vendor; 775 bfad->pci_attr.pcifn = PCI_FUNC(pdev->devfn); 776 777 bfad->pcidev = pdev; 778 779 /* Adjust PCIe Maximum Read Request Size */ 780 if (pci_is_pcie(pdev) && pcie_max_read_reqsz) { 781 if (pcie_max_read_reqsz >= 128 && 782 pcie_max_read_reqsz <= 4096 && 783 is_power_of_2(pcie_max_read_reqsz)) { 784 int max_rq = pcie_get_readrq(pdev); 785 printk(KERN_WARNING "BFA[%s]: " 786 "pcie_max_read_request_size is %d, " 787 "reset to %d\n", bfad->pci_name, max_rq, 788 pcie_max_read_reqsz); 789 pcie_set_readrq(pdev, pcie_max_read_reqsz); 790 } else { 791 printk(KERN_WARNING "BFA[%s]: invalid " 792 "pcie_max_read_request_size %d ignored\n", 793 bfad->pci_name, pcie_max_read_reqsz); 794 } 795 } 796 797 pci_save_state(pdev); 798 799 return 0; 800 801 out_release_region: 802 pci_release_regions(pdev); 803 out_disable_device: 804 pci_disable_device(pdev); 805 out: 806 return rc; 807 } 808 809 void 810 bfad_pci_uninit(struct pci_dev *pdev, struct bfad_s *bfad) 811 { 812 pci_iounmap(pdev, bfad->pci_bar0_kva); 813 pci_iounmap(pdev, bfad->pci_bar2_kva); 814 pci_release_regions(pdev); 815 /* Disable PCIE Advanced Error Recovery (AER) */ 816 pci_disable_pcie_error_reporting(pdev); 817 pci_disable_device(pdev); 818 } 819 820 bfa_status_t 821 bfad_drv_init(struct bfad_s *bfad) 822 { 823 bfa_status_t rc; 824 unsigned long flags; 825 826 bfad->cfg_data.rport_del_timeout = rport_del_timeout; 827 bfad->cfg_data.lun_queue_depth = bfa_lun_queue_depth; 828 bfad->cfg_data.io_max_sge = bfa_io_max_sge; 829 bfad->cfg_data.binding_method = FCP_PWWN_BINDING; 830 831 rc = bfad_hal_mem_alloc(bfad); 832 if (rc != BFA_STATUS_OK) { 833 printk(KERN_WARNING "bfad%d bfad_hal_mem_alloc failure\n", 834 bfad->inst_no); 835 printk(KERN_WARNING 836 "Not enough memory to attach all QLogic BR-series HBA ports. System may need more memory.\n"); 837 return BFA_STATUS_FAILED; 838 } 839 840 bfad->bfa.trcmod = bfad->trcmod; 841 bfad->bfa.plog = &bfad->plog_buf; 842 bfa_plog_init(&bfad->plog_buf); 843 bfa_plog_str(&bfad->plog_buf, BFA_PL_MID_DRVR, BFA_PL_EID_DRIVER_START, 844 0, "Driver Attach"); 845 846 bfa_attach(&bfad->bfa, bfad, &bfad->ioc_cfg, &bfad->meminfo, 847 &bfad->hal_pcidev); 848 849 /* FCS INIT */ 850 spin_lock_irqsave(&bfad->bfad_lock, flags); 851 bfad->bfa_fcs.trcmod = bfad->trcmod; 852 bfa_fcs_attach(&bfad->bfa_fcs, &bfad->bfa, bfad, BFA_FALSE); 853 bfad->bfa_fcs.fdmi_enabled = fdmi_enable; 854 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 855 856 bfad->bfad_flags |= BFAD_DRV_INIT_DONE; 857 858 return BFA_STATUS_OK; 859 } 860 861 void 862 bfad_drv_uninit(struct bfad_s *bfad) 863 { 864 unsigned long flags; 865 866 spin_lock_irqsave(&bfad->bfad_lock, flags); 867 init_completion(&bfad->comp); 868 bfa_iocfc_stop(&bfad->bfa); 869 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 870 wait_for_completion(&bfad->comp); 871 872 del_timer_sync(&bfad->hal_tmo); 873 bfa_isr_disable(&bfad->bfa); 874 bfa_detach(&bfad->bfa); 875 bfad_remove_intr(bfad); 876 bfad_hal_mem_release(bfad); 877 878 bfad->bfad_flags &= ~BFAD_DRV_INIT_DONE; 879 } 880 881 void 882 bfad_drv_start(struct bfad_s *bfad) 883 { 884 unsigned long flags; 885 886 spin_lock_irqsave(&bfad->bfad_lock, flags); 887 bfa_iocfc_start(&bfad->bfa); 888 bfa_fcs_pbc_vport_init(&bfad->bfa_fcs); 889 bfa_fcs_fabric_modstart(&bfad->bfa_fcs); 890 bfad->bfad_flags |= BFAD_HAL_START_DONE; 891 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 892 893 if (bfad->im) 894 flush_workqueue(bfad->im->drv_workq); 895 } 896 897 void 898 bfad_fcs_stop(struct bfad_s *bfad) 899 { 900 unsigned long flags; 901 902 spin_lock_irqsave(&bfad->bfad_lock, flags); 903 init_completion(&bfad->comp); 904 bfad->pport.flags |= BFAD_PORT_DELETE; 905 bfa_fcs_exit(&bfad->bfa_fcs); 906 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 907 wait_for_completion(&bfad->comp); 908 909 bfa_sm_send_event(bfad, BFAD_E_FCS_EXIT_COMP); 910 } 911 912 void 913 bfad_stop(struct bfad_s *bfad) 914 { 915 unsigned long flags; 916 917 spin_lock_irqsave(&bfad->bfad_lock, flags); 918 init_completion(&bfad->comp); 919 bfa_iocfc_stop(&bfad->bfa); 920 bfad->bfad_flags &= ~BFAD_HAL_START_DONE; 921 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 922 wait_for_completion(&bfad->comp); 923 924 bfa_sm_send_event(bfad, BFAD_E_EXIT_COMP); 925 } 926 927 bfa_status_t 928 bfad_cfg_pport(struct bfad_s *bfad, enum bfa_lport_role role) 929 { 930 int rc = BFA_STATUS_OK; 931 932 /* Allocate scsi_host for the physical port */ 933 if ((supported_fc4s & BFA_LPORT_ROLE_FCP_IM) && 934 (role & BFA_LPORT_ROLE_FCP_IM)) { 935 if (bfad->pport.im_port == NULL) { 936 rc = BFA_STATUS_FAILED; 937 goto out; 938 } 939 940 rc = bfad_im_scsi_host_alloc(bfad, bfad->pport.im_port, 941 &bfad->pcidev->dev); 942 if (rc != BFA_STATUS_OK) 943 goto out; 944 945 bfad->pport.roles |= BFA_LPORT_ROLE_FCP_IM; 946 } 947 948 bfad->bfad_flags |= BFAD_CFG_PPORT_DONE; 949 950 out: 951 return rc; 952 } 953 954 void 955 bfad_uncfg_pport(struct bfad_s *bfad) 956 { 957 if ((supported_fc4s & BFA_LPORT_ROLE_FCP_IM) && 958 (bfad->pport.roles & BFA_LPORT_ROLE_FCP_IM)) { 959 bfad_im_scsi_host_free(bfad, bfad->pport.im_port); 960 bfad_im_port_clean(bfad->pport.im_port); 961 kfree(bfad->pport.im_port); 962 bfad->pport.roles &= ~BFA_LPORT_ROLE_FCP_IM; 963 } 964 965 bfad->bfad_flags &= ~BFAD_CFG_PPORT_DONE; 966 } 967 968 bfa_status_t 969 bfad_start_ops(struct bfad_s *bfad) { 970 971 int retval; 972 unsigned long flags; 973 struct bfad_vport_s *vport, *vport_new; 974 struct bfa_fcs_driver_info_s driver_info; 975 976 /* Limit min/max. xfer size to [64k-32MB] */ 977 if (max_xfer_size < BFAD_MIN_SECTORS >> 1) 978 max_xfer_size = BFAD_MIN_SECTORS >> 1; 979 if (max_xfer_size > BFAD_MAX_SECTORS >> 1) 980 max_xfer_size = BFAD_MAX_SECTORS >> 1; 981 982 /* Fill the driver_info info to fcs*/ 983 memset(&driver_info, 0, sizeof(driver_info)); 984 strncpy(driver_info.version, BFAD_DRIVER_VERSION, 985 sizeof(driver_info.version) - 1); 986 if (host_name) 987 strncpy(driver_info.host_machine_name, host_name, 988 sizeof(driver_info.host_machine_name) - 1); 989 if (os_name) 990 strncpy(driver_info.host_os_name, os_name, 991 sizeof(driver_info.host_os_name) - 1); 992 if (os_patch) 993 strncpy(driver_info.host_os_patch, os_patch, 994 sizeof(driver_info.host_os_patch) - 1); 995 996 strncpy(driver_info.os_device_name, bfad->pci_name, 997 sizeof(driver_info.os_device_name) - 1); 998 999 /* FCS driver info init */ 1000 spin_lock_irqsave(&bfad->bfad_lock, flags); 1001 bfa_fcs_driver_info_init(&bfad->bfa_fcs, &driver_info); 1002 1003 if (bfad->bfad_flags & BFAD_CFG_PPORT_DONE) 1004 bfa_fcs_update_cfg(&bfad->bfa_fcs); 1005 else 1006 bfa_fcs_init(&bfad->bfa_fcs); 1007 1008 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 1009 1010 if (!(bfad->bfad_flags & BFAD_CFG_PPORT_DONE)) { 1011 retval = bfad_cfg_pport(bfad, BFA_LPORT_ROLE_FCP_IM); 1012 if (retval != BFA_STATUS_OK) 1013 return BFA_STATUS_FAILED; 1014 } 1015 1016 /* Setup fc host fixed attribute if the lk supports */ 1017 bfad_fc_host_init(bfad->pport.im_port); 1018 1019 /* BFAD level FC4 IM specific resource allocation */ 1020 retval = bfad_im_probe(bfad); 1021 if (retval != BFA_STATUS_OK) { 1022 printk(KERN_WARNING "bfad_im_probe failed\n"); 1023 if (bfa_sm_cmp_state(bfad, bfad_sm_initializing)) 1024 bfa_sm_set_state(bfad, bfad_sm_failed); 1025 return BFA_STATUS_FAILED; 1026 } else 1027 bfad->bfad_flags |= BFAD_FC4_PROBE_DONE; 1028 1029 bfad_drv_start(bfad); 1030 1031 /* Complete pbc vport create */ 1032 list_for_each_entry_safe(vport, vport_new, &bfad->pbc_vport_list, 1033 list_entry) { 1034 struct fc_vport_identifiers vid; 1035 struct fc_vport *fc_vport; 1036 char pwwn_buf[BFA_STRING_32]; 1037 1038 memset(&vid, 0, sizeof(vid)); 1039 vid.roles = FC_PORT_ROLE_FCP_INITIATOR; 1040 vid.vport_type = FC_PORTTYPE_NPIV; 1041 vid.disable = false; 1042 vid.node_name = wwn_to_u64((u8 *) 1043 (&((vport->fcs_vport).lport.port_cfg.nwwn))); 1044 vid.port_name = wwn_to_u64((u8 *) 1045 (&((vport->fcs_vport).lport.port_cfg.pwwn))); 1046 fc_vport = fc_vport_create(bfad->pport.im_port->shost, 0, &vid); 1047 if (!fc_vport) { 1048 wwn2str(pwwn_buf, vid.port_name); 1049 printk(KERN_WARNING "bfad%d: failed to create pbc vport" 1050 " %s\n", bfad->inst_no, pwwn_buf); 1051 } 1052 list_del(&vport->list_entry); 1053 kfree(vport); 1054 } 1055 1056 /* 1057 * If bfa_linkup_delay is set to -1 default; try to retrive the 1058 * value using the bfad_get_linkup_delay(); else use the 1059 * passed in module param value as the bfa_linkup_delay. 1060 */ 1061 if (bfa_linkup_delay < 0) { 1062 bfa_linkup_delay = bfad_get_linkup_delay(bfad); 1063 bfad_rport_online_wait(bfad); 1064 bfa_linkup_delay = -1; 1065 } else 1066 bfad_rport_online_wait(bfad); 1067 1068 BFA_LOG(KERN_INFO, bfad, bfa_log_level, "bfa device claimed\n"); 1069 1070 return BFA_STATUS_OK; 1071 } 1072 1073 int 1074 bfad_worker(void *ptr) 1075 { 1076 struct bfad_s *bfad = ptr; 1077 unsigned long flags; 1078 1079 if (kthread_should_stop()) 1080 return 0; 1081 1082 /* Send event BFAD_E_INIT_SUCCESS */ 1083 bfa_sm_send_event(bfad, BFAD_E_INIT_SUCCESS); 1084 1085 spin_lock_irqsave(&bfad->bfad_lock, flags); 1086 bfad->bfad_tsk = NULL; 1087 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 1088 1089 return 0; 1090 } 1091 1092 /* 1093 * BFA driver interrupt functions 1094 */ 1095 irqreturn_t 1096 bfad_intx(int irq, void *dev_id) 1097 { 1098 struct bfad_s *bfad = dev_id; 1099 struct list_head doneq; 1100 unsigned long flags; 1101 bfa_boolean_t rc; 1102 1103 spin_lock_irqsave(&bfad->bfad_lock, flags); 1104 rc = bfa_intx(&bfad->bfa); 1105 if (!rc) { 1106 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 1107 return IRQ_NONE; 1108 } 1109 1110 bfa_comp_deq(&bfad->bfa, &doneq); 1111 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 1112 1113 if (!list_empty(&doneq)) { 1114 bfa_comp_process(&bfad->bfa, &doneq); 1115 1116 spin_lock_irqsave(&bfad->bfad_lock, flags); 1117 bfa_comp_free(&bfad->bfa, &doneq); 1118 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 1119 } 1120 1121 return IRQ_HANDLED; 1122 1123 } 1124 1125 static irqreturn_t 1126 bfad_msix(int irq, void *dev_id) 1127 { 1128 struct bfad_msix_s *vec = dev_id; 1129 struct bfad_s *bfad = vec->bfad; 1130 struct list_head doneq; 1131 unsigned long flags; 1132 1133 spin_lock_irqsave(&bfad->bfad_lock, flags); 1134 1135 bfa_msix(&bfad->bfa, vec->msix.entry); 1136 bfa_comp_deq(&bfad->bfa, &doneq); 1137 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 1138 1139 if (!list_empty(&doneq)) { 1140 bfa_comp_process(&bfad->bfa, &doneq); 1141 1142 spin_lock_irqsave(&bfad->bfad_lock, flags); 1143 bfa_comp_free(&bfad->bfa, &doneq); 1144 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 1145 } 1146 1147 return IRQ_HANDLED; 1148 } 1149 1150 /* 1151 * Initialize the MSIX entry table. 1152 */ 1153 static void 1154 bfad_init_msix_entry(struct bfad_s *bfad, struct msix_entry *msix_entries, 1155 int mask, int max_bit) 1156 { 1157 int i; 1158 int match = 0x00000001; 1159 1160 for (i = 0, bfad->nvec = 0; i < MAX_MSIX_ENTRY; i++) { 1161 if (mask & match) { 1162 bfad->msix_tab[bfad->nvec].msix.entry = i; 1163 bfad->msix_tab[bfad->nvec].bfad = bfad; 1164 msix_entries[bfad->nvec].entry = i; 1165 bfad->nvec++; 1166 } 1167 1168 match <<= 1; 1169 } 1170 1171 } 1172 1173 int 1174 bfad_install_msix_handler(struct bfad_s *bfad) 1175 { 1176 int i, error = 0; 1177 1178 for (i = 0; i < bfad->nvec; i++) { 1179 sprintf(bfad->msix_tab[i].name, "bfa-%s-%s", 1180 bfad->pci_name, 1181 ((bfa_asic_id_cb(bfad->hal_pcidev.device_id)) ? 1182 msix_name_cb[i] : msix_name_ct[i])); 1183 1184 error = request_irq(bfad->msix_tab[i].msix.vector, 1185 (irq_handler_t) bfad_msix, 0, 1186 bfad->msix_tab[i].name, &bfad->msix_tab[i]); 1187 bfa_trc(bfad, i); 1188 bfa_trc(bfad, bfad->msix_tab[i].msix.vector); 1189 if (error) { 1190 int j; 1191 1192 for (j = 0; j < i; j++) 1193 free_irq(bfad->msix_tab[j].msix.vector, 1194 &bfad->msix_tab[j]); 1195 1196 bfad->bfad_flags &= ~BFAD_MSIX_ON; 1197 pci_disable_msix(bfad->pcidev); 1198 1199 return 1; 1200 } 1201 } 1202 1203 return 0; 1204 } 1205 1206 /* 1207 * Setup MSIX based interrupt. 1208 */ 1209 int 1210 bfad_setup_intr(struct bfad_s *bfad) 1211 { 1212 int error; 1213 u32 mask = 0, i, num_bit = 0, max_bit = 0; 1214 struct msix_entry msix_entries[MAX_MSIX_ENTRY]; 1215 struct pci_dev *pdev = bfad->pcidev; 1216 u16 reg; 1217 1218 /* Call BFA to get the msix map for this PCI function. */ 1219 bfa_msix_getvecs(&bfad->bfa, &mask, &num_bit, &max_bit); 1220 1221 /* Set up the msix entry table */ 1222 bfad_init_msix_entry(bfad, msix_entries, mask, max_bit); 1223 1224 if ((bfa_asic_id_ctc(pdev->device) && !msix_disable_ct) || 1225 (bfa_asic_id_cb(pdev->device) && !msix_disable_cb)) { 1226 1227 error = pci_enable_msix_exact(bfad->pcidev, 1228 msix_entries, bfad->nvec); 1229 /* In CT1 & CT2, try to allocate just one vector */ 1230 if (error == -ENOSPC && bfa_asic_id_ctc(pdev->device)) { 1231 printk(KERN_WARNING "bfa %s: trying one msix " 1232 "vector failed to allocate %d[%d]\n", 1233 bfad->pci_name, bfad->nvec, error); 1234 bfad->nvec = 1; 1235 error = pci_enable_msix_exact(bfad->pcidev, 1236 msix_entries, 1); 1237 } 1238 1239 if (error) { 1240 printk(KERN_WARNING "bfad%d: " 1241 "pci_enable_msix_exact failed (%d), " 1242 "use line based.\n", 1243 bfad->inst_no, error); 1244 goto line_based; 1245 } 1246 1247 /* Disable INTX in MSI-X mode */ 1248 pci_read_config_word(pdev, PCI_COMMAND, ®); 1249 1250 if (!(reg & PCI_COMMAND_INTX_DISABLE)) 1251 pci_write_config_word(pdev, PCI_COMMAND, 1252 reg | PCI_COMMAND_INTX_DISABLE); 1253 1254 /* Save the vectors */ 1255 for (i = 0; i < bfad->nvec; i++) { 1256 bfa_trc(bfad, msix_entries[i].vector); 1257 bfad->msix_tab[i].msix.vector = msix_entries[i].vector; 1258 } 1259 1260 bfa_msix_init(&bfad->bfa, bfad->nvec); 1261 1262 bfad->bfad_flags |= BFAD_MSIX_ON; 1263 1264 return 0; 1265 } 1266 1267 line_based: 1268 error = request_irq(bfad->pcidev->irq, (irq_handler_t)bfad_intx, 1269 BFAD_IRQ_FLAGS, BFAD_DRIVER_NAME, bfad); 1270 if (error) 1271 return error; 1272 1273 bfad->bfad_flags |= BFAD_INTX_ON; 1274 1275 return 0; 1276 } 1277 1278 void 1279 bfad_remove_intr(struct bfad_s *bfad) 1280 { 1281 int i; 1282 1283 if (bfad->bfad_flags & BFAD_MSIX_ON) { 1284 for (i = 0; i < bfad->nvec; i++) 1285 free_irq(bfad->msix_tab[i].msix.vector, 1286 &bfad->msix_tab[i]); 1287 1288 pci_disable_msix(bfad->pcidev); 1289 bfad->bfad_flags &= ~BFAD_MSIX_ON; 1290 } else if (bfad->bfad_flags & BFAD_INTX_ON) { 1291 free_irq(bfad->pcidev->irq, bfad); 1292 } 1293 } 1294 1295 /* 1296 * PCI probe entry. 1297 */ 1298 int 1299 bfad_pci_probe(struct pci_dev *pdev, const struct pci_device_id *pid) 1300 { 1301 struct bfad_s *bfad; 1302 int error = -ENODEV, retval, i; 1303 1304 /* For single port cards - only claim function 0 */ 1305 if ((pdev->device == BFA_PCI_DEVICE_ID_FC_8G1P) && 1306 (PCI_FUNC(pdev->devfn) != 0)) 1307 return -ENODEV; 1308 1309 bfad = kzalloc(sizeof(struct bfad_s), GFP_KERNEL); 1310 if (!bfad) { 1311 error = -ENOMEM; 1312 goto out; 1313 } 1314 1315 bfad->trcmod = kzalloc(sizeof(struct bfa_trc_mod_s), GFP_KERNEL); 1316 if (!bfad->trcmod) { 1317 printk(KERN_WARNING "Error alloc trace buffer!\n"); 1318 error = -ENOMEM; 1319 goto out_alloc_trace_failure; 1320 } 1321 1322 /* TRACE INIT */ 1323 bfa_trc_init(bfad->trcmod); 1324 bfa_trc(bfad, bfad_inst); 1325 1326 /* AEN INIT */ 1327 INIT_LIST_HEAD(&bfad->free_aen_q); 1328 INIT_LIST_HEAD(&bfad->active_aen_q); 1329 for (i = 0; i < BFA_AEN_MAX_ENTRY; i++) 1330 list_add_tail(&bfad->aen_list[i].qe, &bfad->free_aen_q); 1331 1332 if (!(bfad_load_fwimg(pdev))) { 1333 kfree(bfad->trcmod); 1334 goto out_alloc_trace_failure; 1335 } 1336 1337 retval = bfad_pci_init(pdev, bfad); 1338 if (retval) { 1339 printk(KERN_WARNING "bfad_pci_init failure!\n"); 1340 error = retval; 1341 goto out_pci_init_failure; 1342 } 1343 1344 mutex_lock(&bfad_mutex); 1345 bfad->inst_no = bfad_inst++; 1346 list_add_tail(&bfad->list_entry, &bfad_list); 1347 mutex_unlock(&bfad_mutex); 1348 1349 /* Initializing the state machine: State set to uninit */ 1350 bfa_sm_set_state(bfad, bfad_sm_uninit); 1351 1352 spin_lock_init(&bfad->bfad_lock); 1353 spin_lock_init(&bfad->bfad_aen_spinlock); 1354 1355 pci_set_drvdata(pdev, bfad); 1356 1357 bfad->ref_count = 0; 1358 bfad->pport.bfad = bfad; 1359 INIT_LIST_HEAD(&bfad->pbc_vport_list); 1360 INIT_LIST_HEAD(&bfad->vport_list); 1361 1362 /* Setup the debugfs node for this bfad */ 1363 if (bfa_debugfs_enable) 1364 bfad_debugfs_init(&bfad->pport); 1365 1366 retval = bfad_drv_init(bfad); 1367 if (retval != BFA_STATUS_OK) 1368 goto out_drv_init_failure; 1369 1370 bfa_sm_send_event(bfad, BFAD_E_CREATE); 1371 1372 if (bfa_sm_cmp_state(bfad, bfad_sm_uninit)) 1373 goto out_bfad_sm_failure; 1374 1375 return 0; 1376 1377 out_bfad_sm_failure: 1378 bfad_hal_mem_release(bfad); 1379 out_drv_init_failure: 1380 /* Remove the debugfs node for this bfad */ 1381 kfree(bfad->regdata); 1382 bfad_debugfs_exit(&bfad->pport); 1383 mutex_lock(&bfad_mutex); 1384 bfad_inst--; 1385 list_del(&bfad->list_entry); 1386 mutex_unlock(&bfad_mutex); 1387 bfad_pci_uninit(pdev, bfad); 1388 out_pci_init_failure: 1389 kfree(bfad->trcmod); 1390 out_alloc_trace_failure: 1391 kfree(bfad); 1392 out: 1393 return error; 1394 } 1395 1396 /* 1397 * PCI remove entry. 1398 */ 1399 void 1400 bfad_pci_remove(struct pci_dev *pdev) 1401 { 1402 struct bfad_s *bfad = pci_get_drvdata(pdev); 1403 unsigned long flags; 1404 1405 bfa_trc(bfad, bfad->inst_no); 1406 1407 spin_lock_irqsave(&bfad->bfad_lock, flags); 1408 if (bfad->bfad_tsk != NULL) { 1409 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 1410 kthread_stop(bfad->bfad_tsk); 1411 } else { 1412 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 1413 } 1414 1415 /* Send Event BFAD_E_STOP */ 1416 bfa_sm_send_event(bfad, BFAD_E_STOP); 1417 1418 /* Driver detach and dealloc mem */ 1419 spin_lock_irqsave(&bfad->bfad_lock, flags); 1420 bfa_detach(&bfad->bfa); 1421 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 1422 bfad_hal_mem_release(bfad); 1423 1424 /* Remove the debugfs node for this bfad */ 1425 kfree(bfad->regdata); 1426 bfad_debugfs_exit(&bfad->pport); 1427 1428 /* Cleaning the BFAD instance */ 1429 mutex_lock(&bfad_mutex); 1430 bfad_inst--; 1431 list_del(&bfad->list_entry); 1432 mutex_unlock(&bfad_mutex); 1433 bfad_pci_uninit(pdev, bfad); 1434 1435 kfree(bfad->trcmod); 1436 kfree(bfad); 1437 } 1438 1439 /* 1440 * PCI Error Recovery entry, error detected. 1441 */ 1442 static pci_ers_result_t 1443 bfad_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state) 1444 { 1445 struct bfad_s *bfad = pci_get_drvdata(pdev); 1446 unsigned long flags; 1447 pci_ers_result_t ret = PCI_ERS_RESULT_NONE; 1448 1449 dev_printk(KERN_ERR, &pdev->dev, 1450 "error detected state: %d - flags: 0x%x\n", 1451 state, bfad->bfad_flags); 1452 1453 switch (state) { 1454 case pci_channel_io_normal: /* non-fatal error */ 1455 spin_lock_irqsave(&bfad->bfad_lock, flags); 1456 bfad->bfad_flags &= ~BFAD_EEH_BUSY; 1457 /* Suspend/fail all bfa operations */ 1458 bfa_ioc_suspend(&bfad->bfa.ioc); 1459 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 1460 del_timer_sync(&bfad->hal_tmo); 1461 ret = PCI_ERS_RESULT_CAN_RECOVER; 1462 break; 1463 case pci_channel_io_frozen: /* fatal error */ 1464 init_completion(&bfad->comp); 1465 spin_lock_irqsave(&bfad->bfad_lock, flags); 1466 bfad->bfad_flags |= BFAD_EEH_BUSY; 1467 /* Suspend/fail all bfa operations */ 1468 bfa_ioc_suspend(&bfad->bfa.ioc); 1469 bfa_fcs_stop(&bfad->bfa_fcs); 1470 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 1471 wait_for_completion(&bfad->comp); 1472 1473 bfad_remove_intr(bfad); 1474 del_timer_sync(&bfad->hal_tmo); 1475 pci_disable_device(pdev); 1476 ret = PCI_ERS_RESULT_NEED_RESET; 1477 break; 1478 case pci_channel_io_perm_failure: /* PCI Card is DEAD */ 1479 spin_lock_irqsave(&bfad->bfad_lock, flags); 1480 bfad->bfad_flags |= BFAD_EEH_BUSY | 1481 BFAD_EEH_PCI_CHANNEL_IO_PERM_FAILURE; 1482 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 1483 1484 /* If the error_detected handler is called with the reason 1485 * pci_channel_io_perm_failure - it will subsequently call 1486 * pci_remove() entry point to remove the pci device from the 1487 * system - So defer the cleanup to pci_remove(); cleaning up 1488 * here causes inconsistent state during pci_remove(). 1489 */ 1490 ret = PCI_ERS_RESULT_DISCONNECT; 1491 break; 1492 default: 1493 WARN_ON(1); 1494 } 1495 1496 return ret; 1497 } 1498 1499 int 1500 restart_bfa(struct bfad_s *bfad) 1501 { 1502 unsigned long flags; 1503 struct pci_dev *pdev = bfad->pcidev; 1504 1505 bfa_attach(&bfad->bfa, bfad, &bfad->ioc_cfg, 1506 &bfad->meminfo, &bfad->hal_pcidev); 1507 1508 /* Enable Interrupt and wait bfa_init completion */ 1509 if (bfad_setup_intr(bfad)) { 1510 dev_printk(KERN_WARNING, &pdev->dev, 1511 "%s: bfad_setup_intr failed\n", bfad->pci_name); 1512 bfa_sm_send_event(bfad, BFAD_E_INIT_FAILED); 1513 return -1; 1514 } 1515 1516 init_completion(&bfad->comp); 1517 spin_lock_irqsave(&bfad->bfad_lock, flags); 1518 bfa_iocfc_init(&bfad->bfa); 1519 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 1520 1521 /* Set up interrupt handler for each vectors */ 1522 if ((bfad->bfad_flags & BFAD_MSIX_ON) && 1523 bfad_install_msix_handler(bfad)) 1524 dev_printk(KERN_WARNING, &pdev->dev, 1525 "%s: install_msix failed.\n", bfad->pci_name); 1526 1527 bfad_init_timer(bfad); 1528 wait_for_completion(&bfad->comp); 1529 bfad_drv_start(bfad); 1530 1531 return 0; 1532 } 1533 1534 /* 1535 * PCI Error Recovery entry, re-initialize the chip. 1536 */ 1537 static pci_ers_result_t 1538 bfad_pci_slot_reset(struct pci_dev *pdev) 1539 { 1540 struct bfad_s *bfad = pci_get_drvdata(pdev); 1541 u8 byte; 1542 1543 dev_printk(KERN_ERR, &pdev->dev, 1544 "bfad_pci_slot_reset flags: 0x%x\n", bfad->bfad_flags); 1545 1546 if (pci_enable_device(pdev)) { 1547 dev_printk(KERN_ERR, &pdev->dev, "Cannot re-enable " 1548 "PCI device after reset.\n"); 1549 return PCI_ERS_RESULT_DISCONNECT; 1550 } 1551 1552 pci_restore_state(pdev); 1553 1554 /* 1555 * Read some byte (e.g. DMA max. payload size which can't 1556 * be 0xff any time) to make sure - we did not hit another PCI error 1557 * in the middle of recovery. If we did, then declare permanent failure. 1558 */ 1559 pci_read_config_byte(pdev, 0x68, &byte); 1560 if (byte == 0xff) { 1561 dev_printk(KERN_ERR, &pdev->dev, 1562 "slot_reset failed ... got another PCI error !\n"); 1563 goto out_disable_device; 1564 } 1565 1566 pci_save_state(pdev); 1567 pci_set_master(pdev); 1568 1569 if (pci_set_dma_mask(bfad->pcidev, DMA_BIT_MASK(64)) != 0) 1570 if (pci_set_dma_mask(bfad->pcidev, DMA_BIT_MASK(32)) != 0) 1571 goto out_disable_device; 1572 1573 pci_cleanup_aer_uncorrect_error_status(pdev); 1574 1575 if (restart_bfa(bfad) == -1) 1576 goto out_disable_device; 1577 1578 pci_enable_pcie_error_reporting(pdev); 1579 dev_printk(KERN_WARNING, &pdev->dev, 1580 "slot_reset completed flags: 0x%x!\n", bfad->bfad_flags); 1581 1582 return PCI_ERS_RESULT_RECOVERED; 1583 1584 out_disable_device: 1585 pci_disable_device(pdev); 1586 return PCI_ERS_RESULT_DISCONNECT; 1587 } 1588 1589 static pci_ers_result_t 1590 bfad_pci_mmio_enabled(struct pci_dev *pdev) 1591 { 1592 unsigned long flags; 1593 struct bfad_s *bfad = pci_get_drvdata(pdev); 1594 1595 dev_printk(KERN_INFO, &pdev->dev, "mmio_enabled\n"); 1596 1597 /* Fetch FW diagnostic information */ 1598 bfa_ioc_debug_save_ftrc(&bfad->bfa.ioc); 1599 1600 /* Cancel all pending IOs */ 1601 spin_lock_irqsave(&bfad->bfad_lock, flags); 1602 init_completion(&bfad->comp); 1603 bfa_fcs_stop(&bfad->bfa_fcs); 1604 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 1605 wait_for_completion(&bfad->comp); 1606 1607 bfad_remove_intr(bfad); 1608 del_timer_sync(&bfad->hal_tmo); 1609 pci_disable_device(pdev); 1610 1611 return PCI_ERS_RESULT_NEED_RESET; 1612 } 1613 1614 static void 1615 bfad_pci_resume(struct pci_dev *pdev) 1616 { 1617 unsigned long flags; 1618 struct bfad_s *bfad = pci_get_drvdata(pdev); 1619 1620 dev_printk(KERN_WARNING, &pdev->dev, "resume\n"); 1621 1622 /* wait until the link is online */ 1623 bfad_rport_online_wait(bfad); 1624 1625 spin_lock_irqsave(&bfad->bfad_lock, flags); 1626 bfad->bfad_flags &= ~BFAD_EEH_BUSY; 1627 spin_unlock_irqrestore(&bfad->bfad_lock, flags); 1628 } 1629 1630 struct pci_device_id bfad_id_table[] = { 1631 { 1632 .vendor = BFA_PCI_VENDOR_ID_BROCADE, 1633 .device = BFA_PCI_DEVICE_ID_FC_8G2P, 1634 .subvendor = PCI_ANY_ID, 1635 .subdevice = PCI_ANY_ID, 1636 }, 1637 { 1638 .vendor = BFA_PCI_VENDOR_ID_BROCADE, 1639 .device = BFA_PCI_DEVICE_ID_FC_8G1P, 1640 .subvendor = PCI_ANY_ID, 1641 .subdevice = PCI_ANY_ID, 1642 }, 1643 { 1644 .vendor = BFA_PCI_VENDOR_ID_BROCADE, 1645 .device = BFA_PCI_DEVICE_ID_CT, 1646 .subvendor = PCI_ANY_ID, 1647 .subdevice = PCI_ANY_ID, 1648 .class = (PCI_CLASS_SERIAL_FIBER << 8), 1649 .class_mask = ~0, 1650 }, 1651 { 1652 .vendor = BFA_PCI_VENDOR_ID_BROCADE, 1653 .device = BFA_PCI_DEVICE_ID_CT_FC, 1654 .subvendor = PCI_ANY_ID, 1655 .subdevice = PCI_ANY_ID, 1656 .class = (PCI_CLASS_SERIAL_FIBER << 8), 1657 .class_mask = ~0, 1658 }, 1659 { 1660 .vendor = BFA_PCI_VENDOR_ID_BROCADE, 1661 .device = BFA_PCI_DEVICE_ID_CT2, 1662 .subvendor = PCI_ANY_ID, 1663 .subdevice = PCI_ANY_ID, 1664 .class = (PCI_CLASS_SERIAL_FIBER << 8), 1665 .class_mask = ~0, 1666 }, 1667 1668 { 1669 .vendor = BFA_PCI_VENDOR_ID_BROCADE, 1670 .device = BFA_PCI_DEVICE_ID_CT2_QUAD, 1671 .subvendor = PCI_ANY_ID, 1672 .subdevice = PCI_ANY_ID, 1673 .class = (PCI_CLASS_SERIAL_FIBER << 8), 1674 .class_mask = ~0, 1675 }, 1676 {0, 0}, 1677 }; 1678 1679 MODULE_DEVICE_TABLE(pci, bfad_id_table); 1680 1681 /* 1682 * PCI error recovery handlers. 1683 */ 1684 static struct pci_error_handlers bfad_err_handler = { 1685 .error_detected = bfad_pci_error_detected, 1686 .slot_reset = bfad_pci_slot_reset, 1687 .mmio_enabled = bfad_pci_mmio_enabled, 1688 .resume = bfad_pci_resume, 1689 }; 1690 1691 static struct pci_driver bfad_pci_driver = { 1692 .name = BFAD_DRIVER_NAME, 1693 .id_table = bfad_id_table, 1694 .probe = bfad_pci_probe, 1695 .remove = bfad_pci_remove, 1696 .err_handler = &bfad_err_handler, 1697 }; 1698 1699 /* 1700 * Driver module init. 1701 */ 1702 static int __init 1703 bfad_init(void) 1704 { 1705 int error = 0; 1706 1707 pr_info("QLogic BR-series BFA FC/FCOE SCSI driver - version: %s\n", 1708 BFAD_DRIVER_VERSION); 1709 1710 if (num_sgpgs > 0) 1711 num_sgpgs_parm = num_sgpgs; 1712 1713 error = bfad_im_module_init(); 1714 if (error) { 1715 error = -ENOMEM; 1716 printk(KERN_WARNING "bfad_im_module_init failure\n"); 1717 goto ext; 1718 } 1719 1720 if (strcmp(FCPI_NAME, " fcpim") == 0) 1721 supported_fc4s |= BFA_LPORT_ROLE_FCP_IM; 1722 1723 bfa_auto_recover = ioc_auto_recover; 1724 bfa_fcs_rport_set_del_timeout(rport_del_timeout); 1725 bfa_fcs_rport_set_max_logins(max_rport_logins); 1726 1727 error = pci_register_driver(&bfad_pci_driver); 1728 if (error) { 1729 printk(KERN_WARNING "pci_register_driver failure\n"); 1730 goto ext; 1731 } 1732 1733 return 0; 1734 1735 ext: 1736 bfad_im_module_exit(); 1737 return error; 1738 } 1739 1740 /* 1741 * Driver module exit. 1742 */ 1743 static void __exit 1744 bfad_exit(void) 1745 { 1746 pci_unregister_driver(&bfad_pci_driver); 1747 bfad_im_module_exit(); 1748 bfad_free_fwimg(); 1749 } 1750 1751 /* Firmware handling */ 1752 static void 1753 bfad_read_firmware(struct pci_dev *pdev, u32 **bfi_image, 1754 u32 *bfi_image_size, char *fw_name) 1755 { 1756 const struct firmware *fw; 1757 1758 if (request_firmware(&fw, fw_name, &pdev->dev)) { 1759 printk(KERN_ALERT "Can't locate firmware %s\n", fw_name); 1760 *bfi_image = NULL; 1761 goto out; 1762 } 1763 1764 *bfi_image = vmalloc(fw->size); 1765 if (NULL == *bfi_image) { 1766 printk(KERN_ALERT "Fail to allocate buffer for fw image " 1767 "size=%x!\n", (u32) fw->size); 1768 goto out; 1769 } 1770 1771 memcpy(*bfi_image, fw->data, fw->size); 1772 *bfi_image_size = fw->size/sizeof(u32); 1773 out: 1774 release_firmware(fw); 1775 } 1776 1777 static u32 * 1778 bfad_load_fwimg(struct pci_dev *pdev) 1779 { 1780 if (bfa_asic_id_ct2(pdev->device)) { 1781 if (bfi_image_ct2_size == 0) 1782 bfad_read_firmware(pdev, &bfi_image_ct2, 1783 &bfi_image_ct2_size, BFAD_FW_FILE_CT2); 1784 return bfi_image_ct2; 1785 } else if (bfa_asic_id_ct(pdev->device)) { 1786 if (bfi_image_ct_size == 0) 1787 bfad_read_firmware(pdev, &bfi_image_ct, 1788 &bfi_image_ct_size, BFAD_FW_FILE_CT); 1789 return bfi_image_ct; 1790 } else if (bfa_asic_id_cb(pdev->device)) { 1791 if (bfi_image_cb_size == 0) 1792 bfad_read_firmware(pdev, &bfi_image_cb, 1793 &bfi_image_cb_size, BFAD_FW_FILE_CB); 1794 return bfi_image_cb; 1795 } 1796 1797 return NULL; 1798 } 1799 1800 static void 1801 bfad_free_fwimg(void) 1802 { 1803 if (bfi_image_ct2_size && bfi_image_ct2) 1804 vfree(bfi_image_ct2); 1805 if (bfi_image_ct_size && bfi_image_ct) 1806 vfree(bfi_image_ct); 1807 if (bfi_image_cb_size && bfi_image_cb) 1808 vfree(bfi_image_cb); 1809 } 1810 1811 module_init(bfad_init); 1812 module_exit(bfad_exit); 1813 MODULE_LICENSE("GPL"); 1814 MODULE_DESCRIPTION("QLogic BR-series Fibre Channel HBA Driver" BFAD_PROTO_NAME); 1815 MODULE_AUTHOR("QLogic Corporation"); 1816 MODULE_VERSION(BFAD_DRIVER_VERSION); 1817