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