1 /* 2 * QLogic Fibre Channel HBA Driver 3 * Copyright (c) 2003-2008 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 15 #include <scsi/scsi_tcq.h> 16 #include <scsi/scsicam.h> 17 #include <scsi/scsi_transport.h> 18 #include <scsi/scsi_transport_fc.h> 19 20 /* 21 * Driver version 22 */ 23 char qla2x00_version_str[40]; 24 25 /* 26 * SRB allocation cache 27 */ 28 static struct kmem_cache *srb_cachep; 29 30 int ql2xlogintimeout = 20; 31 module_param(ql2xlogintimeout, int, S_IRUGO|S_IRUSR); 32 MODULE_PARM_DESC(ql2xlogintimeout, 33 "Login timeout value in seconds."); 34 35 int qlport_down_retry; 36 module_param(qlport_down_retry, int, S_IRUGO|S_IRUSR); 37 MODULE_PARM_DESC(qlport_down_retry, 38 "Maximum number of command retries to a port that returns " 39 "a PORT-DOWN status."); 40 41 int ql2xplogiabsentdevice; 42 module_param(ql2xplogiabsentdevice, int, S_IRUGO|S_IWUSR); 43 MODULE_PARM_DESC(ql2xplogiabsentdevice, 44 "Option to enable PLOGI to devices that are not present after " 45 "a Fabric scan. This is needed for several broken switches. " 46 "Default is 0 - no PLOGI. 1 - perfom PLOGI."); 47 48 int ql2xloginretrycount = 0; 49 module_param(ql2xloginretrycount, int, S_IRUGO|S_IRUSR); 50 MODULE_PARM_DESC(ql2xloginretrycount, 51 "Specify an alternate value for the NVRAM login retry count."); 52 53 int ql2xallocfwdump = 1; 54 module_param(ql2xallocfwdump, int, S_IRUGO|S_IRUSR); 55 MODULE_PARM_DESC(ql2xallocfwdump, 56 "Option to enable allocation of memory for a firmware dump " 57 "during HBA initialization. Memory allocation requirements " 58 "vary by ISP type. Default is 1 - allocate memory."); 59 60 int ql2xextended_error_logging; 61 module_param(ql2xextended_error_logging, int, S_IRUGO|S_IWUSR); 62 MODULE_PARM_DESC(ql2xextended_error_logging, 63 "Option to enable extended error logging, " 64 "Default is 0 - no logging. 1 - log errors."); 65 66 static void qla2x00_free_device(scsi_qla_host_t *); 67 68 int ql2xfdmienable=1; 69 module_param(ql2xfdmienable, int, S_IRUGO|S_IRUSR); 70 MODULE_PARM_DESC(ql2xfdmienable, 71 "Enables FDMI registratons " 72 "Default is 0 - no FDMI. 1 - perfom FDMI."); 73 74 #define MAX_Q_DEPTH 32 75 static int ql2xmaxqdepth = MAX_Q_DEPTH; 76 module_param(ql2xmaxqdepth, int, S_IRUGO|S_IWUSR); 77 MODULE_PARM_DESC(ql2xmaxqdepth, 78 "Maximum queue depth to report for target devices."); 79 80 int ql2xqfullrampup = 120; 81 module_param(ql2xqfullrampup, int, S_IRUGO|S_IWUSR); 82 MODULE_PARM_DESC(ql2xqfullrampup, 83 "Number of seconds to wait to begin to ramp-up the queue " 84 "depth for a device after a queue-full condition has been " 85 "detected. Default is 120 seconds."); 86 87 int ql2xiidmaenable=1; 88 module_param(ql2xiidmaenable, int, S_IRUGO|S_IRUSR); 89 MODULE_PARM_DESC(ql2xiidmaenable, 90 "Enables iIDMA settings " 91 "Default is 1 - perform iIDMA. 0 - no iIDMA."); 92 93 int ql2xmaxqueues = 1; 94 module_param(ql2xmaxqueues, int, S_IRUGO|S_IRUSR); 95 MODULE_PARM_DESC(ql2xmaxqueues, 96 "Enables MQ settings " 97 "Default is 1 for single queue. Set it to number \ 98 of queues in MQ mode."); 99 /* 100 * SCSI host template entry points 101 */ 102 static int qla2xxx_slave_configure(struct scsi_device * device); 103 static int qla2xxx_slave_alloc(struct scsi_device *); 104 static int qla2xxx_scan_finished(struct Scsi_Host *, unsigned long time); 105 static void qla2xxx_scan_start(struct Scsi_Host *); 106 static void qla2xxx_slave_destroy(struct scsi_device *); 107 static int qla2x00_queuecommand(struct scsi_cmnd *cmd, 108 void (*fn)(struct scsi_cmnd *)); 109 static int qla24xx_queuecommand(struct scsi_cmnd *cmd, 110 void (*fn)(struct scsi_cmnd *)); 111 static int qla2xxx_eh_abort(struct scsi_cmnd *); 112 static int qla2xxx_eh_device_reset(struct scsi_cmnd *); 113 static int qla2xxx_eh_target_reset(struct scsi_cmnd *); 114 static int qla2xxx_eh_bus_reset(struct scsi_cmnd *); 115 static int qla2xxx_eh_host_reset(struct scsi_cmnd *); 116 117 static int qla2x00_change_queue_depth(struct scsi_device *, int); 118 static int qla2x00_change_queue_type(struct scsi_device *, int); 119 120 static struct scsi_host_template qla2x00_driver_template = { 121 .module = THIS_MODULE, 122 .name = QLA2XXX_DRIVER_NAME, 123 .queuecommand = qla2x00_queuecommand, 124 125 .eh_abort_handler = qla2xxx_eh_abort, 126 .eh_device_reset_handler = qla2xxx_eh_device_reset, 127 .eh_target_reset_handler = qla2xxx_eh_target_reset, 128 .eh_bus_reset_handler = qla2xxx_eh_bus_reset, 129 .eh_host_reset_handler = qla2xxx_eh_host_reset, 130 131 .slave_configure = qla2xxx_slave_configure, 132 133 .slave_alloc = qla2xxx_slave_alloc, 134 .slave_destroy = qla2xxx_slave_destroy, 135 .scan_finished = qla2xxx_scan_finished, 136 .scan_start = qla2xxx_scan_start, 137 .change_queue_depth = qla2x00_change_queue_depth, 138 .change_queue_type = qla2x00_change_queue_type, 139 .this_id = -1, 140 .cmd_per_lun = 3, 141 .use_clustering = ENABLE_CLUSTERING, 142 .sg_tablesize = SG_ALL, 143 144 /* 145 * The RISC allows for each command to transfer (2^32-1) bytes of data, 146 * which equates to 0x800000 sectors. 147 */ 148 .max_sectors = 0xFFFF, 149 .shost_attrs = qla2x00_host_attrs, 150 }; 151 152 struct scsi_host_template qla24xx_driver_template = { 153 .module = THIS_MODULE, 154 .name = QLA2XXX_DRIVER_NAME, 155 .queuecommand = qla24xx_queuecommand, 156 157 .eh_abort_handler = qla2xxx_eh_abort, 158 .eh_device_reset_handler = qla2xxx_eh_device_reset, 159 .eh_target_reset_handler = qla2xxx_eh_target_reset, 160 .eh_bus_reset_handler = qla2xxx_eh_bus_reset, 161 .eh_host_reset_handler = qla2xxx_eh_host_reset, 162 163 .slave_configure = qla2xxx_slave_configure, 164 165 .slave_alloc = qla2xxx_slave_alloc, 166 .slave_destroy = qla2xxx_slave_destroy, 167 .scan_finished = qla2xxx_scan_finished, 168 .scan_start = qla2xxx_scan_start, 169 .change_queue_depth = qla2x00_change_queue_depth, 170 .change_queue_type = qla2x00_change_queue_type, 171 .this_id = -1, 172 .cmd_per_lun = 3, 173 .use_clustering = ENABLE_CLUSTERING, 174 .sg_tablesize = SG_ALL, 175 176 .max_sectors = 0xFFFF, 177 .shost_attrs = qla2x00_host_attrs, 178 }; 179 180 static struct scsi_transport_template *qla2xxx_transport_template = NULL; 181 struct scsi_transport_template *qla2xxx_transport_vport_template = NULL; 182 183 /* TODO Convert to inlines 184 * 185 * Timer routines 186 */ 187 188 __inline__ void 189 qla2x00_start_timer(scsi_qla_host_t *vha, void *func, unsigned long interval) 190 { 191 init_timer(&vha->timer); 192 vha->timer.expires = jiffies + interval * HZ; 193 vha->timer.data = (unsigned long)vha; 194 vha->timer.function = (void (*)(unsigned long))func; 195 add_timer(&vha->timer); 196 vha->timer_active = 1; 197 } 198 199 static inline void 200 qla2x00_restart_timer(scsi_qla_host_t *vha, unsigned long interval) 201 { 202 mod_timer(&vha->timer, jiffies + interval * HZ); 203 } 204 205 static __inline__ void 206 qla2x00_stop_timer(scsi_qla_host_t *vha) 207 { 208 del_timer_sync(&vha->timer); 209 vha->timer_active = 0; 210 } 211 212 static int qla2x00_do_dpc(void *data); 213 214 static void qla2x00_rst_aen(scsi_qla_host_t *); 215 216 static int qla2x00_mem_alloc(struct qla_hw_data *, uint16_t, uint16_t, 217 struct req_que **, struct rsp_que **); 218 static void qla2x00_mem_free(struct qla_hw_data *); 219 static void qla2x00_sp_free_dma(srb_t *); 220 221 /* -------------------------------------------------------------------------- */ 222 static int qla2x00_alloc_queues(struct qla_hw_data *ha) 223 { 224 ha->req_q_map = kzalloc(sizeof(struct req_que *) * ha->max_queues, 225 GFP_KERNEL); 226 if (!ha->req_q_map) { 227 qla_printk(KERN_WARNING, ha, 228 "Unable to allocate memory for request queue ptrs\n"); 229 goto fail_req_map; 230 } 231 232 ha->rsp_q_map = kzalloc(sizeof(struct rsp_que *) * ha->max_queues, 233 GFP_KERNEL); 234 if (!ha->rsp_q_map) { 235 qla_printk(KERN_WARNING, ha, 236 "Unable to allocate memory for response queue ptrs\n"); 237 goto fail_rsp_map; 238 } 239 set_bit(0, ha->rsp_qid_map); 240 set_bit(0, ha->req_qid_map); 241 return 1; 242 243 fail_rsp_map: 244 kfree(ha->req_q_map); 245 ha->req_q_map = NULL; 246 fail_req_map: 247 return -ENOMEM; 248 } 249 250 static void qla2x00_free_que(struct qla_hw_data *ha, struct req_que *req, 251 struct rsp_que *rsp) 252 { 253 if (rsp && rsp->ring) 254 dma_free_coherent(&ha->pdev->dev, 255 (rsp->length + 1) * sizeof(response_t), 256 rsp->ring, rsp->dma); 257 258 kfree(rsp); 259 rsp = NULL; 260 if (req && req->ring) 261 dma_free_coherent(&ha->pdev->dev, 262 (req->length + 1) * sizeof(request_t), 263 req->ring, req->dma); 264 265 kfree(req); 266 req = NULL; 267 } 268 269 static void qla2x00_free_queues(struct qla_hw_data *ha) 270 { 271 struct req_que *req; 272 struct rsp_que *rsp; 273 int cnt; 274 275 for (cnt = 0; cnt < ha->max_queues; cnt++) { 276 rsp = ha->rsp_q_map[cnt]; 277 req = ha->req_q_map[cnt]; 278 qla2x00_free_que(ha, req, rsp); 279 } 280 kfree(ha->rsp_q_map); 281 ha->rsp_q_map = NULL; 282 283 kfree(ha->req_q_map); 284 ha->req_q_map = NULL; 285 } 286 287 static char * 288 qla2x00_pci_info_str(struct scsi_qla_host *vha, char *str) 289 { 290 struct qla_hw_data *ha = vha->hw; 291 static char *pci_bus_modes[] = { 292 "33", "66", "100", "133", 293 }; 294 uint16_t pci_bus; 295 296 strcpy(str, "PCI"); 297 pci_bus = (ha->pci_attr & (BIT_9 | BIT_10)) >> 9; 298 if (pci_bus) { 299 strcat(str, "-X ("); 300 strcat(str, pci_bus_modes[pci_bus]); 301 } else { 302 pci_bus = (ha->pci_attr & BIT_8) >> 8; 303 strcat(str, " ("); 304 strcat(str, pci_bus_modes[pci_bus]); 305 } 306 strcat(str, " MHz)"); 307 308 return (str); 309 } 310 311 static char * 312 qla24xx_pci_info_str(struct scsi_qla_host *vha, char *str) 313 { 314 static char *pci_bus_modes[] = { "33", "66", "100", "133", }; 315 struct qla_hw_data *ha = vha->hw; 316 uint32_t pci_bus; 317 int pcie_reg; 318 319 pcie_reg = pci_find_capability(ha->pdev, PCI_CAP_ID_EXP); 320 if (pcie_reg) { 321 char lwstr[6]; 322 uint16_t pcie_lstat, lspeed, lwidth; 323 324 pcie_reg += 0x12; 325 pci_read_config_word(ha->pdev, pcie_reg, &pcie_lstat); 326 lspeed = pcie_lstat & (BIT_0 | BIT_1 | BIT_2 | BIT_3); 327 lwidth = (pcie_lstat & 328 (BIT_4 | BIT_5 | BIT_6 | BIT_7 | BIT_8 | BIT_9)) >> 4; 329 330 strcpy(str, "PCIe ("); 331 if (lspeed == 1) 332 strcat(str, "2.5GT/s "); 333 else if (lspeed == 2) 334 strcat(str, "5.0GT/s "); 335 else 336 strcat(str, "<unknown> "); 337 snprintf(lwstr, sizeof(lwstr), "x%d)", lwidth); 338 strcat(str, lwstr); 339 340 return str; 341 } 342 343 strcpy(str, "PCI"); 344 pci_bus = (ha->pci_attr & CSRX_PCIX_BUS_MODE_MASK) >> 8; 345 if (pci_bus == 0 || pci_bus == 8) { 346 strcat(str, " ("); 347 strcat(str, pci_bus_modes[pci_bus >> 3]); 348 } else { 349 strcat(str, "-X "); 350 if (pci_bus & BIT_2) 351 strcat(str, "Mode 2"); 352 else 353 strcat(str, "Mode 1"); 354 strcat(str, " ("); 355 strcat(str, pci_bus_modes[pci_bus & ~BIT_2]); 356 } 357 strcat(str, " MHz)"); 358 359 return str; 360 } 361 362 static char * 363 qla2x00_fw_version_str(struct scsi_qla_host *vha, char *str) 364 { 365 char un_str[10]; 366 struct qla_hw_data *ha = vha->hw; 367 368 sprintf(str, "%d.%02d.%02d ", ha->fw_major_version, 369 ha->fw_minor_version, 370 ha->fw_subminor_version); 371 372 if (ha->fw_attributes & BIT_9) { 373 strcat(str, "FLX"); 374 return (str); 375 } 376 377 switch (ha->fw_attributes & 0xFF) { 378 case 0x7: 379 strcat(str, "EF"); 380 break; 381 case 0x17: 382 strcat(str, "TP"); 383 break; 384 case 0x37: 385 strcat(str, "IP"); 386 break; 387 case 0x77: 388 strcat(str, "VI"); 389 break; 390 default: 391 sprintf(un_str, "(%x)", ha->fw_attributes); 392 strcat(str, un_str); 393 break; 394 } 395 if (ha->fw_attributes & 0x100) 396 strcat(str, "X"); 397 398 return (str); 399 } 400 401 static char * 402 qla24xx_fw_version_str(struct scsi_qla_host *vha, char *str) 403 { 404 struct qla_hw_data *ha = vha->hw; 405 406 sprintf(str, "%d.%02d.%02d (%x)", ha->fw_major_version, 407 ha->fw_minor_version, ha->fw_subminor_version, ha->fw_attributes); 408 return str; 409 } 410 411 static inline srb_t * 412 qla2x00_get_new_sp(scsi_qla_host_t *vha, fc_port_t *fcport, 413 struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *)) 414 { 415 srb_t *sp; 416 struct qla_hw_data *ha = vha->hw; 417 418 sp = mempool_alloc(ha->srb_mempool, GFP_ATOMIC); 419 if (!sp) 420 return sp; 421 422 sp->fcport = fcport; 423 sp->cmd = cmd; 424 sp->que = ha->req_q_map[0]; 425 sp->flags = 0; 426 CMD_SP(cmd) = (void *)sp; 427 cmd->scsi_done = done; 428 429 return sp; 430 } 431 432 static int 433 qla2x00_queuecommand(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *)) 434 { 435 scsi_qla_host_t *vha = shost_priv(cmd->device->host); 436 fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata; 437 struct fc_rport *rport = starget_to_rport(scsi_target(cmd->device)); 438 struct qla_hw_data *ha = vha->hw; 439 srb_t *sp; 440 int rval; 441 442 if (unlikely(pci_channel_offline(ha->pdev))) { 443 cmd->result = DID_REQUEUE << 16; 444 goto qc_fail_command; 445 } 446 447 rval = fc_remote_port_chkready(rport); 448 if (rval) { 449 cmd->result = rval; 450 goto qc_fail_command; 451 } 452 453 /* Close window on fcport/rport state-transitioning. */ 454 if (fcport->drport) 455 goto qc_target_busy; 456 457 if (atomic_read(&fcport->state) != FCS_ONLINE) { 458 if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD || 459 atomic_read(&vha->loop_state) == LOOP_DEAD) { 460 cmd->result = DID_NO_CONNECT << 16; 461 goto qc_fail_command; 462 } 463 goto qc_target_busy; 464 } 465 466 spin_unlock_irq(vha->host->host_lock); 467 468 sp = qla2x00_get_new_sp(vha, fcport, cmd, done); 469 if (!sp) 470 goto qc_host_busy_lock; 471 472 rval = ha->isp_ops->start_scsi(sp); 473 if (rval != QLA_SUCCESS) 474 goto qc_host_busy_free_sp; 475 476 spin_lock_irq(vha->host->host_lock); 477 478 return 0; 479 480 qc_host_busy_free_sp: 481 qla2x00_sp_free_dma(sp); 482 mempool_free(sp, ha->srb_mempool); 483 484 qc_host_busy_lock: 485 spin_lock_irq(vha->host->host_lock); 486 return SCSI_MLQUEUE_HOST_BUSY; 487 488 qc_target_busy: 489 return SCSI_MLQUEUE_TARGET_BUSY; 490 491 qc_fail_command: 492 done(cmd); 493 494 return 0; 495 } 496 497 498 static int 499 qla24xx_queuecommand(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *)) 500 { 501 scsi_qla_host_t *vha = shost_priv(cmd->device->host); 502 fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata; 503 struct fc_rport *rport = starget_to_rport(scsi_target(cmd->device)); 504 struct qla_hw_data *ha = vha->hw; 505 struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev); 506 srb_t *sp; 507 int rval; 508 509 if (unlikely(pci_channel_offline(ha->pdev))) { 510 cmd->result = DID_REQUEUE << 16; 511 goto qc24_fail_command; 512 } 513 514 rval = fc_remote_port_chkready(rport); 515 if (rval) { 516 cmd->result = rval; 517 goto qc24_fail_command; 518 } 519 520 /* Close window on fcport/rport state-transitioning. */ 521 if (fcport->drport) 522 goto qc24_target_busy; 523 524 if (atomic_read(&fcport->state) != FCS_ONLINE) { 525 if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD || 526 atomic_read(&base_vha->loop_state) == LOOP_DEAD) { 527 cmd->result = DID_NO_CONNECT << 16; 528 goto qc24_fail_command; 529 } 530 goto qc24_target_busy; 531 } 532 533 spin_unlock_irq(vha->host->host_lock); 534 535 sp = qla2x00_get_new_sp(base_vha, fcport, cmd, done); 536 if (!sp) 537 goto qc24_host_busy_lock; 538 539 rval = ha->isp_ops->start_scsi(sp); 540 if (rval != QLA_SUCCESS) 541 goto qc24_host_busy_free_sp; 542 543 spin_lock_irq(vha->host->host_lock); 544 545 return 0; 546 547 qc24_host_busy_free_sp: 548 qla2x00_sp_free_dma(sp); 549 mempool_free(sp, ha->srb_mempool); 550 551 qc24_host_busy_lock: 552 spin_lock_irq(vha->host->host_lock); 553 return SCSI_MLQUEUE_HOST_BUSY; 554 555 qc24_target_busy: 556 return SCSI_MLQUEUE_TARGET_BUSY; 557 558 qc24_fail_command: 559 done(cmd); 560 561 return 0; 562 } 563 564 565 /* 566 * qla2x00_eh_wait_on_command 567 * Waits for the command to be returned by the Firmware for some 568 * max time. 569 * 570 * Input: 571 * cmd = Scsi Command to wait on. 572 * 573 * Return: 574 * Not Found : 0 575 * Found : 1 576 */ 577 static int 578 qla2x00_eh_wait_on_command(struct scsi_cmnd *cmd) 579 { 580 #define ABORT_POLLING_PERIOD 1000 581 #define ABORT_WAIT_ITER ((10 * 1000) / (ABORT_POLLING_PERIOD)) 582 unsigned long wait_iter = ABORT_WAIT_ITER; 583 int ret = QLA_SUCCESS; 584 585 while (CMD_SP(cmd)) { 586 msleep(ABORT_POLLING_PERIOD); 587 588 if (--wait_iter) 589 break; 590 } 591 if (CMD_SP(cmd)) 592 ret = QLA_FUNCTION_FAILED; 593 594 return ret; 595 } 596 597 /* 598 * qla2x00_wait_for_hba_online 599 * Wait till the HBA is online after going through 600 * <= MAX_RETRIES_OF_ISP_ABORT or 601 * finally HBA is disabled ie marked offline 602 * 603 * Input: 604 * ha - pointer to host adapter structure 605 * 606 * Note: 607 * Does context switching-Release SPIN_LOCK 608 * (if any) before calling this routine. 609 * 610 * Return: 611 * Success (Adapter is online) : 0 612 * Failed (Adapter is offline/disabled) : 1 613 */ 614 int 615 qla2x00_wait_for_hba_online(scsi_qla_host_t *vha) 616 { 617 int return_status; 618 unsigned long wait_online; 619 struct qla_hw_data *ha = vha->hw; 620 scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev); 621 622 wait_online = jiffies + (MAX_LOOP_TIMEOUT * HZ); 623 while (((test_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags)) || 624 test_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags) || 625 test_bit(ISP_ABORT_RETRY, &base_vha->dpc_flags) || 626 ha->dpc_active) && time_before(jiffies, wait_online)) { 627 628 msleep(1000); 629 } 630 if (base_vha->flags.online) 631 return_status = QLA_SUCCESS; 632 else 633 return_status = QLA_FUNCTION_FAILED; 634 635 return (return_status); 636 } 637 638 /* 639 * qla2x00_wait_for_loop_ready 640 * Wait for MAX_LOOP_TIMEOUT(5 min) value for loop 641 * to be in LOOP_READY state. 642 * Input: 643 * ha - pointer to host adapter structure 644 * 645 * Note: 646 * Does context switching-Release SPIN_LOCK 647 * (if any) before calling this routine. 648 * 649 * 650 * Return: 651 * Success (LOOP_READY) : 0 652 * Failed (LOOP_NOT_READY) : 1 653 */ 654 static inline int 655 qla2x00_wait_for_loop_ready(scsi_qla_host_t *vha) 656 { 657 int return_status = QLA_SUCCESS; 658 unsigned long loop_timeout ; 659 struct qla_hw_data *ha = vha->hw; 660 scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev); 661 662 /* wait for 5 min at the max for loop to be ready */ 663 loop_timeout = jiffies + (MAX_LOOP_TIMEOUT * HZ); 664 665 while ((!atomic_read(&base_vha->loop_down_timer) && 666 atomic_read(&base_vha->loop_state) == LOOP_DOWN) || 667 atomic_read(&base_vha->loop_state) != LOOP_READY) { 668 if (atomic_read(&base_vha->loop_state) == LOOP_DEAD) { 669 return_status = QLA_FUNCTION_FAILED; 670 break; 671 } 672 msleep(1000); 673 if (time_after_eq(jiffies, loop_timeout)) { 674 return_status = QLA_FUNCTION_FAILED; 675 break; 676 } 677 } 678 return (return_status); 679 } 680 681 void 682 qla2x00_abort_fcport_cmds(fc_port_t *fcport) 683 { 684 int cnt, que, id; 685 unsigned long flags; 686 srb_t *sp; 687 scsi_qla_host_t *vha = fcport->vha; 688 struct qla_hw_data *ha = vha->hw; 689 struct req_que *req; 690 691 spin_lock_irqsave(&ha->hardware_lock, flags); 692 for (que = 0; que < QLA_MAX_HOST_QUES; que++) { 693 id = vha->req_ques[que]; 694 req = ha->req_q_map[id]; 695 if (!req) 696 continue; 697 for (cnt = 1; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) { 698 sp = req->outstanding_cmds[cnt]; 699 if (!sp) 700 continue; 701 if (sp->fcport != fcport) 702 continue; 703 704 spin_unlock_irqrestore(&ha->hardware_lock, flags); 705 if (ha->isp_ops->abort_command(vha, sp, req)) { 706 DEBUG2(qla_printk(KERN_WARNING, ha, 707 "Abort failed -- %lx\n", 708 sp->cmd->serial_number)); 709 } else { 710 if (qla2x00_eh_wait_on_command(sp->cmd) != 711 QLA_SUCCESS) 712 DEBUG2(qla_printk(KERN_WARNING, ha, 713 "Abort failed while waiting -- %lx\n", 714 sp->cmd->serial_number)); 715 } 716 spin_lock_irqsave(&ha->hardware_lock, flags); 717 } 718 } 719 spin_unlock_irqrestore(&ha->hardware_lock, flags); 720 } 721 722 static void 723 qla2x00_block_error_handler(struct scsi_cmnd *cmnd) 724 { 725 struct Scsi_Host *shost = cmnd->device->host; 726 struct fc_rport *rport = starget_to_rport(scsi_target(cmnd->device)); 727 unsigned long flags; 728 729 spin_lock_irqsave(shost->host_lock, flags); 730 while (rport->port_state == FC_PORTSTATE_BLOCKED) { 731 spin_unlock_irqrestore(shost->host_lock, flags); 732 msleep(1000); 733 spin_lock_irqsave(shost->host_lock, flags); 734 } 735 spin_unlock_irqrestore(shost->host_lock, flags); 736 return; 737 } 738 739 /************************************************************************** 740 * qla2xxx_eh_abort 741 * 742 * Description: 743 * The abort function will abort the specified command. 744 * 745 * Input: 746 * cmd = Linux SCSI command packet to be aborted. 747 * 748 * Returns: 749 * Either SUCCESS or FAILED. 750 * 751 * Note: 752 * Only return FAILED if command not returned by firmware. 753 **************************************************************************/ 754 static int 755 qla2xxx_eh_abort(struct scsi_cmnd *cmd) 756 { 757 scsi_qla_host_t *vha = shost_priv(cmd->device->host); 758 srb_t *sp; 759 int ret, i; 760 unsigned int id, lun; 761 unsigned long serial; 762 unsigned long flags; 763 int wait = 0; 764 struct qla_hw_data *ha = vha->hw; 765 struct req_que *req; 766 srb_t *spt; 767 768 qla2x00_block_error_handler(cmd); 769 770 if (!CMD_SP(cmd)) 771 return SUCCESS; 772 773 ret = SUCCESS; 774 775 id = cmd->device->id; 776 lun = cmd->device->lun; 777 serial = cmd->serial_number; 778 spt = (srb_t *) CMD_SP(cmd); 779 if (!spt) 780 return SUCCESS; 781 req = spt->que; 782 783 /* Check active list for command command. */ 784 spin_lock_irqsave(&ha->hardware_lock, flags); 785 for (i = 1; i < MAX_OUTSTANDING_COMMANDS; i++) { 786 sp = req->outstanding_cmds[i]; 787 788 if (sp == NULL) 789 continue; 790 791 if (sp->cmd != cmd) 792 continue; 793 794 DEBUG2(printk("%s(%ld): aborting sp %p from RISC." 795 " pid=%ld.\n", __func__, vha->host_no, sp, serial)); 796 797 spin_unlock_irqrestore(&ha->hardware_lock, flags); 798 if (ha->isp_ops->abort_command(vha, sp, req)) { 799 DEBUG2(printk("%s(%ld): abort_command " 800 "mbx failed.\n", __func__, vha->host_no)); 801 ret = FAILED; 802 } else { 803 DEBUG3(printk("%s(%ld): abort_command " 804 "mbx success.\n", __func__, vha->host_no)); 805 wait = 1; 806 } 807 spin_lock_irqsave(&ha->hardware_lock, flags); 808 break; 809 } 810 spin_unlock_irqrestore(&ha->hardware_lock, flags); 811 812 /* Wait for the command to be returned. */ 813 if (wait) { 814 if (qla2x00_eh_wait_on_command(cmd) != QLA_SUCCESS) { 815 qla_printk(KERN_ERR, ha, 816 "scsi(%ld:%d:%d): Abort handler timed out -- %lx " 817 "%x.\n", vha->host_no, id, lun, serial, ret); 818 ret = FAILED; 819 } 820 } 821 822 qla_printk(KERN_INFO, ha, 823 "scsi(%ld:%d:%d): Abort command issued -- %d %lx %x.\n", 824 vha->host_no, id, lun, wait, serial, ret); 825 826 return ret; 827 } 828 829 enum nexus_wait_type { 830 WAIT_HOST = 0, 831 WAIT_TARGET, 832 WAIT_LUN, 833 }; 834 835 static int 836 qla2x00_eh_wait_for_pending_commands(scsi_qla_host_t *vha, unsigned int t, 837 unsigned int l, srb_t *sp, enum nexus_wait_type type) 838 { 839 int cnt, match, status; 840 unsigned long flags; 841 struct qla_hw_data *ha = vha->hw; 842 struct req_que *req; 843 844 status = QLA_SUCCESS; 845 if (!sp) 846 return status; 847 848 spin_lock_irqsave(&ha->hardware_lock, flags); 849 req = sp->que; 850 for (cnt = 1; status == QLA_SUCCESS && 851 cnt < MAX_OUTSTANDING_COMMANDS; cnt++) { 852 sp = req->outstanding_cmds[cnt]; 853 if (!sp) 854 continue; 855 856 if (vha->vp_idx != sp->fcport->vha->vp_idx) 857 continue; 858 match = 0; 859 switch (type) { 860 case WAIT_HOST: 861 match = 1; 862 break; 863 case WAIT_TARGET: 864 match = sp->cmd->device->id == t; 865 break; 866 case WAIT_LUN: 867 match = (sp->cmd->device->id == t && 868 sp->cmd->device->lun == l); 869 break; 870 } 871 if (!match) 872 continue; 873 874 spin_unlock_irqrestore(&ha->hardware_lock, flags); 875 status = qla2x00_eh_wait_on_command(sp->cmd); 876 spin_lock_irqsave(&ha->hardware_lock, flags); 877 } 878 spin_unlock_irqrestore(&ha->hardware_lock, flags); 879 880 return status; 881 } 882 883 static char *reset_errors[] = { 884 "HBA not online", 885 "HBA not ready", 886 "Task management failed", 887 "Waiting for command completions", 888 }; 889 890 static int 891 __qla2xxx_eh_generic_reset(char *name, enum nexus_wait_type type, 892 struct scsi_cmnd *cmd, int (*do_reset)(struct fc_port *, unsigned int)) 893 { 894 scsi_qla_host_t *vha = shost_priv(cmd->device->host); 895 fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata; 896 int err; 897 898 qla2x00_block_error_handler(cmd); 899 900 if (!fcport) 901 return FAILED; 902 903 qla_printk(KERN_INFO, vha->hw, "scsi(%ld:%d:%d): %s RESET ISSUED.\n", 904 vha->host_no, cmd->device->id, cmd->device->lun, name); 905 906 err = 0; 907 if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) 908 goto eh_reset_failed; 909 err = 1; 910 if (qla2x00_wait_for_loop_ready(vha) != QLA_SUCCESS) 911 goto eh_reset_failed; 912 err = 2; 913 if (do_reset(fcport, cmd->device->lun) != QLA_SUCCESS) 914 goto eh_reset_failed; 915 err = 3; 916 if (qla2x00_eh_wait_for_pending_commands(vha, cmd->device->id, 917 cmd->device->lun, (srb_t *) CMD_SP(cmd), type) != QLA_SUCCESS) 918 goto eh_reset_failed; 919 920 qla_printk(KERN_INFO, vha->hw, "scsi(%ld:%d:%d): %s RESET SUCCEEDED.\n", 921 vha->host_no, cmd->device->id, cmd->device->lun, name); 922 923 return SUCCESS; 924 925 eh_reset_failed: 926 qla_printk(KERN_INFO, vha->hw, "scsi(%ld:%d:%d): %s RESET FAILED: %s.\n" 927 , vha->host_no, cmd->device->id, cmd->device->lun, name, 928 reset_errors[err]); 929 return FAILED; 930 } 931 932 static int 933 qla2xxx_eh_device_reset(struct scsi_cmnd *cmd) 934 { 935 scsi_qla_host_t *vha = shost_priv(cmd->device->host); 936 struct qla_hw_data *ha = vha->hw; 937 938 return __qla2xxx_eh_generic_reset("DEVICE", WAIT_LUN, cmd, 939 ha->isp_ops->lun_reset); 940 } 941 942 static int 943 qla2xxx_eh_target_reset(struct scsi_cmnd *cmd) 944 { 945 scsi_qla_host_t *vha = shost_priv(cmd->device->host); 946 struct qla_hw_data *ha = vha->hw; 947 948 return __qla2xxx_eh_generic_reset("TARGET", WAIT_TARGET, cmd, 949 ha->isp_ops->target_reset); 950 } 951 952 /************************************************************************** 953 * qla2xxx_eh_bus_reset 954 * 955 * Description: 956 * The bus reset function will reset the bus and abort any executing 957 * commands. 958 * 959 * Input: 960 * cmd = Linux SCSI command packet of the command that cause the 961 * bus reset. 962 * 963 * Returns: 964 * SUCCESS/FAILURE (defined as macro in scsi.h). 965 * 966 **************************************************************************/ 967 static int 968 qla2xxx_eh_bus_reset(struct scsi_cmnd *cmd) 969 { 970 scsi_qla_host_t *vha = shost_priv(cmd->device->host); 971 fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata; 972 int ret = FAILED; 973 unsigned int id, lun; 974 unsigned long serial; 975 srb_t *sp = (srb_t *) CMD_SP(cmd); 976 977 qla2x00_block_error_handler(cmd); 978 979 id = cmd->device->id; 980 lun = cmd->device->lun; 981 serial = cmd->serial_number; 982 983 if (!fcport) 984 return ret; 985 986 qla_printk(KERN_INFO, vha->hw, 987 "scsi(%ld:%d:%d): BUS RESET ISSUED.\n", vha->host_no, id, lun); 988 989 if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) { 990 DEBUG2(printk("%s failed:board disabled\n",__func__)); 991 goto eh_bus_reset_done; 992 } 993 994 if (qla2x00_wait_for_loop_ready(vha) == QLA_SUCCESS) { 995 if (qla2x00_loop_reset(vha) == QLA_SUCCESS) 996 ret = SUCCESS; 997 } 998 if (ret == FAILED) 999 goto eh_bus_reset_done; 1000 1001 /* Flush outstanding commands. */ 1002 if (qla2x00_eh_wait_for_pending_commands(vha, 0, 0, sp, WAIT_HOST) != 1003 QLA_SUCCESS) 1004 ret = FAILED; 1005 1006 eh_bus_reset_done: 1007 qla_printk(KERN_INFO, vha->hw, "%s: reset %s\n", __func__, 1008 (ret == FAILED) ? "failed" : "succeded"); 1009 1010 return ret; 1011 } 1012 1013 /************************************************************************** 1014 * qla2xxx_eh_host_reset 1015 * 1016 * Description: 1017 * The reset function will reset the Adapter. 1018 * 1019 * Input: 1020 * cmd = Linux SCSI command packet of the command that cause the 1021 * adapter reset. 1022 * 1023 * Returns: 1024 * Either SUCCESS or FAILED. 1025 * 1026 * Note: 1027 **************************************************************************/ 1028 static int 1029 qla2xxx_eh_host_reset(struct scsi_cmnd *cmd) 1030 { 1031 scsi_qla_host_t *vha = shost_priv(cmd->device->host); 1032 fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata; 1033 struct qla_hw_data *ha = vha->hw; 1034 int ret = FAILED; 1035 unsigned int id, lun; 1036 unsigned long serial; 1037 srb_t *sp = (srb_t *) CMD_SP(cmd); 1038 scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev); 1039 1040 qla2x00_block_error_handler(cmd); 1041 1042 id = cmd->device->id; 1043 lun = cmd->device->lun; 1044 serial = cmd->serial_number; 1045 1046 if (!fcport) 1047 return ret; 1048 1049 qla_printk(KERN_INFO, ha, 1050 "scsi(%ld:%d:%d): ADAPTER RESET ISSUED.\n", vha->host_no, id, lun); 1051 1052 if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) 1053 goto eh_host_reset_lock; 1054 1055 /* 1056 * Fixme-may be dpc thread is active and processing 1057 * loop_resync,so wait a while for it to 1058 * be completed and then issue big hammer.Otherwise 1059 * it may cause I/O failure as big hammer marks the 1060 * devices as lost kicking of the port_down_timer 1061 * while dpc is stuck for the mailbox to complete. 1062 */ 1063 qla2x00_wait_for_loop_ready(vha); 1064 if (vha != base_vha) { 1065 if (qla2x00_vp_abort_isp(vha)) 1066 goto eh_host_reset_lock; 1067 } else { 1068 set_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags); 1069 if (qla2x00_abort_isp(base_vha)) { 1070 clear_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags); 1071 /* failed. schedule dpc to try */ 1072 set_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags); 1073 1074 if (qla2x00_wait_for_hba_online(vha) != QLA_SUCCESS) 1075 goto eh_host_reset_lock; 1076 } 1077 clear_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags); 1078 } 1079 1080 /* Waiting for command to be returned to OS.*/ 1081 if (qla2x00_eh_wait_for_pending_commands(vha, 0, 0, sp, WAIT_HOST) == 1082 QLA_SUCCESS) 1083 ret = SUCCESS; 1084 1085 eh_host_reset_lock: 1086 qla_printk(KERN_INFO, ha, "%s: reset %s\n", __func__, 1087 (ret == FAILED) ? "failed" : "succeded"); 1088 1089 return ret; 1090 } 1091 1092 /* 1093 * qla2x00_loop_reset 1094 * Issue loop reset. 1095 * 1096 * Input: 1097 * ha = adapter block pointer. 1098 * 1099 * Returns: 1100 * 0 = success 1101 */ 1102 int 1103 qla2x00_loop_reset(scsi_qla_host_t *vha) 1104 { 1105 int ret; 1106 struct fc_port *fcport; 1107 struct qla_hw_data *ha = vha->hw; 1108 1109 if (ha->flags.enable_lip_full_login && !vha->vp_idx) { 1110 ret = qla2x00_full_login_lip(vha); 1111 if (ret != QLA_SUCCESS) { 1112 DEBUG2_3(printk("%s(%ld): failed: " 1113 "full_login_lip=%d.\n", __func__, vha->host_no, 1114 ret)); 1115 } 1116 atomic_set(&vha->loop_state, LOOP_DOWN); 1117 atomic_set(&vha->loop_down_timer, LOOP_DOWN_TIME); 1118 qla2x00_mark_all_devices_lost(vha, 0); 1119 qla2x00_wait_for_loop_ready(vha); 1120 } 1121 1122 if (ha->flags.enable_lip_reset && !vha->vp_idx) { 1123 ret = qla2x00_lip_reset(vha); 1124 if (ret != QLA_SUCCESS) { 1125 DEBUG2_3(printk("%s(%ld): failed: " 1126 "lip_reset=%d.\n", __func__, vha->host_no, ret)); 1127 } else 1128 qla2x00_wait_for_loop_ready(vha); 1129 } 1130 1131 if (ha->flags.enable_target_reset) { 1132 list_for_each_entry(fcport, &vha->vp_fcports, list) { 1133 if (fcport->port_type != FCT_TARGET) 1134 continue; 1135 1136 ret = ha->isp_ops->target_reset(fcport, 0); 1137 if (ret != QLA_SUCCESS) { 1138 DEBUG2_3(printk("%s(%ld): bus_reset failed: " 1139 "target_reset=%d d_id=%x.\n", __func__, 1140 vha->host_no, ret, fcport->d_id.b24)); 1141 } 1142 } 1143 } 1144 /* Issue marker command only when we are going to start the I/O */ 1145 vha->marker_needed = 1; 1146 1147 return QLA_SUCCESS; 1148 } 1149 1150 void 1151 qla2x00_abort_all_cmds(scsi_qla_host_t *vha, int res) 1152 { 1153 int que, cnt; 1154 unsigned long flags; 1155 srb_t *sp; 1156 struct qla_hw_data *ha = vha->hw; 1157 struct req_que *req; 1158 1159 spin_lock_irqsave(&ha->hardware_lock, flags); 1160 for (que = 0; que < ha->max_queues; que++) { 1161 req = ha->req_q_map[que]; 1162 if (!req) 1163 continue; 1164 for (cnt = 1; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) { 1165 sp = req->outstanding_cmds[cnt]; 1166 if (sp && sp->fcport->vha == vha) { 1167 req->outstanding_cmds[cnt] = NULL; 1168 sp->cmd->result = res; 1169 qla2x00_sp_compl(ha, sp); 1170 } 1171 } 1172 } 1173 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1174 } 1175 1176 static int 1177 qla2xxx_slave_alloc(struct scsi_device *sdev) 1178 { 1179 struct fc_rport *rport = starget_to_rport(scsi_target(sdev)); 1180 1181 if (!rport || fc_remote_port_chkready(rport)) 1182 return -ENXIO; 1183 1184 sdev->hostdata = *(fc_port_t **)rport->dd_data; 1185 1186 return 0; 1187 } 1188 1189 static int 1190 qla2xxx_slave_configure(struct scsi_device *sdev) 1191 { 1192 scsi_qla_host_t *vha = shost_priv(sdev->host); 1193 struct qla_hw_data *ha = vha->hw; 1194 struct fc_rport *rport = starget_to_rport(sdev->sdev_target); 1195 struct req_que *req = ha->req_q_map[vha->req_ques[0]]; 1196 1197 if (sdev->tagged_supported) 1198 scsi_activate_tcq(sdev, req->max_q_depth); 1199 else 1200 scsi_deactivate_tcq(sdev, req->max_q_depth); 1201 1202 rport->dev_loss_tmo = ha->port_down_retry_count; 1203 1204 return 0; 1205 } 1206 1207 static void 1208 qla2xxx_slave_destroy(struct scsi_device *sdev) 1209 { 1210 sdev->hostdata = NULL; 1211 } 1212 1213 static int 1214 qla2x00_change_queue_depth(struct scsi_device *sdev, int qdepth) 1215 { 1216 scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth); 1217 return sdev->queue_depth; 1218 } 1219 1220 static int 1221 qla2x00_change_queue_type(struct scsi_device *sdev, int tag_type) 1222 { 1223 if (sdev->tagged_supported) { 1224 scsi_set_tag_type(sdev, tag_type); 1225 if (tag_type) 1226 scsi_activate_tcq(sdev, sdev->queue_depth); 1227 else 1228 scsi_deactivate_tcq(sdev, sdev->queue_depth); 1229 } else 1230 tag_type = 0; 1231 1232 return tag_type; 1233 } 1234 1235 /** 1236 * qla2x00_config_dma_addressing() - Configure OS DMA addressing method. 1237 * @ha: HA context 1238 * 1239 * At exit, the @ha's flags.enable_64bit_addressing set to indicated 1240 * supported addressing method. 1241 */ 1242 static void 1243 qla2x00_config_dma_addressing(struct qla_hw_data *ha) 1244 { 1245 /* Assume a 32bit DMA mask. */ 1246 ha->flags.enable_64bit_addressing = 0; 1247 1248 if (!dma_set_mask(&ha->pdev->dev, DMA_64BIT_MASK)) { 1249 /* Any upper-dword bits set? */ 1250 if (MSD(dma_get_required_mask(&ha->pdev->dev)) && 1251 !pci_set_consistent_dma_mask(ha->pdev, DMA_64BIT_MASK)) { 1252 /* Ok, a 64bit DMA mask is applicable. */ 1253 ha->flags.enable_64bit_addressing = 1; 1254 ha->isp_ops->calc_req_entries = qla2x00_calc_iocbs_64; 1255 ha->isp_ops->build_iocbs = qla2x00_build_scsi_iocbs_64; 1256 return; 1257 } 1258 } 1259 1260 dma_set_mask(&ha->pdev->dev, DMA_32BIT_MASK); 1261 pci_set_consistent_dma_mask(ha->pdev, DMA_32BIT_MASK); 1262 } 1263 1264 static void 1265 qla2x00_enable_intrs(struct qla_hw_data *ha) 1266 { 1267 unsigned long flags = 0; 1268 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp; 1269 1270 spin_lock_irqsave(&ha->hardware_lock, flags); 1271 ha->interrupts_on = 1; 1272 /* enable risc and host interrupts */ 1273 WRT_REG_WORD(®->ictrl, ICR_EN_INT | ICR_EN_RISC); 1274 RD_REG_WORD(®->ictrl); 1275 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1276 1277 } 1278 1279 static void 1280 qla2x00_disable_intrs(struct qla_hw_data *ha) 1281 { 1282 unsigned long flags = 0; 1283 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp; 1284 1285 spin_lock_irqsave(&ha->hardware_lock, flags); 1286 ha->interrupts_on = 0; 1287 /* disable risc and host interrupts */ 1288 WRT_REG_WORD(®->ictrl, 0); 1289 RD_REG_WORD(®->ictrl); 1290 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1291 } 1292 1293 static void 1294 qla24xx_enable_intrs(struct qla_hw_data *ha) 1295 { 1296 unsigned long flags = 0; 1297 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24; 1298 1299 spin_lock_irqsave(&ha->hardware_lock, flags); 1300 ha->interrupts_on = 1; 1301 WRT_REG_DWORD(®->ictrl, ICRX_EN_RISC_INT); 1302 RD_REG_DWORD(®->ictrl); 1303 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1304 } 1305 1306 static void 1307 qla24xx_disable_intrs(struct qla_hw_data *ha) 1308 { 1309 unsigned long flags = 0; 1310 struct device_reg_24xx __iomem *reg = &ha->iobase->isp24; 1311 1312 if (IS_NOPOLLING_TYPE(ha)) 1313 return; 1314 spin_lock_irqsave(&ha->hardware_lock, flags); 1315 ha->interrupts_on = 0; 1316 WRT_REG_DWORD(®->ictrl, 0); 1317 RD_REG_DWORD(®->ictrl); 1318 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1319 } 1320 1321 static struct isp_operations qla2100_isp_ops = { 1322 .pci_config = qla2100_pci_config, 1323 .reset_chip = qla2x00_reset_chip, 1324 .chip_diag = qla2x00_chip_diag, 1325 .config_rings = qla2x00_config_rings, 1326 .reset_adapter = qla2x00_reset_adapter, 1327 .nvram_config = qla2x00_nvram_config, 1328 .update_fw_options = qla2x00_update_fw_options, 1329 .load_risc = qla2x00_load_risc, 1330 .pci_info_str = qla2x00_pci_info_str, 1331 .fw_version_str = qla2x00_fw_version_str, 1332 .intr_handler = qla2100_intr_handler, 1333 .enable_intrs = qla2x00_enable_intrs, 1334 .disable_intrs = qla2x00_disable_intrs, 1335 .abort_command = qla2x00_abort_command, 1336 .target_reset = qla2x00_abort_target, 1337 .lun_reset = qla2x00_lun_reset, 1338 .fabric_login = qla2x00_login_fabric, 1339 .fabric_logout = qla2x00_fabric_logout, 1340 .calc_req_entries = qla2x00_calc_iocbs_32, 1341 .build_iocbs = qla2x00_build_scsi_iocbs_32, 1342 .prep_ms_iocb = qla2x00_prep_ms_iocb, 1343 .prep_ms_fdmi_iocb = qla2x00_prep_ms_fdmi_iocb, 1344 .read_nvram = qla2x00_read_nvram_data, 1345 .write_nvram = qla2x00_write_nvram_data, 1346 .fw_dump = qla2100_fw_dump, 1347 .beacon_on = NULL, 1348 .beacon_off = NULL, 1349 .beacon_blink = NULL, 1350 .read_optrom = qla2x00_read_optrom_data, 1351 .write_optrom = qla2x00_write_optrom_data, 1352 .get_flash_version = qla2x00_get_flash_version, 1353 .start_scsi = qla2x00_start_scsi, 1354 .wrt_req_reg = NULL, 1355 .wrt_rsp_reg = NULL, 1356 .rd_req_reg = NULL, 1357 }; 1358 1359 static struct isp_operations qla2300_isp_ops = { 1360 .pci_config = qla2300_pci_config, 1361 .reset_chip = qla2x00_reset_chip, 1362 .chip_diag = qla2x00_chip_diag, 1363 .config_rings = qla2x00_config_rings, 1364 .reset_adapter = qla2x00_reset_adapter, 1365 .nvram_config = qla2x00_nvram_config, 1366 .update_fw_options = qla2x00_update_fw_options, 1367 .load_risc = qla2x00_load_risc, 1368 .pci_info_str = qla2x00_pci_info_str, 1369 .fw_version_str = qla2x00_fw_version_str, 1370 .intr_handler = qla2300_intr_handler, 1371 .enable_intrs = qla2x00_enable_intrs, 1372 .disable_intrs = qla2x00_disable_intrs, 1373 .abort_command = qla2x00_abort_command, 1374 .target_reset = qla2x00_abort_target, 1375 .lun_reset = qla2x00_lun_reset, 1376 .fabric_login = qla2x00_login_fabric, 1377 .fabric_logout = qla2x00_fabric_logout, 1378 .calc_req_entries = qla2x00_calc_iocbs_32, 1379 .build_iocbs = qla2x00_build_scsi_iocbs_32, 1380 .prep_ms_iocb = qla2x00_prep_ms_iocb, 1381 .prep_ms_fdmi_iocb = qla2x00_prep_ms_fdmi_iocb, 1382 .read_nvram = qla2x00_read_nvram_data, 1383 .write_nvram = qla2x00_write_nvram_data, 1384 .fw_dump = qla2300_fw_dump, 1385 .beacon_on = qla2x00_beacon_on, 1386 .beacon_off = qla2x00_beacon_off, 1387 .beacon_blink = qla2x00_beacon_blink, 1388 .read_optrom = qla2x00_read_optrom_data, 1389 .write_optrom = qla2x00_write_optrom_data, 1390 .get_flash_version = qla2x00_get_flash_version, 1391 .start_scsi = qla2x00_start_scsi, 1392 .wrt_req_reg = NULL, 1393 .wrt_rsp_reg = NULL, 1394 .rd_req_reg = NULL, 1395 }; 1396 1397 static struct isp_operations qla24xx_isp_ops = { 1398 .pci_config = qla24xx_pci_config, 1399 .reset_chip = qla24xx_reset_chip, 1400 .chip_diag = qla24xx_chip_diag, 1401 .config_rings = qla24xx_config_rings, 1402 .reset_adapter = qla24xx_reset_adapter, 1403 .nvram_config = qla24xx_nvram_config, 1404 .update_fw_options = qla24xx_update_fw_options, 1405 .load_risc = qla24xx_load_risc, 1406 .pci_info_str = qla24xx_pci_info_str, 1407 .fw_version_str = qla24xx_fw_version_str, 1408 .intr_handler = qla24xx_intr_handler, 1409 .enable_intrs = qla24xx_enable_intrs, 1410 .disable_intrs = qla24xx_disable_intrs, 1411 .abort_command = qla24xx_abort_command, 1412 .target_reset = qla24xx_abort_target, 1413 .lun_reset = qla24xx_lun_reset, 1414 .fabric_login = qla24xx_login_fabric, 1415 .fabric_logout = qla24xx_fabric_logout, 1416 .calc_req_entries = NULL, 1417 .build_iocbs = NULL, 1418 .prep_ms_iocb = qla24xx_prep_ms_iocb, 1419 .prep_ms_fdmi_iocb = qla24xx_prep_ms_fdmi_iocb, 1420 .read_nvram = qla24xx_read_nvram_data, 1421 .write_nvram = qla24xx_write_nvram_data, 1422 .fw_dump = qla24xx_fw_dump, 1423 .beacon_on = qla24xx_beacon_on, 1424 .beacon_off = qla24xx_beacon_off, 1425 .beacon_blink = qla24xx_beacon_blink, 1426 .read_optrom = qla24xx_read_optrom_data, 1427 .write_optrom = qla24xx_write_optrom_data, 1428 .get_flash_version = qla24xx_get_flash_version, 1429 .start_scsi = qla24xx_start_scsi, 1430 .wrt_req_reg = qla24xx_wrt_req_reg, 1431 .wrt_rsp_reg = qla24xx_wrt_rsp_reg, 1432 .rd_req_reg = qla24xx_rd_req_reg, 1433 }; 1434 1435 static struct isp_operations qla25xx_isp_ops = { 1436 .pci_config = qla25xx_pci_config, 1437 .reset_chip = qla24xx_reset_chip, 1438 .chip_diag = qla24xx_chip_diag, 1439 .config_rings = qla24xx_config_rings, 1440 .reset_adapter = qla24xx_reset_adapter, 1441 .nvram_config = qla24xx_nvram_config, 1442 .update_fw_options = qla24xx_update_fw_options, 1443 .load_risc = qla24xx_load_risc, 1444 .pci_info_str = qla24xx_pci_info_str, 1445 .fw_version_str = qla24xx_fw_version_str, 1446 .intr_handler = qla24xx_intr_handler, 1447 .enable_intrs = qla24xx_enable_intrs, 1448 .disable_intrs = qla24xx_disable_intrs, 1449 .abort_command = qla24xx_abort_command, 1450 .target_reset = qla24xx_abort_target, 1451 .lun_reset = qla24xx_lun_reset, 1452 .fabric_login = qla24xx_login_fabric, 1453 .fabric_logout = qla24xx_fabric_logout, 1454 .calc_req_entries = NULL, 1455 .build_iocbs = NULL, 1456 .prep_ms_iocb = qla24xx_prep_ms_iocb, 1457 .prep_ms_fdmi_iocb = qla24xx_prep_ms_fdmi_iocb, 1458 .read_nvram = qla25xx_read_nvram_data, 1459 .write_nvram = qla25xx_write_nvram_data, 1460 .fw_dump = qla25xx_fw_dump, 1461 .beacon_on = qla24xx_beacon_on, 1462 .beacon_off = qla24xx_beacon_off, 1463 .beacon_blink = qla24xx_beacon_blink, 1464 .read_optrom = qla25xx_read_optrom_data, 1465 .write_optrom = qla24xx_write_optrom_data, 1466 .get_flash_version = qla24xx_get_flash_version, 1467 .start_scsi = qla24xx_start_scsi, 1468 .wrt_req_reg = qla24xx_wrt_req_reg, 1469 .wrt_rsp_reg = qla24xx_wrt_rsp_reg, 1470 .rd_req_reg = qla24xx_rd_req_reg, 1471 }; 1472 1473 static struct isp_operations qla81xx_isp_ops = { 1474 .pci_config = qla25xx_pci_config, 1475 .reset_chip = qla24xx_reset_chip, 1476 .chip_diag = qla24xx_chip_diag, 1477 .config_rings = qla24xx_config_rings, 1478 .reset_adapter = qla24xx_reset_adapter, 1479 .nvram_config = qla81xx_nvram_config, 1480 .update_fw_options = qla81xx_update_fw_options, 1481 .load_risc = qla81xx_load_risc, 1482 .pci_info_str = qla24xx_pci_info_str, 1483 .fw_version_str = qla24xx_fw_version_str, 1484 .intr_handler = qla24xx_intr_handler, 1485 .enable_intrs = qla24xx_enable_intrs, 1486 .disable_intrs = qla24xx_disable_intrs, 1487 .abort_command = qla24xx_abort_command, 1488 .target_reset = qla24xx_abort_target, 1489 .lun_reset = qla24xx_lun_reset, 1490 .fabric_login = qla24xx_login_fabric, 1491 .fabric_logout = qla24xx_fabric_logout, 1492 .calc_req_entries = NULL, 1493 .build_iocbs = NULL, 1494 .prep_ms_iocb = qla24xx_prep_ms_iocb, 1495 .prep_ms_fdmi_iocb = qla24xx_prep_ms_fdmi_iocb, 1496 .read_nvram = qla25xx_read_nvram_data, 1497 .write_nvram = qla25xx_write_nvram_data, 1498 .fw_dump = qla81xx_fw_dump, 1499 .beacon_on = qla24xx_beacon_on, 1500 .beacon_off = qla24xx_beacon_off, 1501 .beacon_blink = qla24xx_beacon_blink, 1502 .read_optrom = qla25xx_read_optrom_data, 1503 .write_optrom = qla24xx_write_optrom_data, 1504 .get_flash_version = qla24xx_get_flash_version, 1505 .start_scsi = qla24xx_start_scsi, 1506 .wrt_req_reg = qla24xx_wrt_req_reg, 1507 .wrt_rsp_reg = qla24xx_wrt_rsp_reg, 1508 .rd_req_reg = qla24xx_rd_req_reg, 1509 }; 1510 1511 static inline void 1512 qla2x00_set_isp_flags(struct qla_hw_data *ha) 1513 { 1514 ha->device_type = DT_EXTENDED_IDS; 1515 switch (ha->pdev->device) { 1516 case PCI_DEVICE_ID_QLOGIC_ISP2100: 1517 ha->device_type |= DT_ISP2100; 1518 ha->device_type &= ~DT_EXTENDED_IDS; 1519 ha->fw_srisc_address = RISC_START_ADDRESS_2100; 1520 break; 1521 case PCI_DEVICE_ID_QLOGIC_ISP2200: 1522 ha->device_type |= DT_ISP2200; 1523 ha->device_type &= ~DT_EXTENDED_IDS; 1524 ha->fw_srisc_address = RISC_START_ADDRESS_2100; 1525 break; 1526 case PCI_DEVICE_ID_QLOGIC_ISP2300: 1527 ha->device_type |= DT_ISP2300; 1528 ha->device_type |= DT_ZIO_SUPPORTED; 1529 ha->fw_srisc_address = RISC_START_ADDRESS_2300; 1530 break; 1531 case PCI_DEVICE_ID_QLOGIC_ISP2312: 1532 ha->device_type |= DT_ISP2312; 1533 ha->device_type |= DT_ZIO_SUPPORTED; 1534 ha->fw_srisc_address = RISC_START_ADDRESS_2300; 1535 break; 1536 case PCI_DEVICE_ID_QLOGIC_ISP2322: 1537 ha->device_type |= DT_ISP2322; 1538 ha->device_type |= DT_ZIO_SUPPORTED; 1539 if (ha->pdev->subsystem_vendor == 0x1028 && 1540 ha->pdev->subsystem_device == 0x0170) 1541 ha->device_type |= DT_OEM_001; 1542 ha->fw_srisc_address = RISC_START_ADDRESS_2300; 1543 break; 1544 case PCI_DEVICE_ID_QLOGIC_ISP6312: 1545 ha->device_type |= DT_ISP6312; 1546 ha->fw_srisc_address = RISC_START_ADDRESS_2300; 1547 break; 1548 case PCI_DEVICE_ID_QLOGIC_ISP6322: 1549 ha->device_type |= DT_ISP6322; 1550 ha->fw_srisc_address = RISC_START_ADDRESS_2300; 1551 break; 1552 case PCI_DEVICE_ID_QLOGIC_ISP2422: 1553 ha->device_type |= DT_ISP2422; 1554 ha->device_type |= DT_ZIO_SUPPORTED; 1555 ha->device_type |= DT_FWI2; 1556 ha->device_type |= DT_IIDMA; 1557 ha->fw_srisc_address = RISC_START_ADDRESS_2400; 1558 break; 1559 case PCI_DEVICE_ID_QLOGIC_ISP2432: 1560 ha->device_type |= DT_ISP2432; 1561 ha->device_type |= DT_ZIO_SUPPORTED; 1562 ha->device_type |= DT_FWI2; 1563 ha->device_type |= DT_IIDMA; 1564 ha->fw_srisc_address = RISC_START_ADDRESS_2400; 1565 break; 1566 case PCI_DEVICE_ID_QLOGIC_ISP8432: 1567 ha->device_type |= DT_ISP8432; 1568 ha->device_type |= DT_ZIO_SUPPORTED; 1569 ha->device_type |= DT_FWI2; 1570 ha->device_type |= DT_IIDMA; 1571 ha->fw_srisc_address = RISC_START_ADDRESS_2400; 1572 break; 1573 case PCI_DEVICE_ID_QLOGIC_ISP5422: 1574 ha->device_type |= DT_ISP5422; 1575 ha->device_type |= DT_FWI2; 1576 ha->fw_srisc_address = RISC_START_ADDRESS_2400; 1577 break; 1578 case PCI_DEVICE_ID_QLOGIC_ISP5432: 1579 ha->device_type |= DT_ISP5432; 1580 ha->device_type |= DT_FWI2; 1581 ha->fw_srisc_address = RISC_START_ADDRESS_2400; 1582 break; 1583 case PCI_DEVICE_ID_QLOGIC_ISP2532: 1584 ha->device_type |= DT_ISP2532; 1585 ha->device_type |= DT_ZIO_SUPPORTED; 1586 ha->device_type |= DT_FWI2; 1587 ha->device_type |= DT_IIDMA; 1588 ha->fw_srisc_address = RISC_START_ADDRESS_2400; 1589 break; 1590 case PCI_DEVICE_ID_QLOGIC_ISP8001: 1591 ha->device_type |= DT_ISP8001; 1592 ha->device_type |= DT_ZIO_SUPPORTED; 1593 ha->device_type |= DT_FWI2; 1594 ha->device_type |= DT_IIDMA; 1595 ha->fw_srisc_address = RISC_START_ADDRESS_2400; 1596 break; 1597 } 1598 } 1599 1600 static int 1601 qla2x00_iospace_config(struct qla_hw_data *ha) 1602 { 1603 resource_size_t pio; 1604 uint16_t msix; 1605 1606 if (pci_request_selected_regions(ha->pdev, ha->bars, 1607 QLA2XXX_DRIVER_NAME)) { 1608 qla_printk(KERN_WARNING, ha, 1609 "Failed to reserve PIO/MMIO regions (%s)\n", 1610 pci_name(ha->pdev)); 1611 1612 goto iospace_error_exit; 1613 } 1614 if (!(ha->bars & 1)) 1615 goto skip_pio; 1616 1617 /* We only need PIO for Flash operations on ISP2312 v2 chips. */ 1618 pio = pci_resource_start(ha->pdev, 0); 1619 if (pci_resource_flags(ha->pdev, 0) & IORESOURCE_IO) { 1620 if (pci_resource_len(ha->pdev, 0) < MIN_IOBASE_LEN) { 1621 qla_printk(KERN_WARNING, ha, 1622 "Invalid PCI I/O region size (%s)...\n", 1623 pci_name(ha->pdev)); 1624 pio = 0; 1625 } 1626 } else { 1627 qla_printk(KERN_WARNING, ha, 1628 "region #0 not a PIO resource (%s)...\n", 1629 pci_name(ha->pdev)); 1630 pio = 0; 1631 } 1632 ha->pio_address = pio; 1633 1634 skip_pio: 1635 /* Use MMIO operations for all accesses. */ 1636 if (!(pci_resource_flags(ha->pdev, 1) & IORESOURCE_MEM)) { 1637 qla_printk(KERN_ERR, ha, 1638 "region #1 not an MMIO resource (%s), aborting\n", 1639 pci_name(ha->pdev)); 1640 goto iospace_error_exit; 1641 } 1642 if (pci_resource_len(ha->pdev, 1) < MIN_IOBASE_LEN) { 1643 qla_printk(KERN_ERR, ha, 1644 "Invalid PCI mem region size (%s), aborting\n", 1645 pci_name(ha->pdev)); 1646 goto iospace_error_exit; 1647 } 1648 1649 ha->iobase = ioremap(pci_resource_start(ha->pdev, 1), MIN_IOBASE_LEN); 1650 if (!ha->iobase) { 1651 qla_printk(KERN_ERR, ha, 1652 "cannot remap MMIO (%s), aborting\n", pci_name(ha->pdev)); 1653 1654 goto iospace_error_exit; 1655 } 1656 1657 /* Determine queue resources */ 1658 ha->max_queues = 1; 1659 if (ql2xmaxqueues <= 1 || (!IS_QLA25XX(ha) && !IS_QLA81XX(ha))) 1660 goto mqiobase_exit; 1661 ha->mqiobase = ioremap(pci_resource_start(ha->pdev, 3), 1662 pci_resource_len(ha->pdev, 3)); 1663 if (ha->mqiobase) { 1664 /* Read MSIX vector size of the board */ 1665 pci_read_config_word(ha->pdev, QLA_PCI_MSIX_CONTROL, &msix); 1666 ha->msix_count = msix; 1667 /* Max queues are bounded by available msix vectors */ 1668 /* queue 0 uses two msix vectors */ 1669 if (ha->msix_count - 1 < ql2xmaxqueues) 1670 ha->max_queues = ha->msix_count - 1; 1671 else if (ql2xmaxqueues > QLA_MQ_SIZE) 1672 ha->max_queues = QLA_MQ_SIZE; 1673 else 1674 ha->max_queues = ql2xmaxqueues; 1675 qla_printk(KERN_INFO, ha, 1676 "MSI-X vector count: %d\n", msix); 1677 } 1678 1679 mqiobase_exit: 1680 ha->msix_count = ha->max_queues + 1; 1681 return (0); 1682 1683 iospace_error_exit: 1684 return (-ENOMEM); 1685 } 1686 1687 static void 1688 qla2xxx_scan_start(struct Scsi_Host *shost) 1689 { 1690 scsi_qla_host_t *vha = shost_priv(shost); 1691 1692 set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags); 1693 set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags); 1694 set_bit(RSCN_UPDATE, &vha->dpc_flags); 1695 set_bit(NPIV_CONFIG_NEEDED, &vha->dpc_flags); 1696 } 1697 1698 static int 1699 qla2xxx_scan_finished(struct Scsi_Host *shost, unsigned long time) 1700 { 1701 scsi_qla_host_t *vha = shost_priv(shost); 1702 1703 if (!vha->host) 1704 return 1; 1705 if (time > vha->hw->loop_reset_delay * HZ) 1706 return 1; 1707 1708 return atomic_read(&vha->loop_state) == LOOP_READY; 1709 } 1710 1711 /* 1712 * PCI driver interface 1713 */ 1714 static int __devinit 1715 qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id) 1716 { 1717 int ret = -ENODEV; 1718 struct Scsi_Host *host; 1719 scsi_qla_host_t *base_vha = NULL; 1720 struct qla_hw_data *ha; 1721 char pci_info[30]; 1722 char fw_str[30]; 1723 struct scsi_host_template *sht; 1724 int bars, max_id, mem_only = 0; 1725 uint16_t req_length = 0, rsp_length = 0; 1726 struct req_que *req = NULL; 1727 struct rsp_que *rsp = NULL; 1728 1729 bars = pci_select_bars(pdev, IORESOURCE_MEM | IORESOURCE_IO); 1730 sht = &qla2x00_driver_template; 1731 if (pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2422 || 1732 pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2432 || 1733 pdev->device == PCI_DEVICE_ID_QLOGIC_ISP8432 || 1734 pdev->device == PCI_DEVICE_ID_QLOGIC_ISP5422 || 1735 pdev->device == PCI_DEVICE_ID_QLOGIC_ISP5432 || 1736 pdev->device == PCI_DEVICE_ID_QLOGIC_ISP2532 || 1737 pdev->device == PCI_DEVICE_ID_QLOGIC_ISP8001) { 1738 bars = pci_select_bars(pdev, IORESOURCE_MEM); 1739 sht = &qla24xx_driver_template; 1740 mem_only = 1; 1741 } 1742 1743 if (mem_only) { 1744 if (pci_enable_device_mem(pdev)) 1745 goto probe_out; 1746 } else { 1747 if (pci_enable_device(pdev)) 1748 goto probe_out; 1749 } 1750 1751 /* This may fail but that's ok */ 1752 pci_enable_pcie_error_reporting(pdev); 1753 1754 ha = kzalloc(sizeof(struct qla_hw_data), GFP_KERNEL); 1755 if (!ha) { 1756 DEBUG(printk("Unable to allocate memory for ha\n")); 1757 goto probe_out; 1758 } 1759 ha->pdev = pdev; 1760 1761 /* Clear our data area */ 1762 ha->bars = bars; 1763 ha->mem_only = mem_only; 1764 spin_lock_init(&ha->hardware_lock); 1765 1766 /* Set ISP-type information. */ 1767 qla2x00_set_isp_flags(ha); 1768 /* Configure PCI I/O space */ 1769 ret = qla2x00_iospace_config(ha); 1770 if (ret) 1771 goto probe_hw_failed; 1772 1773 qla_printk(KERN_INFO, ha, 1774 "Found an ISP%04X, irq %d, iobase 0x%p\n", pdev->device, pdev->irq, 1775 ha->iobase); 1776 1777 ha->prev_topology = 0; 1778 ha->init_cb_size = sizeof(init_cb_t); 1779 ha->link_data_rate = PORT_SPEED_UNKNOWN; 1780 ha->optrom_size = OPTROM_SIZE_2300; 1781 1782 /* Assign ISP specific operations. */ 1783 max_id = MAX_TARGETS_2200; 1784 if (IS_QLA2100(ha)) { 1785 max_id = MAX_TARGETS_2100; 1786 ha->mbx_count = MAILBOX_REGISTER_COUNT_2100; 1787 req_length = REQUEST_ENTRY_CNT_2100; 1788 rsp_length = RESPONSE_ENTRY_CNT_2100; 1789 ha->max_loop_id = SNS_LAST_LOOP_ID_2100; 1790 ha->gid_list_info_size = 4; 1791 ha->flash_conf_off = ~0; 1792 ha->flash_data_off = ~0; 1793 ha->nvram_conf_off = ~0; 1794 ha->nvram_data_off = ~0; 1795 ha->isp_ops = &qla2100_isp_ops; 1796 } else if (IS_QLA2200(ha)) { 1797 ha->mbx_count = MAILBOX_REGISTER_COUNT; 1798 req_length = REQUEST_ENTRY_CNT_2200; 1799 rsp_length = RESPONSE_ENTRY_CNT_2100; 1800 ha->max_loop_id = SNS_LAST_LOOP_ID_2100; 1801 ha->gid_list_info_size = 4; 1802 ha->flash_conf_off = ~0; 1803 ha->flash_data_off = ~0; 1804 ha->nvram_conf_off = ~0; 1805 ha->nvram_data_off = ~0; 1806 ha->isp_ops = &qla2100_isp_ops; 1807 } else if (IS_QLA23XX(ha)) { 1808 ha->mbx_count = MAILBOX_REGISTER_COUNT; 1809 req_length = REQUEST_ENTRY_CNT_2200; 1810 rsp_length = RESPONSE_ENTRY_CNT_2300; 1811 ha->max_loop_id = SNS_LAST_LOOP_ID_2300; 1812 ha->gid_list_info_size = 6; 1813 if (IS_QLA2322(ha) || IS_QLA6322(ha)) 1814 ha->optrom_size = OPTROM_SIZE_2322; 1815 ha->flash_conf_off = ~0; 1816 ha->flash_data_off = ~0; 1817 ha->nvram_conf_off = ~0; 1818 ha->nvram_data_off = ~0; 1819 ha->isp_ops = &qla2300_isp_ops; 1820 } else if (IS_QLA24XX_TYPE(ha)) { 1821 ha->mbx_count = MAILBOX_REGISTER_COUNT; 1822 req_length = REQUEST_ENTRY_CNT_24XX; 1823 rsp_length = RESPONSE_ENTRY_CNT_2300; 1824 ha->max_loop_id = SNS_LAST_LOOP_ID_2300; 1825 ha->init_cb_size = sizeof(struct mid_init_cb_24xx); 1826 ha->gid_list_info_size = 8; 1827 ha->optrom_size = OPTROM_SIZE_24XX; 1828 ha->nvram_npiv_size = QLA_MAX_VPORTS_QLA24XX; 1829 ha->isp_ops = &qla24xx_isp_ops; 1830 ha->flash_conf_off = FARX_ACCESS_FLASH_CONF; 1831 ha->flash_data_off = FARX_ACCESS_FLASH_DATA; 1832 ha->nvram_conf_off = FARX_ACCESS_NVRAM_CONF; 1833 ha->nvram_data_off = FARX_ACCESS_NVRAM_DATA; 1834 } else if (IS_QLA25XX(ha)) { 1835 ha->mbx_count = MAILBOX_REGISTER_COUNT; 1836 req_length = REQUEST_ENTRY_CNT_24XX; 1837 rsp_length = RESPONSE_ENTRY_CNT_2300; 1838 ha->max_loop_id = SNS_LAST_LOOP_ID_2300; 1839 ha->init_cb_size = sizeof(struct mid_init_cb_24xx); 1840 ha->gid_list_info_size = 8; 1841 ha->optrom_size = OPTROM_SIZE_25XX; 1842 ha->nvram_npiv_size = QLA_MAX_VPORTS_QLA25XX; 1843 ha->isp_ops = &qla25xx_isp_ops; 1844 ha->flash_conf_off = FARX_ACCESS_FLASH_CONF; 1845 ha->flash_data_off = FARX_ACCESS_FLASH_DATA; 1846 ha->nvram_conf_off = FARX_ACCESS_NVRAM_CONF; 1847 ha->nvram_data_off = FARX_ACCESS_NVRAM_DATA; 1848 } else if (IS_QLA81XX(ha)) { 1849 ha->mbx_count = MAILBOX_REGISTER_COUNT; 1850 req_length = REQUEST_ENTRY_CNT_24XX; 1851 rsp_length = RESPONSE_ENTRY_CNT_2300; 1852 ha->max_loop_id = SNS_LAST_LOOP_ID_2300; 1853 ha->init_cb_size = sizeof(struct mid_init_cb_81xx); 1854 ha->gid_list_info_size = 8; 1855 ha->optrom_size = OPTROM_SIZE_81XX; 1856 ha->isp_ops = &qla81xx_isp_ops; 1857 ha->flash_conf_off = FARX_ACCESS_FLASH_CONF_81XX; 1858 ha->flash_data_off = FARX_ACCESS_FLASH_DATA_81XX; 1859 ha->nvram_conf_off = ~0; 1860 ha->nvram_data_off = ~0; 1861 } 1862 1863 mutex_init(&ha->vport_lock); 1864 init_completion(&ha->mbx_cmd_comp); 1865 complete(&ha->mbx_cmd_comp); 1866 init_completion(&ha->mbx_intr_comp); 1867 1868 set_bit(0, (unsigned long *) ha->vp_idx_map); 1869 1870 qla2x00_config_dma_addressing(ha); 1871 ret = qla2x00_mem_alloc(ha, req_length, rsp_length, &req, &rsp); 1872 if (!ret) { 1873 qla_printk(KERN_WARNING, ha, 1874 "[ERROR] Failed to allocate memory for adapter\n"); 1875 1876 goto probe_hw_failed; 1877 } 1878 1879 req->max_q_depth = MAX_Q_DEPTH; 1880 if (ql2xmaxqdepth != 0 && ql2xmaxqdepth <= 0xffffU) 1881 req->max_q_depth = ql2xmaxqdepth; 1882 1883 1884 base_vha = qla2x00_create_host(sht, ha); 1885 if (!base_vha) { 1886 qla_printk(KERN_WARNING, ha, 1887 "[ERROR] Failed to allocate memory for scsi_host\n"); 1888 1889 ret = -ENOMEM; 1890 qla2x00_mem_free(ha); 1891 qla2x00_free_que(ha, req, rsp); 1892 goto probe_hw_failed; 1893 } 1894 1895 pci_set_drvdata(pdev, base_vha); 1896 1897 host = base_vha->host; 1898 base_vha->req_ques[0] = req->id; 1899 host->can_queue = req->length + 128; 1900 if (IS_QLA2XXX_MIDTYPE(ha)) 1901 base_vha->mgmt_svr_loop_id = 10 + base_vha->vp_idx; 1902 else 1903 base_vha->mgmt_svr_loop_id = MANAGEMENT_SERVER + 1904 base_vha->vp_idx; 1905 if (IS_QLA2100(ha)) 1906 host->sg_tablesize = 32; 1907 host->max_id = max_id; 1908 host->this_id = 255; 1909 host->cmd_per_lun = 3; 1910 host->unique_id = host->host_no; 1911 host->max_cmd_len = MAX_CMDSZ; 1912 host->max_channel = MAX_BUSES - 1; 1913 host->max_lun = MAX_LUNS; 1914 host->transportt = qla2xxx_transport_template; 1915 1916 /* Set up the irqs */ 1917 ret = qla2x00_request_irqs(ha, rsp); 1918 if (ret) 1919 goto probe_init_failed; 1920 /* Alloc arrays of request and response ring ptrs */ 1921 if (!qla2x00_alloc_queues(ha)) { 1922 qla_printk(KERN_WARNING, ha, 1923 "[ERROR] Failed to allocate memory for queue" 1924 " pointers\n"); 1925 goto probe_init_failed; 1926 } 1927 ha->rsp_q_map[0] = rsp; 1928 ha->req_q_map[0] = req; 1929 1930 if (ha->mqenable) { 1931 ha->isp_ops->wrt_req_reg = qla25xx_wrt_req_reg; 1932 ha->isp_ops->wrt_rsp_reg = qla25xx_wrt_rsp_reg; 1933 ha->isp_ops->rd_req_reg = qla25xx_rd_req_reg; 1934 } 1935 1936 if (qla2x00_initialize_adapter(base_vha)) { 1937 qla_printk(KERN_WARNING, ha, 1938 "Failed to initialize adapter\n"); 1939 1940 DEBUG2(printk("scsi(%ld): Failed to initialize adapter - " 1941 "Adapter flags %x.\n", 1942 base_vha->host_no, base_vha->device_flags)); 1943 1944 ret = -ENODEV; 1945 goto probe_failed; 1946 } 1947 1948 /* 1949 * Startup the kernel thread for this host adapter 1950 */ 1951 ha->dpc_thread = kthread_create(qla2x00_do_dpc, ha, 1952 "%s_dpc", base_vha->host_str); 1953 if (IS_ERR(ha->dpc_thread)) { 1954 qla_printk(KERN_WARNING, ha, 1955 "Unable to start DPC thread!\n"); 1956 ret = PTR_ERR(ha->dpc_thread); 1957 goto probe_failed; 1958 } 1959 1960 list_add_tail(&base_vha->list, &ha->vp_list); 1961 base_vha->host->irq = ha->pdev->irq; 1962 1963 /* Initialized the timer */ 1964 qla2x00_start_timer(base_vha, qla2x00_timer, WATCH_INTERVAL); 1965 1966 DEBUG2(printk("DEBUG: detect hba %ld at address = %p\n", 1967 base_vha->host_no, ha)); 1968 1969 base_vha->flags.init_done = 1; 1970 base_vha->flags.online = 1; 1971 1972 ret = scsi_add_host(host, &pdev->dev); 1973 if (ret) 1974 goto probe_failed; 1975 1976 ha->isp_ops->enable_intrs(ha); 1977 1978 scsi_scan_host(host); 1979 1980 qla2x00_alloc_sysfs_attr(base_vha); 1981 1982 qla2x00_init_host_attr(base_vha); 1983 1984 qla2x00_dfs_setup(base_vha); 1985 1986 qla_printk(KERN_INFO, ha, "\n" 1987 " QLogic Fibre Channel HBA Driver: %s\n" 1988 " QLogic %s - %s\n" 1989 " ISP%04X: %s @ %s hdma%c, host#=%ld, fw=%s\n", 1990 qla2x00_version_str, ha->model_number, 1991 ha->model_desc ? ha->model_desc : "", pdev->device, 1992 ha->isp_ops->pci_info_str(base_vha, pci_info), pci_name(pdev), 1993 ha->flags.enable_64bit_addressing ? '+' : '-', base_vha->host_no, 1994 ha->isp_ops->fw_version_str(base_vha, fw_str)); 1995 1996 return 0; 1997 1998 probe_init_failed: 1999 qla2x00_free_que(ha, req, rsp); 2000 ha->max_queues = 0; 2001 2002 probe_failed: 2003 qla2x00_free_device(base_vha); 2004 2005 scsi_host_put(base_vha->host); 2006 2007 probe_hw_failed: 2008 if (ha->iobase) 2009 iounmap(ha->iobase); 2010 2011 pci_release_selected_regions(ha->pdev, ha->bars); 2012 kfree(ha); 2013 ha = NULL; 2014 2015 probe_out: 2016 pci_disable_device(pdev); 2017 return ret; 2018 } 2019 2020 static void 2021 qla2x00_remove_one(struct pci_dev *pdev) 2022 { 2023 scsi_qla_host_t *base_vha, *vha, *temp; 2024 struct qla_hw_data *ha; 2025 2026 base_vha = pci_get_drvdata(pdev); 2027 ha = base_vha->hw; 2028 2029 list_for_each_entry_safe(vha, temp, &ha->vp_list, list) { 2030 if (vha && vha->fc_vport) 2031 fc_vport_terminate(vha->fc_vport); 2032 } 2033 2034 set_bit(UNLOADING, &base_vha->dpc_flags); 2035 2036 qla2x00_dfs_remove(base_vha); 2037 2038 qla84xx_put_chip(base_vha); 2039 2040 qla2x00_free_sysfs_attr(base_vha); 2041 2042 fc_remove_host(base_vha->host); 2043 2044 scsi_remove_host(base_vha->host); 2045 2046 qla2x00_free_device(base_vha); 2047 2048 scsi_host_put(base_vha->host); 2049 2050 if (ha->iobase) 2051 iounmap(ha->iobase); 2052 2053 if (ha->mqiobase) 2054 iounmap(ha->mqiobase); 2055 2056 pci_release_selected_regions(ha->pdev, ha->bars); 2057 kfree(ha); 2058 ha = NULL; 2059 2060 pci_disable_device(pdev); 2061 pci_set_drvdata(pdev, NULL); 2062 } 2063 2064 static void 2065 qla2x00_free_device(scsi_qla_host_t *vha) 2066 { 2067 struct qla_hw_data *ha = vha->hw; 2068 qla2x00_abort_all_cmds(vha, DID_NO_CONNECT << 16); 2069 2070 /* Disable timer */ 2071 if (vha->timer_active) 2072 qla2x00_stop_timer(vha); 2073 2074 vha->flags.online = 0; 2075 2076 /* Kill the kernel thread for this host */ 2077 if (ha->dpc_thread) { 2078 struct task_struct *t = ha->dpc_thread; 2079 2080 /* 2081 * qla2xxx_wake_dpc checks for ->dpc_thread 2082 * so we need to zero it out. 2083 */ 2084 ha->dpc_thread = NULL; 2085 kthread_stop(t); 2086 } 2087 2088 if (ha->flags.fce_enabled) 2089 qla2x00_disable_fce_trace(vha, NULL, NULL); 2090 2091 if (ha->eft) 2092 qla2x00_disable_eft_trace(vha); 2093 2094 /* Stop currently executing firmware. */ 2095 qla2x00_try_to_stop_firmware(vha); 2096 2097 /* turn-off interrupts on the card */ 2098 if (ha->interrupts_on) 2099 ha->isp_ops->disable_intrs(ha); 2100 2101 qla2x00_free_irqs(vha); 2102 2103 qla2x00_mem_free(ha); 2104 2105 qla2x00_free_queues(ha); 2106 } 2107 2108 static inline void 2109 qla2x00_schedule_rport_del(struct scsi_qla_host *vha, fc_port_t *fcport, 2110 int defer) 2111 { 2112 struct fc_rport *rport; 2113 2114 if (!fcport->rport) 2115 return; 2116 2117 rport = fcport->rport; 2118 if (defer) { 2119 spin_lock_irq(vha->host->host_lock); 2120 fcport->drport = rport; 2121 spin_unlock_irq(vha->host->host_lock); 2122 set_bit(FCPORT_UPDATE_NEEDED, &vha->dpc_flags); 2123 qla2xxx_wake_dpc(vha); 2124 } else 2125 fc_remote_port_delete(rport); 2126 } 2127 2128 /* 2129 * qla2x00_mark_device_lost Updates fcport state when device goes offline. 2130 * 2131 * Input: ha = adapter block pointer. fcport = port structure pointer. 2132 * 2133 * Return: None. 2134 * 2135 * Context: 2136 */ 2137 void qla2x00_mark_device_lost(scsi_qla_host_t *vha, fc_port_t *fcport, 2138 int do_login, int defer) 2139 { 2140 if (atomic_read(&fcport->state) == FCS_ONLINE && 2141 vha->vp_idx == fcport->vp_idx) { 2142 atomic_set(&fcport->state, FCS_DEVICE_LOST); 2143 qla2x00_schedule_rport_del(vha, fcport, defer); 2144 } 2145 /* 2146 * We may need to retry the login, so don't change the state of the 2147 * port but do the retries. 2148 */ 2149 if (atomic_read(&fcport->state) != FCS_DEVICE_DEAD) 2150 atomic_set(&fcport->state, FCS_DEVICE_LOST); 2151 2152 if (!do_login) 2153 return; 2154 2155 if (fcport->login_retry == 0) { 2156 fcport->login_retry = vha->hw->login_retry_count; 2157 set_bit(RELOGIN_NEEDED, &vha->dpc_flags); 2158 2159 DEBUG(printk("scsi(%ld): Port login retry: " 2160 "%02x%02x%02x%02x%02x%02x%02x%02x, " 2161 "id = 0x%04x retry cnt=%d\n", 2162 vha->host_no, 2163 fcport->port_name[0], 2164 fcport->port_name[1], 2165 fcport->port_name[2], 2166 fcport->port_name[3], 2167 fcport->port_name[4], 2168 fcport->port_name[5], 2169 fcport->port_name[6], 2170 fcport->port_name[7], 2171 fcport->loop_id, 2172 fcport->login_retry)); 2173 } 2174 } 2175 2176 /* 2177 * qla2x00_mark_all_devices_lost 2178 * Updates fcport state when device goes offline. 2179 * 2180 * Input: 2181 * ha = adapter block pointer. 2182 * fcport = port structure pointer. 2183 * 2184 * Return: 2185 * None. 2186 * 2187 * Context: 2188 */ 2189 void 2190 qla2x00_mark_all_devices_lost(scsi_qla_host_t *vha, int defer) 2191 { 2192 fc_port_t *fcport; 2193 2194 list_for_each_entry(fcport, &vha->vp_fcports, list) { 2195 if (vha->vp_idx != fcport->vp_idx) 2196 continue; 2197 /* 2198 * No point in marking the device as lost, if the device is 2199 * already DEAD. 2200 */ 2201 if (atomic_read(&fcport->state) == FCS_DEVICE_DEAD) 2202 continue; 2203 if (atomic_read(&fcport->state) == FCS_ONLINE) { 2204 atomic_set(&fcport->state, FCS_DEVICE_LOST); 2205 qla2x00_schedule_rport_del(vha, fcport, defer); 2206 } else 2207 atomic_set(&fcport->state, FCS_DEVICE_LOST); 2208 } 2209 } 2210 2211 /* 2212 * qla2x00_mem_alloc 2213 * Allocates adapter memory. 2214 * 2215 * Returns: 2216 * 0 = success. 2217 * !0 = failure. 2218 */ 2219 static int 2220 qla2x00_mem_alloc(struct qla_hw_data *ha, uint16_t req_len, uint16_t rsp_len, 2221 struct req_que **req, struct rsp_que **rsp) 2222 { 2223 char name[16]; 2224 2225 ha->init_cb = dma_alloc_coherent(&ha->pdev->dev, ha->init_cb_size, 2226 &ha->init_cb_dma, GFP_KERNEL); 2227 if (!ha->init_cb) 2228 goto fail; 2229 2230 ha->gid_list = dma_alloc_coherent(&ha->pdev->dev, GID_LIST_SIZE, 2231 &ha->gid_list_dma, GFP_KERNEL); 2232 if (!ha->gid_list) 2233 goto fail_free_init_cb; 2234 2235 ha->srb_mempool = mempool_create_slab_pool(SRB_MIN_REQ, srb_cachep); 2236 if (!ha->srb_mempool) 2237 goto fail_free_gid_list; 2238 2239 /* Get memory for cached NVRAM */ 2240 ha->nvram = kzalloc(MAX_NVRAM_SIZE, GFP_KERNEL); 2241 if (!ha->nvram) 2242 goto fail_free_srb_mempool; 2243 2244 snprintf(name, sizeof(name), "%s_%d", QLA2XXX_DRIVER_NAME, 2245 ha->pdev->device); 2246 ha->s_dma_pool = dma_pool_create(name, &ha->pdev->dev, 2247 DMA_POOL_SIZE, 8, 0); 2248 if (!ha->s_dma_pool) 2249 goto fail_free_nvram; 2250 2251 /* Allocate memory for SNS commands */ 2252 if (IS_QLA2100(ha) || IS_QLA2200(ha)) { 2253 /* Get consistent memory allocated for SNS commands */ 2254 ha->sns_cmd = dma_alloc_coherent(&ha->pdev->dev, 2255 sizeof(struct sns_cmd_pkt), &ha->sns_cmd_dma, GFP_KERNEL); 2256 if (!ha->sns_cmd) 2257 goto fail_dma_pool; 2258 } else { 2259 /* Get consistent memory allocated for MS IOCB */ 2260 ha->ms_iocb = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, 2261 &ha->ms_iocb_dma); 2262 if (!ha->ms_iocb) 2263 goto fail_dma_pool; 2264 /* Get consistent memory allocated for CT SNS commands */ 2265 ha->ct_sns = dma_alloc_coherent(&ha->pdev->dev, 2266 sizeof(struct ct_sns_pkt), &ha->ct_sns_dma, GFP_KERNEL); 2267 if (!ha->ct_sns) 2268 goto fail_free_ms_iocb; 2269 } 2270 2271 /* Allocate memory for request ring */ 2272 *req = kzalloc(sizeof(struct req_que), GFP_KERNEL); 2273 if (!*req) { 2274 DEBUG(printk("Unable to allocate memory for req\n")); 2275 goto fail_req; 2276 } 2277 (*req)->length = req_len; 2278 (*req)->ring = dma_alloc_coherent(&ha->pdev->dev, 2279 ((*req)->length + 1) * sizeof(request_t), 2280 &(*req)->dma, GFP_KERNEL); 2281 if (!(*req)->ring) { 2282 DEBUG(printk("Unable to allocate memory for req_ring\n")); 2283 goto fail_req_ring; 2284 } 2285 /* Allocate memory for response ring */ 2286 *rsp = kzalloc(sizeof(struct rsp_que), GFP_KERNEL); 2287 if (!*rsp) { 2288 qla_printk(KERN_WARNING, ha, 2289 "Unable to allocate memory for rsp\n"); 2290 goto fail_rsp; 2291 } 2292 (*rsp)->hw = ha; 2293 (*rsp)->length = rsp_len; 2294 (*rsp)->ring = dma_alloc_coherent(&ha->pdev->dev, 2295 ((*rsp)->length + 1) * sizeof(response_t), 2296 &(*rsp)->dma, GFP_KERNEL); 2297 if (!(*rsp)->ring) { 2298 qla_printk(KERN_WARNING, ha, 2299 "Unable to allocate memory for rsp_ring\n"); 2300 goto fail_rsp_ring; 2301 } 2302 (*req)->rsp = *rsp; 2303 (*rsp)->req = *req; 2304 /* Allocate memory for NVRAM data for vports */ 2305 if (ha->nvram_npiv_size) { 2306 ha->npiv_info = kzalloc(sizeof(struct qla_npiv_entry) * 2307 ha->nvram_npiv_size, GFP_KERNEL); 2308 if (!ha->npiv_info) { 2309 qla_printk(KERN_WARNING, ha, 2310 "Unable to allocate memory for npiv info\n"); 2311 goto fail_npiv_info; 2312 } 2313 } else 2314 ha->npiv_info = NULL; 2315 2316 INIT_LIST_HEAD(&ha->vp_list); 2317 return 1; 2318 2319 fail_npiv_info: 2320 dma_free_coherent(&ha->pdev->dev, ((*rsp)->length + 1) * 2321 sizeof(response_t), (*rsp)->ring, (*rsp)->dma); 2322 (*rsp)->ring = NULL; 2323 (*rsp)->dma = 0; 2324 fail_rsp_ring: 2325 kfree(*rsp); 2326 fail_rsp: 2327 dma_free_coherent(&ha->pdev->dev, ((*req)->length + 1) * 2328 sizeof(request_t), (*req)->ring, (*req)->dma); 2329 (*req)->ring = NULL; 2330 (*req)->dma = 0; 2331 fail_req_ring: 2332 kfree(*req); 2333 fail_req: 2334 dma_free_coherent(&ha->pdev->dev, sizeof(struct ct_sns_pkt), 2335 ha->ct_sns, ha->ct_sns_dma); 2336 ha->ct_sns = NULL; 2337 ha->ct_sns_dma = 0; 2338 fail_free_ms_iocb: 2339 dma_pool_free(ha->s_dma_pool, ha->ms_iocb, ha->ms_iocb_dma); 2340 ha->ms_iocb = NULL; 2341 ha->ms_iocb_dma = 0; 2342 fail_dma_pool: 2343 dma_pool_destroy(ha->s_dma_pool); 2344 ha->s_dma_pool = NULL; 2345 fail_free_nvram: 2346 kfree(ha->nvram); 2347 ha->nvram = NULL; 2348 fail_free_srb_mempool: 2349 mempool_destroy(ha->srb_mempool); 2350 ha->srb_mempool = NULL; 2351 fail_free_gid_list: 2352 dma_free_coherent(&ha->pdev->dev, GID_LIST_SIZE, ha->gid_list, 2353 ha->gid_list_dma); 2354 ha->gid_list = NULL; 2355 ha->gid_list_dma = 0; 2356 fail_free_init_cb: 2357 dma_free_coherent(&ha->pdev->dev, ha->init_cb_size, ha->init_cb, 2358 ha->init_cb_dma); 2359 ha->init_cb = NULL; 2360 ha->init_cb_dma = 0; 2361 fail: 2362 DEBUG(printk("%s: Memory allocation failure\n", __func__)); 2363 return -ENOMEM; 2364 } 2365 2366 /* 2367 * qla2x00_mem_free 2368 * Frees all adapter allocated memory. 2369 * 2370 * Input: 2371 * ha = adapter block pointer. 2372 */ 2373 static void 2374 qla2x00_mem_free(struct qla_hw_data *ha) 2375 { 2376 if (ha->srb_mempool) 2377 mempool_destroy(ha->srb_mempool); 2378 2379 if (ha->fce) 2380 dma_free_coherent(&ha->pdev->dev, FCE_SIZE, ha->fce, 2381 ha->fce_dma); 2382 2383 if (ha->fw_dump) { 2384 if (ha->eft) 2385 dma_free_coherent(&ha->pdev->dev, 2386 ntohl(ha->fw_dump->eft_size), ha->eft, ha->eft_dma); 2387 vfree(ha->fw_dump); 2388 } 2389 2390 if (ha->sns_cmd) 2391 dma_free_coherent(&ha->pdev->dev, sizeof(struct sns_cmd_pkt), 2392 ha->sns_cmd, ha->sns_cmd_dma); 2393 2394 if (ha->ct_sns) 2395 dma_free_coherent(&ha->pdev->dev, sizeof(struct ct_sns_pkt), 2396 ha->ct_sns, ha->ct_sns_dma); 2397 2398 if (ha->sfp_data) 2399 dma_pool_free(ha->s_dma_pool, ha->sfp_data, ha->sfp_data_dma); 2400 2401 if (ha->ms_iocb) 2402 dma_pool_free(ha->s_dma_pool, ha->ms_iocb, ha->ms_iocb_dma); 2403 2404 if (ha->s_dma_pool) 2405 dma_pool_destroy(ha->s_dma_pool); 2406 2407 2408 if (ha->gid_list) 2409 dma_free_coherent(&ha->pdev->dev, GID_LIST_SIZE, ha->gid_list, 2410 ha->gid_list_dma); 2411 2412 2413 if (ha->init_cb) 2414 dma_free_coherent(&ha->pdev->dev, ha->init_cb_size, 2415 ha->init_cb, ha->init_cb_dma); 2416 vfree(ha->optrom_buffer); 2417 kfree(ha->nvram); 2418 kfree(ha->npiv_info); 2419 2420 ha->srb_mempool = NULL; 2421 ha->eft = NULL; 2422 ha->eft_dma = 0; 2423 ha->sns_cmd = NULL; 2424 ha->sns_cmd_dma = 0; 2425 ha->ct_sns = NULL; 2426 ha->ct_sns_dma = 0; 2427 ha->ms_iocb = NULL; 2428 ha->ms_iocb_dma = 0; 2429 ha->init_cb = NULL; 2430 ha->init_cb_dma = 0; 2431 2432 ha->s_dma_pool = NULL; 2433 2434 ha->gid_list = NULL; 2435 ha->gid_list_dma = 0; 2436 2437 ha->fw_dump = NULL; 2438 ha->fw_dumped = 0; 2439 ha->fw_dump_reading = 0; 2440 } 2441 2442 struct scsi_qla_host *qla2x00_create_host(struct scsi_host_template *sht, 2443 struct qla_hw_data *ha) 2444 { 2445 struct Scsi_Host *host; 2446 struct scsi_qla_host *vha = NULL; 2447 2448 host = scsi_host_alloc(sht, sizeof(scsi_qla_host_t)); 2449 if (host == NULL) { 2450 printk(KERN_WARNING 2451 "qla2xxx: Couldn't allocate host from scsi layer!\n"); 2452 goto fail; 2453 } 2454 2455 /* Clear our data area */ 2456 vha = shost_priv(host); 2457 memset(vha, 0, sizeof(scsi_qla_host_t)); 2458 2459 vha->host = host; 2460 vha->host_no = host->host_no; 2461 vha->hw = ha; 2462 2463 INIT_LIST_HEAD(&vha->vp_fcports); 2464 INIT_LIST_HEAD(&vha->work_list); 2465 INIT_LIST_HEAD(&vha->list); 2466 2467 sprintf(vha->host_str, "%s_%ld", QLA2XXX_DRIVER_NAME, vha->host_no); 2468 return vha; 2469 2470 fail: 2471 return vha; 2472 } 2473 2474 static struct qla_work_evt * 2475 qla2x00_alloc_work(struct scsi_qla_host *vha, enum qla_work_type type, 2476 int locked) 2477 { 2478 struct qla_work_evt *e; 2479 2480 e = kzalloc(sizeof(struct qla_work_evt), locked ? GFP_ATOMIC: 2481 GFP_KERNEL); 2482 if (!e) 2483 return NULL; 2484 2485 INIT_LIST_HEAD(&e->list); 2486 e->type = type; 2487 e->flags = QLA_EVT_FLAG_FREE; 2488 return e; 2489 } 2490 2491 static int 2492 qla2x00_post_work(struct scsi_qla_host *vha, struct qla_work_evt *e, int locked) 2493 { 2494 unsigned long uninitialized_var(flags); 2495 struct qla_hw_data *ha = vha->hw; 2496 2497 if (!locked) 2498 spin_lock_irqsave(&ha->hardware_lock, flags); 2499 list_add_tail(&e->list, &vha->work_list); 2500 qla2xxx_wake_dpc(vha); 2501 if (!locked) 2502 spin_unlock_irqrestore(&ha->hardware_lock, flags); 2503 return QLA_SUCCESS; 2504 } 2505 2506 int 2507 qla2x00_post_aen_work(struct scsi_qla_host *vha, enum fc_host_event_code code, 2508 u32 data) 2509 { 2510 struct qla_work_evt *e; 2511 2512 e = qla2x00_alloc_work(vha, QLA_EVT_AEN, 1); 2513 if (!e) 2514 return QLA_FUNCTION_FAILED; 2515 2516 e->u.aen.code = code; 2517 e->u.aen.data = data; 2518 return qla2x00_post_work(vha, e, 1); 2519 } 2520 2521 int 2522 qla2x00_post_idc_ack_work(struct scsi_qla_host *vha, uint16_t *mb) 2523 { 2524 struct qla_work_evt *e; 2525 2526 e = qla2x00_alloc_work(vha, QLA_EVT_IDC_ACK, 1); 2527 if (!e) 2528 return QLA_FUNCTION_FAILED; 2529 2530 memcpy(e->u.idc_ack.mb, mb, QLA_IDC_ACK_REGS * sizeof(uint16_t)); 2531 return qla2x00_post_work(vha, e, 1); 2532 } 2533 2534 static void 2535 qla2x00_do_work(struct scsi_qla_host *vha) 2536 { 2537 struct qla_work_evt *e; 2538 struct qla_hw_data *ha = vha->hw; 2539 2540 spin_lock_irq(&ha->hardware_lock); 2541 while (!list_empty(&vha->work_list)) { 2542 e = list_entry(vha->work_list.next, struct qla_work_evt, list); 2543 list_del_init(&e->list); 2544 spin_unlock_irq(&ha->hardware_lock); 2545 2546 switch (e->type) { 2547 case QLA_EVT_AEN: 2548 fc_host_post_event(vha->host, fc_get_event_number(), 2549 e->u.aen.code, e->u.aen.data); 2550 break; 2551 case QLA_EVT_IDC_ACK: 2552 qla81xx_idc_ack(vha, e->u.idc_ack.mb); 2553 break; 2554 } 2555 if (e->flags & QLA_EVT_FLAG_FREE) 2556 kfree(e); 2557 spin_lock_irq(&ha->hardware_lock); 2558 } 2559 spin_unlock_irq(&ha->hardware_lock); 2560 } 2561 /* Relogins all the fcports of a vport 2562 * Context: dpc thread 2563 */ 2564 void qla2x00_relogin(struct scsi_qla_host *vha) 2565 { 2566 fc_port_t *fcport; 2567 int status; 2568 uint16_t next_loopid = 0; 2569 struct qla_hw_data *ha = vha->hw; 2570 2571 list_for_each_entry(fcport, &vha->vp_fcports, list) { 2572 /* 2573 * If the port is not ONLINE then try to login 2574 * to it if we haven't run out of retries. 2575 */ 2576 if (atomic_read(&fcport->state) != 2577 FCS_ONLINE && fcport->login_retry) { 2578 2579 if (fcport->flags & FCF_FABRIC_DEVICE) { 2580 if (fcport->flags & FCF_TAPE_PRESENT) 2581 ha->isp_ops->fabric_logout(vha, 2582 fcport->loop_id, 2583 fcport->d_id.b.domain, 2584 fcport->d_id.b.area, 2585 fcport->d_id.b.al_pa); 2586 2587 status = qla2x00_fabric_login(vha, fcport, 2588 &next_loopid); 2589 } else 2590 status = qla2x00_local_device_login(vha, 2591 fcport); 2592 2593 fcport->login_retry--; 2594 if (status == QLA_SUCCESS) { 2595 fcport->old_loop_id = fcport->loop_id; 2596 2597 DEBUG(printk("scsi(%ld): port login OK: logged " 2598 "in ID 0x%x\n", vha->host_no, fcport->loop_id)); 2599 2600 qla2x00_update_fcport(vha, fcport); 2601 2602 } else if (status == 1) { 2603 set_bit(RELOGIN_NEEDED, &vha->dpc_flags); 2604 /* retry the login again */ 2605 DEBUG(printk("scsi(%ld): Retrying" 2606 " %d login again loop_id 0x%x\n", 2607 vha->host_no, fcport->login_retry, 2608 fcport->loop_id)); 2609 } else { 2610 fcport->login_retry = 0; 2611 } 2612 2613 if (fcport->login_retry == 0 && status != QLA_SUCCESS) 2614 fcport->loop_id = FC_NO_LOOP_ID; 2615 } 2616 if (test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags)) 2617 break; 2618 } 2619 } 2620 2621 /************************************************************************** 2622 * qla2x00_do_dpc 2623 * This kernel thread is a task that is schedule by the interrupt handler 2624 * to perform the background processing for interrupts. 2625 * 2626 * Notes: 2627 * This task always run in the context of a kernel thread. It 2628 * is kick-off by the driver's detect code and starts up 2629 * up one per adapter. It immediately goes to sleep and waits for 2630 * some fibre event. When either the interrupt handler or 2631 * the timer routine detects a event it will one of the task 2632 * bits then wake us up. 2633 **************************************************************************/ 2634 static int 2635 qla2x00_do_dpc(void *data) 2636 { 2637 int rval; 2638 scsi_qla_host_t *base_vha; 2639 struct qla_hw_data *ha; 2640 2641 ha = (struct qla_hw_data *)data; 2642 base_vha = pci_get_drvdata(ha->pdev); 2643 2644 set_user_nice(current, -20); 2645 2646 while (!kthread_should_stop()) { 2647 DEBUG3(printk("qla2x00: DPC handler sleeping\n")); 2648 2649 set_current_state(TASK_INTERRUPTIBLE); 2650 schedule(); 2651 __set_current_state(TASK_RUNNING); 2652 2653 DEBUG3(printk("qla2x00: DPC handler waking up\n")); 2654 2655 /* Initialization not yet finished. Don't do anything yet. */ 2656 if (!base_vha->flags.init_done) 2657 continue; 2658 2659 DEBUG3(printk("scsi(%ld): DPC handler\n", base_vha->host_no)); 2660 2661 ha->dpc_active = 1; 2662 2663 if (ha->flags.mbox_busy) { 2664 ha->dpc_active = 0; 2665 continue; 2666 } 2667 2668 qla2x00_do_work(base_vha); 2669 2670 if (test_and_clear_bit(ISP_ABORT_NEEDED, 2671 &base_vha->dpc_flags)) { 2672 2673 DEBUG(printk("scsi(%ld): dpc: sched " 2674 "qla2x00_abort_isp ha = %p\n", 2675 base_vha->host_no, ha)); 2676 if (!(test_and_set_bit(ABORT_ISP_ACTIVE, 2677 &base_vha->dpc_flags))) { 2678 2679 if (qla2x00_abort_isp(base_vha)) { 2680 /* failed. retry later */ 2681 set_bit(ISP_ABORT_NEEDED, 2682 &base_vha->dpc_flags); 2683 } 2684 clear_bit(ABORT_ISP_ACTIVE, 2685 &base_vha->dpc_flags); 2686 } 2687 2688 DEBUG(printk("scsi(%ld): dpc: qla2x00_abort_isp end\n", 2689 base_vha->host_no)); 2690 } 2691 2692 if (test_bit(FCPORT_UPDATE_NEEDED, &base_vha->dpc_flags)) { 2693 qla2x00_update_fcports(base_vha); 2694 clear_bit(FCPORT_UPDATE_NEEDED, &base_vha->dpc_flags); 2695 } 2696 2697 if (test_and_clear_bit(RESET_MARKER_NEEDED, 2698 &base_vha->dpc_flags) && 2699 (!(test_and_set_bit(RESET_ACTIVE, &base_vha->dpc_flags)))) { 2700 2701 DEBUG(printk("scsi(%ld): qla2x00_reset_marker()\n", 2702 base_vha->host_no)); 2703 2704 qla2x00_rst_aen(base_vha); 2705 clear_bit(RESET_ACTIVE, &base_vha->dpc_flags); 2706 } 2707 2708 /* Retry each device up to login retry count */ 2709 if ((test_and_clear_bit(RELOGIN_NEEDED, 2710 &base_vha->dpc_flags)) && 2711 !test_bit(LOOP_RESYNC_NEEDED, &base_vha->dpc_flags) && 2712 atomic_read(&base_vha->loop_state) != LOOP_DOWN) { 2713 2714 DEBUG(printk("scsi(%ld): qla2x00_port_login()\n", 2715 base_vha->host_no)); 2716 qla2x00_relogin(base_vha); 2717 2718 DEBUG(printk("scsi(%ld): qla2x00_port_login - end\n", 2719 base_vha->host_no)); 2720 } 2721 2722 if (test_and_clear_bit(LOOP_RESYNC_NEEDED, 2723 &base_vha->dpc_flags)) { 2724 2725 DEBUG(printk("scsi(%ld): qla2x00_loop_resync()\n", 2726 base_vha->host_no)); 2727 2728 if (!(test_and_set_bit(LOOP_RESYNC_ACTIVE, 2729 &base_vha->dpc_flags))) { 2730 2731 rval = qla2x00_loop_resync(base_vha); 2732 2733 clear_bit(LOOP_RESYNC_ACTIVE, 2734 &base_vha->dpc_flags); 2735 } 2736 2737 DEBUG(printk("scsi(%ld): qla2x00_loop_resync - end\n", 2738 base_vha->host_no)); 2739 } 2740 2741 if (test_bit(NPIV_CONFIG_NEEDED, &base_vha->dpc_flags) && 2742 atomic_read(&base_vha->loop_state) == LOOP_READY) { 2743 clear_bit(NPIV_CONFIG_NEEDED, &base_vha->dpc_flags); 2744 qla2xxx_flash_npiv_conf(base_vha); 2745 } 2746 2747 if (!ha->interrupts_on) 2748 ha->isp_ops->enable_intrs(ha); 2749 2750 if (test_and_clear_bit(BEACON_BLINK_NEEDED, 2751 &base_vha->dpc_flags)) 2752 ha->isp_ops->beacon_blink(base_vha); 2753 2754 qla2x00_do_dpc_all_vps(base_vha); 2755 2756 ha->dpc_active = 0; 2757 } /* End of while(1) */ 2758 2759 DEBUG(printk("scsi(%ld): DPC handler exiting\n", base_vha->host_no)); 2760 2761 /* 2762 * Make sure that nobody tries to wake us up again. 2763 */ 2764 ha->dpc_active = 0; 2765 2766 return 0; 2767 } 2768 2769 void 2770 qla2xxx_wake_dpc(struct scsi_qla_host *vha) 2771 { 2772 struct qla_hw_data *ha = vha->hw; 2773 struct task_struct *t = ha->dpc_thread; 2774 2775 if (!test_bit(UNLOADING, &vha->dpc_flags) && t) 2776 wake_up_process(t); 2777 } 2778 2779 /* 2780 * qla2x00_rst_aen 2781 * Processes asynchronous reset. 2782 * 2783 * Input: 2784 * ha = adapter block pointer. 2785 */ 2786 static void 2787 qla2x00_rst_aen(scsi_qla_host_t *vha) 2788 { 2789 if (vha->flags.online && !vha->flags.reset_active && 2790 !atomic_read(&vha->loop_down_timer) && 2791 !(test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags))) { 2792 do { 2793 clear_bit(RESET_MARKER_NEEDED, &vha->dpc_flags); 2794 2795 /* 2796 * Issue marker command only when we are going to start 2797 * the I/O. 2798 */ 2799 vha->marker_needed = 1; 2800 } while (!atomic_read(&vha->loop_down_timer) && 2801 (test_bit(RESET_MARKER_NEEDED, &vha->dpc_flags))); 2802 } 2803 } 2804 2805 static void 2806 qla2x00_sp_free_dma(srb_t *sp) 2807 { 2808 struct scsi_cmnd *cmd = sp->cmd; 2809 2810 if (sp->flags & SRB_DMA_VALID) { 2811 scsi_dma_unmap(cmd); 2812 sp->flags &= ~SRB_DMA_VALID; 2813 } 2814 CMD_SP(cmd) = NULL; 2815 } 2816 2817 void 2818 qla2x00_sp_compl(struct qla_hw_data *ha, srb_t *sp) 2819 { 2820 struct scsi_cmnd *cmd = sp->cmd; 2821 2822 qla2x00_sp_free_dma(sp); 2823 2824 mempool_free(sp, ha->srb_mempool); 2825 2826 cmd->scsi_done(cmd); 2827 } 2828 2829 /************************************************************************** 2830 * qla2x00_timer 2831 * 2832 * Description: 2833 * One second timer 2834 * 2835 * Context: Interrupt 2836 ***************************************************************************/ 2837 void 2838 qla2x00_timer(scsi_qla_host_t *vha) 2839 { 2840 unsigned long cpu_flags = 0; 2841 fc_port_t *fcport; 2842 int start_dpc = 0; 2843 int index; 2844 srb_t *sp; 2845 int t; 2846 struct qla_hw_data *ha = vha->hw; 2847 struct req_que *req; 2848 /* 2849 * Ports - Port down timer. 2850 * 2851 * Whenever, a port is in the LOST state we start decrementing its port 2852 * down timer every second until it reaches zero. Once it reaches zero 2853 * the port it marked DEAD. 2854 */ 2855 t = 0; 2856 list_for_each_entry(fcport, &vha->vp_fcports, list) { 2857 if (fcport->port_type != FCT_TARGET) 2858 continue; 2859 2860 if (atomic_read(&fcport->state) == FCS_DEVICE_LOST) { 2861 2862 if (atomic_read(&fcport->port_down_timer) == 0) 2863 continue; 2864 2865 if (atomic_dec_and_test(&fcport->port_down_timer) != 0) 2866 atomic_set(&fcport->state, FCS_DEVICE_DEAD); 2867 2868 DEBUG(printk("scsi(%ld): fcport-%d - port retry count: " 2869 "%d remaining\n", 2870 vha->host_no, 2871 t, atomic_read(&fcport->port_down_timer))); 2872 } 2873 t++; 2874 } /* End of for fcport */ 2875 2876 2877 /* Loop down handler. */ 2878 if (atomic_read(&vha->loop_down_timer) > 0 && 2879 !(test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags)) 2880 && vha->flags.online) { 2881 2882 if (atomic_read(&vha->loop_down_timer) == 2883 vha->loop_down_abort_time) { 2884 2885 DEBUG(printk("scsi(%ld): Loop Down - aborting the " 2886 "queues before time expire\n", 2887 vha->host_no)); 2888 2889 if (!IS_QLA2100(ha) && vha->link_down_timeout) 2890 atomic_set(&vha->loop_state, LOOP_DEAD); 2891 2892 /* Schedule an ISP abort to return any tape commands. */ 2893 /* NPIV - scan physical port only */ 2894 if (!vha->vp_idx) { 2895 spin_lock_irqsave(&ha->hardware_lock, 2896 cpu_flags); 2897 req = ha->req_q_map[0]; 2898 for (index = 1; 2899 index < MAX_OUTSTANDING_COMMANDS; 2900 index++) { 2901 fc_port_t *sfcp; 2902 2903 sp = req->outstanding_cmds[index]; 2904 if (!sp) 2905 continue; 2906 sfcp = sp->fcport; 2907 if (!(sfcp->flags & FCF_TAPE_PRESENT)) 2908 continue; 2909 2910 set_bit(ISP_ABORT_NEEDED, 2911 &vha->dpc_flags); 2912 break; 2913 } 2914 spin_unlock_irqrestore(&ha->hardware_lock, 2915 cpu_flags); 2916 } 2917 set_bit(ABORT_QUEUES_NEEDED, &vha->dpc_flags); 2918 start_dpc++; 2919 } 2920 2921 /* if the loop has been down for 4 minutes, reinit adapter */ 2922 if (atomic_dec_and_test(&vha->loop_down_timer) != 0) { 2923 DEBUG(printk("scsi(%ld): Loop down exceed 4 mins - " 2924 "restarting queues.\n", 2925 vha->host_no)); 2926 2927 set_bit(RESTART_QUEUES_NEEDED, &vha->dpc_flags); 2928 start_dpc++; 2929 2930 if (!(vha->device_flags & DFLG_NO_CABLE) && 2931 !vha->vp_idx) { 2932 DEBUG(printk("scsi(%ld): Loop down - " 2933 "aborting ISP.\n", 2934 vha->host_no)); 2935 qla_printk(KERN_WARNING, ha, 2936 "Loop down - aborting ISP.\n"); 2937 2938 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags); 2939 } 2940 } 2941 DEBUG3(printk("scsi(%ld): Loop Down - seconds remaining %d\n", 2942 vha->host_no, 2943 atomic_read(&vha->loop_down_timer))); 2944 } 2945 2946 /* Check if beacon LED needs to be blinked */ 2947 if (ha->beacon_blink_led == 1) { 2948 set_bit(BEACON_BLINK_NEEDED, &vha->dpc_flags); 2949 start_dpc++; 2950 } 2951 2952 /* Process any deferred work. */ 2953 if (!list_empty(&vha->work_list)) 2954 start_dpc++; 2955 2956 /* Schedule the DPC routine if needed */ 2957 if ((test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags) || 2958 test_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags) || 2959 test_bit(FCPORT_UPDATE_NEEDED, &vha->dpc_flags) || 2960 start_dpc || 2961 test_bit(RESET_MARKER_NEEDED, &vha->dpc_flags) || 2962 test_bit(BEACON_BLINK_NEEDED, &vha->dpc_flags) || 2963 test_bit(VP_DPC_NEEDED, &vha->dpc_flags) || 2964 test_bit(RELOGIN_NEEDED, &vha->dpc_flags))) 2965 qla2xxx_wake_dpc(vha); 2966 2967 qla2x00_restart_timer(vha, WATCH_INTERVAL); 2968 } 2969 2970 /* Firmware interface routines. */ 2971 2972 #define FW_BLOBS 7 2973 #define FW_ISP21XX 0 2974 #define FW_ISP22XX 1 2975 #define FW_ISP2300 2 2976 #define FW_ISP2322 3 2977 #define FW_ISP24XX 4 2978 #define FW_ISP25XX 5 2979 #define FW_ISP81XX 6 2980 2981 #define FW_FILE_ISP21XX "ql2100_fw.bin" 2982 #define FW_FILE_ISP22XX "ql2200_fw.bin" 2983 #define FW_FILE_ISP2300 "ql2300_fw.bin" 2984 #define FW_FILE_ISP2322 "ql2322_fw.bin" 2985 #define FW_FILE_ISP24XX "ql2400_fw.bin" 2986 #define FW_FILE_ISP25XX "ql2500_fw.bin" 2987 #define FW_FILE_ISP81XX "ql8100_fw.bin" 2988 2989 static DEFINE_MUTEX(qla_fw_lock); 2990 2991 static struct fw_blob qla_fw_blobs[FW_BLOBS] = { 2992 { .name = FW_FILE_ISP21XX, .segs = { 0x1000, 0 }, }, 2993 { .name = FW_FILE_ISP22XX, .segs = { 0x1000, 0 }, }, 2994 { .name = FW_FILE_ISP2300, .segs = { 0x800, 0 }, }, 2995 { .name = FW_FILE_ISP2322, .segs = { 0x800, 0x1c000, 0x1e000, 0 }, }, 2996 { .name = FW_FILE_ISP24XX, }, 2997 { .name = FW_FILE_ISP25XX, }, 2998 { .name = FW_FILE_ISP81XX, }, 2999 }; 3000 3001 struct fw_blob * 3002 qla2x00_request_firmware(scsi_qla_host_t *vha) 3003 { 3004 struct qla_hw_data *ha = vha->hw; 3005 struct fw_blob *blob; 3006 3007 blob = NULL; 3008 if (IS_QLA2100(ha)) { 3009 blob = &qla_fw_blobs[FW_ISP21XX]; 3010 } else if (IS_QLA2200(ha)) { 3011 blob = &qla_fw_blobs[FW_ISP22XX]; 3012 } else if (IS_QLA2300(ha) || IS_QLA2312(ha) || IS_QLA6312(ha)) { 3013 blob = &qla_fw_blobs[FW_ISP2300]; 3014 } else if (IS_QLA2322(ha) || IS_QLA6322(ha)) { 3015 blob = &qla_fw_blobs[FW_ISP2322]; 3016 } else if (IS_QLA24XX_TYPE(ha)) { 3017 blob = &qla_fw_blobs[FW_ISP24XX]; 3018 } else if (IS_QLA25XX(ha)) { 3019 blob = &qla_fw_blobs[FW_ISP25XX]; 3020 } else if (IS_QLA81XX(ha)) { 3021 blob = &qla_fw_blobs[FW_ISP81XX]; 3022 } 3023 3024 mutex_lock(&qla_fw_lock); 3025 if (blob->fw) 3026 goto out; 3027 3028 if (request_firmware(&blob->fw, blob->name, &ha->pdev->dev)) { 3029 DEBUG2(printk("scsi(%ld): Failed to load firmware image " 3030 "(%s).\n", vha->host_no, blob->name)); 3031 blob->fw = NULL; 3032 blob = NULL; 3033 goto out; 3034 } 3035 3036 out: 3037 mutex_unlock(&qla_fw_lock); 3038 return blob; 3039 } 3040 3041 static void 3042 qla2x00_release_firmware(void) 3043 { 3044 int idx; 3045 3046 mutex_lock(&qla_fw_lock); 3047 for (idx = 0; idx < FW_BLOBS; idx++) 3048 if (qla_fw_blobs[idx].fw) 3049 release_firmware(qla_fw_blobs[idx].fw); 3050 mutex_unlock(&qla_fw_lock); 3051 } 3052 3053 static pci_ers_result_t 3054 qla2xxx_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state) 3055 { 3056 switch (state) { 3057 case pci_channel_io_normal: 3058 return PCI_ERS_RESULT_CAN_RECOVER; 3059 case pci_channel_io_frozen: 3060 pci_disable_device(pdev); 3061 return PCI_ERS_RESULT_NEED_RESET; 3062 case pci_channel_io_perm_failure: 3063 qla2x00_remove_one(pdev); 3064 return PCI_ERS_RESULT_DISCONNECT; 3065 } 3066 return PCI_ERS_RESULT_NEED_RESET; 3067 } 3068 3069 static pci_ers_result_t 3070 qla2xxx_pci_mmio_enabled(struct pci_dev *pdev) 3071 { 3072 int risc_paused = 0; 3073 uint32_t stat; 3074 unsigned long flags; 3075 scsi_qla_host_t *base_vha = pci_get_drvdata(pdev); 3076 struct qla_hw_data *ha = base_vha->hw; 3077 struct device_reg_2xxx __iomem *reg = &ha->iobase->isp; 3078 struct device_reg_24xx __iomem *reg24 = &ha->iobase->isp24; 3079 3080 spin_lock_irqsave(&ha->hardware_lock, flags); 3081 if (IS_QLA2100(ha) || IS_QLA2200(ha)){ 3082 stat = RD_REG_DWORD(®->hccr); 3083 if (stat & HCCR_RISC_PAUSE) 3084 risc_paused = 1; 3085 } else if (IS_QLA23XX(ha)) { 3086 stat = RD_REG_DWORD(®->u.isp2300.host_status); 3087 if (stat & HSR_RISC_PAUSED) 3088 risc_paused = 1; 3089 } else if (IS_FWI2_CAPABLE(ha)) { 3090 stat = RD_REG_DWORD(®24->host_status); 3091 if (stat & HSRX_RISC_PAUSED) 3092 risc_paused = 1; 3093 } 3094 spin_unlock_irqrestore(&ha->hardware_lock, flags); 3095 3096 if (risc_paused) { 3097 qla_printk(KERN_INFO, ha, "RISC paused -- mmio_enabled, " 3098 "Dumping firmware!\n"); 3099 ha->isp_ops->fw_dump(base_vha, 0); 3100 3101 return PCI_ERS_RESULT_NEED_RESET; 3102 } else 3103 return PCI_ERS_RESULT_RECOVERED; 3104 } 3105 3106 static pci_ers_result_t 3107 qla2xxx_pci_slot_reset(struct pci_dev *pdev) 3108 { 3109 pci_ers_result_t ret = PCI_ERS_RESULT_DISCONNECT; 3110 scsi_qla_host_t *base_vha = pci_get_drvdata(pdev); 3111 struct qla_hw_data *ha = base_vha->hw; 3112 int rc; 3113 3114 if (ha->mem_only) 3115 rc = pci_enable_device_mem(pdev); 3116 else 3117 rc = pci_enable_device(pdev); 3118 3119 if (rc) { 3120 qla_printk(KERN_WARNING, ha, 3121 "Can't re-enable PCI device after reset.\n"); 3122 3123 return ret; 3124 } 3125 pci_set_master(pdev); 3126 3127 if (ha->isp_ops->pci_config(base_vha)) 3128 return ret; 3129 3130 set_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags); 3131 if (qla2x00_abort_isp(base_vha) == QLA_SUCCESS) 3132 ret = PCI_ERS_RESULT_RECOVERED; 3133 clear_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags); 3134 3135 return ret; 3136 } 3137 3138 static void 3139 qla2xxx_pci_resume(struct pci_dev *pdev) 3140 { 3141 scsi_qla_host_t *base_vha = pci_get_drvdata(pdev); 3142 struct qla_hw_data *ha = base_vha->hw; 3143 int ret; 3144 3145 ret = qla2x00_wait_for_hba_online(base_vha); 3146 if (ret != QLA_SUCCESS) { 3147 qla_printk(KERN_ERR, ha, 3148 "the device failed to resume I/O " 3149 "from slot/link_reset"); 3150 } 3151 pci_cleanup_aer_uncorrect_error_status(pdev); 3152 } 3153 3154 static struct pci_error_handlers qla2xxx_err_handler = { 3155 .error_detected = qla2xxx_pci_error_detected, 3156 .mmio_enabled = qla2xxx_pci_mmio_enabled, 3157 .slot_reset = qla2xxx_pci_slot_reset, 3158 .resume = qla2xxx_pci_resume, 3159 }; 3160 3161 static struct pci_device_id qla2xxx_pci_tbl[] = { 3162 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2100) }, 3163 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2200) }, 3164 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2300) }, 3165 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2312) }, 3166 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2322) }, 3167 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP6312) }, 3168 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP6322) }, 3169 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2422) }, 3170 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2432) }, 3171 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP8432) }, 3172 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP5422) }, 3173 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP5432) }, 3174 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP2532) }, 3175 { PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP8001) }, 3176 { 0 }, 3177 }; 3178 MODULE_DEVICE_TABLE(pci, qla2xxx_pci_tbl); 3179 3180 static struct pci_driver qla2xxx_pci_driver = { 3181 .name = QLA2XXX_DRIVER_NAME, 3182 .driver = { 3183 .owner = THIS_MODULE, 3184 }, 3185 .id_table = qla2xxx_pci_tbl, 3186 .probe = qla2x00_probe_one, 3187 .remove = qla2x00_remove_one, 3188 .err_handler = &qla2xxx_err_handler, 3189 }; 3190 3191 /** 3192 * qla2x00_module_init - Module initialization. 3193 **/ 3194 static int __init 3195 qla2x00_module_init(void) 3196 { 3197 int ret = 0; 3198 3199 /* Allocate cache for SRBs. */ 3200 srb_cachep = kmem_cache_create("qla2xxx_srbs", sizeof(srb_t), 0, 3201 SLAB_HWCACHE_ALIGN, NULL); 3202 if (srb_cachep == NULL) { 3203 printk(KERN_ERR 3204 "qla2xxx: Unable to allocate SRB cache...Failing load!\n"); 3205 return -ENOMEM; 3206 } 3207 3208 /* Derive version string. */ 3209 strcpy(qla2x00_version_str, QLA2XXX_VERSION); 3210 if (ql2xextended_error_logging) 3211 strcat(qla2x00_version_str, "-debug"); 3212 3213 qla2xxx_transport_template = 3214 fc_attach_transport(&qla2xxx_transport_functions); 3215 if (!qla2xxx_transport_template) { 3216 kmem_cache_destroy(srb_cachep); 3217 return -ENODEV; 3218 } 3219 qla2xxx_transport_vport_template = 3220 fc_attach_transport(&qla2xxx_transport_vport_functions); 3221 if (!qla2xxx_transport_vport_template) { 3222 kmem_cache_destroy(srb_cachep); 3223 fc_release_transport(qla2xxx_transport_template); 3224 return -ENODEV; 3225 } 3226 3227 printk(KERN_INFO "QLogic Fibre Channel HBA Driver: %s\n", 3228 qla2x00_version_str); 3229 ret = pci_register_driver(&qla2xxx_pci_driver); 3230 if (ret) { 3231 kmem_cache_destroy(srb_cachep); 3232 fc_release_transport(qla2xxx_transport_template); 3233 fc_release_transport(qla2xxx_transport_vport_template); 3234 } 3235 return ret; 3236 } 3237 3238 /** 3239 * qla2x00_module_exit - Module cleanup. 3240 **/ 3241 static void __exit 3242 qla2x00_module_exit(void) 3243 { 3244 pci_unregister_driver(&qla2xxx_pci_driver); 3245 qla2x00_release_firmware(); 3246 kmem_cache_destroy(srb_cachep); 3247 fc_release_transport(qla2xxx_transport_template); 3248 fc_release_transport(qla2xxx_transport_vport_template); 3249 } 3250 3251 module_init(qla2x00_module_init); 3252 module_exit(qla2x00_module_exit); 3253 3254 MODULE_AUTHOR("QLogic Corporation"); 3255 MODULE_DESCRIPTION("QLogic Fibre Channel HBA Driver"); 3256 MODULE_LICENSE("GPL"); 3257 MODULE_VERSION(QLA2XXX_VERSION); 3258 MODULE_FIRMWARE(FW_FILE_ISP21XX); 3259 MODULE_FIRMWARE(FW_FILE_ISP22XX); 3260 MODULE_FIRMWARE(FW_FILE_ISP2300); 3261 MODULE_FIRMWARE(FW_FILE_ISP2322); 3262 MODULE_FIRMWARE(FW_FILE_ISP24XX); 3263 MODULE_FIRMWARE(FW_FILE_ISP25XX); 3264 MODULE_FIRMWARE(FW_FILE_ISP81XX); 3265