1 /* 2 * QLogic Fibre Channel HBA Driver 3 * Copyright (c) 2003-2010 QLogic Corporation 4 * 5 * See LICENSE.qla2xxx for copyright and licensing details. 6 */ 7 #include "qla_def.h" 8 9 #include <linux/moduleparam.h> 10 #include <linux/vmalloc.h> 11 #include <linux/delay.h> 12 #include <linux/kthread.h> 13 #include <linux/mutex.h> 14 #include <linux/kobject.h> 15 #include <linux/slab.h> 16 17 #include <scsi/scsi_tcq.h> 18 #include <scsi/scsicam.h> 19 #include <scsi/scsi_transport.h> 20 #include <scsi/scsi_transport_fc.h> 21 22 /* 23 * Driver version 24 */ 25 char qla2x00_version_str[40]; 26 27 static int apidev_major; 28 29 /* 30 * SRB allocation cache 31 */ 32 static struct kmem_cache *srb_cachep; 33 34 /* 35 * CT6 CTX allocation cache 36 */ 37 static struct kmem_cache *ctx_cachep; 38 39 int ql2xlogintimeout = 20; 40 module_param(ql2xlogintimeout, int, S_IRUGO|S_IRUSR); 41 MODULE_PARM_DESC(ql2xlogintimeout, 42 "Login timeout value in seconds."); 43 44 int qlport_down_retry; 45 module_param(qlport_down_retry, int, S_IRUGO|S_IRUSR); 46 MODULE_PARM_DESC(qlport_down_retry, 47 "Maximum number of command retries to a port that returns " 48 "a PORT-DOWN status."); 49 50 int ql2xplogiabsentdevice; 51 module_param(ql2xplogiabsentdevice, int, S_IRUGO|S_IWUSR); 52 MODULE_PARM_DESC(ql2xplogiabsentdevice, 53 "Option to enable PLOGI to devices that are not present after " 54 "a Fabric scan. This is needed for several broken switches. " 55 "Default is 0 - no PLOGI. 1 - perfom PLOGI."); 56 57 int ql2xloginretrycount = 0; 58 module_param(ql2xloginretrycount, int, S_IRUGO|S_IRUSR); 59 MODULE_PARM_DESC(ql2xloginretrycount, 60 "Specify an alternate value for the NVRAM login retry count."); 61 62 int ql2xallocfwdump = 1; 63 module_param(ql2xallocfwdump, int, S_IRUGO|S_IRUSR); 64 MODULE_PARM_DESC(ql2xallocfwdump, 65 "Option to enable allocation of memory for a firmware dump " 66 "during HBA initialization. Memory allocation requirements " 67 "vary by ISP type. Default is 1 - allocate memory."); 68 69 int ql2xextended_error_logging; 70 module_param(ql2xextended_error_logging, int, S_IRUGO|S_IWUSR); 71 MODULE_PARM_DESC(ql2xextended_error_logging, 72 "Option to enable extended error logging, " 73 "Default is 0 - no logging. 1 - log errors."); 74 75 int ql2xshiftctondsd = 6; 76 module_param(ql2xshiftctondsd, int, S_IRUGO|S_IRUSR); 77 MODULE_PARM_DESC(ql2xshiftctondsd, 78 "Set to control shifting of command type processing " 79 "based on total number of SG elements."); 80 81 static void qla2x00_free_device(scsi_qla_host_t *); 82 83 int ql2xfdmienable=1; 84 module_param(ql2xfdmienable, int, S_IRUGO|S_IRUSR); 85 MODULE_PARM_DESC(ql2xfdmienable, 86 "Enables FDMI registrations. " 87 "0 - no FDMI. Default is 1 - perform FDMI."); 88 89 #define MAX_Q_DEPTH 32 90 static int ql2xmaxqdepth = MAX_Q_DEPTH; 91 module_param(ql2xmaxqdepth, int, S_IRUGO|S_IWUSR); 92 MODULE_PARM_DESC(ql2xmaxqdepth, 93 "Maximum queue depth to report for target devices."); 94 95 /* Do not change the value of this after module load */ 96 int ql2xenabledif = 1; 97 module_param(ql2xenabledif, int, S_IRUGO|S_IWUSR); 98 MODULE_PARM_DESC(ql2xenabledif, 99 " Enable T10-CRC-DIF " 100 " Default is 0 - No DIF Support. 1 - Enable it"); 101 102 int ql2xenablehba_err_chk; 103 module_param(ql2xenablehba_err_chk, int, S_IRUGO|S_IWUSR); 104 MODULE_PARM_DESC(ql2xenablehba_err_chk, 105 " Enable T10-CRC-DIF Error isolation by HBA" 106 " Default is 0 - Error isolation disabled, 1 - Enable it"); 107 108 int ql2xiidmaenable=1; 109 module_param(ql2xiidmaenable, int, S_IRUGO|S_IRUSR); 110 MODULE_PARM_DESC(ql2xiidmaenable, 111 "Enables iIDMA settings " 112 "Default is 1 - perform iIDMA. 0 - no iIDMA."); 113 114 int ql2xmaxqueues = 1; 115 module_param(ql2xmaxqueues, int, S_IRUGO|S_IRUSR); 116 MODULE_PARM_DESC(ql2xmaxqueues, 117 "Enables MQ settings " 118 "Default is 1 for single queue. Set it to number " 119 "of queues in MQ mode."); 120 121 int ql2xmultique_tag; 122 module_param(ql2xmultique_tag, int, S_IRUGO|S_IRUSR); 123 MODULE_PARM_DESC(ql2xmultique_tag, 124 "Enables CPU affinity settings for the driver " 125 "Default is 0 for no affinity of request and response IO. " 126 "Set it to 1 to turn on the cpu affinity."); 127 128 int ql2xfwloadbin; 129 module_param(ql2xfwloadbin, int, S_IRUGO|S_IRUSR); 130 MODULE_PARM_DESC(ql2xfwloadbin, 131 "Option to specify location from which to load ISP firmware:\n" 132 " 2 -- load firmware via the request_firmware() (hotplug)\n" 133 " interface.\n" 134 " 1 -- load firmware from flash.\n" 135 " 0 -- use default semantics.\n"); 136 137 int ql2xetsenable; 138 module_param(ql2xetsenable, int, S_IRUGO|S_IRUSR); 139 MODULE_PARM_DESC(ql2xetsenable, 140 "Enables firmware ETS burst." 141 "Default is 0 - skip ETS enablement."); 142 143 int ql2xdbwr = 1; 144 module_param(ql2xdbwr, int, S_IRUGO|S_IRUSR); 145 MODULE_PARM_DESC(ql2xdbwr, 146 "Option to specify scheme for request queue posting\n" 147 " 0 -- Regular doorbell.\n" 148 " 1 -- CAMRAM doorbell (faster).\n"); 149 150 int ql2xdontresethba; 151 module_param(ql2xdontresethba, int, S_IRUGO|S_IRUSR); 152 MODULE_PARM_DESC(ql2xdontresethba, 153 "Option to specify reset behaviour\n" 154 " 0 (Default) -- Reset on failure.\n" 155 " 1 -- Do not reset on failure.\n"); 156 157 int ql2xtargetreset = 1; 158 module_param(ql2xtargetreset, int, S_IRUGO|S_IRUSR); 159 MODULE_PARM_DESC(ql2xtargetreset, 160 "Enable target reset." 161 "Default is 1 - use hw defaults."); 162 163 int ql2xgffidenable; 164 module_param(ql2xgffidenable, int, S_IRUGO|S_IRUSR); 165 MODULE_PARM_DESC(ql2xgffidenable, 166 "Enables GFF_ID checks of port type. " 167 "Default is 0 - Do not use GFF_ID information."); 168 169 int ql2xasynctmfenable; 170 module_param(ql2xasynctmfenable, int, S_IRUGO|S_IRUSR); 171 MODULE_PARM_DESC(ql2xasynctmfenable, 172 "Enables issue of TM IOCBs asynchronously via IOCB mechanism" 173 "Default is 0 - Issue TM IOCBs via mailbox mechanism."); 174 /* 175 * SCSI host template entry points 176 */ 177 static int qla2xxx_slave_configure(struct scsi_device * device); 178 static int qla2xxx_slave_alloc(struct scsi_device *); 179 static int qla2xxx_scan_finished(struct Scsi_Host *, unsigned long time); 180 static void qla2xxx_scan_start(struct Scsi_Host *); 181 static void qla2xxx_slave_destroy(struct scsi_device *); 182 static int qla2xxx_queuecommand(struct Scsi_Host *h, struct scsi_cmnd *cmd); 183 static int qla2xxx_eh_abort(struct scsi_cmnd *); 184 static int qla2xxx_eh_device_reset(struct scsi_cmnd *); 185 static int qla2xxx_eh_target_reset(struct scsi_cmnd *); 186 static int qla2xxx_eh_bus_reset(struct scsi_cmnd *); 187 static int qla2xxx_eh_host_reset(struct scsi_cmnd *); 188 189 static int qla2x00_change_queue_depth(struct scsi_device *, int, int); 190 static int qla2x00_change_queue_type(struct scsi_device *, int); 191 192 struct scsi_host_template qla2xxx_driver_template = { 193 .module = THIS_MODULE, 194 .name = QLA2XXX_DRIVER_NAME, 195 .queuecommand = qla2xxx_queuecommand, 196 197 .eh_abort_handler = qla2xxx_eh_abort, 198 .eh_device_reset_handler = qla2xxx_eh_device_reset, 199 .eh_target_reset_handler = qla2xxx_eh_target_reset, 200 .eh_bus_reset_handler = qla2xxx_eh_bus_reset, 201 .eh_host_reset_handler = qla2xxx_eh_host_reset, 202 203 .slave_configure = qla2xxx_slave_configure, 204 205 .slave_alloc = qla2xxx_slave_alloc, 206 .slave_destroy = qla2xxx_slave_destroy, 207 .scan_finished = qla2xxx_scan_finished, 208 .scan_start = qla2xxx_scan_start, 209 .change_queue_depth = qla2x00_change_queue_depth, 210 .change_queue_type = qla2x00_change_queue_type, 211 .this_id = -1, 212 .cmd_per_lun = 3, 213 .use_clustering = ENABLE_CLUSTERING, 214 .sg_tablesize = SG_ALL, 215 216 .max_sectors = 0xFFFF, 217 .shost_attrs = qla2x00_host_attrs, 218 }; 219 220 static struct scsi_transport_template *qla2xxx_transport_template = NULL; 221 struct scsi_transport_template *qla2xxx_transport_vport_template = NULL; 222 223 /* TODO Convert to inlines 224 * 225 * Timer routines 226 */ 227 228 __inline__ void 229 qla2x00_start_timer(scsi_qla_host_t *vha, void *func, unsigned long interval) 230 { 231 init_timer(&vha->timer); 232 vha->timer.expires = jiffies + interval * HZ; 233 vha->timer.data = (unsigned long)vha; 234 vha->timer.function = (void (*)(unsigned long))func; 235 add_timer(&vha->timer); 236 vha->timer_active = 1; 237 } 238 239 static inline void 240 qla2x00_restart_timer(scsi_qla_host_t *vha, unsigned long interval) 241 { 242 /* Currently used for 82XX only. */ 243 if (vha->device_flags & DFLG_DEV_FAILED) 244 return; 245 246 mod_timer(&vha->timer, jiffies + interval * HZ); 247 } 248 249 static __inline__ void 250 qla2x00_stop_timer(scsi_qla_host_t *vha) 251 { 252 del_timer_sync(&vha->timer); 253 vha->timer_active = 0; 254 } 255 256 static int qla2x00_do_dpc(void *data); 257 258 static void qla2x00_rst_aen(scsi_qla_host_t *); 259 260 static int qla2x00_mem_alloc(struct qla_hw_data *, uint16_t, uint16_t, 261 struct req_que **, struct rsp_que **); 262 static void qla2x00_free_fw_dump(struct qla_hw_data *); 263 static void qla2x00_mem_free(struct qla_hw_data *); 264 static void qla2x00_sp_free_dma(srb_t *); 265 266 /* -------------------------------------------------------------------------- */ 267 static int qla2x00_alloc_queues(struct qla_hw_data *ha) 268 { 269 ha->req_q_map = kzalloc(sizeof(struct req_que *) * ha->max_req_queues, 270 GFP_KERNEL); 271 if (!ha->req_q_map) { 272 qla_printk(KERN_WARNING, ha, 273 "Unable to allocate memory for request queue ptrs\n"); 274 goto fail_req_map; 275 } 276 277 ha->rsp_q_map = kzalloc(sizeof(struct rsp_que *) * ha->max_rsp_queues, 278 GFP_KERNEL); 279 if (!ha->rsp_q_map) { 280 qla_printk(KERN_WARNING, ha, 281 "Unable to allocate memory for response queue ptrs\n"); 282 goto fail_rsp_map; 283 } 284 set_bit(0, ha->rsp_qid_map); 285 set_bit(0, ha->req_qid_map); 286 return 1; 287 288 fail_rsp_map: 289 kfree(ha->req_q_map); 290 ha->req_q_map = NULL; 291 fail_req_map: 292 return -ENOMEM; 293 } 294 295 static void qla2x00_free_req_que(struct qla_hw_data *ha, struct req_que *req) 296 { 297 if (req && req->ring) 298 dma_free_coherent(&ha->pdev->dev, 299 (req->length + 1) * sizeof(request_t), 300 req->ring, req->dma); 301 302 kfree(req); 303 req = NULL; 304 } 305 306 static void qla2x00_free_rsp_que(struct qla_hw_data *ha, struct rsp_que *rsp) 307 { 308 if (rsp && rsp->ring) 309 dma_free_coherent(&ha->pdev->dev, 310 (rsp->length + 1) * sizeof(response_t), 311 rsp->ring, rsp->dma); 312 313 kfree(rsp); 314 rsp = NULL; 315 } 316 317 static void qla2x00_free_queues(struct qla_hw_data *ha) 318 { 319 struct req_que *req; 320 struct rsp_que *rsp; 321 int cnt; 322 323 for (cnt = 0; cnt < ha->max_req_queues; cnt++) { 324 req = ha->req_q_map[cnt]; 325 qla2x00_free_req_que(ha, req); 326 } 327 kfree(ha->req_q_map); 328 ha->req_q_map = NULL; 329 330 for (cnt = 0; cnt < ha->max_rsp_queues; cnt++) { 331 rsp = ha->rsp_q_map[cnt]; 332 qla2x00_free_rsp_que(ha, rsp); 333 } 334 kfree(ha->rsp_q_map); 335 ha->rsp_q_map = NULL; 336 } 337 338 static int qla25xx_setup_mode(struct scsi_qla_host *vha) 339 { 340 uint16_t options = 0; 341 int ques, req, ret; 342 struct qla_hw_data *ha = vha->hw; 343 344 if (!(ha->fw_attributes & BIT_6)) { 345 qla_printk(KERN_INFO, ha, 346 "Firmware is not multi-queue capable\n"); 347 goto fail; 348 } 349 if (ql2xmultique_tag) { 350 /* create a request queue for IO */ 351 options |= BIT_7; 352 req = qla25xx_create_req_que(ha, options, 0, 0, -1, 353 QLA_DEFAULT_QUE_QOS); 354 if (!req) { 355 qla_printk(KERN_WARNING, ha, 356 "Can't create request queue\n"); 357 goto fail; 358 } 359 ha->wq = create_workqueue("qla2xxx_wq"); 360 vha->req = ha->req_q_map[req]; 361 options |= BIT_1; 362 for (ques = 1; ques < ha->max_rsp_queues; ques++) { 363 ret = qla25xx_create_rsp_que(ha, options, 0, 0, req); 364 if (!ret) { 365 qla_printk(KERN_WARNING, ha, 366 "Response Queue create failed\n"); 367 goto fail2; 368 } 369 } 370 ha->flags.cpu_affinity_enabled = 1; 371 372 DEBUG2(qla_printk(KERN_INFO, ha, 373 "CPU affinity mode enabled, no. of response" 374 " queues:%d, no. of request queues:%d\n", 375 ha->max_rsp_queues, ha->max_req_queues)); 376 } 377 return 0; 378 fail2: 379 qla25xx_delete_queues(vha); 380 destroy_workqueue(ha->wq); 381 ha->wq = NULL; 382 fail: 383 ha->mqenable = 0; 384 kfree(ha->req_q_map); 385 kfree(ha->rsp_q_map); 386 ha->max_req_queues = ha->max_rsp_queues = 1; 387 return 1; 388 } 389 390 static char * 391 qla2x00_pci_info_str(struct scsi_qla_host *vha, char *str) 392 { 393 struct qla_hw_data *ha = vha->hw; 394 static char *pci_bus_modes[] = { 395 "33", "66", "100", "133", 396 }; 397 uint16_t pci_bus; 398 399 strcpy(str, "PCI"); 400 pci_bus = (ha->pci_attr & (BIT_9 | BIT_10)) >> 9; 401 if (pci_bus) { 402 strcat(str, "-X ("); 403 strcat(str, pci_bus_modes[pci_bus]); 404 } else { 405 pci_bus = (ha->pci_attr & BIT_8) >> 8; 406 strcat(str, " ("); 407 strcat(str, pci_bus_modes[pci_bus]); 408 } 409 strcat(str, " MHz)"); 410 411 return (str); 412 } 413 414 static char * 415 qla24xx_pci_info_str(struct scsi_qla_host *vha, char *str) 416 { 417 static char *pci_bus_modes[] = { "33", "66", "100", "133", }; 418 struct qla_hw_data *ha = vha->hw; 419 uint32_t pci_bus; 420 int pcie_reg; 421 422 pcie_reg = pci_find_capability(ha->pdev, PCI_CAP_ID_EXP); 423 if (pcie_reg) { 424 char lwstr[6]; 425 uint16_t pcie_lstat, lspeed, lwidth; 426 427 pcie_reg += 0x12; 428 pci_read_config_word(ha->pdev, pcie_reg, &pcie_lstat); 429 lspeed = pcie_lstat & (BIT_0 | BIT_1 | BIT_2 | BIT_3); 430 lwidth = (pcie_lstat & 431 (BIT_4 | BIT_5 | BIT_6 | BIT_7 | BIT_8 | BIT_9)) >> 4; 432 433 strcpy(str, "PCIe ("); 434 if (lspeed == 1) 435 strcat(str, "2.5GT/s "); 436 else if (lspeed == 2) 437 strcat(str, "5.0GT/s "); 438 else 439 strcat(str, "<unknown> "); 440 snprintf(lwstr, sizeof(lwstr), "x%d)", lwidth); 441 strcat(str, lwstr); 442 443 return str; 444 } 445 446 strcpy(str, "PCI"); 447 pci_bus = (ha->pci_attr & CSRX_PCIX_BUS_MODE_MASK) >> 8; 448 if (pci_bus == 0 || pci_bus == 8) { 449 strcat(str, " ("); 450 strcat(str, pci_bus_modes[pci_bus >> 3]); 451 } else { 452 strcat(str, "-X "); 453 if (pci_bus & BIT_2) 454 strcat(str, "Mode 2"); 455 else 456 strcat(str, "Mode 1"); 457 strcat(str, " ("); 458 strcat(str, pci_bus_modes[pci_bus & ~BIT_2]); 459 } 460 strcat(str, " MHz)"); 461 462 return str; 463 } 464 465 static char * 466 qla2x00_fw_version_str(struct scsi_qla_host *vha, char *str) 467 { 468 char un_str[10]; 469 struct qla_hw_data *ha = vha->hw; 470 471 sprintf(str, "%d.%02d.%02d ", ha->fw_major_version, 472 ha->fw_minor_version, 473 ha->fw_subminor_version); 474 475 if (ha->fw_attributes & BIT_9) { 476 strcat(str, "FLX"); 477 return (str); 478 } 479 480 switch (ha->fw_attributes & 0xFF) { 481 case 0x7: 482 strcat(str, "EF"); 483 break; 484 case 0x17: 485 strcat(str, "TP"); 486 break; 487 case 0x37: 488 strcat(str, "IP"); 489 break; 490 case 0x77: 491 strcat(str, "VI"); 492 break; 493 default: 494 sprintf(un_str, "(%x)", ha->fw_attributes); 495 strcat(str, un_str); 496 break; 497 } 498 if (ha->fw_attributes & 0x100) 499 strcat(str, "X"); 500 501 return (str); 502 } 503 504 static char * 505 qla24xx_fw_version_str(struct scsi_qla_host *vha, char *str) 506 { 507 struct qla_hw_data *ha = vha->hw; 508 509 sprintf(str, "%d.%02d.%02d (%x)", ha->fw_major_version, 510 ha->fw_minor_version, ha->fw_subminor_version, ha->fw_attributes); 511 return str; 512 } 513 514 static inline srb_t * 515 qla2x00_get_new_sp(scsi_qla_host_t *vha, fc_port_t *fcport, 516 struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *)) 517 { 518 srb_t *sp; 519 struct qla_hw_data *ha = vha->hw; 520 521 sp = mempool_alloc(ha->srb_mempool, GFP_ATOMIC); 522 if (!sp) 523 return sp; 524 525 atomic_set(&sp->ref_count, 1); 526 sp->fcport = fcport; 527 sp->cmd = cmd; 528 sp->flags = 0; 529 CMD_SP(cmd) = (void *)sp; 530 cmd->scsi_done = done; 531 sp->ctx = NULL; 532 533 return sp; 534 } 535 536 static int 537 qla2xxx_queuecommand_lck(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *)) 538 { 539 scsi_qla_host_t *vha = shost_priv(cmd->device->host); 540 fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata; 541 struct fc_rport *rport = starget_to_rport(scsi_target(cmd->device)); 542 struct qla_hw_data *ha = vha->hw; 543 struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev); 544 srb_t *sp; 545 int rval; 546 547 spin_unlock_irq(vha->host->host_lock); 548 if (ha->flags.eeh_busy) { 549 if (ha->flags.pci_channel_io_perm_failure) 550 cmd->result = DID_NO_CONNECT << 16; 551 else 552 cmd->result = DID_REQUEUE << 16; 553 goto qc24_fail_command; 554 } 555 556 rval = fc_remote_port_chkready(rport); 557 if (rval) { 558 cmd->result = rval; 559 goto qc24_fail_command; 560 } 561 562 if (!vha->flags.difdix_supported && 563 scsi_get_prot_op(cmd) != SCSI_PROT_NORMAL) { 564 DEBUG2(qla_printk(KERN_ERR, ha, 565 "DIF Cap Not Reg, fail DIF capable cmd's:%x\n", 566 cmd->cmnd[0])); 567 cmd->result = DID_NO_CONNECT << 16; 568 goto qc24_fail_command; 569 } 570 if (atomic_read(&fcport->state) != FCS_ONLINE) { 571 if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD || 572 atomic_read(&fcport->state) == FCS_DEVICE_LOST || 573 atomic_read(&base_vha->loop_state) == LOOP_DEAD) { 574 cmd->result = DID_NO_CONNECT << 16; 575 goto qc24_fail_command; 576 } 577 goto qc24_target_busy; 578 } 579 580 sp = qla2x00_get_new_sp(base_vha, fcport, cmd, done); 581 if (!sp) 582 goto qc24_host_busy_lock; 583 584 rval = ha->isp_ops->start_scsi(sp); 585 if (rval != QLA_SUCCESS) 586 goto qc24_host_busy_free_sp; 587 588 spin_lock_irq(vha->host->host_lock); 589 590 return 0; 591 592 qc24_host_busy_free_sp: 593 qla2x00_sp_free_dma(sp); 594 mempool_free(sp, ha->srb_mempool); 595 596 qc24_host_busy_lock: 597 spin_lock_irq(vha->host->host_lock); 598 return SCSI_MLQUEUE_HOST_BUSY; 599 600 qc24_target_busy: 601 spin_lock_irq(vha->host->host_lock); 602 return SCSI_MLQUEUE_TARGET_BUSY; 603 604 qc24_fail_command: 605 spin_lock_irq(vha->host->host_lock); 606 done(cmd); 607 608 return 0; 609 } 610 611 static DEF_SCSI_QCMD(qla2xxx_queuecommand) 612 613 614 /* 615 * qla2x00_eh_wait_on_command 616 * Waits for the command to be returned by the Firmware for some 617 * max time. 618 * 619 * Input: 620 * cmd = Scsi Command to wait on. 621 * 622 * Return: 623 * Not Found : 0 624 * Found : 1 625 */ 626 static int 627 qla2x00_eh_wait_on_command(struct scsi_cmnd *cmd) 628 { 629 #define ABORT_POLLING_PERIOD 1000 630 #define ABORT_WAIT_ITER ((10 * 1000) / (ABORT_POLLING_PERIOD)) 631 unsigned long wait_iter = ABORT_WAIT_ITER; 632 scsi_qla_host_t *vha = shost_priv(cmd->device->host); 633 struct qla_hw_data *ha = vha->hw; 634 int ret = QLA_SUCCESS; 635 636 if (unlikely(pci_channel_offline(ha->pdev)) || ha->flags.eeh_busy) { 637 DEBUG17(qla_printk(KERN_WARNING, ha, "return:eh_wait\n")); 638 return ret; 639 } 640 641 while (CMD_SP(cmd) && wait_iter--) { 642 msleep(ABORT_POLLING_PERIOD); 643 } 644 if (CMD_SP(cmd)) 645 ret = QLA_FUNCTION_FAILED; 646 647 return ret; 648 } 649 650 /* 651 * qla2x00_wait_for_hba_online 652 * Wait till the HBA is online after going through 653 * <= MAX_RETRIES_OF_ISP_ABORT or 654 * finally HBA is disabled ie marked offline 655 * 656 * Input: 657 * ha - pointer to host adapter structure 658 * 659 * Note: 660 * Does context switching-Release SPIN_LOCK 661 * (if any) before calling this routine. 662 * 663 * Return: 664 * Success (Adapter is online) : 0 665 * Failed (Adapter is offline/disabled) : 1 666 */ 667 int 668 qla2x00_wait_for_hba_online(scsi_qla_host_t *vha) 669 { 670 int return_status; 671 unsigned long wait_online; 672 struct qla_hw_data *ha = vha->hw; 673 scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev); 674 675 wait_online = jiffies + (MAX_LOOP_TIMEOUT * HZ); 676 while (((test_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags)) || 677 test_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags) || 678 test_bit(ISP_ABORT_RETRY, &base_vha->dpc_flags) || 679 ha->dpc_active) && time_before(jiffies, wait_online)) { 680 681 msleep(1000); 682 } 683 if (base_vha->flags.online) 684 return_status = QLA_SUCCESS; 685 else 686 return_status = QLA_FUNCTION_FAILED; 687 688 return (return_status); 689 } 690 691 /* 692 * qla2x00_wait_for_reset_ready 693 * Wait till the HBA is online after going through 694 * <= MAX_RETRIES_OF_ISP_ABORT or 695 * finally HBA is disabled ie marked offline or flash 696 * operations are in progress. 697 * 698 * Input: 699 * ha - pointer to host adapter structure 700 * 701 * Note: 702 * Does context switching-Release SPIN_LOCK 703 * (if any) before calling this routine. 704 * 705 * Return: 706 * Success (Adapter is online/no flash ops) : 0 707 * Failed (Adapter is offline/disabled/flash ops in progress) : 1 708 */ 709 static int 710 qla2x00_wait_for_reset_ready(scsi_qla_host_t *vha) 711 { 712 int return_status; 713 unsigned long wait_online; 714 struct qla_hw_data *ha = vha->hw; 715 scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev); 716 717 wait_online = jiffies + (MAX_LOOP_TIMEOUT * HZ); 718 while (((test_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags)) || 719 test_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags) || 720 test_bit(ISP_ABORT_RETRY, &base_vha->dpc_flags) || 721 ha->optrom_state != QLA_SWAITING || 722 ha->dpc_active) && time_before(jiffies, wait_online)) 723 msleep(1000); 724 725 if (base_vha->flags.online && ha->optrom_state == QLA_SWAITING) 726 return_status = QLA_SUCCESS; 727 else 728 return_status = QLA_FUNCTION_FAILED; 729 730 DEBUG2(printk("%s return_status=%d\n", __func__, return_status)); 731 732 return return_status; 733 } 734 735 int 736 qla2x00_wait_for_chip_reset(scsi_qla_host_t *vha) 737 { 738 int return_status; 739 unsigned long wait_reset; 740 struct qla_hw_data *ha = vha->hw; 741 scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev); 742 743 wait_reset = jiffies + (MAX_LOOP_TIMEOUT * HZ); 744 while (((test_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags)) || 745 test_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags) || 746 test_bit(ISP_ABORT_RETRY, &base_vha->dpc_flags) || 747 ha->dpc_active) && time_before(jiffies, wait_reset)) { 748 749 msleep(1000); 750 751 if (!test_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags) && 752 ha->flags.chip_reset_done) 753 break; 754 } 755 if (ha->flags.chip_reset_done) 756 return_status = QLA_SUCCESS; 757 else 758 return_status = QLA_FUNCTION_FAILED; 759 760 return return_status; 761 } 762 763 /* 764 * qla2x00_wait_for_loop_ready 765 * Wait for MAX_LOOP_TIMEOUT(5 min) value for loop 766 * to be in LOOP_READY state. 767 * Input: 768 * ha - pointer to host adapter structure 769 * 770 * Note: 771 * Does context switching-Release SPIN_LOCK 772 * (if any) before calling this routine. 773 * 774 * 775 * Return: 776 * Success (LOOP_READY) : 0 777 * Failed (LOOP_NOT_READY) : 1 778 */ 779 static inline int 780 qla2x00_wait_for_loop_ready(scsi_qla_host_t *vha) 781 { 782 int return_status = QLA_SUCCESS; 783 unsigned long loop_timeout ; 784 struct qla_hw_data *ha = vha->hw; 785 scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev); 786 787 /* wait for 5 min at the max for loop to be ready */ 788 loop_timeout = jiffies + (MAX_LOOP_TIMEOUT * HZ); 789 790 while ((!atomic_read(&base_vha->loop_down_timer) && 791 atomic_read(&base_vha->loop_state) == LOOP_DOWN) || 792 atomic_read(&base_vha->loop_state) != LOOP_READY) { 793 if (atomic_read(&base_vha->loop_state) == LOOP_DEAD) { 794 return_status = QLA_FUNCTION_FAILED; 795 break; 796 } 797 msleep(1000); 798 if (time_after_eq(jiffies, loop_timeout)) { 799 return_status = QLA_FUNCTION_FAILED; 800 break; 801 } 802 } 803 return (return_status); 804 } 805 806 static void 807 sp_get(struct srb *sp) 808 { 809 atomic_inc(&sp->ref_count); 810 } 811 812 /************************************************************************** 813 * qla2xxx_eh_abort 814 * 815 * Description: 816 * The abort function will abort the specified command. 817 * 818 * Input: 819 * cmd = Linux SCSI command packet to be aborted. 820 * 821 * Returns: 822 * Either SUCCESS or FAILED. 823 * 824 * Note: 825 * Only return FAILED if command not returned by firmware. 826 **************************************************************************/ 827 static int 828 qla2xxx_eh_abort(struct scsi_cmnd *cmd) 829 { 830 scsi_qla_host_t *vha = shost_priv(cmd->device->host); 831 srb_t *sp; 832 int ret = SUCCESS; 833 unsigned int id, lun; 834 unsigned long flags; 835 int wait = 0; 836 struct qla_hw_data *ha = vha->hw; 837 838 fc_block_scsi_eh(cmd); 839 840 if (!CMD_SP(cmd)) 841 return SUCCESS; 842 843 id = cmd->device->id; 844 lun = cmd->device->lun; 845 846 spin_lock_irqsave(&ha->hardware_lock, flags); 847 sp = (srb_t *) CMD_SP(cmd); 848 if (!sp) { 849 spin_unlock_irqrestore(&ha->hardware_lock, flags); 850 return SUCCESS; 851 } 852 853 DEBUG2(printk("%s(%ld): aborting sp %p from RISC.", 854 __func__, vha->host_no, sp)); 855 856 /* Get a reference to the sp and drop the lock.*/ 857 sp_get(sp); 858 859 spin_unlock_irqrestore(&ha->hardware_lock, flags); 860 if (ha->isp_ops->abort_command(sp)) { 861 DEBUG2(printk("%s(%ld): abort_command " 862 "mbx failed.\n", __func__, vha->host_no)); 863 ret = FAILED; 864 } else { 865 DEBUG3(printk("%s(%ld): abort_command " 866 "mbx success.\n", __func__, vha->host_no)); 867 wait = 1; 868 } 869 qla2x00_sp_compl(ha, sp); 870 871 /* Wait for the command to be returned. */ 872 if (wait) { 873 if (qla2x00_eh_wait_on_command(cmd) != QLA_SUCCESS) { 874 qla_printk(KERN_ERR, ha, 875 "scsi(%ld:%d:%d): Abort handler timed out -- %x.\n", 876 vha->host_no, id, lun, ret); 877 ret = FAILED; 878 } 879 } 880 881 qla_printk(KERN_INFO, ha, 882 "scsi(%ld:%d:%d): Abort command issued -- %d %x.\n", 883 vha->host_no, id, lun, wait, ret); 884 885 return ret; 886 } 887 888 int 889 qla2x00_eh_wait_for_pending_commands(scsi_qla_host_t *vha, unsigned int t, 890 unsigned int l, enum nexus_wait_type type) 891 { 892 int cnt, match, status; 893 unsigned long flags; 894 struct qla_hw_data *ha = vha->hw; 895 struct req_que *req; 896 srb_t *sp; 897 898 status = QLA_SUCCESS; 899 900 spin_lock_irqsave(&ha->hardware_lock, flags); 901 req = vha->req; 902 for (cnt = 1; status == QLA_SUCCESS && 903 cnt < MAX_OUTSTANDING_COMMANDS; cnt++) { 904 sp = req->outstanding_cmds[cnt]; 905 if (!sp) 906 continue; 907 if ((sp->ctx) && !IS_PROT_IO(sp)) 908 continue; 909 if (vha->vp_idx != sp->fcport->vha->vp_idx) 910 continue; 911 match = 0; 912 switch (type) { 913 case WAIT_HOST: 914 match = 1; 915 break; 916 case WAIT_TARGET: 917 match = sp->cmd->device->id == t; 918 break; 919 case WAIT_LUN: 920 match = (sp->cmd->device->id == t && 921 sp->cmd->device->lun == l); 922 break; 923 } 924 if (!match) 925 continue; 926 927 spin_unlock_irqrestore(&ha->hardware_lock, flags); 928 status = qla2x00_eh_wait_on_command(sp->cmd); 929 spin_lock_irqsave(&ha->hardware_lock, flags); 930 } 931 spin_unlock_irqrestore(&ha->hardware_lock, flags); 932 933 return status; 934 } 935 936 static char *reset_errors[] = { 937 "HBA not online", 938 "HBA not ready", 939 "Task management failed", 940 "Waiting for command completions", 941 }; 942 943 static int 944 __qla2xxx_eh_generic_reset(char *name, enum nexus_wait_type type, 945 struct scsi_cmnd *cmd, int (*do_reset)(struct fc_port *, unsigned int, int)) 946 { 947 scsi_qla_host_t *vha = shost_priv(cmd->device->host); 948 fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata; 949 int err; 950 951 fc_block_scsi_eh(cmd); 952 953 if (!fcport) 954 return FAILED; 955 956 qla_printk(KERN_INFO, vha->hw, "scsi(%ld:%d:%d): %s RESET ISSUED.\n", 957 vha->host_no, cmd->device->id, cmd->device->lun, name); 958 959 err = 0; 960 if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) 961 goto eh_reset_failed; 962 err = 1; 963 if (qla2x00_wait_for_loop_ready(vha) != QLA_SUCCESS) 964 goto eh_reset_failed; 965 err = 2; 966 if (do_reset(fcport, cmd->device->lun, cmd->request->cpu + 1) 967 != QLA_SUCCESS) 968 goto eh_reset_failed; 969 err = 3; 970 if (qla2x00_eh_wait_for_pending_commands(vha, cmd->device->id, 971 cmd->device->lun, type) != QLA_SUCCESS) 972 goto eh_reset_failed; 973 974 qla_printk(KERN_INFO, vha->hw, "scsi(%ld:%d:%d): %s RESET SUCCEEDED.\n", 975 vha->host_no, cmd->device->id, cmd->device->lun, name); 976 977 return SUCCESS; 978 979 eh_reset_failed: 980 qla_printk(KERN_INFO, vha->hw, "scsi(%ld:%d:%d): %s RESET FAILED: %s.\n" 981 , vha->host_no, cmd->device->id, cmd->device->lun, name, 982 reset_errors[err]); 983 return FAILED; 984 } 985 986 static int 987 qla2xxx_eh_device_reset(struct scsi_cmnd *cmd) 988 { 989 scsi_qla_host_t *vha = shost_priv(cmd->device->host); 990 struct qla_hw_data *ha = vha->hw; 991 992 return __qla2xxx_eh_generic_reset("DEVICE", WAIT_LUN, cmd, 993 ha->isp_ops->lun_reset); 994 } 995 996 static int 997 qla2xxx_eh_target_reset(struct scsi_cmnd *cmd) 998 { 999 scsi_qla_host_t *vha = shost_priv(cmd->device->host); 1000 struct qla_hw_data *ha = vha->hw; 1001 1002 return __qla2xxx_eh_generic_reset("TARGET", WAIT_TARGET, cmd, 1003 ha->isp_ops->target_reset); 1004 } 1005 1006 /************************************************************************** 1007 * qla2xxx_eh_bus_reset 1008 * 1009 * Description: 1010 * The bus reset function will reset the bus and abort any executing 1011 * commands. 1012 * 1013 * Input: 1014 * cmd = Linux SCSI command packet of the command that cause the 1015 * bus reset. 1016 * 1017 * Returns: 1018 * SUCCESS/FAILURE (defined as macro in scsi.h). 1019 * 1020 **************************************************************************/ 1021 static int 1022 qla2xxx_eh_bus_reset(struct scsi_cmnd *cmd) 1023 { 1024 scsi_qla_host_t *vha = shost_priv(cmd->device->host); 1025 fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata; 1026 int ret = FAILED; 1027 unsigned int id, lun; 1028 1029 fc_block_scsi_eh(cmd); 1030 1031 id = cmd->device->id; 1032 lun = cmd->device->lun; 1033 1034 if (!fcport) 1035 return ret; 1036 1037 qla_printk(KERN_INFO, vha->hw, 1038 "scsi(%ld:%d:%d): BUS RESET ISSUED.\n", vha->host_no, id, lun); 1039 1040 if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) { 1041 DEBUG2(printk("%s failed:board disabled\n",__func__)); 1042 goto eh_bus_reset_done; 1043 } 1044 1045 if (qla2x00_wait_for_loop_ready(vha) == QLA_SUCCESS) { 1046 if (qla2x00_loop_reset(vha) == QLA_SUCCESS) 1047 ret = SUCCESS; 1048 } 1049 if (ret == FAILED) 1050 goto eh_bus_reset_done; 1051 1052 /* Flush outstanding commands. */ 1053 if (qla2x00_eh_wait_for_pending_commands(vha, 0, 0, WAIT_HOST) != 1054 QLA_SUCCESS) 1055 ret = FAILED; 1056 1057 eh_bus_reset_done: 1058 qla_printk(KERN_INFO, vha->hw, "%s: reset %s\n", __func__, 1059 (ret == FAILED) ? "failed" : "succeded"); 1060 1061 return ret; 1062 } 1063 1064 /************************************************************************** 1065 * qla2xxx_eh_host_reset 1066 * 1067 * Description: 1068 * The reset function will reset the Adapter. 1069 * 1070 * Input: 1071 * cmd = Linux SCSI command packet of the command that cause the 1072 * adapter reset. 1073 * 1074 * Returns: 1075 * Either SUCCESS or FAILED. 1076 * 1077 * Note: 1078 **************************************************************************/ 1079 static int 1080 qla2xxx_eh_host_reset(struct scsi_cmnd *cmd) 1081 { 1082 scsi_qla_host_t *vha = shost_priv(cmd->device->host); 1083 fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata; 1084 struct qla_hw_data *ha = vha->hw; 1085 int ret = FAILED; 1086 unsigned int id, lun; 1087 scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev); 1088 1089 fc_block_scsi_eh(cmd); 1090 1091 id = cmd->device->id; 1092 lun = cmd->device->lun; 1093 1094 if (!fcport) 1095 return ret; 1096 1097 qla_printk(KERN_INFO, ha, 1098 "scsi(%ld:%d:%d): ADAPTER RESET ISSUED.\n", vha->host_no, id, lun); 1099 1100 if (qla2x00_wait_for_reset_ready(vha) != QLA_SUCCESS) 1101 goto eh_host_reset_lock; 1102 1103 /* 1104 * Fixme-may be dpc thread is active and processing 1105 * loop_resync,so wait a while for it to 1106 * be completed and then issue big hammer.Otherwise 1107 * it may cause I/O failure as big hammer marks the 1108 * devices as lost kicking of the port_down_timer 1109 * while dpc is stuck for the mailbox to complete. 1110 */ 1111 qla2x00_wait_for_loop_ready(vha); 1112 if (vha != base_vha) { 1113 if (qla2x00_vp_abort_isp(vha)) 1114 goto eh_host_reset_lock; 1115 } else { 1116 if (IS_QLA82XX(vha->hw)) { 1117 if (!qla82xx_fcoe_ctx_reset(vha)) { 1118 /* Ctx reset success */ 1119 ret = SUCCESS; 1120 goto eh_host_reset_lock; 1121 } 1122 /* fall thru if ctx reset failed */ 1123 } 1124 if (ha->wq) 1125 flush_workqueue(ha->wq); 1126 1127 set_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags); 1128 if (ha->isp_ops->abort_isp(base_vha)) { 1129 clear_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags); 1130 /* failed. schedule dpc to try */ 1131 set_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags); 1132 1133 if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) 1134 goto eh_host_reset_lock; 1135 } 1136 clear_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags); 1137 } 1138 1139 /* Waiting for command to be returned to OS.*/ 1140 if (qla2x00_eh_wait_for_pending_commands(vha, 0, 0, WAIT_HOST) == 1141 QLA_SUCCESS) 1142 ret = SUCCESS; 1143 1144 eh_host_reset_lock: 1145 qla_printk(KERN_INFO, ha, "%s: reset %s\n", __func__, 1146 (ret == FAILED) ? "failed" : "succeded"); 1147 1148 return ret; 1149 } 1150 1151 /* 1152 * qla2x00_loop_reset 1153 * Issue loop reset. 1154 * 1155 * Input: 1156 * ha = adapter block pointer. 1157 * 1158 * Returns: 1159 * 0 = success 1160 */ 1161 int 1162 qla2x00_loop_reset(scsi_qla_host_t *vha) 1163 { 1164 int ret; 1165 struct fc_port *fcport; 1166 struct qla_hw_data *ha = vha->hw; 1167 1168 if (ql2xtargetreset == 1 && ha->flags.enable_target_reset) { 1169 list_for_each_entry(fcport, &vha->vp_fcports, list) { 1170 if (fcport->port_type != FCT_TARGET) 1171 continue; 1172 1173 ret = ha->isp_ops->target_reset(fcport, 0, 0); 1174 if (ret != QLA_SUCCESS) { 1175 DEBUG2_3(printk("%s(%ld): bus_reset failed: " 1176 "target_reset=%d d_id=%x.\n", __func__, 1177 vha->host_no, ret, fcport->d_id.b24)); 1178 } 1179 } 1180 } 1181 1182 if (ha->flags.enable_lip_full_login && !IS_QLA8XXX_TYPE(ha)) { 1183 ret = qla2x00_full_login_lip(vha); 1184 if (ret != QLA_SUCCESS) { 1185 DEBUG2_3(printk("%s(%ld): failed: " 1186 "full_login_lip=%d.\n", __func__, vha->host_no, 1187 ret)); 1188 } 1189 atomic_set(&vha->loop_state, LOOP_DOWN); 1190 atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME); 1191 qla2x00_mark_all_devices_lost(vha, 0); 1192 qla2x00_wait_for_loop_ready(vha); 1193 } 1194 1195 if (ha->flags.enable_lip_reset) { 1196 ret = qla2x00_lip_reset(vha); 1197 if (ret != QLA_SUCCESS) { 1198 DEBUG2_3(printk("%s(%ld): failed: " 1199 "lip_reset=%d.\n", __func__, vha->host_no, ret)); 1200 } else 1201 qla2x00_wait_for_loop_ready(vha); 1202 } 1203 1204 /* Issue marker command only when we are going to start the I/O */ 1205 vha->marker_needed = 1; 1206 1207 return QLA_SUCCESS; 1208 } 1209 1210 void 1211 qla2x00_abort_all_cmds(scsi_qla_host_t *vha, int res) 1212 { 1213 int que, cnt; 1214 unsigned long flags; 1215 srb_t *sp; 1216 struct srb_ctx *ctx; 1217 struct qla_hw_data *ha = vha->hw; 1218 struct req_que *req; 1219 1220 spin_lock_irqsave(&ha->hardware_lock, flags); 1221 for (que = 0; que < ha->max_req_queues; que++) { 1222 req = ha->req_q_map[que]; 1223 if (!req) 1224 continue; 1225 for (cnt = 1; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) { 1226 sp = req->outstanding_cmds[cnt]; 1227 if (sp) { 1228 req->outstanding_cmds[cnt] = NULL; 1229 if (!sp->ctx || 1230 (sp->flags & SRB_FCP_CMND_DMA_VALID) || 1231 IS_PROT_IO(sp)) { 1232 sp->cmd->result = res; 1233 qla2x00_sp_compl(ha, sp); 1234 } else { 1235 ctx = sp->ctx; 1236 if (ctx->type == SRB_LOGIN_CMD || 1237 ctx->type == SRB_LOGOUT_CMD) { 1238 ctx->u.iocb_cmd->free(sp); 1239 } else { 1240 struct fc_bsg_job *bsg_job = 1241 ctx->u.bsg_job; 1242 if (bsg_job->request->msgcode 1243 == FC_BSG_HST_CT) 1244 kfree(sp->fcport); 1245 bsg_job->req->errors = 0; 1246 bsg_job->reply->result = res; 1247 bsg_job->job_done(bsg_job); 1248 kfree(sp->ctx); 1249 mempool_free(sp, 1250 ha->srb_mempool); 1251 } 1252 } 1253 } 1254 } 1255 } 1256 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1257 } 1258 1259 static int 1260 qla2xxx_slave_alloc(struct scsi_device *sdev) 1261 { 1262 struct fc_rport *rport = starget_to_rport(scsi_target(sdev)); 1263 1264 if (!rport || fc_remote_port_chkready(rport)) 1265 return -ENXIO; 1266 1267 sdev->hostdata = *(fc_port_t **)rport->dd_data; 1268 1269 return 0; 1270 } 1271 1272 static int 1273 qla2xxx_slave_configure(struct scsi_device *sdev) 1274 { 1275 scsi_qla_host_t *vha = shost_priv(sdev->host); 1276 struct req_que *req = vha->req; 1277 1278 if (sdev->tagged_supported) 1279 scsi_activate_tcq(sdev, req->max_q_depth); 1280 else 1281 scsi_deactivate_tcq(sdev, req->max_q_depth); 1282 return 0; 1283 } 1284 1285 static void 1286 qla2xxx_slave_destroy(struct scsi_device *sdev) 1287 { 1288 sdev->hostdata = NULL; 1289 } 1290 1291 static void qla2x00_handle_queue_full(struct scsi_device *sdev, int qdepth) 1292 { 1293 fc_port_t *fcport = (struct fc_port *) sdev->hostdata; 1294 1295 if (!scsi_track_queue_full(sdev, qdepth)) 1296 return; 1297 1298 DEBUG2(qla_printk(KERN_INFO, fcport->vha->hw, 1299 "scsi(%ld:%d:%d:%d): Queue depth adjusted-down to %d.\n", 1300 fcport->vha->host_no, sdev->channel, sdev->id, sdev->lun, 1301 sdev->queue_depth)); 1302 } 1303 1304 static void qla2x00_adjust_sdev_qdepth_up(struct scsi_device *sdev, int qdepth) 1305 { 1306 fc_port_t *fcport = sdev->hostdata; 1307 struct scsi_qla_host *vha = fcport->vha; 1308 struct qla_hw_data *ha = vha->hw; 1309 struct req_que *req = NULL; 1310 1311 req = vha->req; 1312 if (!req) 1313 return; 1314 1315 if (req->max_q_depth <= sdev->queue_depth || req->max_q_depth < qdepth) 1316 return; 1317 1318 if (sdev->ordered_tags) 1319 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, qdepth); 1320 else 1321 scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, qdepth); 1322 1323 DEBUG2(qla_printk(KERN_INFO, ha, 1324 "scsi(%ld:%d:%d:%d): Queue depth adjusted-up to %d.\n", 1325 fcport->vha->host_no, sdev->channel, sdev->id, sdev->lun, 1326 sdev->queue_depth)); 1327 } 1328 1329 static int 1330 qla2x00_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason) 1331 { 1332 switch (reason) { 1333 case SCSI_QDEPTH_DEFAULT: 1334 scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth); 1335 break; 1336 case SCSI_QDEPTH_QFULL: 1337 qla2x00_handle_queue_full(sdev, qdepth); 1338 break; 1339 case SCSI_QDEPTH_RAMP_UP: 1340 qla2x00_adjust_sdev_qdepth_up(sdev, qdepth); 1341 break; 1342 default: 1343 return -EOPNOTSUPP; 1344 } 1345 1346 return sdev->queue_depth; 1347 } 1348 1349 static int 1350 qla2x00_change_queue_type(struct scsi_device *sdev, int tag_type) 1351 { 1352 if (sdev->tagged_supported) { 1353 scsi_set_tag_type(sdev, tag_type); 1354 if (tag_type) 1355 scsi_activate_tcq(sdev, sdev->queue_depth); 1356 else 1357 scsi_deactivate_tcq(sdev, sdev->queue_depth); 1358 } else 1359 tag_type = 0; 1360 1361 return tag_type; 1362 } 1363 1364 /** 1365 * qla2x00_config_dma_addressing() - Configure OS DMA addressing method. 1366 * @ha: HA context 1367 * 1368 * At exit, the @ha's flags.enable_64bit_addressing set to indicated 1369 * supported addressing method. 1370 */ 1371 static void 1372 qla2x00_config_dma_addressing(struct qla_hw_data *ha) 1373 { 1374 /* Assume a 32bit DMA mask. */ 1375 ha->flags.enable_64bit_addressing = 0; 1376 1377 if (!dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(64))) { 1378 /* Any upper-dword bits set? */ 1379 if (MSD(dma_get_required_mask(&ha->pdev->dev)) && 1380 !pci_set_consistent_dma_mask(ha->pdev, DMA_BIT_MASK(64))) { 1381 /* Ok, a 64bit DMA mask is applicable. */ 1382 ha->flags.enable_64bit_addressing = 1; 1383 ha->isp_ops->calc_req_entries = qla2x00_calc_iocbs_64; 1384 ha->isp_ops->build_iocbs = qla2x00_build_scsi_iocbs_64; 1385 return; 1386 } 1387 } 1388 1389 dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(32)); 1390 pci_set_consistent_dma_mask(ha->pdev, DMA_BIT_MASK(32)); 1391 } 1392 1393 static void 1394 qla2x00_enable_intrs(struct qla_hw_data *ha) 1395 { 1396 unsigned long flags = 0; 1397 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp; 1398 1399 spin_lock_irqsave(&ha->hardware_lock, flags); 1400 ha->interrupts_on = 1; 1401 /* enable risc and host interrupts */ 1402 WRT_REG_WORD(®->ictrl, ICR_EN_INT | ICR_EN_RISC); 1403 RD_REG_WORD(®->ictrl); 1404 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1405 1406 } 1407 1408 static void 1409 qla2x00_disable_intrs(struct qla_hw_data *ha) 1410 { 1411 unsigned long flags = 0; 1412 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp; 1413 1414 spin_lock_irqsave(&ha->hardware_lock, flags); 1415 ha->interrupts_on = 0; 1416 /* disable risc and host interrupts */ 1417 WRT_REG_WORD(®->ictrl, 0); 1418 RD_REG_WORD(®->ictrl); 1419 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1420 } 1421 1422 static void 1423 qla24xx_enable_intrs(struct qla_hw_data *ha) 1424 { 1425 unsigned long flags = 0; 1426 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24; 1427 1428 spin_lock_irqsave(&ha->hardware_lock, flags); 1429 ha->interrupts_on = 1; 1430 WRT_REG_DWORD(®->ictrl, ICRX_EN_RISC_INT); 1431 RD_REG_DWORD(®->ictrl); 1432 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1433 } 1434 1435 static void 1436 qla24xx_disable_intrs(struct qla_hw_data *ha) 1437 { 1438 unsigned long flags = 0; 1439 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24; 1440 1441 if (IS_NOPOLLING_TYPE(ha)) 1442 return; 1443 spin_lock_irqsave(&ha->hardware_lock, flags); 1444 ha->interrupts_on = 0; 1445 WRT_REG_DWORD(®->ictrl, 0); 1446 RD_REG_DWORD(®->ictrl); 1447 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1448 } 1449 1450 static struct isp_operations qla2100_isp_ops = { 1451 .pci_config = qla2100_pci_config, 1452 .reset_chip = qla2x00_reset_chip, 1453 .chip_diag = qla2x00_chip_diag, 1454 .config_rings = qla2x00_config_rings, 1455 .reset_adapter = qla2x00_reset_adapter, 1456 .nvram_config = qla2x00_nvram_config, 1457 .update_fw_options = qla2x00_update_fw_options, 1458 .load_risc = qla2x00_load_risc, 1459 .pci_info_str = qla2x00_pci_info_str, 1460 .fw_version_str = qla2x00_fw_version_str, 1461 .intr_handler = qla2100_intr_handler, 1462 .enable_intrs = qla2x00_enable_intrs, 1463 .disable_intrs = qla2x00_disable_intrs, 1464 .abort_command = qla2x00_abort_command, 1465 .target_reset = qla2x00_abort_target, 1466 .lun_reset = qla2x00_lun_reset, 1467 .fabric_login = qla2x00_login_fabric, 1468 .fabric_logout = qla2x00_fabric_logout, 1469 .calc_req_entries = qla2x00_calc_iocbs_32, 1470 .build_iocbs = qla2x00_build_scsi_iocbs_32, 1471 .prep_ms_iocb = qla2x00_prep_ms_iocb, 1472 .prep_ms_fdmi_iocb = qla2x00_prep_ms_fdmi_iocb, 1473 .read_nvram = qla2x00_read_nvram_data, 1474 .write_nvram = qla2x00_write_nvram_data, 1475 .fw_dump = qla2100_fw_dump, 1476 .beacon_on = NULL, 1477 .beacon_off = NULL, 1478 .beacon_blink = NULL, 1479 .read_optrom = qla2x00_read_optrom_data, 1480 .write_optrom = qla2x00_write_optrom_data, 1481 .get_flash_version = qla2x00_get_flash_version, 1482 .start_scsi = qla2x00_start_scsi, 1483 .abort_isp = qla2x00_abort_isp, 1484 }; 1485 1486 static struct isp_operations qla2300_isp_ops = { 1487 .pci_config = qla2300_pci_config, 1488 .reset_chip = qla2x00_reset_chip, 1489 .chip_diag = qla2x00_chip_diag, 1490 .config_rings = qla2x00_config_rings, 1491 .reset_adapter = qla2x00_reset_adapter, 1492 .nvram_config = qla2x00_nvram_config, 1493 .update_fw_options = qla2x00_update_fw_options, 1494 .load_risc = qla2x00_load_risc, 1495 .pci_info_str = qla2x00_pci_info_str, 1496 .fw_version_str = qla2x00_fw_version_str, 1497 .intr_handler = qla2300_intr_handler, 1498 .enable_intrs = qla2x00_enable_intrs, 1499 .disable_intrs = qla2x00_disable_intrs, 1500 .abort_command = qla2x00_abort_command, 1501 .target_reset = qla2x00_abort_target, 1502 .lun_reset = qla2x00_lun_reset, 1503 .fabric_login = qla2x00_login_fabric, 1504 .fabric_logout = qla2x00_fabric_logout, 1505 .calc_req_entries = qla2x00_calc_iocbs_32, 1506 .build_iocbs = qla2x00_build_scsi_iocbs_32, 1507 .prep_ms_iocb = qla2x00_prep_ms_iocb, 1508 .prep_ms_fdmi_iocb = qla2x00_prep_ms_fdmi_iocb, 1509 .read_nvram = qla2x00_read_nvram_data, 1510 .write_nvram = qla2x00_write_nvram_data, 1511 .fw_dump = qla2300_fw_dump, 1512 .beacon_on = qla2x00_beacon_on, 1513 .beacon_off = qla2x00_beacon_off, 1514 .beacon_blink = qla2x00_beacon_blink, 1515 .read_optrom = qla2x00_read_optrom_data, 1516 .write_optrom = qla2x00_write_optrom_data, 1517 .get_flash_version = qla2x00_get_flash_version, 1518 .start_scsi = qla2x00_start_scsi, 1519 .abort_isp = qla2x00_abort_isp, 1520 }; 1521 1522 static struct isp_operations qla24xx_isp_ops = { 1523 .pci_config = qla24xx_pci_config, 1524 .reset_chip = qla24xx_reset_chip, 1525 .chip_diag = qla24xx_chip_diag, 1526 .config_rings = qla24xx_config_rings, 1527 .reset_adapter = qla24xx_reset_adapter, 1528 .nvram_config = qla24xx_nvram_config, 1529 .update_fw_options = qla24xx_update_fw_options, 1530 .load_risc = qla24xx_load_risc, 1531 .pci_info_str = qla24xx_pci_info_str, 1532 .fw_version_str = qla24xx_fw_version_str, 1533 .intr_handler = qla24xx_intr_handler, 1534 .enable_intrs = qla24xx_enable_intrs, 1535 .disable_intrs = qla24xx_disable_intrs, 1536 .abort_command = qla24xx_abort_command, 1537 .target_reset = qla24xx_abort_target, 1538 .lun_reset = qla24xx_lun_reset, 1539 .fabric_login = qla24xx_login_fabric, 1540 .fabric_logout = qla24xx_fabric_logout, 1541 .calc_req_entries = NULL, 1542 .build_iocbs = NULL, 1543 .prep_ms_iocb = qla24xx_prep_ms_iocb, 1544 .prep_ms_fdmi_iocb = qla24xx_prep_ms_fdmi_iocb, 1545 .read_nvram = qla24xx_read_nvram_data, 1546 .write_nvram = qla24xx_write_nvram_data, 1547 .fw_dump = qla24xx_fw_dump, 1548 .beacon_on = qla24xx_beacon_on, 1549 .beacon_off = qla24xx_beacon_off, 1550 .beacon_blink = qla24xx_beacon_blink, 1551 .read_optrom = qla24xx_read_optrom_data, 1552 .write_optrom = qla24xx_write_optrom_data, 1553 .get_flash_version = qla24xx_get_flash_version, 1554 .start_scsi = qla24xx_start_scsi, 1555 .abort_isp = qla2x00_abort_isp, 1556 }; 1557 1558 static struct isp_operations qla25xx_isp_ops = { 1559 .pci_config = qla25xx_pci_config, 1560 .reset_chip = qla24xx_reset_chip, 1561 .chip_diag = qla24xx_chip_diag, 1562 .config_rings = qla24xx_config_rings, 1563 .reset_adapter = qla24xx_reset_adapter, 1564 .nvram_config = qla24xx_nvram_config, 1565 .update_fw_options = qla24xx_update_fw_options, 1566 .load_risc = qla24xx_load_risc, 1567 .pci_info_str = qla24xx_pci_info_str, 1568 .fw_version_str = qla24xx_fw_version_str, 1569 .intr_handler = qla24xx_intr_handler, 1570 .enable_intrs = qla24xx_enable_intrs, 1571 .disable_intrs = qla24xx_disable_intrs, 1572 .abort_command = qla24xx_abort_command, 1573 .target_reset = qla24xx_abort_target, 1574 .lun_reset = qla24xx_lun_reset, 1575 .fabric_login = qla24xx_login_fabric, 1576 .fabric_logout = qla24xx_fabric_logout, 1577 .calc_req_entries = NULL, 1578 .build_iocbs = NULL, 1579 .prep_ms_iocb = qla24xx_prep_ms_iocb, 1580 .prep_ms_fdmi_iocb = qla24xx_prep_ms_fdmi_iocb, 1581 .read_nvram = qla25xx_read_nvram_data, 1582 .write_nvram = qla25xx_write_nvram_data, 1583 .fw_dump = qla25xx_fw_dump, 1584 .beacon_on = qla24xx_beacon_on, 1585 .beacon_off = qla24xx_beacon_off, 1586 .beacon_blink = qla24xx_beacon_blink, 1587 .read_optrom = qla25xx_read_optrom_data, 1588 .write_optrom = qla24xx_write_optrom_data, 1589 .get_flash_version = qla24xx_get_flash_version, 1590 .start_scsi = qla24xx_dif_start_scsi, 1591 .abort_isp = qla2x00_abort_isp, 1592 }; 1593 1594 static struct isp_operations qla81xx_isp_ops = { 1595 .pci_config = qla25xx_pci_config, 1596 .reset_chip = qla24xx_reset_chip, 1597 .chip_diag = qla24xx_chip_diag, 1598 .config_rings = qla24xx_config_rings, 1599 .reset_adapter = qla24xx_reset_adapter, 1600 .nvram_config = qla81xx_nvram_config, 1601 .update_fw_options = qla81xx_update_fw_options, 1602 .load_risc = qla81xx_load_risc, 1603 .pci_info_str = qla24xx_pci_info_str, 1604 .fw_version_str = qla24xx_fw_version_str, 1605 .intr_handler = qla24xx_intr_handler, 1606 .enable_intrs = qla24xx_enable_intrs, 1607 .disable_intrs = qla24xx_disable_intrs, 1608 .abort_command = qla24xx_abort_command, 1609 .target_reset = qla24xx_abort_target, 1610 .lun_reset = qla24xx_lun_reset, 1611 .fabric_login = qla24xx_login_fabric, 1612 .fabric_logout = qla24xx_fabric_logout, 1613 .calc_req_entries = NULL, 1614 .build_iocbs = NULL, 1615 .prep_ms_iocb = qla24xx_prep_ms_iocb, 1616 .prep_ms_fdmi_iocb = qla24xx_prep_ms_fdmi_iocb, 1617 .read_nvram = NULL, 1618 .write_nvram = NULL, 1619 .fw_dump = qla81xx_fw_dump, 1620 .beacon_on = qla24xx_beacon_on, 1621 .beacon_off = qla24xx_beacon_off, 1622 .beacon_blink = qla24xx_beacon_blink, 1623 .read_optrom = qla25xx_read_optrom_data, 1624 .write_optrom = qla24xx_write_optrom_data, 1625 .get_flash_version = qla24xx_get_flash_version, 1626 .start_scsi = qla24xx_dif_start_scsi, 1627 .abort_isp = qla2x00_abort_isp, 1628 }; 1629 1630 static struct isp_operations qla82xx_isp_ops = { 1631 .pci_config = qla82xx_pci_config, 1632 .reset_chip = qla82xx_reset_chip, 1633 .chip_diag = qla24xx_chip_diag, 1634 .config_rings = qla82xx_config_rings, 1635 .reset_adapter = qla24xx_reset_adapter, 1636 .nvram_config = qla81xx_nvram_config, 1637 .update_fw_options = qla24xx_update_fw_options, 1638 .load_risc = qla82xx_load_risc, 1639 .pci_info_str = qla82xx_pci_info_str, 1640 .fw_version_str = qla24xx_fw_version_str, 1641 .intr_handler = qla82xx_intr_handler, 1642 .enable_intrs = qla82xx_enable_intrs, 1643 .disable_intrs = qla82xx_disable_intrs, 1644 .abort_command = qla24xx_abort_command, 1645 .target_reset = qla24xx_abort_target, 1646 .lun_reset = qla24xx_lun_reset, 1647 .fabric_login = qla24xx_login_fabric, 1648 .fabric_logout = qla24xx_fabric_logout, 1649 .calc_req_entries = NULL, 1650 .build_iocbs = NULL, 1651 .prep_ms_iocb = qla24xx_prep_ms_iocb, 1652 .prep_ms_fdmi_iocb = qla24xx_prep_ms_fdmi_iocb, 1653 .read_nvram = qla24xx_read_nvram_data, 1654 .write_nvram = qla24xx_write_nvram_data, 1655 .fw_dump = qla24xx_fw_dump, 1656 .beacon_on = qla24xx_beacon_on, 1657 .beacon_off = qla24xx_beacon_off, 1658 .beacon_blink = qla24xx_beacon_blink, 1659 .read_optrom = qla82xx_read_optrom_data, 1660 .write_optrom = qla82xx_write_optrom_data, 1661 .get_flash_version = qla24xx_get_flash_version, 1662 .start_scsi = qla82xx_start_scsi, 1663 .abort_isp = qla82xx_abort_isp, 1664 }; 1665 1666 static inline void 1667 qla2x00_set_isp_flags(struct qla_hw_data *ha) 1668 { 1669 ha->device_type = DT_EXTENDED_IDS; 1670 switch (ha->pdev->device) { 1671 case PCI_DEVICE_ID_QLOGIC_ISP2100: 1672 ha->device_type |= DT_ISP2100; 1673 ha->device_type &= ~DT_EXTENDED_IDS; 1674 ha->fw_srisc_address = RISC_START_ADDRESS_2100; 1675 break; 1676 case PCI_DEVICE_ID_QLOGIC_ISP2200: 1677 ha->device_type |= DT_ISP2200; 1678 ha->device_type &= ~DT_EXTENDED_IDS; 1679 ha->fw_srisc_address = RISC_START_ADDRESS_2100; 1680 break; 1681 case PCI_DEVICE_ID_QLOGIC_ISP2300: 1682 ha->device_type |= DT_ISP2300; 1683 ha->device_type |= DT_ZIO_SUPPORTED; 1684 ha->fw_srisc_address = RISC_START_ADDRESS_2300; 1685 break; 1686 case PCI_DEVICE_ID_QLOGIC_ISP2312: 1687 ha->device_type |= DT_ISP2312; 1688 ha->device_type |= DT_ZIO_SUPPORTED; 1689 ha->fw_srisc_address = RISC_START_ADDRESS_2300; 1690 break; 1691 case PCI_DEVICE_ID_QLOGIC_ISP2322: 1692 ha->device_type |= DT_ISP2322; 1693 ha->device_type |= DT_ZIO_SUPPORTED; 1694 if (ha->pdev->subsystem_vendor == 0x1028 && 1695 ha->pdev->subsystem_device == 0x0170) 1696 ha->device_type |= DT_OEM_001; 1697 ha->fw_srisc_address = RISC_START_ADDRESS_2300; 1698 break; 1699 case PCI_DEVICE_ID_QLOGIC_ISP6312: 1700 ha->device_type |= DT_ISP6312; 1701 ha->fw_srisc_address = RISC_START_ADDRESS_2300; 1702 break; 1703 case PCI_DEVICE_ID_QLOGIC_ISP6322: 1704 ha->device_type |= DT_ISP6322; 1705 ha->fw_srisc_address = RISC_START_ADDRESS_2300; 1706 break; 1707 case PCI_DEVICE_ID_QLOGIC_ISP2422: 1708 ha->device_type |= DT_ISP2422; 1709 ha->device_type |= DT_ZIO_SUPPORTED; 1710 ha->device_type |= DT_FWI2; 1711 ha->device_type |= DT_IIDMA; 1712 ha->fw_srisc_address = RISC_START_ADDRESS_2400; 1713 break; 1714 case PCI_DEVICE_ID_QLOGIC_ISP2432: 1715 ha->device_type |= DT_ISP2432; 1716 ha->device_type |= DT_ZIO_SUPPORTED; 1717 ha->device_type |= DT_FWI2; 1718 ha->device_type |= DT_IIDMA; 1719 ha->fw_srisc_address = RISC_START_ADDRESS_2400; 1720 break; 1721 case PCI_DEVICE_ID_QLOGIC_ISP8432: 1722 ha->device_type |= DT_ISP8432; 1723 ha->device_type |= DT_ZIO_SUPPORTED; 1724 ha->device_type |= DT_FWI2; 1725 ha->device_type |= DT_IIDMA; 1726 ha->fw_srisc_address = RISC_START_ADDRESS_2400; 1727 break; 1728 case PCI_DEVICE_ID_QLOGIC_ISP5422: 1729 ha->device_type |= DT_ISP5422; 1730 ha->device_type |= DT_FWI2; 1731 ha->fw_srisc_address = RISC_START_ADDRESS_2400; 1732 break; 1733 case PCI_DEVICE_ID_QLOGIC_ISP5432: 1734 ha->device_type |= DT_ISP5432; 1735 ha->device_type |= DT_FWI2; 1736 ha->fw_srisc_address = RISC_START_ADDRESS_2400; 1737 break; 1738 case PCI_DEVICE_ID_QLOGIC_ISP2532: 1739 ha->device_type |= DT_ISP2532; 1740 ha->device_type |= DT_ZIO_SUPPORTED; 1741 ha->device_type |= DT_FWI2; 1742 ha->device_type |= DT_IIDMA; 1743 ha->fw_srisc_address = RISC_START_ADDRESS_2400; 1744 break; 1745 case PCI_DEVICE_ID_QLOGIC_ISP8001: 1746 ha->device_type |= DT_ISP8001; 1747 ha->device_type |= DT_ZIO_SUPPORTED; 1748 ha->device_type |= DT_FWI2; 1749 ha->device_type |= DT_IIDMA; 1750 ha->fw_srisc_address = RISC_START_ADDRESS_2400; 1751 break; 1752 case PCI_DEVICE_ID_QLOGIC_ISP8021: 1753 ha->device_type |= DT_ISP8021; 1754 ha->device_type |= DT_ZIO_SUPPORTED; 1755 ha->device_type |= DT_FWI2; 1756 ha->fw_srisc_address = RISC_START_ADDRESS_2400; 1757 /* Initialize 82XX ISP flags */ 1758 qla82xx_init_flags(ha); 1759 break; 1760 } 1761 1762 if (IS_QLA82XX(ha)) 1763 ha->port_no = !(ha->portnum & 1); 1764 else 1765 /* Get adapter physical port no from interrupt pin register. */ 1766 pci_read_config_byte(ha->pdev, PCI_INTERRUPT_PIN, &ha->port_no); 1767 1768 if (ha->port_no & 1) 1769 ha->flags.port0 = 1; 1770 else 1771 ha->flags.port0 = 0; 1772 } 1773 1774 static int 1775 qla2x00_iospace_config(struct qla_hw_data *ha) 1776 { 1777 resource_size_t pio; 1778 uint16_t msix; 1779 int cpus; 1780 1781 if (IS_QLA82XX(ha)) 1782 return qla82xx_iospace_config(ha); 1783 1784 if (pci_request_selected_regions(ha->pdev, ha->bars, 1785 QLA2XXX_DRIVER_NAME)) { 1786 qla_printk(KERN_WARNING, ha, 1787 "Failed to reserve PIO/MMIO regions (%s)\n", 1788 pci_name(ha->pdev)); 1789 1790 goto iospace_error_exit; 1791 } 1792 if (!(ha->bars & 1)) 1793 goto skip_pio; 1794 1795 /* We only need PIO for Flash operations on ISP2312 v2 chips. */ 1796 pio = pci_resource_start(ha->pdev, 0); 1797 if (pci_resource_flags(ha->pdev, 0) & IORESOURCE_IO) { 1798 if (pci_resource_len(ha->pdev, 0) < MIN_IOBASE_LEN) { 1799 qla_printk(KERN_WARNING, ha, 1800 "Invalid PCI I/O region size (%s)...\n", 1801 pci_name(ha->pdev)); 1802 pio = 0; 1803 } 1804 } else { 1805 qla_printk(KERN_WARNING, ha, 1806 "region #0 not a PIO resource (%s)...\n", 1807 pci_name(ha->pdev)); 1808 pio = 0; 1809 } 1810 ha->pio_address = pio; 1811 1812 skip_pio: 1813 /* Use MMIO operations for all accesses. */ 1814 if (!(pci_resource_flags(ha->pdev, 1) & IORESOURCE_MEM)) { 1815 qla_printk(KERN_ERR, ha, 1816 "region #1 not an MMIO resource (%s), aborting\n", 1817 pci_name(ha->pdev)); 1818 goto iospace_error_exit; 1819 } 1820 if (pci_resource_len(ha->pdev, 1) < MIN_IOBASE_LEN) { 1821 qla_printk(KERN_ERR, ha, 1822 "Invalid PCI mem region size (%s), aborting\n", 1823 pci_name(ha->pdev)); 1824 goto iospace_error_exit; 1825 } 1826 1827 ha->iobase = ioremap(pci_resource_start(ha->pdev, 1), MIN_IOBASE_LEN); 1828 if (!ha->iobase) { 1829 qla_printk(KERN_ERR, ha, 1830 "cannot remap MMIO (%s), aborting\n", pci_name(ha->pdev)); 1831 1832 goto iospace_error_exit; 1833 } 1834 1835 /* Determine queue resources */ 1836 ha->max_req_queues = ha->max_rsp_queues = 1; 1837 if ((ql2xmaxqueues <= 1 && !ql2xmultique_tag) || 1838 (ql2xmaxqueues > 1 && ql2xmultique_tag) || 1839 (!IS_QLA25XX(ha) && !IS_QLA81XX(ha))) 1840 goto mqiobase_exit; 1841 1842 ha->mqiobase = ioremap(pci_resource_start(ha->pdev, 3), 1843 pci_resource_len(ha->pdev, 3)); 1844 if (ha->mqiobase) { 1845 /* Read MSIX vector size of the board */ 1846 pci_read_config_word(ha->pdev, QLA_PCI_MSIX_CONTROL, &msix); 1847 ha->msix_count = msix; 1848 /* Max queues are bounded by available msix vectors */ 1849 /* queue 0 uses two msix vectors */ 1850 if (ql2xmultique_tag) { 1851 cpus = num_online_cpus(); 1852 ha->max_rsp_queues = (ha->msix_count - 1 > cpus) ? 1853 (cpus + 1) : (ha->msix_count - 1); 1854 ha->max_req_queues = 2; 1855 } else if (ql2xmaxqueues > 1) { 1856 ha->max_req_queues = ql2xmaxqueues > QLA_MQ_SIZE ? 1857 QLA_MQ_SIZE : ql2xmaxqueues; 1858 DEBUG2(qla_printk(KERN_INFO, ha, "QoS mode set, max no" 1859 " of request queues:%d\n", ha->max_req_queues)); 1860 } 1861 qla_printk(KERN_INFO, ha, 1862 "MSI-X vector count: %d\n", msix); 1863 } else 1864 qla_printk(KERN_INFO, ha, "BAR 3 not enabled\n"); 1865 1866 mqiobase_exit: 1867 ha->msix_count = ha->max_rsp_queues + 1; 1868 return (0); 1869 1870 iospace_error_exit: 1871 return (-ENOMEM); 1872 } 1873 1874 static void 1875 qla2xxx_scan_start(struct Scsi_Host *shost) 1876 { 1877 scsi_qla_host_t *vha = shost_priv(shost); 1878 1879 if (vha->hw->flags.running_gold_fw) 1880 return; 1881 1882 set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags); 1883 set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags); 1884 set_bit(RSCN_UPDATE, &vha->dpc_flags); 1885 set_bit(NPIV_CONFIG_NEEDED, &vha->dpc_flags); 1886 } 1887 1888 static int 1889 qla2xxx_scan_finished(struct Scsi_Host *shost, unsigned long time) 1890 { 1891 scsi_qla_host_t *vha = shost_priv(shost); 1892 1893 if (!vha->host) 1894 return 1; 1895 if (time > vha->hw->loop_reset_delay * HZ) 1896 return 1; 1897 1898 return atomic_read(&vha->loop_state) == LOOP_READY; 1899 } 1900 1901 /* 1902 * PCI driver interface 1903 */ 1904 static int __devinit 1905 qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id) 1906 { 1907 int ret = -ENODEV; 1908 struct Scsi_Host *host; 1909 scsi_qla_host_t *base_vha = NULL; 1910 struct qla_hw_data *ha; 1911 char pci_info[30]; 1912 char fw_str[30]; 1913 struct scsi_host_template *sht; 1914 int bars, max_id, mem_only = 0; 1915 uint16_t req_length = 0, rsp_length = 0; 1916 struct req_que *req = NULL; 1917 struct rsp_que *rsp = NULL; 1918 1919 bars = pci_select_bars(pdev, IORESOURCE_MEM | IORESOURCE_IO); 1920 sht = &qla2xxx_driver_template; 1921 if (pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2422 || 1922 pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2432 || 1923 pdev->device == PCI_DEVICE_ID_QLOGIC_ISP8432 || 1924 pdev->device == PCI_DEVICE_ID_QLOGIC_ISP5422 || 1925 pdev->device == PCI_DEVICE_ID_QLOGIC_ISP5432 || 1926 pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2532 || 1927 pdev->device == PCI_DEVICE_ID_QLOGIC_ISP8001 || 1928 pdev->device == PCI_DEVICE_ID_QLOGIC_ISP8021) { 1929 bars = pci_select_bars(pdev, IORESOURCE_MEM); 1930 mem_only = 1; 1931 } 1932 1933 if (mem_only) { 1934 if (pci_enable_device_mem(pdev)) 1935 goto probe_out; 1936 } else { 1937 if (pci_enable_device(pdev)) 1938 goto probe_out; 1939 } 1940 1941 /* This may fail but that's ok */ 1942 pci_enable_pcie_error_reporting(pdev); 1943 1944 ha = kzalloc(sizeof(struct qla_hw_data), GFP_KERNEL); 1945 if (!ha) { 1946 DEBUG(printk("Unable to allocate memory for ha\n")); 1947 goto probe_out; 1948 } 1949 ha->pdev = pdev; 1950 1951 /* Clear our data area */ 1952 ha->bars = bars; 1953 ha->mem_only = mem_only; 1954 spin_lock_init(&ha->hardware_lock); 1955 spin_lock_init(&ha->vport_slock); 1956 1957 /* Set ISP-type information. */ 1958 qla2x00_set_isp_flags(ha); 1959 1960 /* Set EEH reset type to fundamental if required by hba */ 1961 if ( IS_QLA24XX(ha) || IS_QLA25XX(ha) || IS_QLA81XX(ha)) { 1962 pdev->needs_freset = 1; 1963 } 1964 1965 /* Configure PCI I/O space */ 1966 ret = qla2x00_iospace_config(ha); 1967 if (ret) 1968 goto probe_hw_failed; 1969 1970 qla_printk(KERN_INFO, ha, 1971 "Found an ISP%04X, irq %d, iobase 0x%p\n", pdev->device, pdev->irq, 1972 ha->iobase); 1973 1974 ha->prev_topology = 0; 1975 ha->init_cb_size = sizeof(init_cb_t); 1976 ha->link_data_rate = PORT_SPEED_UNKNOWN; 1977 ha->optrom_size = OPTROM_SIZE_2300; 1978 1979 /* Assign ISP specific operations. */ 1980 max_id = MAX_TARGETS_2200; 1981 if (IS_QLA2100(ha)) { 1982 max_id = MAX_TARGETS_2100; 1983 ha->mbx_count = MAILBOX_REGISTER_COUNT_2100; 1984 req_length = REQUEST_ENTRY_CNT_2100; 1985 rsp_length = RESPONSE_ENTRY_CNT_2100; 1986 ha->max_loop_id = SNS_LAST_LOOP_ID_2100; 1987 ha->gid_list_info_size = 4; 1988 ha->flash_conf_off = ~0; 1989 ha->flash_data_off = ~0; 1990 ha->nvram_conf_off = ~0; 1991 ha->nvram_data_off = ~0; 1992 ha->isp_ops = &qla2100_isp_ops; 1993 } else if (IS_QLA2200(ha)) { 1994 ha->mbx_count = MAILBOX_REGISTER_COUNT; 1995 req_length = REQUEST_ENTRY_CNT_2200; 1996 rsp_length = RESPONSE_ENTRY_CNT_2100; 1997 ha->max_loop_id = SNS_LAST_LOOP_ID_2100; 1998 ha->gid_list_info_size = 4; 1999 ha->flash_conf_off = ~0; 2000 ha->flash_data_off = ~0; 2001 ha->nvram_conf_off = ~0; 2002 ha->nvram_data_off = ~0; 2003 ha->isp_ops = &qla2100_isp_ops; 2004 } else if (IS_QLA23XX(ha)) { 2005 ha->mbx_count = MAILBOX_REGISTER_COUNT; 2006 req_length = REQUEST_ENTRY_CNT_2200; 2007 rsp_length = RESPONSE_ENTRY_CNT_2300; 2008 ha->max_loop_id = SNS_LAST_LOOP_ID_2300; 2009 ha->gid_list_info_size = 6; 2010 if (IS_QLA2322(ha) || IS_QLA6322(ha)) 2011 ha->optrom_size = OPTROM_SIZE_2322; 2012 ha->flash_conf_off = ~0; 2013 ha->flash_data_off = ~0; 2014 ha->nvram_conf_off = ~0; 2015 ha->nvram_data_off = ~0; 2016 ha->isp_ops = &qla2300_isp_ops; 2017 } else if (IS_QLA24XX_TYPE(ha)) { 2018 ha->mbx_count = MAILBOX_REGISTER_COUNT; 2019 req_length = REQUEST_ENTRY_CNT_24XX; 2020 rsp_length = RESPONSE_ENTRY_CNT_2300; 2021 ha->max_loop_id = SNS_LAST_LOOP_ID_2300; 2022 ha->init_cb_size = sizeof(struct mid_init_cb_24xx); 2023 ha->gid_list_info_size = 8; 2024 ha->optrom_size = OPTROM_SIZE_24XX; 2025 ha->nvram_npiv_size = QLA_MAX_VPORTS_QLA24XX; 2026 ha->isp_ops = &qla24xx_isp_ops; 2027 ha->flash_conf_off = FARX_ACCESS_FLASH_CONF; 2028 ha->flash_data_off = FARX_ACCESS_FLASH_DATA; 2029 ha->nvram_conf_off = FARX_ACCESS_NVRAM_CONF; 2030 ha->nvram_data_off = FARX_ACCESS_NVRAM_DATA; 2031 } else if (IS_QLA25XX(ha)) { 2032 ha->mbx_count = MAILBOX_REGISTER_COUNT; 2033 req_length = REQUEST_ENTRY_CNT_24XX; 2034 rsp_length = RESPONSE_ENTRY_CNT_2300; 2035 ha->max_loop_id = SNS_LAST_LOOP_ID_2300; 2036 ha->init_cb_size = sizeof(struct mid_init_cb_24xx); 2037 ha->gid_list_info_size = 8; 2038 ha->optrom_size = OPTROM_SIZE_25XX; 2039 ha->nvram_npiv_size = QLA_MAX_VPORTS_QLA25XX; 2040 ha->isp_ops = &qla25xx_isp_ops; 2041 ha->flash_conf_off = FARX_ACCESS_FLASH_CONF; 2042 ha->flash_data_off = FARX_ACCESS_FLASH_DATA; 2043 ha->nvram_conf_off = FARX_ACCESS_NVRAM_CONF; 2044 ha->nvram_data_off = FARX_ACCESS_NVRAM_DATA; 2045 } else if (IS_QLA81XX(ha)) { 2046 ha->mbx_count = MAILBOX_REGISTER_COUNT; 2047 req_length = REQUEST_ENTRY_CNT_24XX; 2048 rsp_length = RESPONSE_ENTRY_CNT_2300; 2049 ha->max_loop_id = SNS_LAST_LOOP_ID_2300; 2050 ha->init_cb_size = sizeof(struct mid_init_cb_81xx); 2051 ha->gid_list_info_size = 8; 2052 ha->optrom_size = OPTROM_SIZE_81XX; 2053 ha->nvram_npiv_size = QLA_MAX_VPORTS_QLA25XX; 2054 ha->isp_ops = &qla81xx_isp_ops; 2055 ha->flash_conf_off = FARX_ACCESS_FLASH_CONF_81XX; 2056 ha->flash_data_off = FARX_ACCESS_FLASH_DATA_81XX; 2057 ha->nvram_conf_off = ~0; 2058 ha->nvram_data_off = ~0; 2059 } else if (IS_QLA82XX(ha)) { 2060 ha->mbx_count = MAILBOX_REGISTER_COUNT; 2061 req_length = REQUEST_ENTRY_CNT_82XX; 2062 rsp_length = RESPONSE_ENTRY_CNT_82XX; 2063 ha->max_loop_id = SNS_LAST_LOOP_ID_2300; 2064 ha->init_cb_size = sizeof(struct mid_init_cb_81xx); 2065 ha->gid_list_info_size = 8; 2066 ha->optrom_size = OPTROM_SIZE_82XX; 2067 ha->nvram_npiv_size = QLA_MAX_VPORTS_QLA25XX; 2068 ha->isp_ops = &qla82xx_isp_ops; 2069 ha->flash_conf_off = FARX_ACCESS_FLASH_CONF; 2070 ha->flash_data_off = FARX_ACCESS_FLASH_DATA; 2071 ha->nvram_conf_off = FARX_ACCESS_NVRAM_CONF; 2072 ha->nvram_data_off = FARX_ACCESS_NVRAM_DATA; 2073 } 2074 2075 mutex_init(&ha->vport_lock); 2076 init_completion(&ha->mbx_cmd_comp); 2077 complete(&ha->mbx_cmd_comp); 2078 init_completion(&ha->mbx_intr_comp); 2079 init_completion(&ha->dcbx_comp); 2080 2081 set_bit(0, (unsigned long *) ha->vp_idx_map); 2082 2083 qla2x00_config_dma_addressing(ha); 2084 ret = qla2x00_mem_alloc(ha, req_length, rsp_length, &req, &rsp); 2085 if (!ret) { 2086 qla_printk(KERN_WARNING, ha, 2087 "[ERROR] Failed to allocate memory for adapter\n"); 2088 2089 goto probe_hw_failed; 2090 } 2091 2092 req->max_q_depth = MAX_Q_DEPTH; 2093 if (ql2xmaxqdepth != 0 && ql2xmaxqdepth <= 0xffffU) 2094 req->max_q_depth = ql2xmaxqdepth; 2095 2096 2097 base_vha = qla2x00_create_host(sht, ha); 2098 if (!base_vha) { 2099 qla_printk(KERN_WARNING, ha, 2100 "[ERROR] Failed to allocate memory for scsi_host\n"); 2101 2102 ret = -ENOMEM; 2103 qla2x00_mem_free(ha); 2104 qla2x00_free_req_que(ha, req); 2105 qla2x00_free_rsp_que(ha, rsp); 2106 goto probe_hw_failed; 2107 } 2108 2109 pci_set_drvdata(pdev, base_vha); 2110 2111 host = base_vha->host; 2112 base_vha->req = req; 2113 host->can_queue = req->length + 128; 2114 if (IS_QLA2XXX_MIDTYPE(ha)) 2115 base_vha->mgmt_svr_loop_id = 10 + base_vha->vp_idx; 2116 else 2117 base_vha->mgmt_svr_loop_id = MANAGEMENT_SERVER + 2118 base_vha->vp_idx; 2119 2120 /* Set the SG table size based on ISP type */ 2121 if (!IS_FWI2_CAPABLE(ha)) { 2122 if (IS_QLA2100(ha)) 2123 host->sg_tablesize = 32; 2124 } else { 2125 if (!IS_QLA82XX(ha)) 2126 host->sg_tablesize = QLA_SG_ALL; 2127 } 2128 2129 host->max_id = max_id; 2130 host->this_id = 255; 2131 host->cmd_per_lun = 3; 2132 host->unique_id = host->host_no; 2133 if ((IS_QLA25XX(ha) || IS_QLA81XX(ha)) && ql2xenabledif) 2134 host->max_cmd_len = 32; 2135 else 2136 host->max_cmd_len = MAX_CMDSZ; 2137 host->max_channel = MAX_BUSES - 1; 2138 host->max_lun = MAX_LUNS; 2139 host->transportt = qla2xxx_transport_template; 2140 sht->vendor_id = (SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_QLOGIC); 2141 2142 /* Set up the irqs */ 2143 ret = qla2x00_request_irqs(ha, rsp); 2144 if (ret) 2145 goto probe_init_failed; 2146 2147 pci_save_state(pdev); 2148 2149 /* Alloc arrays of request and response ring ptrs */ 2150 que_init: 2151 if (!qla2x00_alloc_queues(ha)) { 2152 qla_printk(KERN_WARNING, ha, 2153 "[ERROR] Failed to allocate memory for queue" 2154 " pointers\n"); 2155 goto probe_init_failed; 2156 } 2157 2158 ha->rsp_q_map[0] = rsp; 2159 ha->req_q_map[0] = req; 2160 rsp->req = req; 2161 req->rsp = rsp; 2162 set_bit(0, ha->req_qid_map); 2163 set_bit(0, ha->rsp_qid_map); 2164 /* FWI2-capable only. */ 2165 req->req_q_in = &ha->iobase->isp24.req_q_in; 2166 req->req_q_out = &ha->iobase->isp24.req_q_out; 2167 rsp->rsp_q_in = &ha->iobase->isp24.rsp_q_in; 2168 rsp->rsp_q_out = &ha->iobase->isp24.rsp_q_out; 2169 if (ha->mqenable) { 2170 req->req_q_in = &ha->mqiobase->isp25mq.req_q_in; 2171 req->req_q_out = &ha->mqiobase->isp25mq.req_q_out; 2172 rsp->rsp_q_in = &ha->mqiobase->isp25mq.rsp_q_in; 2173 rsp->rsp_q_out = &ha->mqiobase->isp25mq.rsp_q_out; 2174 } 2175 2176 if (IS_QLA82XX(ha)) { 2177 req->req_q_out = &ha->iobase->isp82.req_q_out[0]; 2178 rsp->rsp_q_in = &ha->iobase->isp82.rsp_q_in[0]; 2179 rsp->rsp_q_out = &ha->iobase->isp82.rsp_q_out[0]; 2180 } 2181 2182 if (qla2x00_initialize_adapter(base_vha)) { 2183 qla_printk(KERN_WARNING, ha, 2184 "Failed to initialize adapter\n"); 2185 2186 DEBUG2(printk("scsi(%ld): Failed to initialize adapter - " 2187 "Adapter flags %x.\n", 2188 base_vha->host_no, base_vha->device_flags)); 2189 2190 if (IS_QLA82XX(ha)) { 2191 qla82xx_idc_lock(ha); 2192 qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE, 2193 QLA82XX_DEV_FAILED); 2194 qla82xx_idc_unlock(ha); 2195 qla_printk(KERN_INFO, ha, "HW State: FAILED\n"); 2196 } 2197 2198 ret = -ENODEV; 2199 goto probe_failed; 2200 } 2201 2202 if (ha->mqenable) { 2203 if (qla25xx_setup_mode(base_vha)) { 2204 qla_printk(KERN_WARNING, ha, 2205 "Can't create queues, falling back to single" 2206 " queue mode\n"); 2207 goto que_init; 2208 } 2209 } 2210 2211 if (ha->flags.running_gold_fw) 2212 goto skip_dpc; 2213 2214 /* 2215 * Startup the kernel thread for this host adapter 2216 */ 2217 ha->dpc_thread = kthread_create(qla2x00_do_dpc, ha, 2218 "%s_dpc", base_vha->host_str); 2219 if (IS_ERR(ha->dpc_thread)) { 2220 qla_printk(KERN_WARNING, ha, 2221 "Unable to start DPC thread!\n"); 2222 ret = PTR_ERR(ha->dpc_thread); 2223 goto probe_failed; 2224 } 2225 2226 skip_dpc: 2227 list_add_tail(&base_vha->list, &ha->vp_list); 2228 base_vha->host->irq = ha->pdev->irq; 2229 2230 /* Initialized the timer */ 2231 qla2x00_start_timer(base_vha, qla2x00_timer, WATCH_INTERVAL); 2232 2233 DEBUG2(printk("DEBUG: detect hba %ld at address = %p\n", 2234 base_vha->host_no, ha)); 2235 2236 if ((IS_QLA25XX(ha) || IS_QLA81XX(ha)) && ql2xenabledif) { 2237 if (ha->fw_attributes & BIT_4) { 2238 base_vha->flags.difdix_supported = 1; 2239 DEBUG18(qla_printk(KERN_INFO, ha, 2240 "Registering for DIF/DIX type 1 and 3" 2241 " protection.\n")); 2242 scsi_host_set_prot(host, 2243 SHOST_DIF_TYPE1_PROTECTION 2244 | SHOST_DIF_TYPE2_PROTECTION 2245 | SHOST_DIF_TYPE3_PROTECTION 2246 | SHOST_DIX_TYPE1_PROTECTION 2247 | SHOST_DIX_TYPE2_PROTECTION 2248 | SHOST_DIX_TYPE3_PROTECTION); 2249 scsi_host_set_guard(host, SHOST_DIX_GUARD_CRC); 2250 } else 2251 base_vha->flags.difdix_supported = 0; 2252 } 2253 2254 ha->isp_ops->enable_intrs(ha); 2255 2256 ret = scsi_add_host(host, &pdev->dev); 2257 if (ret) 2258 goto probe_failed; 2259 2260 base_vha->flags.init_done = 1; 2261 base_vha->flags.online = 1; 2262 2263 scsi_scan_host(host); 2264 2265 qla2x00_alloc_sysfs_attr(base_vha); 2266 2267 qla2x00_init_host_attr(base_vha); 2268 2269 qla2x00_dfs_setup(base_vha); 2270 2271 qla_printk(KERN_INFO, ha, "\n" 2272 " QLogic Fibre Channel HBA Driver: %s\n" 2273 " QLogic %s - %s\n" 2274 " ISP%04X: %s @ %s hdma%c, host#=%ld, fw=%s\n", 2275 qla2x00_version_str, ha->model_number, 2276 ha->model_desc ? ha->model_desc : "", pdev->device, 2277 ha->isp_ops->pci_info_str(base_vha, pci_info), pci_name(pdev), 2278 ha->flags.enable_64bit_addressing ? '+' : '-', base_vha->host_no, 2279 ha->isp_ops->fw_version_str(base_vha, fw_str)); 2280 2281 return 0; 2282 2283 probe_init_failed: 2284 qla2x00_free_req_que(ha, req); 2285 qla2x00_free_rsp_que(ha, rsp); 2286 ha->max_req_queues = ha->max_rsp_queues = 0; 2287 2288 probe_failed: 2289 if (base_vha->timer_active) 2290 qla2x00_stop_timer(base_vha); 2291 base_vha->flags.online = 0; 2292 if (ha->dpc_thread) { 2293 struct task_struct *t = ha->dpc_thread; 2294 2295 ha->dpc_thread = NULL; 2296 kthread_stop(t); 2297 } 2298 2299 qla2x00_free_device(base_vha); 2300 2301 scsi_host_put(base_vha->host); 2302 2303 probe_hw_failed: 2304 if (IS_QLA82XX(ha)) { 2305 qla82xx_idc_lock(ha); 2306 qla82xx_clear_drv_active(ha); 2307 qla82xx_idc_unlock(ha); 2308 iounmap((device_reg_t __iomem *)ha->nx_pcibase); 2309 if (!ql2xdbwr) 2310 iounmap((device_reg_t __iomem *)ha->nxdb_wr_ptr); 2311 } else { 2312 if (ha->iobase) 2313 iounmap(ha->iobase); 2314 } 2315 pci_release_selected_regions(ha->pdev, ha->bars); 2316 kfree(ha); 2317 ha = NULL; 2318 2319 probe_out: 2320 pci_disable_device(pdev); 2321 return ret; 2322 } 2323 2324 static void 2325 qla2x00_shutdown(struct pci_dev *pdev) 2326 { 2327 scsi_qla_host_t *vha; 2328 struct qla_hw_data *ha; 2329 2330 vha = pci_get_drvdata(pdev); 2331 ha = vha->hw; 2332 2333 /* Turn-off FCE trace */ 2334 if (ha->flags.fce_enabled) { 2335 qla2x00_disable_fce_trace(vha, NULL, NULL); 2336 ha->flags.fce_enabled = 0; 2337 } 2338 2339 /* Turn-off EFT trace */ 2340 if (ha->eft) 2341 qla2x00_disable_eft_trace(vha); 2342 2343 /* Stop currently executing firmware. */ 2344 qla2x00_try_to_stop_firmware(vha); 2345 2346 /* Turn adapter off line */ 2347 vha->flags.online = 0; 2348 2349 /* turn-off interrupts on the card */ 2350 if (ha->interrupts_on) { 2351 vha->flags.init_done = 0; 2352 ha->isp_ops->disable_intrs(ha); 2353 } 2354 2355 qla2x00_free_irqs(vha); 2356 2357 qla2x00_free_fw_dump(ha); 2358 } 2359 2360 static void 2361 qla2x00_remove_one(struct pci_dev *pdev) 2362 { 2363 scsi_qla_host_t *base_vha, *vha; 2364 struct qla_hw_data *ha; 2365 unsigned long flags; 2366 2367 base_vha = pci_get_drvdata(pdev); 2368 ha = base_vha->hw; 2369 2370 spin_lock_irqsave(&ha->vport_slock, flags); 2371 list_for_each_entry(vha, &ha->vp_list, list) { 2372 atomic_inc(&vha->vref_count); 2373 2374 if (vha && vha->fc_vport) { 2375 spin_unlock_irqrestore(&ha->vport_slock, flags); 2376 2377 fc_vport_terminate(vha->fc_vport); 2378 2379 spin_lock_irqsave(&ha->vport_slock, flags); 2380 } 2381 2382 atomic_dec(&vha->vref_count); 2383 } 2384 spin_unlock_irqrestore(&ha->vport_slock, flags); 2385 2386 set_bit(UNLOADING, &base_vha->dpc_flags); 2387 2388 qla2x00_abort_all_cmds(base_vha, DID_NO_CONNECT << 16); 2389 2390 qla2x00_dfs_remove(base_vha); 2391 2392 qla84xx_put_chip(base_vha); 2393 2394 /* Disable timer */ 2395 if (base_vha->timer_active) 2396 qla2x00_stop_timer(base_vha); 2397 2398 base_vha->flags.online = 0; 2399 2400 /* Flush the work queue and remove it */ 2401 if (ha->wq) { 2402 flush_workqueue(ha->wq); 2403 destroy_workqueue(ha->wq); 2404 ha->wq = NULL; 2405 } 2406 2407 /* Kill the kernel thread for this host */ 2408 if (ha->dpc_thread) { 2409 struct task_struct *t = ha->dpc_thread; 2410 2411 /* 2412 * qla2xxx_wake_dpc checks for ->dpc_thread 2413 * so we need to zero it out. 2414 */ 2415 ha->dpc_thread = NULL; 2416 kthread_stop(t); 2417 } 2418 2419 qla2x00_free_sysfs_attr(base_vha); 2420 2421 fc_remove_host(base_vha->host); 2422 2423 scsi_remove_host(base_vha->host); 2424 2425 qla2x00_free_device(base_vha); 2426 2427 scsi_host_put(base_vha->host); 2428 2429 if (IS_QLA82XX(ha)) { 2430 qla82xx_idc_lock(ha); 2431 qla82xx_clear_drv_active(ha); 2432 qla82xx_idc_unlock(ha); 2433 2434 iounmap((device_reg_t __iomem *)ha->nx_pcibase); 2435 if (!ql2xdbwr) 2436 iounmap((device_reg_t __iomem *)ha->nxdb_wr_ptr); 2437 } else { 2438 if (ha->iobase) 2439 iounmap(ha->iobase); 2440 2441 if (ha->mqiobase) 2442 iounmap(ha->mqiobase); 2443 } 2444 2445 pci_release_selected_regions(ha->pdev, ha->bars); 2446 kfree(ha); 2447 ha = NULL; 2448 2449 pci_disable_pcie_error_reporting(pdev); 2450 2451 pci_disable_device(pdev); 2452 pci_set_drvdata(pdev, NULL); 2453 } 2454 2455 static void 2456 qla2x00_free_device(scsi_qla_host_t *vha) 2457 { 2458 struct qla_hw_data *ha = vha->hw; 2459 2460 qla2x00_abort_all_cmds(vha, DID_NO_CONNECT << 16); 2461 2462 /* Disable timer */ 2463 if (vha->timer_active) 2464 qla2x00_stop_timer(vha); 2465 2466 /* Kill the kernel thread for this host */ 2467 if (ha->dpc_thread) { 2468 struct task_struct *t = ha->dpc_thread; 2469 2470 /* 2471 * qla2xxx_wake_dpc checks for ->dpc_thread 2472 * so we need to zero it out. 2473 */ 2474 ha->dpc_thread = NULL; 2475 kthread_stop(t); 2476 } 2477 2478 qla25xx_delete_queues(vha); 2479 2480 if (ha->flags.fce_enabled) 2481 qla2x00_disable_fce_trace(vha, NULL, NULL); 2482 2483 if (ha->eft) 2484 qla2x00_disable_eft_trace(vha); 2485 2486 /* Stop currently executing firmware. */ 2487 qla2x00_try_to_stop_firmware(vha); 2488 2489 vha->flags.online = 0; 2490 2491 /* turn-off interrupts on the card */ 2492 if (ha->interrupts_on) { 2493 vha->flags.init_done = 0; 2494 ha->isp_ops->disable_intrs(ha); 2495 } 2496 2497 qla2x00_free_irqs(vha); 2498 2499 qla2x00_free_fcports(vha); 2500 2501 qla2x00_mem_free(ha); 2502 2503 qla2x00_free_queues(ha); 2504 } 2505 2506 void qla2x00_free_fcports(struct scsi_qla_host *vha) 2507 { 2508 fc_port_t *fcport, *tfcport; 2509 2510 list_for_each_entry_safe(fcport, tfcport, &vha->vp_fcports, list) { 2511 list_del(&fcport->list); 2512 kfree(fcport); 2513 fcport = NULL; 2514 } 2515 } 2516 2517 static inline void 2518 qla2x00_schedule_rport_del(struct scsi_qla_host *vha, fc_port_t *fcport, 2519 int defer) 2520 { 2521 struct fc_rport *rport; 2522 scsi_qla_host_t *base_vha; 2523 2524 if (!fcport->rport) 2525 return; 2526 2527 rport = fcport->rport; 2528 if (defer) { 2529 base_vha = pci_get_drvdata(vha->hw->pdev); 2530 spin_lock_irq(vha->host->host_lock); 2531 fcport->drport = rport; 2532 spin_unlock_irq(vha->host->host_lock); 2533 set_bit(FCPORT_UPDATE_NEEDED, &base_vha->dpc_flags); 2534 qla2xxx_wake_dpc(base_vha); 2535 } else 2536 fc_remote_port_delete(rport); 2537 } 2538 2539 /* 2540 * qla2x00_mark_device_lost Updates fcport state when device goes offline. 2541 * 2542 * Input: ha = adapter block pointer. fcport = port structure pointer. 2543 * 2544 * Return: None. 2545 * 2546 * Context: 2547 */ 2548 void qla2x00_mark_device_lost(scsi_qla_host_t *vha, fc_port_t *fcport, 2549 int do_login, int defer) 2550 { 2551 if (atomic_read(&fcport->state) == FCS_ONLINE && 2552 vha->vp_idx == fcport->vp_idx) { 2553 atomic_set(&fcport->state, FCS_DEVICE_LOST); 2554 qla2x00_schedule_rport_del(vha, fcport, defer); 2555 } 2556 /* 2557 * We may need to retry the login, so don't change the state of the 2558 * port but do the retries. 2559 */ 2560 if (atomic_read(&fcport->state) != FCS_DEVICE_DEAD) 2561 atomic_set(&fcport->state, FCS_DEVICE_LOST); 2562 2563 if (!do_login) 2564 return; 2565 2566 if (fcport->login_retry == 0) { 2567 fcport->login_retry = vha->hw->login_retry_count; 2568 set_bit(RELOGIN_NEEDED, &vha->dpc_flags); 2569 2570 DEBUG(printk("scsi(%ld): Port login retry: " 2571 "%02x%02x%02x%02x%02x%02x%02x%02x, " 2572 "id = 0x%04x retry cnt=%d\n", 2573 vha->host_no, 2574 fcport->port_name[0], 2575 fcport->port_name[1], 2576 fcport->port_name[2], 2577 fcport->port_name[3], 2578 fcport->port_name[4], 2579 fcport->port_name[5], 2580 fcport->port_name[6], 2581 fcport->port_name[7], 2582 fcport->loop_id, 2583 fcport->login_retry)); 2584 } 2585 } 2586 2587 /* 2588 * qla2x00_mark_all_devices_lost 2589 * Updates fcport state when device goes offline. 2590 * 2591 * Input: 2592 * ha = adapter block pointer. 2593 * fcport = port structure pointer. 2594 * 2595 * Return: 2596 * None. 2597 * 2598 * Context: 2599 */ 2600 void 2601 qla2x00_mark_all_devices_lost(scsi_qla_host_t *vha, int defer) 2602 { 2603 fc_port_t *fcport; 2604 2605 list_for_each_entry(fcport, &vha->vp_fcports, list) { 2606 if (vha->vp_idx != 0 && vha->vp_idx != fcport->vp_idx) 2607 continue; 2608 2609 /* 2610 * No point in marking the device as lost, if the device is 2611 * already DEAD. 2612 */ 2613 if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD) 2614 continue; 2615 if (atomic_read(&fcport->state) == FCS_ONLINE) { 2616 atomic_set(&fcport->state, FCS_DEVICE_LOST); 2617 if (defer) 2618 qla2x00_schedule_rport_del(vha, fcport, defer); 2619 else if (vha->vp_idx == fcport->vp_idx) 2620 qla2x00_schedule_rport_del(vha, fcport, defer); 2621 } 2622 } 2623 } 2624 2625 /* 2626 * qla2x00_mem_alloc 2627 * Allocates adapter memory. 2628 * 2629 * Returns: 2630 * 0 = success. 2631 * !0 = failure. 2632 */ 2633 static int 2634 qla2x00_mem_alloc(struct qla_hw_data *ha, uint16_t req_len, uint16_t rsp_len, 2635 struct req_que **req, struct rsp_que **rsp) 2636 { 2637 char name[16]; 2638 2639 ha->init_cb = dma_alloc_coherent(&ha->pdev->dev, ha->init_cb_size, 2640 &ha->init_cb_dma, GFP_KERNEL); 2641 if (!ha->init_cb) 2642 goto fail; 2643 2644 ha->gid_list = dma_alloc_coherent(&ha->pdev->dev, GID_LIST_SIZE, 2645 &ha->gid_list_dma, GFP_KERNEL); 2646 if (!ha->gid_list) 2647 goto fail_free_init_cb; 2648 2649 ha->srb_mempool = mempool_create_slab_pool(SRB_MIN_REQ, srb_cachep); 2650 if (!ha->srb_mempool) 2651 goto fail_free_gid_list; 2652 2653 if (IS_QLA82XX(ha)) { 2654 /* Allocate cache for CT6 Ctx. */ 2655 if (!ctx_cachep) { 2656 ctx_cachep = kmem_cache_create("qla2xxx_ctx", 2657 sizeof(struct ct6_dsd), 0, 2658 SLAB_HWCACHE_ALIGN, NULL); 2659 if (!ctx_cachep) 2660 goto fail_free_gid_list; 2661 } 2662 ha->ctx_mempool = mempool_create_slab_pool(SRB_MIN_REQ, 2663 ctx_cachep); 2664 if (!ha->ctx_mempool) 2665 goto fail_free_srb_mempool; 2666 } 2667 2668 /* Get memory for cached NVRAM */ 2669 ha->nvram = kzalloc(MAX_NVRAM_SIZE, GFP_KERNEL); 2670 if (!ha->nvram) 2671 goto fail_free_ctx_mempool; 2672 2673 snprintf(name, sizeof(name), "%s_%d", QLA2XXX_DRIVER_NAME, 2674 ha->pdev->device); 2675 ha->s_dma_pool = dma_pool_create(name, &ha->pdev->dev, 2676 DMA_POOL_SIZE, 8, 0); 2677 if (!ha->s_dma_pool) 2678 goto fail_free_nvram; 2679 2680 if (IS_QLA82XX(ha) || ql2xenabledif) { 2681 ha->dl_dma_pool = dma_pool_create(name, &ha->pdev->dev, 2682 DSD_LIST_DMA_POOL_SIZE, 8, 0); 2683 if (!ha->dl_dma_pool) { 2684 qla_printk(KERN_WARNING, ha, 2685 "Memory Allocation failed - dl_dma_pool\n"); 2686 goto fail_s_dma_pool; 2687 } 2688 2689 ha->fcp_cmnd_dma_pool = dma_pool_create(name, &ha->pdev->dev, 2690 FCP_CMND_DMA_POOL_SIZE, 8, 0); 2691 if (!ha->fcp_cmnd_dma_pool) { 2692 qla_printk(KERN_WARNING, ha, 2693 "Memory Allocation failed - fcp_cmnd_dma_pool\n"); 2694 goto fail_dl_dma_pool; 2695 } 2696 } 2697 2698 /* Allocate memory for SNS commands */ 2699 if (IS_QLA2100(ha) || IS_QLA2200(ha)) { 2700 /* Get consistent memory allocated for SNS commands */ 2701 ha->sns_cmd = dma_alloc_coherent(&ha->pdev->dev, 2702 sizeof(struct sns_cmd_pkt), &ha->sns_cmd_dma, GFP_KERNEL); 2703 if (!ha->sns_cmd) 2704 goto fail_dma_pool; 2705 } else { 2706 /* Get consistent memory allocated for MS IOCB */ 2707 ha->ms_iocb = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, 2708 &ha->ms_iocb_dma); 2709 if (!ha->ms_iocb) 2710 goto fail_dma_pool; 2711 /* Get consistent memory allocated for CT SNS commands */ 2712 ha->ct_sns = dma_alloc_coherent(&ha->pdev->dev, 2713 sizeof(struct ct_sns_pkt), &ha->ct_sns_dma, GFP_KERNEL); 2714 if (!ha->ct_sns) 2715 goto fail_free_ms_iocb; 2716 } 2717 2718 /* Allocate memory for request ring */ 2719 *req = kzalloc(sizeof(struct req_que), GFP_KERNEL); 2720 if (!*req) { 2721 DEBUG(printk("Unable to allocate memory for req\n")); 2722 goto fail_req; 2723 } 2724 (*req)->length = req_len; 2725 (*req)->ring = dma_alloc_coherent(&ha->pdev->dev, 2726 ((*req)->length + 1) * sizeof(request_t), 2727 &(*req)->dma, GFP_KERNEL); 2728 if (!(*req)->ring) { 2729 DEBUG(printk("Unable to allocate memory for req_ring\n")); 2730 goto fail_req_ring; 2731 } 2732 /* Allocate memory for response ring */ 2733 *rsp = kzalloc(sizeof(struct rsp_que), GFP_KERNEL); 2734 if (!*rsp) { 2735 qla_printk(KERN_WARNING, ha, 2736 "Unable to allocate memory for rsp\n"); 2737 goto fail_rsp; 2738 } 2739 (*rsp)->hw = ha; 2740 (*rsp)->length = rsp_len; 2741 (*rsp)->ring = dma_alloc_coherent(&ha->pdev->dev, 2742 ((*rsp)->length + 1) * sizeof(response_t), 2743 &(*rsp)->dma, GFP_KERNEL); 2744 if (!(*rsp)->ring) { 2745 qla_printk(KERN_WARNING, ha, 2746 "Unable to allocate memory for rsp_ring\n"); 2747 goto fail_rsp_ring; 2748 } 2749 (*req)->rsp = *rsp; 2750 (*rsp)->req = *req; 2751 /* Allocate memory for NVRAM data for vports */ 2752 if (ha->nvram_npiv_size) { 2753 ha->npiv_info = kzalloc(sizeof(struct qla_npiv_entry) * 2754 ha->nvram_npiv_size, GFP_KERNEL); 2755 if (!ha->npiv_info) { 2756 qla_printk(KERN_WARNING, ha, 2757 "Unable to allocate memory for npiv info\n"); 2758 goto fail_npiv_info; 2759 } 2760 } else 2761 ha->npiv_info = NULL; 2762 2763 /* Get consistent memory allocated for EX-INIT-CB. */ 2764 if (IS_QLA8XXX_TYPE(ha)) { 2765 ha->ex_init_cb = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, 2766 &ha->ex_init_cb_dma); 2767 if (!ha->ex_init_cb) 2768 goto fail_ex_init_cb; 2769 } 2770 2771 INIT_LIST_HEAD(&ha->gbl_dsd_list); 2772 2773 /* Get consistent memory allocated for Async Port-Database. */ 2774 if (!IS_FWI2_CAPABLE(ha)) { 2775 ha->async_pd = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, 2776 &ha->async_pd_dma); 2777 if (!ha->async_pd) 2778 goto fail_async_pd; 2779 } 2780 2781 INIT_LIST_HEAD(&ha->vp_list); 2782 return 1; 2783 2784 fail_async_pd: 2785 dma_pool_free(ha->s_dma_pool, ha->ex_init_cb, ha->ex_init_cb_dma); 2786 fail_ex_init_cb: 2787 kfree(ha->npiv_info); 2788 fail_npiv_info: 2789 dma_free_coherent(&ha->pdev->dev, ((*rsp)->length + 1) * 2790 sizeof(response_t), (*rsp)->ring, (*rsp)->dma); 2791 (*rsp)->ring = NULL; 2792 (*rsp)->dma = 0; 2793 fail_rsp_ring: 2794 kfree(*rsp); 2795 fail_rsp: 2796 dma_free_coherent(&ha->pdev->dev, ((*req)->length + 1) * 2797 sizeof(request_t), (*req)->ring, (*req)->dma); 2798 (*req)->ring = NULL; 2799 (*req)->dma = 0; 2800 fail_req_ring: 2801 kfree(*req); 2802 fail_req: 2803 dma_free_coherent(&ha->pdev->dev, sizeof(struct ct_sns_pkt), 2804 ha->ct_sns, ha->ct_sns_dma); 2805 ha->ct_sns = NULL; 2806 ha->ct_sns_dma = 0; 2807 fail_free_ms_iocb: 2808 dma_pool_free(ha->s_dma_pool, ha->ms_iocb, ha->ms_iocb_dma); 2809 ha->ms_iocb = NULL; 2810 ha->ms_iocb_dma = 0; 2811 fail_dma_pool: 2812 if (IS_QLA82XX(ha) || ql2xenabledif) { 2813 dma_pool_destroy(ha->fcp_cmnd_dma_pool); 2814 ha->fcp_cmnd_dma_pool = NULL; 2815 } 2816 fail_dl_dma_pool: 2817 if (IS_QLA82XX(ha) || ql2xenabledif) { 2818 dma_pool_destroy(ha->dl_dma_pool); 2819 ha->dl_dma_pool = NULL; 2820 } 2821 fail_s_dma_pool: 2822 dma_pool_destroy(ha->s_dma_pool); 2823 ha->s_dma_pool = NULL; 2824 fail_free_nvram: 2825 kfree(ha->nvram); 2826 ha->nvram = NULL; 2827 fail_free_ctx_mempool: 2828 mempool_destroy(ha->ctx_mempool); 2829 ha->ctx_mempool = NULL; 2830 fail_free_srb_mempool: 2831 mempool_destroy(ha->srb_mempool); 2832 ha->srb_mempool = NULL; 2833 fail_free_gid_list: 2834 dma_free_coherent(&ha->pdev->dev, GID_LIST_SIZE, ha->gid_list, 2835 ha->gid_list_dma); 2836 ha->gid_list = NULL; 2837 ha->gid_list_dma = 0; 2838 fail_free_init_cb: 2839 dma_free_coherent(&ha->pdev->dev, ha->init_cb_size, ha->init_cb, 2840 ha->init_cb_dma); 2841 ha->init_cb = NULL; 2842 ha->init_cb_dma = 0; 2843 fail: 2844 DEBUG(printk("%s: Memory allocation failure\n", __func__)); 2845 return -ENOMEM; 2846 } 2847 2848 /* 2849 * qla2x00_free_fw_dump 2850 * Frees fw dump stuff. 2851 * 2852 * Input: 2853 * ha = adapter block pointer. 2854 */ 2855 static void 2856 qla2x00_free_fw_dump(struct qla_hw_data *ha) 2857 { 2858 if (ha->fce) 2859 dma_free_coherent(&ha->pdev->dev, FCE_SIZE, ha->fce, 2860 ha->fce_dma); 2861 2862 if (ha->fw_dump) { 2863 if (ha->eft) 2864 dma_free_coherent(&ha->pdev->dev, 2865 ntohl(ha->fw_dump->eft_size), ha->eft, ha->eft_dma); 2866 vfree(ha->fw_dump); 2867 } 2868 ha->fce = NULL; 2869 ha->fce_dma = 0; 2870 ha->eft = NULL; 2871 ha->eft_dma = 0; 2872 ha->fw_dump = NULL; 2873 ha->fw_dumped = 0; 2874 ha->fw_dump_reading = 0; 2875 } 2876 2877 /* 2878 * qla2x00_mem_free 2879 * Frees all adapter allocated memory. 2880 * 2881 * Input: 2882 * ha = adapter block pointer. 2883 */ 2884 static void 2885 qla2x00_mem_free(struct qla_hw_data *ha) 2886 { 2887 qla2x00_free_fw_dump(ha); 2888 2889 if (ha->srb_mempool) 2890 mempool_destroy(ha->srb_mempool); 2891 2892 if (ha->dcbx_tlv) 2893 dma_free_coherent(&ha->pdev->dev, DCBX_TLV_DATA_SIZE, 2894 ha->dcbx_tlv, ha->dcbx_tlv_dma); 2895 2896 if (ha->xgmac_data) 2897 dma_free_coherent(&ha->pdev->dev, XGMAC_DATA_SIZE, 2898 ha->xgmac_data, ha->xgmac_data_dma); 2899 2900 if (ha->sns_cmd) 2901 dma_free_coherent(&ha->pdev->dev, sizeof(struct sns_cmd_pkt), 2902 ha->sns_cmd, ha->sns_cmd_dma); 2903 2904 if (ha->ct_sns) 2905 dma_free_coherent(&ha->pdev->dev, sizeof(struct ct_sns_pkt), 2906 ha->ct_sns, ha->ct_sns_dma); 2907 2908 if (ha->sfp_data) 2909 dma_pool_free(ha->s_dma_pool, ha->sfp_data, ha->sfp_data_dma); 2910 2911 if (ha->edc_data) 2912 dma_pool_free(ha->s_dma_pool, ha->edc_data, ha->edc_data_dma); 2913 2914 if (ha->ms_iocb) 2915 dma_pool_free(ha->s_dma_pool, ha->ms_iocb, ha->ms_iocb_dma); 2916 2917 if (ha->ex_init_cb) 2918 dma_pool_free(ha->s_dma_pool, 2919 ha->ex_init_cb, ha->ex_init_cb_dma); 2920 2921 if (ha->async_pd) 2922 dma_pool_free(ha->s_dma_pool, ha->async_pd, ha->async_pd_dma); 2923 2924 if (ha->s_dma_pool) 2925 dma_pool_destroy(ha->s_dma_pool); 2926 2927 if (ha->gid_list) 2928 dma_free_coherent(&ha->pdev->dev, GID_LIST_SIZE, ha->gid_list, 2929 ha->gid_list_dma); 2930 2931 if (IS_QLA82XX(ha)) { 2932 if (!list_empty(&ha->gbl_dsd_list)) { 2933 struct dsd_dma *dsd_ptr, *tdsd_ptr; 2934 2935 /* clean up allocated prev pool */ 2936 list_for_each_entry_safe(dsd_ptr, 2937 tdsd_ptr, &ha->gbl_dsd_list, list) { 2938 dma_pool_free(ha->dl_dma_pool, 2939 dsd_ptr->dsd_addr, dsd_ptr->dsd_list_dma); 2940 list_del(&dsd_ptr->list); 2941 kfree(dsd_ptr); 2942 } 2943 } 2944 } 2945 2946 if (ha->dl_dma_pool) 2947 dma_pool_destroy(ha->dl_dma_pool); 2948 2949 if (ha->fcp_cmnd_dma_pool) 2950 dma_pool_destroy(ha->fcp_cmnd_dma_pool); 2951 2952 if (ha->ctx_mempool) 2953 mempool_destroy(ha->ctx_mempool); 2954 2955 if (ha->init_cb) 2956 dma_free_coherent(&ha->pdev->dev, ha->init_cb_size, 2957 ha->init_cb, ha->init_cb_dma); 2958 vfree(ha->optrom_buffer); 2959 kfree(ha->nvram); 2960 kfree(ha->npiv_info); 2961 2962 ha->srb_mempool = NULL; 2963 ha->ctx_mempool = NULL; 2964 ha->sns_cmd = NULL; 2965 ha->sns_cmd_dma = 0; 2966 ha->ct_sns = NULL; 2967 ha->ct_sns_dma = 0; 2968 ha->ms_iocb = NULL; 2969 ha->ms_iocb_dma = 0; 2970 ha->init_cb = NULL; 2971 ha->init_cb_dma = 0; 2972 ha->ex_init_cb = NULL; 2973 ha->ex_init_cb_dma = 0; 2974 ha->async_pd = NULL; 2975 ha->async_pd_dma = 0; 2976 2977 ha->s_dma_pool = NULL; 2978 ha->dl_dma_pool = NULL; 2979 ha->fcp_cmnd_dma_pool = NULL; 2980 2981 ha->gid_list = NULL; 2982 ha->gid_list_dma = 0; 2983 } 2984 2985 struct scsi_qla_host *qla2x00_create_host(struct scsi_host_template *sht, 2986 struct qla_hw_data *ha) 2987 { 2988 struct Scsi_Host *host; 2989 struct scsi_qla_host *vha = NULL; 2990 2991 host = scsi_host_alloc(sht, sizeof(scsi_qla_host_t)); 2992 if (host == NULL) { 2993 printk(KERN_WARNING 2994 "qla2xxx: Couldn't allocate host from scsi layer!\n"); 2995 goto fail; 2996 } 2997 2998 /* Clear our data area */ 2999 vha = shost_priv(host); 3000 memset(vha, 0, sizeof(scsi_qla_host_t)); 3001 3002 vha->host = host; 3003 vha->host_no = host->host_no; 3004 vha->hw = ha; 3005 3006 INIT_LIST_HEAD(&vha->vp_fcports); 3007 INIT_LIST_HEAD(&vha->work_list); 3008 INIT_LIST_HEAD(&vha->list); 3009 3010 spin_lock_init(&vha->work_lock); 3011 3012 sprintf(vha->host_str, "%s_%ld", QLA2XXX_DRIVER_NAME, vha->host_no); 3013 return vha; 3014 3015 fail: 3016 return vha; 3017 } 3018 3019 static struct qla_work_evt * 3020 qla2x00_alloc_work(struct scsi_qla_host *vha, enum qla_work_type type) 3021 { 3022 struct qla_work_evt *e; 3023 uint8_t bail; 3024 3025 QLA_VHA_MARK_BUSY(vha, bail); 3026 if (bail) 3027 return NULL; 3028 3029 e = kzalloc(sizeof(struct qla_work_evt), GFP_ATOMIC); 3030 if (!e) { 3031 QLA_VHA_MARK_NOT_BUSY(vha); 3032 return NULL; 3033 } 3034 3035 INIT_LIST_HEAD(&e->list); 3036 e->type = type; 3037 e->flags = QLA_EVT_FLAG_FREE; 3038 return e; 3039 } 3040 3041 static int 3042 qla2x00_post_work(struct scsi_qla_host *vha, struct qla_work_evt *e) 3043 { 3044 unsigned long flags; 3045 3046 spin_lock_irqsave(&vha->work_lock, flags); 3047 list_add_tail(&e->list, &vha->work_list); 3048 spin_unlock_irqrestore(&vha->work_lock, flags); 3049 qla2xxx_wake_dpc(vha); 3050 3051 return QLA_SUCCESS; 3052 } 3053 3054 int 3055 qla2x00_post_aen_work(struct scsi_qla_host *vha, enum fc_host_event_code code, 3056 u32 data) 3057 { 3058 struct qla_work_evt *e; 3059 3060 e = qla2x00_alloc_work(vha, QLA_EVT_AEN); 3061 if (!e) 3062 return QLA_FUNCTION_FAILED; 3063 3064 e->u.aen.code = code; 3065 e->u.aen.data = data; 3066 return qla2x00_post_work(vha, e); 3067 } 3068 3069 int 3070 qla2x00_post_idc_ack_work(struct scsi_qla_host *vha, uint16_t *mb) 3071 { 3072 struct qla_work_evt *e; 3073 3074 e = qla2x00_alloc_work(vha, QLA_EVT_IDC_ACK); 3075 if (!e) 3076 return QLA_FUNCTION_FAILED; 3077 3078 memcpy(e->u.idc_ack.mb, mb, QLA_IDC_ACK_REGS * sizeof(uint16_t)); 3079 return qla2x00_post_work(vha, e); 3080 } 3081 3082 #define qla2x00_post_async_work(name, type) \ 3083 int qla2x00_post_async_##name##_work( \ 3084 struct scsi_qla_host *vha, \ 3085 fc_port_t *fcport, uint16_t *data) \ 3086 { \ 3087 struct qla_work_evt *e; \ 3088 \ 3089 e = qla2x00_alloc_work(vha, type); \ 3090 if (!e) \ 3091 return QLA_FUNCTION_FAILED; \ 3092 \ 3093 e->u.logio.fcport = fcport; \ 3094 if (data) { \ 3095 e->u.logio.data[0] = data[0]; \ 3096 e->u.logio.data[1] = data[1]; \ 3097 } \ 3098 return qla2x00_post_work(vha, e); \ 3099 } 3100 3101 qla2x00_post_async_work(login, QLA_EVT_ASYNC_LOGIN); 3102 qla2x00_post_async_work(login_done, QLA_EVT_ASYNC_LOGIN_DONE); 3103 qla2x00_post_async_work(logout, QLA_EVT_ASYNC_LOGOUT); 3104 qla2x00_post_async_work(logout_done, QLA_EVT_ASYNC_LOGOUT_DONE); 3105 qla2x00_post_async_work(adisc, QLA_EVT_ASYNC_ADISC); 3106 qla2x00_post_async_work(adisc_done, QLA_EVT_ASYNC_ADISC_DONE); 3107 3108 int 3109 qla2x00_post_uevent_work(struct scsi_qla_host *vha, u32 code) 3110 { 3111 struct qla_work_evt *e; 3112 3113 e = qla2x00_alloc_work(vha, QLA_EVT_UEVENT); 3114 if (!e) 3115 return QLA_FUNCTION_FAILED; 3116 3117 e->u.uevent.code = code; 3118 return qla2x00_post_work(vha, e); 3119 } 3120 3121 static void 3122 qla2x00_uevent_emit(struct scsi_qla_host *vha, u32 code) 3123 { 3124 char event_string[40]; 3125 char *envp[] = { event_string, NULL }; 3126 3127 switch (code) { 3128 case QLA_UEVENT_CODE_FW_DUMP: 3129 snprintf(event_string, sizeof(event_string), "FW_DUMP=%ld", 3130 vha->host_no); 3131 break; 3132 default: 3133 /* do nothing */ 3134 break; 3135 } 3136 kobject_uevent_env(&vha->hw->pdev->dev.kobj, KOBJ_CHANGE, envp); 3137 } 3138 3139 void 3140 qla2x00_do_work(struct scsi_qla_host *vha) 3141 { 3142 struct qla_work_evt *e, *tmp; 3143 unsigned long flags; 3144 LIST_HEAD(work); 3145 3146 spin_lock_irqsave(&vha->work_lock, flags); 3147 list_splice_init(&vha->work_list, &work); 3148 spin_unlock_irqrestore(&vha->work_lock, flags); 3149 3150 list_for_each_entry_safe(e, tmp, &work, list) { 3151 list_del_init(&e->list); 3152 3153 switch (e->type) { 3154 case QLA_EVT_AEN: 3155 fc_host_post_event(vha->host, fc_get_event_number(), 3156 e->u.aen.code, e->u.aen.data); 3157 break; 3158 case QLA_EVT_IDC_ACK: 3159 qla81xx_idc_ack(vha, e->u.idc_ack.mb); 3160 break; 3161 case QLA_EVT_ASYNC_LOGIN: 3162 qla2x00_async_login(vha, e->u.logio.fcport, 3163 e->u.logio.data); 3164 break; 3165 case QLA_EVT_ASYNC_LOGIN_DONE: 3166 qla2x00_async_login_done(vha, e->u.logio.fcport, 3167 e->u.logio.data); 3168 break; 3169 case QLA_EVT_ASYNC_LOGOUT: 3170 qla2x00_async_logout(vha, e->u.logio.fcport); 3171 break; 3172 case QLA_EVT_ASYNC_LOGOUT_DONE: 3173 qla2x00_async_logout_done(vha, e->u.logio.fcport, 3174 e->u.logio.data); 3175 break; 3176 case QLA_EVT_ASYNC_ADISC: 3177 qla2x00_async_adisc(vha, e->u.logio.fcport, 3178 e->u.logio.data); 3179 break; 3180 case QLA_EVT_ASYNC_ADISC_DONE: 3181 qla2x00_async_adisc_done(vha, e->u.logio.fcport, 3182 e->u.logio.data); 3183 break; 3184 case QLA_EVT_UEVENT: 3185 qla2x00_uevent_emit(vha, e->u.uevent.code); 3186 break; 3187 } 3188 if (e->flags & QLA_EVT_FLAG_FREE) 3189 kfree(e); 3190 3191 /* For each work completed decrement vha ref count */ 3192 QLA_VHA_MARK_NOT_BUSY(vha); 3193 } 3194 } 3195 3196 /* Relogins all the fcports of a vport 3197 * Context: dpc thread 3198 */ 3199 void qla2x00_relogin(struct scsi_qla_host *vha) 3200 { 3201 fc_port_t *fcport; 3202 int status; 3203 uint16_t next_loopid = 0; 3204 struct qla_hw_data *ha = vha->hw; 3205 uint16_t data[2]; 3206 3207 list_for_each_entry(fcport, &vha->vp_fcports, list) { 3208 /* 3209 * If the port is not ONLINE then try to login 3210 * to it if we haven't run out of retries. 3211 */ 3212 if (atomic_read(&fcport->state) != FCS_ONLINE && 3213 fcport->login_retry && !(fcport->flags & FCF_ASYNC_SENT)) { 3214 fcport->login_retry--; 3215 if (fcport->flags & FCF_FABRIC_DEVICE) { 3216 if (fcport->flags & FCF_FCP2_DEVICE) 3217 ha->isp_ops->fabric_logout(vha, 3218 fcport->loop_id, 3219 fcport->d_id.b.domain, 3220 fcport->d_id.b.area, 3221 fcport->d_id.b.al_pa); 3222 3223 if (IS_ALOGIO_CAPABLE(ha)) { 3224 fcport->flags |= FCF_ASYNC_SENT; 3225 data[0] = 0; 3226 data[1] = QLA_LOGIO_LOGIN_RETRIED; 3227 status = qla2x00_post_async_login_work( 3228 vha, fcport, data); 3229 if (status == QLA_SUCCESS) 3230 continue; 3231 /* Attempt a retry. */ 3232 status = 1; 3233 } else 3234 status = qla2x00_fabric_login(vha, 3235 fcport, &next_loopid); 3236 } else 3237 status = qla2x00_local_device_login(vha, 3238 fcport); 3239 3240 if (status == QLA_SUCCESS) { 3241 fcport->old_loop_id = fcport->loop_id; 3242 3243 DEBUG(printk("scsi(%ld): port login OK: logged " 3244 "in ID 0x%x\n", vha->host_no, fcport->loop_id)); 3245 3246 qla2x00_update_fcport(vha, fcport); 3247 3248 } else if (status == 1) { 3249 set_bit(RELOGIN_NEEDED, &vha->dpc_flags); 3250 /* retry the login again */ 3251 DEBUG(printk("scsi(%ld): Retrying" 3252 " %d login again loop_id 0x%x\n", 3253 vha->host_no, fcport->login_retry, 3254 fcport->loop_id)); 3255 } else { 3256 fcport->login_retry = 0; 3257 } 3258 3259 if (fcport->login_retry == 0 && status != QLA_SUCCESS) 3260 fcport->loop_id = FC_NO_LOOP_ID; 3261 } 3262 if (test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags)) 3263 break; 3264 } 3265 } 3266 3267 /************************************************************************** 3268 * qla2x00_do_dpc 3269 * This kernel thread is a task that is schedule by the interrupt handler 3270 * to perform the background processing for interrupts. 3271 * 3272 * Notes: 3273 * This task always run in the context of a kernel thread. It 3274 * is kick-off by the driver's detect code and starts up 3275 * up one per adapter. It immediately goes to sleep and waits for 3276 * some fibre event. When either the interrupt handler or 3277 * the timer routine detects a event it will one of the task 3278 * bits then wake us up. 3279 **************************************************************************/ 3280 static int 3281 qla2x00_do_dpc(void *data) 3282 { 3283 int rval; 3284 scsi_qla_host_t *base_vha; 3285 struct qla_hw_data *ha; 3286 3287 ha = (struct qla_hw_data *)data; 3288 base_vha = pci_get_drvdata(ha->pdev); 3289 3290 set_user_nice(current, -20); 3291 3292 while (!kthread_should_stop()) { 3293 DEBUG3(printk("qla2x00: DPC handler sleeping\n")); 3294 3295 set_current_state(TASK_INTERRUPTIBLE); 3296 schedule(); 3297 __set_current_state(TASK_RUNNING); 3298 3299 DEBUG3(printk("qla2x00: DPC handler waking up\n")); 3300 3301 /* Initialization not yet finished. Don't do anything yet. */ 3302 if (!base_vha->flags.init_done) 3303 continue; 3304 3305 if (ha->flags.eeh_busy) { 3306 DEBUG17(qla_printk(KERN_WARNING, ha, 3307 "qla2x00_do_dpc: dpc_flags: %lx\n", 3308 base_vha->dpc_flags)); 3309 continue; 3310 } 3311 3312 DEBUG3(printk("scsi(%ld): DPC handler\n", base_vha->host_no)); 3313 3314 ha->dpc_active = 1; 3315 3316 if (ha->flags.mbox_busy) { 3317 ha->dpc_active = 0; 3318 continue; 3319 } 3320 3321 qla2x00_do_work(base_vha); 3322 3323 if (IS_QLA82XX(ha)) { 3324 if (test_and_clear_bit(ISP_UNRECOVERABLE, 3325 &base_vha->dpc_flags)) { 3326 qla82xx_idc_lock(ha); 3327 qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE, 3328 QLA82XX_DEV_FAILED); 3329 qla82xx_idc_unlock(ha); 3330 qla_printk(KERN_INFO, ha, 3331 "HW State: FAILED\n"); 3332 qla82xx_device_state_handler(base_vha); 3333 continue; 3334 } 3335 3336 if (test_and_clear_bit(FCOE_CTX_RESET_NEEDED, 3337 &base_vha->dpc_flags)) { 3338 3339 DEBUG(printk(KERN_INFO 3340 "scsi(%ld): dpc: sched " 3341 "qla82xx_fcoe_ctx_reset ha = %p\n", 3342 base_vha->host_no, ha)); 3343 if (!(test_and_set_bit(ABORT_ISP_ACTIVE, 3344 &base_vha->dpc_flags))) { 3345 if (qla82xx_fcoe_ctx_reset(base_vha)) { 3346 /* FCoE-ctx reset failed. 3347 * Escalate to chip-reset 3348 */ 3349 set_bit(ISP_ABORT_NEEDED, 3350 &base_vha->dpc_flags); 3351 } 3352 clear_bit(ABORT_ISP_ACTIVE, 3353 &base_vha->dpc_flags); 3354 } 3355 3356 DEBUG(printk("scsi(%ld): dpc:" 3357 " qla82xx_fcoe_ctx_reset end\n", 3358 base_vha->host_no)); 3359 } 3360 } 3361 3362 if (test_and_clear_bit(ISP_ABORT_NEEDED, 3363 &base_vha->dpc_flags)) { 3364 3365 DEBUG(printk("scsi(%ld): dpc: sched " 3366 "qla2x00_abort_isp ha = %p\n", 3367 base_vha->host_no, ha)); 3368 if (!(test_and_set_bit(ABORT_ISP_ACTIVE, 3369 &base_vha->dpc_flags))) { 3370 3371 if (ha->isp_ops->abort_isp(base_vha)) { 3372 /* failed. retry later */ 3373 set_bit(ISP_ABORT_NEEDED, 3374 &base_vha->dpc_flags); 3375 } 3376 clear_bit(ABORT_ISP_ACTIVE, 3377 &base_vha->dpc_flags); 3378 } 3379 3380 DEBUG(printk("scsi(%ld): dpc: qla2x00_abort_isp end\n", 3381 base_vha->host_no)); 3382 } 3383 3384 if (test_bit(FCPORT_UPDATE_NEEDED, &base_vha->dpc_flags)) { 3385 qla2x00_update_fcports(base_vha); 3386 clear_bit(FCPORT_UPDATE_NEEDED, &base_vha->dpc_flags); 3387 } 3388 3389 if (test_and_clear_bit(RESET_MARKER_NEEDED, 3390 &base_vha->dpc_flags) && 3391 (!(test_and_set_bit(RESET_ACTIVE, &base_vha->dpc_flags)))) { 3392 3393 DEBUG(printk("scsi(%ld): qla2x00_reset_marker()\n", 3394 base_vha->host_no)); 3395 3396 qla2x00_rst_aen(base_vha); 3397 clear_bit(RESET_ACTIVE, &base_vha->dpc_flags); 3398 } 3399 3400 /* Retry each device up to login retry count */ 3401 if ((test_and_clear_bit(RELOGIN_NEEDED, 3402 &base_vha->dpc_flags)) && 3403 !test_bit(LOOP_RESYNC_NEEDED, &base_vha->dpc_flags) && 3404 atomic_read(&base_vha->loop_state) != LOOP_DOWN) { 3405 3406 DEBUG(printk("scsi(%ld): qla2x00_port_login()\n", 3407 base_vha->host_no)); 3408 qla2x00_relogin(base_vha); 3409 3410 DEBUG(printk("scsi(%ld): qla2x00_port_login - end\n", 3411 base_vha->host_no)); 3412 } 3413 3414 if (test_and_clear_bit(LOOP_RESYNC_NEEDED, 3415 &base_vha->dpc_flags)) { 3416 3417 DEBUG(printk("scsi(%ld): qla2x00_loop_resync()\n", 3418 base_vha->host_no)); 3419 3420 if (!(test_and_set_bit(LOOP_RESYNC_ACTIVE, 3421 &base_vha->dpc_flags))) { 3422 3423 rval = qla2x00_loop_resync(base_vha); 3424 3425 clear_bit(LOOP_RESYNC_ACTIVE, 3426 &base_vha->dpc_flags); 3427 } 3428 3429 DEBUG(printk("scsi(%ld): qla2x00_loop_resync - end\n", 3430 base_vha->host_no)); 3431 } 3432 3433 if (test_bit(NPIV_CONFIG_NEEDED, &base_vha->dpc_flags) && 3434 atomic_read(&base_vha->loop_state) == LOOP_READY) { 3435 clear_bit(NPIV_CONFIG_NEEDED, &base_vha->dpc_flags); 3436 qla2xxx_flash_npiv_conf(base_vha); 3437 } 3438 3439 if (!ha->interrupts_on) 3440 ha->isp_ops->enable_intrs(ha); 3441 3442 if (test_and_clear_bit(BEACON_BLINK_NEEDED, 3443 &base_vha->dpc_flags)) 3444 ha->isp_ops->beacon_blink(base_vha); 3445 3446 qla2x00_do_dpc_all_vps(base_vha); 3447 3448 ha->dpc_active = 0; 3449 } /* End of while(1) */ 3450 3451 DEBUG(printk("scsi(%ld): DPC handler exiting\n", base_vha->host_no)); 3452 3453 /* 3454 * Make sure that nobody tries to wake us up again. 3455 */ 3456 ha->dpc_active = 0; 3457 3458 /* Cleanup any residual CTX SRBs. */ 3459 qla2x00_abort_all_cmds(base_vha, DID_NO_CONNECT << 16); 3460 3461 return 0; 3462 } 3463 3464 void 3465 qla2xxx_wake_dpc(struct scsi_qla_host *vha) 3466 { 3467 struct qla_hw_data *ha = vha->hw; 3468 struct task_struct *t = ha->dpc_thread; 3469 3470 if (!test_bit(UNLOADING, &vha->dpc_flags) && t) 3471 wake_up_process(t); 3472 } 3473 3474 /* 3475 * qla2x00_rst_aen 3476 * Processes asynchronous reset. 3477 * 3478 * Input: 3479 * ha = adapter block pointer. 3480 */ 3481 static void 3482 qla2x00_rst_aen(scsi_qla_host_t *vha) 3483 { 3484 if (vha->flags.online && !vha->flags.reset_active && 3485 !atomic_read(&vha->loop_down_timer) && 3486 !(test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags))) { 3487 do { 3488 clear_bit(RESET_MARKER_NEEDED, &vha->dpc_flags); 3489 3490 /* 3491 * Issue marker command only when we are going to start 3492 * the I/O. 3493 */ 3494 vha->marker_needed = 1; 3495 } while (!atomic_read(&vha->loop_down_timer) && 3496 (test_bit(RESET_MARKER_NEEDED, &vha->dpc_flags))); 3497 } 3498 } 3499 3500 static void 3501 qla2x00_sp_free_dma(srb_t *sp) 3502 { 3503 struct scsi_cmnd *cmd = sp->cmd; 3504 struct qla_hw_data *ha = sp->fcport->vha->hw; 3505 3506 if (sp->flags & SRB_DMA_VALID) { 3507 scsi_dma_unmap(cmd); 3508 sp->flags &= ~SRB_DMA_VALID; 3509 } 3510 3511 if (sp->flags & SRB_CRC_PROT_DMA_VALID) { 3512 dma_unmap_sg(&ha->pdev->dev, scsi_prot_sglist(cmd), 3513 scsi_prot_sg_count(cmd), cmd->sc_data_direction); 3514 sp->flags &= ~SRB_CRC_PROT_DMA_VALID; 3515 } 3516 3517 if (sp->flags & SRB_CRC_CTX_DSD_VALID) { 3518 /* List assured to be having elements */ 3519 qla2x00_clean_dsd_pool(ha, sp); 3520 sp->flags &= ~SRB_CRC_CTX_DSD_VALID; 3521 } 3522 3523 if (sp->flags & SRB_CRC_CTX_DMA_VALID) { 3524 dma_pool_free(ha->dl_dma_pool, sp->ctx, 3525 ((struct crc_context *)sp->ctx)->crc_ctx_dma); 3526 sp->flags &= ~SRB_CRC_CTX_DMA_VALID; 3527 } 3528 3529 CMD_SP(cmd) = NULL; 3530 } 3531 3532 static void 3533 qla2x00_sp_final_compl(struct qla_hw_data *ha, srb_t *sp) 3534 { 3535 struct scsi_cmnd *cmd = sp->cmd; 3536 3537 qla2x00_sp_free_dma(sp); 3538 3539 if (sp->flags & SRB_FCP_CMND_DMA_VALID) { 3540 struct ct6_dsd *ctx = sp->ctx; 3541 dma_pool_free(ha->fcp_cmnd_dma_pool, ctx->fcp_cmnd, 3542 ctx->fcp_cmnd_dma); 3543 list_splice(&ctx->dsd_list, &ha->gbl_dsd_list); 3544 ha->gbl_dsd_inuse -= ctx->dsd_use_cnt; 3545 ha->gbl_dsd_avail += ctx->dsd_use_cnt; 3546 mempool_free(sp->ctx, ha->ctx_mempool); 3547 sp->ctx = NULL; 3548 } 3549 3550 mempool_free(sp, ha->srb_mempool); 3551 cmd->scsi_done(cmd); 3552 } 3553 3554 void 3555 qla2x00_sp_compl(struct qla_hw_data *ha, srb_t *sp) 3556 { 3557 if (atomic_read(&sp->ref_count) == 0) { 3558 DEBUG2(qla_printk(KERN_WARNING, ha, 3559 "SP reference-count to ZERO -- sp=%p\n", sp)); 3560 DEBUG2(BUG()); 3561 return; 3562 } 3563 if (!atomic_dec_and_test(&sp->ref_count)) 3564 return; 3565 qla2x00_sp_final_compl(ha, sp); 3566 } 3567 3568 /************************************************************************** 3569 * qla2x00_timer 3570 * 3571 * Description: 3572 * One second timer 3573 * 3574 * Context: Interrupt 3575 ***************************************************************************/ 3576 void 3577 qla2x00_timer(scsi_qla_host_t *vha) 3578 { 3579 unsigned long cpu_flags = 0; 3580 int start_dpc = 0; 3581 int index; 3582 srb_t *sp; 3583 uint16_t w; 3584 struct qla_hw_data *ha = vha->hw; 3585 struct req_que *req; 3586 3587 if (ha->flags.eeh_busy) { 3588 qla2x00_restart_timer(vha, WATCH_INTERVAL); 3589 return; 3590 } 3591 3592 if (IS_QLA82XX(ha)) 3593 qla82xx_watchdog(vha); 3594 3595 /* Hardware read to raise pending EEH errors during mailbox waits. */ 3596 if (!pci_channel_offline(ha->pdev)) 3597 pci_read_config_word(ha->pdev, PCI_VENDOR_ID, &w); 3598 3599 /* Loop down handler. */ 3600 if (atomic_read(&vha->loop_down_timer) > 0 && 3601 !(test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags)) 3602 && vha->flags.online) { 3603 3604 if (atomic_read(&vha->loop_down_timer) == 3605 vha->loop_down_abort_time) { 3606 3607 DEBUG(printk("scsi(%ld): Loop Down - aborting the " 3608 "queues before time expire\n", 3609 vha->host_no)); 3610 3611 if (!IS_QLA2100(ha) && vha->link_down_timeout) 3612 atomic_set(&vha->loop_state, LOOP_DEAD); 3613 3614 /* 3615 * Schedule an ISP abort to return any FCP2-device 3616 * commands. 3617 */ 3618 /* NPIV - scan physical port only */ 3619 if (!vha->vp_idx) { 3620 spin_lock_irqsave(&ha->hardware_lock, 3621 cpu_flags); 3622 req = ha->req_q_map[0]; 3623 for (index = 1; 3624 index < MAX_OUTSTANDING_COMMANDS; 3625 index++) { 3626 fc_port_t *sfcp; 3627 3628 sp = req->outstanding_cmds[index]; 3629 if (!sp) 3630 continue; 3631 if (sp->ctx && !IS_PROT_IO(sp)) 3632 continue; 3633 sfcp = sp->fcport; 3634 if (!(sfcp->flags & FCF_FCP2_DEVICE)) 3635 continue; 3636 3637 set_bit(ISP_ABORT_NEEDED, 3638 &vha->dpc_flags); 3639 break; 3640 } 3641 spin_unlock_irqrestore(&ha->hardware_lock, 3642 cpu_flags); 3643 } 3644 start_dpc++; 3645 } 3646 3647 /* if the loop has been down for 4 minutes, reinit adapter */ 3648 if (atomic_dec_and_test(&vha->loop_down_timer) != 0) { 3649 if (!(vha->device_flags & DFLG_NO_CABLE)) { 3650 DEBUG(printk("scsi(%ld): Loop down - " 3651 "aborting ISP.\n", 3652 vha->host_no)); 3653 qla_printk(KERN_WARNING, ha, 3654 "Loop down - aborting ISP.\n"); 3655 3656 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags); 3657 } 3658 } 3659 DEBUG3(printk("scsi(%ld): Loop Down - seconds remaining %d\n", 3660 vha->host_no, 3661 atomic_read(&vha->loop_down_timer))); 3662 } 3663 3664 /* Check if beacon LED needs to be blinked */ 3665 if (ha->beacon_blink_led == 1) { 3666 set_bit(BEACON_BLINK_NEEDED, &vha->dpc_flags); 3667 start_dpc++; 3668 } 3669 3670 /* Process any deferred work. */ 3671 if (!list_empty(&vha->work_list)) 3672 start_dpc++; 3673 3674 /* Schedule the DPC routine if needed */ 3675 if ((test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags) || 3676 test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags) || 3677 test_bit(FCPORT_UPDATE_NEEDED, &vha->dpc_flags) || 3678 start_dpc || 3679 test_bit(RESET_MARKER_NEEDED, &vha->dpc_flags) || 3680 test_bit(BEACON_BLINK_NEEDED, &vha->dpc_flags) || 3681 test_bit(ISP_UNRECOVERABLE, &vha->dpc_flags) || 3682 test_bit(FCOE_CTX_RESET_NEEDED, &vha->dpc_flags) || 3683 test_bit(VP_DPC_NEEDED, &vha->dpc_flags) || 3684 test_bit(RELOGIN_NEEDED, &vha->dpc_flags))) 3685 qla2xxx_wake_dpc(vha); 3686 3687 qla2x00_restart_timer(vha, WATCH_INTERVAL); 3688 } 3689 3690 /* Firmware interface routines. */ 3691 3692 #define FW_BLOBS 8 3693 #define FW_ISP21XX 0 3694 #define FW_ISP22XX 1 3695 #define FW_ISP2300 2 3696 #define FW_ISP2322 3 3697 #define FW_ISP24XX 4 3698 #define FW_ISP25XX 5 3699 #define FW_ISP81XX 6 3700 #define FW_ISP82XX 7 3701 3702 #define FW_FILE_ISP21XX "ql2100_fw.bin" 3703 #define FW_FILE_ISP22XX "ql2200_fw.bin" 3704 #define FW_FILE_ISP2300 "ql2300_fw.bin" 3705 #define FW_FILE_ISP2322 "ql2322_fw.bin" 3706 #define FW_FILE_ISP24XX "ql2400_fw.bin" 3707 #define FW_FILE_ISP25XX "ql2500_fw.bin" 3708 #define FW_FILE_ISP81XX "ql8100_fw.bin" 3709 #define FW_FILE_ISP82XX "ql8200_fw.bin" 3710 3711 static DEFINE_MUTEX(qla_fw_lock); 3712 3713 static struct fw_blob qla_fw_blobs[FW_BLOBS] = { 3714 { .name = FW_FILE_ISP21XX, .segs = { 0x1000, 0 }, }, 3715 { .name = FW_FILE_ISP22XX, .segs = { 0x1000, 0 }, }, 3716 { .name = FW_FILE_ISP2300, .segs = { 0x800, 0 }, }, 3717 { .name = FW_FILE_ISP2322, .segs = { 0x800, 0x1c000, 0x1e000, 0 }, }, 3718 { .name = FW_FILE_ISP24XX, }, 3719 { .name = FW_FILE_ISP25XX, }, 3720 { .name = FW_FILE_ISP81XX, }, 3721 { .name = FW_FILE_ISP82XX, }, 3722 }; 3723 3724 struct fw_blob * 3725 qla2x00_request_firmware(scsi_qla_host_t *vha) 3726 { 3727 struct qla_hw_data *ha = vha->hw; 3728 struct fw_blob *blob; 3729 3730 blob = NULL; 3731 if (IS_QLA2100(ha)) { 3732 blob = &qla_fw_blobs[FW_ISP21XX]; 3733 } else if (IS_QLA2200(ha)) { 3734 blob = &qla_fw_blobs[FW_ISP22XX]; 3735 } else if (IS_QLA2300(ha) || IS_QLA2312(ha) || IS_QLA6312(ha)) { 3736 blob = &qla_fw_blobs[FW_ISP2300]; 3737 } else if (IS_QLA2322(ha) || IS_QLA6322(ha)) { 3738 blob = &qla_fw_blobs[FW_ISP2322]; 3739 } else if (IS_QLA24XX_TYPE(ha)) { 3740 blob = &qla_fw_blobs[FW_ISP24XX]; 3741 } else if (IS_QLA25XX(ha)) { 3742 blob = &qla_fw_blobs[FW_ISP25XX]; 3743 } else if (IS_QLA81XX(ha)) { 3744 blob = &qla_fw_blobs[FW_ISP81XX]; 3745 } else if (IS_QLA82XX(ha)) { 3746 blob = &qla_fw_blobs[FW_ISP82XX]; 3747 } 3748 3749 mutex_lock(&qla_fw_lock); 3750 if (blob->fw) 3751 goto out; 3752 3753 if (request_firmware(&blob->fw, blob->name, &ha->pdev->dev)) { 3754 DEBUG2(printk("scsi(%ld): Failed to load firmware image " 3755 "(%s).\n", vha->host_no, blob->name)); 3756 blob->fw = NULL; 3757 blob = NULL; 3758 goto out; 3759 } 3760 3761 out: 3762 mutex_unlock(&qla_fw_lock); 3763 return blob; 3764 } 3765 3766 static void 3767 qla2x00_release_firmware(void) 3768 { 3769 int idx; 3770 3771 mutex_lock(&qla_fw_lock); 3772 for (idx = 0; idx < FW_BLOBS; idx++) 3773 if (qla_fw_blobs[idx].fw) 3774 release_firmware(qla_fw_blobs[idx].fw); 3775 mutex_unlock(&qla_fw_lock); 3776 } 3777 3778 static pci_ers_result_t 3779 qla2xxx_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state) 3780 { 3781 scsi_qla_host_t *vha = pci_get_drvdata(pdev); 3782 struct qla_hw_data *ha = vha->hw; 3783 3784 DEBUG2(qla_printk(KERN_WARNING, ha, "error_detected:state %x\n", 3785 state)); 3786 3787 switch (state) { 3788 case pci_channel_io_normal: 3789 ha->flags.eeh_busy = 0; 3790 return PCI_ERS_RESULT_CAN_RECOVER; 3791 case pci_channel_io_frozen: 3792 ha->flags.eeh_busy = 1; 3793 /* For ISP82XX complete any pending mailbox cmd */ 3794 if (IS_QLA82XX(ha)) { 3795 ha->flags.fw_hung = 1; 3796 if (ha->flags.mbox_busy) { 3797 ha->flags.mbox_int = 1; 3798 DEBUG2(qla_printk(KERN_ERR, ha, 3799 "Due to pci channel io frozen, doing premature " 3800 "completion of mbx command\n")); 3801 complete(&ha->mbx_intr_comp); 3802 } 3803 } 3804 qla2x00_free_irqs(vha); 3805 pci_disable_device(pdev); 3806 /* Return back all IOs */ 3807 qla2x00_abort_all_cmds(vha, DID_RESET << 16); 3808 return PCI_ERS_RESULT_NEED_RESET; 3809 case pci_channel_io_perm_failure: 3810 ha->flags.pci_channel_io_perm_failure = 1; 3811 qla2x00_abort_all_cmds(vha, DID_NO_CONNECT << 16); 3812 return PCI_ERS_RESULT_DISCONNECT; 3813 } 3814 return PCI_ERS_RESULT_NEED_RESET; 3815 } 3816 3817 static pci_ers_result_t 3818 qla2xxx_pci_mmio_enabled(struct pci_dev *pdev) 3819 { 3820 int risc_paused = 0; 3821 uint32_t stat; 3822 unsigned long flags; 3823 scsi_qla_host_t *base_vha = pci_get_drvdata(pdev); 3824 struct qla_hw_data *ha = base_vha->hw; 3825 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp; 3826 struct device_reg_24xx __iomem *reg24 = &ha->iobase->isp24; 3827 3828 if (IS_QLA82XX(ha)) 3829 return PCI_ERS_RESULT_RECOVERED; 3830 3831 spin_lock_irqsave(&ha->hardware_lock, flags); 3832 if (IS_QLA2100(ha) || IS_QLA2200(ha)){ 3833 stat = RD_REG_DWORD(®->hccr); 3834 if (stat & HCCR_RISC_PAUSE) 3835 risc_paused = 1; 3836 } else if (IS_QLA23XX(ha)) { 3837 stat = RD_REG_DWORD(®->u.isp2300.host_status); 3838 if (stat & HSR_RISC_PAUSED) 3839 risc_paused = 1; 3840 } else if (IS_FWI2_CAPABLE(ha)) { 3841 stat = RD_REG_DWORD(®24->host_status); 3842 if (stat & HSRX_RISC_PAUSED) 3843 risc_paused = 1; 3844 } 3845 spin_unlock_irqrestore(&ha->hardware_lock, flags); 3846 3847 if (risc_paused) { 3848 qla_printk(KERN_INFO, ha, "RISC paused -- mmio_enabled, " 3849 "Dumping firmware!\n"); 3850 ha->isp_ops->fw_dump(base_vha, 0); 3851 3852 return PCI_ERS_RESULT_NEED_RESET; 3853 } else 3854 return PCI_ERS_RESULT_RECOVERED; 3855 } 3856 3857 uint32_t qla82xx_error_recovery(scsi_qla_host_t *base_vha) 3858 { 3859 uint32_t rval = QLA_FUNCTION_FAILED; 3860 uint32_t drv_active = 0; 3861 struct qla_hw_data *ha = base_vha->hw; 3862 int fn; 3863 struct pci_dev *other_pdev = NULL; 3864 3865 DEBUG17(qla_printk(KERN_INFO, ha, 3866 "scsi(%ld): In qla82xx_error_recovery\n", base_vha->host_no)); 3867 3868 set_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags); 3869 3870 if (base_vha->flags.online) { 3871 /* Abort all outstanding commands, 3872 * so as to be requeued later */ 3873 qla2x00_abort_isp_cleanup(base_vha); 3874 } 3875 3876 3877 fn = PCI_FUNC(ha->pdev->devfn); 3878 while (fn > 0) { 3879 fn--; 3880 DEBUG17(qla_printk(KERN_INFO, ha, 3881 "Finding pci device at function = 0x%x\n", fn)); 3882 other_pdev = 3883 pci_get_domain_bus_and_slot(pci_domain_nr(ha->pdev->bus), 3884 ha->pdev->bus->number, PCI_DEVFN(PCI_SLOT(ha->pdev->devfn), 3885 fn)); 3886 3887 if (!other_pdev) 3888 continue; 3889 if (atomic_read(&other_pdev->enable_cnt)) { 3890 DEBUG17(qla_printk(KERN_INFO, ha, 3891 "Found PCI func availabe and enabled at 0x%x\n", 3892 fn)); 3893 pci_dev_put(other_pdev); 3894 break; 3895 } 3896 pci_dev_put(other_pdev); 3897 } 3898 3899 if (!fn) { 3900 /* Reset owner */ 3901 DEBUG17(qla_printk(KERN_INFO, ha, 3902 "This devfn is reset owner = 0x%x\n", ha->pdev->devfn)); 3903 qla82xx_idc_lock(ha); 3904 3905 qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE, 3906 QLA82XX_DEV_INITIALIZING); 3907 3908 qla82xx_wr_32(ha, QLA82XX_CRB_DRV_IDC_VERSION, 3909 QLA82XX_IDC_VERSION); 3910 3911 drv_active = qla82xx_rd_32(ha, QLA82XX_CRB_DRV_ACTIVE); 3912 DEBUG17(qla_printk(KERN_INFO, ha, 3913 "drv_active = 0x%x\n", drv_active)); 3914 3915 qla82xx_idc_unlock(ha); 3916 /* Reset if device is not already reset 3917 * drv_active would be 0 if a reset has already been done 3918 */ 3919 if (drv_active) 3920 rval = qla82xx_start_firmware(base_vha); 3921 else 3922 rval = QLA_SUCCESS; 3923 qla82xx_idc_lock(ha); 3924 3925 if (rval != QLA_SUCCESS) { 3926 qla_printk(KERN_INFO, ha, "HW State: FAILED\n"); 3927 qla82xx_clear_drv_active(ha); 3928 qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE, 3929 QLA82XX_DEV_FAILED); 3930 } else { 3931 qla_printk(KERN_INFO, ha, "HW State: READY\n"); 3932 qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE, 3933 QLA82XX_DEV_READY); 3934 qla82xx_idc_unlock(ha); 3935 ha->flags.fw_hung = 0; 3936 rval = qla82xx_restart_isp(base_vha); 3937 qla82xx_idc_lock(ha); 3938 /* Clear driver state register */ 3939 qla82xx_wr_32(ha, QLA82XX_CRB_DRV_STATE, 0); 3940 qla82xx_set_drv_active(base_vha); 3941 } 3942 qla82xx_idc_unlock(ha); 3943 } else { 3944 DEBUG17(qla_printk(KERN_INFO, ha, 3945 "This devfn is not reset owner = 0x%x\n", ha->pdev->devfn)); 3946 if ((qla82xx_rd_32(ha, QLA82XX_CRB_DEV_STATE) == 3947 QLA82XX_DEV_READY)) { 3948 ha->flags.fw_hung = 0; 3949 rval = qla82xx_restart_isp(base_vha); 3950 qla82xx_idc_lock(ha); 3951 qla82xx_set_drv_active(base_vha); 3952 qla82xx_idc_unlock(ha); 3953 } 3954 } 3955 clear_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags); 3956 3957 return rval; 3958 } 3959 3960 static pci_ers_result_t 3961 qla2xxx_pci_slot_reset(struct pci_dev *pdev) 3962 { 3963 pci_ers_result_t ret = PCI_ERS_RESULT_DISCONNECT; 3964 scsi_qla_host_t *base_vha = pci_get_drvdata(pdev); 3965 struct qla_hw_data *ha = base_vha->hw; 3966 struct rsp_que *rsp; 3967 int rc, retries = 10; 3968 3969 DEBUG17(qla_printk(KERN_WARNING, ha, "slot_reset\n")); 3970 3971 /* Workaround: qla2xxx driver which access hardware earlier 3972 * needs error state to be pci_channel_io_online. 3973 * Otherwise mailbox command timesout. 3974 */ 3975 pdev->error_state = pci_channel_io_normal; 3976 3977 pci_restore_state(pdev); 3978 3979 /* pci_restore_state() clears the saved_state flag of the device 3980 * save restored state which resets saved_state flag 3981 */ 3982 pci_save_state(pdev); 3983 3984 if (ha->mem_only) 3985 rc = pci_enable_device_mem(pdev); 3986 else 3987 rc = pci_enable_device(pdev); 3988 3989 if (rc) { 3990 qla_printk(KERN_WARNING, ha, 3991 "Can't re-enable PCI device after reset.\n"); 3992 goto exit_slot_reset; 3993 } 3994 3995 rsp = ha->rsp_q_map[0]; 3996 if (qla2x00_request_irqs(ha, rsp)) 3997 goto exit_slot_reset; 3998 3999 if (ha->isp_ops->pci_config(base_vha)) 4000 goto exit_slot_reset; 4001 4002 if (IS_QLA82XX(ha)) { 4003 if (qla82xx_error_recovery(base_vha) == QLA_SUCCESS) { 4004 ret = PCI_ERS_RESULT_RECOVERED; 4005 goto exit_slot_reset; 4006 } else 4007 goto exit_slot_reset; 4008 } 4009 4010 while (ha->flags.mbox_busy && retries--) 4011 msleep(1000); 4012 4013 set_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags); 4014 if (ha->isp_ops->abort_isp(base_vha) == QLA_SUCCESS) 4015 ret = PCI_ERS_RESULT_RECOVERED; 4016 clear_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags); 4017 4018 4019 exit_slot_reset: 4020 DEBUG17(qla_printk(KERN_WARNING, ha, 4021 "slot_reset-return:ret=%x\n", ret)); 4022 4023 return ret; 4024 } 4025 4026 static void 4027 qla2xxx_pci_resume(struct pci_dev *pdev) 4028 { 4029 scsi_qla_host_t *base_vha = pci_get_drvdata(pdev); 4030 struct qla_hw_data *ha = base_vha->hw; 4031 int ret; 4032 4033 DEBUG17(qla_printk(KERN_WARNING, ha, "pci_resume\n")); 4034 4035 ret = qla2x00_wait_for_hba_online(base_vha); 4036 if (ret != QLA_SUCCESS) { 4037 qla_printk(KERN_ERR, ha, 4038 "the device failed to resume I/O " 4039 "from slot/link_reset"); 4040 } 4041 4042 pci_cleanup_aer_uncorrect_error_status(pdev); 4043 4044 ha->flags.eeh_busy = 0; 4045 } 4046 4047 static struct pci_error_handlers qla2xxx_err_handler = { 4048 .error_detected = qla2xxx_pci_error_detected, 4049 .mmio_enabled = qla2xxx_pci_mmio_enabled, 4050 .slot_reset = qla2xxx_pci_slot_reset, 4051 .resume = qla2xxx_pci_resume, 4052 }; 4053 4054 static struct pci_device_id qla2xxx_pci_tbl[] = { 4055 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2100) }, 4056 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2200) }, 4057 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2300) }, 4058 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2312) }, 4059 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2322) }, 4060 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP6312) }, 4061 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP6322) }, 4062 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2422) }, 4063 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2432) }, 4064 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP8432) }, 4065 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP5422) }, 4066 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP5432) }, 4067 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2532) }, 4068 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP8001) }, 4069 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP8021) }, 4070 { 0 }, 4071 }; 4072 MODULE_DEVICE_TABLE(pci, qla2xxx_pci_tbl); 4073 4074 static struct pci_driver qla2xxx_pci_driver = { 4075 .name = QLA2XXX_DRIVER_NAME, 4076 .driver = { 4077 .owner = THIS_MODULE, 4078 }, 4079 .id_table = qla2xxx_pci_tbl, 4080 .probe = qla2x00_probe_one, 4081 .remove = qla2x00_remove_one, 4082 .shutdown = qla2x00_shutdown, 4083 .err_handler = &qla2xxx_err_handler, 4084 }; 4085 4086 static struct file_operations apidev_fops = { 4087 .owner = THIS_MODULE, 4088 .llseek = noop_llseek, 4089 }; 4090 4091 /** 4092 * qla2x00_module_init - Module initialization. 4093 **/ 4094 static int __init 4095 qla2x00_module_init(void) 4096 { 4097 int ret = 0; 4098 4099 /* Allocate cache for SRBs. */ 4100 srb_cachep = kmem_cache_create("qla2xxx_srbs", sizeof(srb_t), 0, 4101 SLAB_HWCACHE_ALIGN, NULL); 4102 if (srb_cachep == NULL) { 4103 printk(KERN_ERR 4104 "qla2xxx: Unable to allocate SRB cache...Failing load!\n"); 4105 return -ENOMEM; 4106 } 4107 4108 /* Derive version string. */ 4109 strcpy(qla2x00_version_str, QLA2XXX_VERSION); 4110 if (ql2xextended_error_logging) 4111 strcat(qla2x00_version_str, "-debug"); 4112 4113 qla2xxx_transport_template = 4114 fc_attach_transport(&qla2xxx_transport_functions); 4115 if (!qla2xxx_transport_template) { 4116 kmem_cache_destroy(srb_cachep); 4117 return -ENODEV; 4118 } 4119 4120 apidev_major = register_chrdev(0, QLA2XXX_APIDEV, &apidev_fops); 4121 if (apidev_major < 0) { 4122 printk(KERN_WARNING "qla2xxx: Unable to register char device " 4123 "%s\n", QLA2XXX_APIDEV); 4124 } 4125 4126 qla2xxx_transport_vport_template = 4127 fc_attach_transport(&qla2xxx_transport_vport_functions); 4128 if (!qla2xxx_transport_vport_template) { 4129 kmem_cache_destroy(srb_cachep); 4130 fc_release_transport(qla2xxx_transport_template); 4131 return -ENODEV; 4132 } 4133 4134 printk(KERN_INFO "QLogic Fibre Channel HBA Driver: %s\n", 4135 qla2x00_version_str); 4136 ret = pci_register_driver(&qla2xxx_pci_driver); 4137 if (ret) { 4138 kmem_cache_destroy(srb_cachep); 4139 fc_release_transport(qla2xxx_transport_template); 4140 fc_release_transport(qla2xxx_transport_vport_template); 4141 } 4142 return ret; 4143 } 4144 4145 /** 4146 * qla2x00_module_exit - Module cleanup. 4147 **/ 4148 static void __exit 4149 qla2x00_module_exit(void) 4150 { 4151 unregister_chrdev(apidev_major, QLA2XXX_APIDEV); 4152 pci_unregister_driver(&qla2xxx_pci_driver); 4153 qla2x00_release_firmware(); 4154 kmem_cache_destroy(srb_cachep); 4155 if (ctx_cachep) 4156 kmem_cache_destroy(ctx_cachep); 4157 fc_release_transport(qla2xxx_transport_template); 4158 fc_release_transport(qla2xxx_transport_vport_template); 4159 } 4160 4161 module_init(qla2x00_module_init); 4162 module_exit(qla2x00_module_exit); 4163 4164 MODULE_AUTHOR("QLogic Corporation"); 4165 MODULE_DESCRIPTION("QLogic Fibre Channel HBA Driver"); 4166 MODULE_LICENSE("GPL"); 4167 MODULE_VERSION(QLA2XXX_VERSION); 4168 MODULE_FIRMWARE(FW_FILE_ISP21XX); 4169 MODULE_FIRMWARE(FW_FILE_ISP22XX); 4170 MODULE_FIRMWARE(FW_FILE_ISP2300); 4171 MODULE_FIRMWARE(FW_FILE_ISP2322); 4172 MODULE_FIRMWARE(FW_FILE_ISP24XX); 4173 MODULE_FIRMWARE(FW_FILE_ISP25XX); 4174