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