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