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