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