1 /* 2 * QLogic iSCSI HBA Driver 3 * Copyright (c) 2003-2006 QLogic Corporation 4 * 5 * See LICENSE.qla4xxx for copyright and licensing details. 6 */ 7 #include <linux/moduleparam.h> 8 #include <linux/slab.h> 9 10 #include <scsi/scsi_tcq.h> 11 #include <scsi/scsicam.h> 12 13 #include "ql4_def.h" 14 #include "ql4_version.h" 15 #include "ql4_glbl.h" 16 #include "ql4_dbg.h" 17 #include "ql4_inline.h" 18 19 /* 20 * Driver version 21 */ 22 static char qla4xxx_version_str[40]; 23 24 /* 25 * SRB allocation cache 26 */ 27 static struct kmem_cache *srb_cachep; 28 29 /* 30 * Module parameter information and variables 31 */ 32 int ql4xdiscoverywait = 60; 33 module_param(ql4xdiscoverywait, int, S_IRUGO | S_IWUSR); 34 MODULE_PARM_DESC(ql4xdiscoverywait, "Discovery wait time"); 35 36 int ql4xdontresethba = 0; 37 module_param(ql4xdontresethba, int, S_IRUGO | S_IWUSR); 38 MODULE_PARM_DESC(ql4xdontresethba, 39 "Don't reset the HBA for driver recovery \n" 40 " 0 - It will reset HBA (Default)\n" 41 " 1 - It will NOT reset HBA"); 42 43 int ql4xextended_error_logging = 0; /* 0 = off, 1 = log errors */ 44 module_param(ql4xextended_error_logging, int, S_IRUGO | S_IWUSR); 45 MODULE_PARM_DESC(ql4xextended_error_logging, 46 "Option to enable extended error logging, " 47 "Default is 0 - no logging, 1 - debug logging"); 48 49 int ql4xenablemsix = 1; 50 module_param(ql4xenablemsix, int, S_IRUGO|S_IWUSR); 51 MODULE_PARM_DESC(ql4xenablemsix, 52 "Set to enable MSI or MSI-X interrupt mechanism.\n" 53 " 0 = enable INTx interrupt mechanism.\n" 54 " 1 = enable MSI-X interrupt mechanism (Default).\n" 55 " 2 = enable MSI interrupt mechanism."); 56 57 #define QL4_DEF_QDEPTH 32 58 59 /* 60 * SCSI host template entry points 61 */ 62 static void qla4xxx_config_dma_addressing(struct scsi_qla_host *ha); 63 64 /* 65 * iSCSI template entry points 66 */ 67 static int qla4xxx_tgt_dscvr(struct Scsi_Host *shost, 68 enum iscsi_tgt_dscvr type, uint32_t enable, 69 struct sockaddr *dst_addr); 70 static int qla4xxx_conn_get_param(struct iscsi_cls_conn *conn, 71 enum iscsi_param param, char *buf); 72 static int qla4xxx_sess_get_param(struct iscsi_cls_session *sess, 73 enum iscsi_param param, char *buf); 74 static int qla4xxx_host_get_param(struct Scsi_Host *shost, 75 enum iscsi_host_param param, char *buf); 76 static void qla4xxx_recovery_timedout(struct iscsi_cls_session *session); 77 static enum blk_eh_timer_return qla4xxx_eh_cmd_timed_out(struct scsi_cmnd *sc); 78 79 /* 80 * SCSI host template entry points 81 */ 82 static int qla4xxx_queuecommand(struct Scsi_Host *h, struct scsi_cmnd *cmd); 83 static int qla4xxx_eh_abort(struct scsi_cmnd *cmd); 84 static int qla4xxx_eh_device_reset(struct scsi_cmnd *cmd); 85 static int qla4xxx_eh_target_reset(struct scsi_cmnd *cmd); 86 static int qla4xxx_eh_host_reset(struct scsi_cmnd *cmd); 87 static int qla4xxx_slave_alloc(struct scsi_device *device); 88 static int qla4xxx_slave_configure(struct scsi_device *device); 89 static void qla4xxx_slave_destroy(struct scsi_device *sdev); 90 static void qla4xxx_scan_start(struct Scsi_Host *shost); 91 92 static struct qla4_8xxx_legacy_intr_set legacy_intr[] = 93 QLA82XX_LEGACY_INTR_CONFIG; 94 95 static struct scsi_host_template qla4xxx_driver_template = { 96 .module = THIS_MODULE, 97 .name = DRIVER_NAME, 98 .proc_name = DRIVER_NAME, 99 .queuecommand = qla4xxx_queuecommand, 100 101 .eh_abort_handler = qla4xxx_eh_abort, 102 .eh_device_reset_handler = qla4xxx_eh_device_reset, 103 .eh_target_reset_handler = qla4xxx_eh_target_reset, 104 .eh_host_reset_handler = qla4xxx_eh_host_reset, 105 .eh_timed_out = qla4xxx_eh_cmd_timed_out, 106 107 .slave_configure = qla4xxx_slave_configure, 108 .slave_alloc = qla4xxx_slave_alloc, 109 .slave_destroy = qla4xxx_slave_destroy, 110 111 .scan_finished = iscsi_scan_finished, 112 .scan_start = qla4xxx_scan_start, 113 114 .this_id = -1, 115 .cmd_per_lun = 3, 116 .use_clustering = ENABLE_CLUSTERING, 117 .sg_tablesize = SG_ALL, 118 119 .max_sectors = 0xFFFF, 120 }; 121 122 static struct iscsi_transport qla4xxx_iscsi_transport = { 123 .owner = THIS_MODULE, 124 .name = DRIVER_NAME, 125 .caps = CAP_FW_DB | CAP_SENDTARGETS_OFFLOAD | 126 CAP_DATA_PATH_OFFLOAD, 127 .param_mask = ISCSI_CONN_PORT | ISCSI_CONN_ADDRESS | 128 ISCSI_TARGET_NAME | ISCSI_TPGT | 129 ISCSI_TARGET_ALIAS, 130 .host_param_mask = ISCSI_HOST_HWADDRESS | 131 ISCSI_HOST_IPADDRESS | 132 ISCSI_HOST_INITIATOR_NAME, 133 .tgt_dscvr = qla4xxx_tgt_dscvr, 134 .get_conn_param = qla4xxx_conn_get_param, 135 .get_session_param = qla4xxx_sess_get_param, 136 .get_host_param = qla4xxx_host_get_param, 137 .session_recovery_timedout = qla4xxx_recovery_timedout, 138 }; 139 140 static struct scsi_transport_template *qla4xxx_scsi_transport; 141 142 static enum blk_eh_timer_return qla4xxx_eh_cmd_timed_out(struct scsi_cmnd *sc) 143 { 144 struct iscsi_cls_session *session; 145 struct ddb_entry *ddb_entry; 146 147 session = starget_to_session(scsi_target(sc->device)); 148 ddb_entry = session->dd_data; 149 150 /* if we are not logged in then the LLD is going to clean up the cmd */ 151 if (atomic_read(&ddb_entry->state) != DDB_STATE_ONLINE) 152 return BLK_EH_RESET_TIMER; 153 else 154 return BLK_EH_NOT_HANDLED; 155 } 156 157 static void qla4xxx_recovery_timedout(struct iscsi_cls_session *session) 158 { 159 struct ddb_entry *ddb_entry = session->dd_data; 160 struct scsi_qla_host *ha = ddb_entry->ha; 161 162 if (atomic_read(&ddb_entry->state) != DDB_STATE_ONLINE) { 163 atomic_set(&ddb_entry->state, DDB_STATE_DEAD); 164 165 DEBUG2(printk("scsi%ld: %s: ddb [%d] session recovery timeout " 166 "of (%d) secs exhausted, marking device DEAD.\n", 167 ha->host_no, __func__, ddb_entry->fw_ddb_index, 168 QL4_SESS_RECOVERY_TMO)); 169 } 170 } 171 172 static int qla4xxx_host_get_param(struct Scsi_Host *shost, 173 enum iscsi_host_param param, char *buf) 174 { 175 struct scsi_qla_host *ha = to_qla_host(shost); 176 int len; 177 178 switch (param) { 179 case ISCSI_HOST_PARAM_HWADDRESS: 180 len = sysfs_format_mac(buf, ha->my_mac, MAC_ADDR_LEN); 181 break; 182 case ISCSI_HOST_PARAM_IPADDRESS: 183 len = sprintf(buf, "%d.%d.%d.%d\n", ha->ip_address[0], 184 ha->ip_address[1], ha->ip_address[2], 185 ha->ip_address[3]); 186 break; 187 case ISCSI_HOST_PARAM_INITIATOR_NAME: 188 len = sprintf(buf, "%s\n", ha->name_string); 189 break; 190 default: 191 return -ENOSYS; 192 } 193 194 return len; 195 } 196 197 static int qla4xxx_sess_get_param(struct iscsi_cls_session *sess, 198 enum iscsi_param param, char *buf) 199 { 200 struct ddb_entry *ddb_entry = sess->dd_data; 201 int len; 202 203 switch (param) { 204 case ISCSI_PARAM_TARGET_NAME: 205 len = snprintf(buf, PAGE_SIZE - 1, "%s\n", 206 ddb_entry->iscsi_name); 207 break; 208 case ISCSI_PARAM_TPGT: 209 len = sprintf(buf, "%u\n", ddb_entry->tpgt); 210 break; 211 case ISCSI_PARAM_TARGET_ALIAS: 212 len = snprintf(buf, PAGE_SIZE - 1, "%s\n", 213 ddb_entry->iscsi_alias); 214 break; 215 default: 216 return -ENOSYS; 217 } 218 219 return len; 220 } 221 222 static int qla4xxx_conn_get_param(struct iscsi_cls_conn *conn, 223 enum iscsi_param param, char *buf) 224 { 225 struct iscsi_cls_session *session; 226 struct ddb_entry *ddb_entry; 227 int len; 228 229 session = iscsi_dev_to_session(conn->dev.parent); 230 ddb_entry = session->dd_data; 231 232 switch (param) { 233 case ISCSI_PARAM_CONN_PORT: 234 len = sprintf(buf, "%hu\n", ddb_entry->port); 235 break; 236 case ISCSI_PARAM_CONN_ADDRESS: 237 /* TODO: what are the ipv6 bits */ 238 len = sprintf(buf, "%pI4\n", &ddb_entry->ip_addr); 239 break; 240 default: 241 return -ENOSYS; 242 } 243 244 return len; 245 } 246 247 static int qla4xxx_tgt_dscvr(struct Scsi_Host *shost, 248 enum iscsi_tgt_dscvr type, uint32_t enable, 249 struct sockaddr *dst_addr) 250 { 251 struct scsi_qla_host *ha; 252 struct sockaddr_in *addr; 253 struct sockaddr_in6 *addr6; 254 int ret = 0; 255 256 ha = (struct scsi_qla_host *) shost->hostdata; 257 258 switch (type) { 259 case ISCSI_TGT_DSCVR_SEND_TARGETS: 260 if (dst_addr->sa_family == AF_INET) { 261 addr = (struct sockaddr_in *)dst_addr; 262 if (qla4xxx_send_tgts(ha, (char *)&addr->sin_addr, 263 addr->sin_port) != QLA_SUCCESS) 264 ret = -EIO; 265 } else if (dst_addr->sa_family == AF_INET6) { 266 /* 267 * TODO: fix qla4xxx_send_tgts 268 */ 269 addr6 = (struct sockaddr_in6 *)dst_addr; 270 if (qla4xxx_send_tgts(ha, (char *)&addr6->sin6_addr, 271 addr6->sin6_port) != QLA_SUCCESS) 272 ret = -EIO; 273 } else 274 ret = -ENOSYS; 275 break; 276 default: 277 ret = -ENOSYS; 278 } 279 return ret; 280 } 281 282 void qla4xxx_destroy_sess(struct ddb_entry *ddb_entry) 283 { 284 if (!ddb_entry->sess) 285 return; 286 287 if (ddb_entry->conn) { 288 atomic_set(&ddb_entry->state, DDB_STATE_DEAD); 289 iscsi_remove_session(ddb_entry->sess); 290 } 291 iscsi_free_session(ddb_entry->sess); 292 } 293 294 int qla4xxx_add_sess(struct ddb_entry *ddb_entry) 295 { 296 int err; 297 298 ddb_entry->sess->recovery_tmo = QL4_SESS_RECOVERY_TMO; 299 300 err = iscsi_add_session(ddb_entry->sess, ddb_entry->fw_ddb_index); 301 if (err) { 302 DEBUG2(printk(KERN_ERR "Could not add session.\n")); 303 return err; 304 } 305 306 ddb_entry->conn = iscsi_create_conn(ddb_entry->sess, 0, 0); 307 if (!ddb_entry->conn) { 308 iscsi_remove_session(ddb_entry->sess); 309 DEBUG2(printk(KERN_ERR "Could not add connection.\n")); 310 return -ENOMEM; 311 } 312 313 /* finally ready to go */ 314 iscsi_unblock_session(ddb_entry->sess); 315 return 0; 316 } 317 318 struct ddb_entry *qla4xxx_alloc_sess(struct scsi_qla_host *ha) 319 { 320 struct ddb_entry *ddb_entry; 321 struct iscsi_cls_session *sess; 322 323 sess = iscsi_alloc_session(ha->host, &qla4xxx_iscsi_transport, 324 sizeof(struct ddb_entry)); 325 if (!sess) 326 return NULL; 327 328 ddb_entry = sess->dd_data; 329 memset(ddb_entry, 0, sizeof(*ddb_entry)); 330 ddb_entry->ha = ha; 331 ddb_entry->sess = sess; 332 return ddb_entry; 333 } 334 335 static void qla4xxx_scan_start(struct Scsi_Host *shost) 336 { 337 struct scsi_qla_host *ha = shost_priv(shost); 338 struct ddb_entry *ddb_entry, *ddbtemp; 339 340 /* finish setup of sessions that were already setup in firmware */ 341 list_for_each_entry_safe(ddb_entry, ddbtemp, &ha->ddb_list, list) { 342 if (ddb_entry->fw_ddb_device_state == DDB_DS_SESSION_ACTIVE) 343 qla4xxx_add_sess(ddb_entry); 344 } 345 } 346 347 /* 348 * Timer routines 349 */ 350 351 static void qla4xxx_start_timer(struct scsi_qla_host *ha, void *func, 352 unsigned long interval) 353 { 354 DEBUG(printk("scsi: %s: Starting timer thread for adapter %d\n", 355 __func__, ha->host->host_no)); 356 init_timer(&ha->timer); 357 ha->timer.expires = jiffies + interval * HZ; 358 ha->timer.data = (unsigned long)ha; 359 ha->timer.function = (void (*)(unsigned long))func; 360 add_timer(&ha->timer); 361 ha->timer_active = 1; 362 } 363 364 static void qla4xxx_stop_timer(struct scsi_qla_host *ha) 365 { 366 del_timer_sync(&ha->timer); 367 ha->timer_active = 0; 368 } 369 370 /*** 371 * qla4xxx_mark_device_missing - mark a device as missing. 372 * @ha: Pointer to host adapter structure. 373 * @ddb_entry: Pointer to device database entry 374 * 375 * This routine marks a device missing and close connection. 376 **/ 377 void qla4xxx_mark_device_missing(struct scsi_qla_host *ha, 378 struct ddb_entry *ddb_entry) 379 { 380 if ((atomic_read(&ddb_entry->state) != DDB_STATE_DEAD)) { 381 atomic_set(&ddb_entry->state, DDB_STATE_MISSING); 382 DEBUG2(printk("scsi%ld: ddb [%d] marked MISSING\n", 383 ha->host_no, ddb_entry->fw_ddb_index)); 384 } else 385 DEBUG2(printk("scsi%ld: ddb [%d] DEAD\n", ha->host_no, 386 ddb_entry->fw_ddb_index)) 387 388 iscsi_block_session(ddb_entry->sess); 389 iscsi_conn_error_event(ddb_entry->conn, ISCSI_ERR_CONN_FAILED); 390 } 391 392 /** 393 * qla4xxx_mark_all_devices_missing - mark all devices as missing. 394 * @ha: Pointer to host adapter structure. 395 * 396 * This routine marks a device missing and resets the relogin retry count. 397 **/ 398 void qla4xxx_mark_all_devices_missing(struct scsi_qla_host *ha) 399 { 400 struct ddb_entry *ddb_entry, *ddbtemp; 401 list_for_each_entry_safe(ddb_entry, ddbtemp, &ha->ddb_list, list) { 402 qla4xxx_mark_device_missing(ha, ddb_entry); 403 } 404 } 405 406 static struct srb* qla4xxx_get_new_srb(struct scsi_qla_host *ha, 407 struct ddb_entry *ddb_entry, 408 struct scsi_cmnd *cmd, 409 void (*done)(struct scsi_cmnd *)) 410 { 411 struct srb *srb; 412 413 srb = mempool_alloc(ha->srb_mempool, GFP_ATOMIC); 414 if (!srb) 415 return srb; 416 417 kref_init(&srb->srb_ref); 418 srb->ha = ha; 419 srb->ddb = ddb_entry; 420 srb->cmd = cmd; 421 srb->flags = 0; 422 CMD_SP(cmd) = (void *)srb; 423 cmd->scsi_done = done; 424 425 return srb; 426 } 427 428 static void qla4xxx_srb_free_dma(struct scsi_qla_host *ha, struct srb *srb) 429 { 430 struct scsi_cmnd *cmd = srb->cmd; 431 432 if (srb->flags & SRB_DMA_VALID) { 433 scsi_dma_unmap(cmd); 434 srb->flags &= ~SRB_DMA_VALID; 435 } 436 CMD_SP(cmd) = NULL; 437 } 438 439 void qla4xxx_srb_compl(struct kref *ref) 440 { 441 struct srb *srb = container_of(ref, struct srb, srb_ref); 442 struct scsi_cmnd *cmd = srb->cmd; 443 struct scsi_qla_host *ha = srb->ha; 444 445 qla4xxx_srb_free_dma(ha, srb); 446 447 mempool_free(srb, ha->srb_mempool); 448 449 cmd->scsi_done(cmd); 450 } 451 452 /** 453 * qla4xxx_queuecommand - scsi layer issues scsi command to driver. 454 * @cmd: Pointer to Linux's SCSI command structure 455 * @done_fn: Function that the driver calls to notify the SCSI mid-layer 456 * that the command has been processed. 457 * 458 * Remarks: 459 * This routine is invoked by Linux to send a SCSI command to the driver. 460 * The mid-level driver tries to ensure that queuecommand never gets 461 * invoked concurrently with itself or the interrupt handler (although 462 * the interrupt handler may call this routine as part of request- 463 * completion handling). Unfortunely, it sometimes calls the scheduler 464 * in interrupt context which is a big NO! NO!. 465 **/ 466 static int qla4xxx_queuecommand_lck(struct scsi_cmnd *cmd, 467 void (*done)(struct scsi_cmnd *)) 468 { 469 struct scsi_qla_host *ha = to_qla_host(cmd->device->host); 470 struct ddb_entry *ddb_entry = cmd->device->hostdata; 471 struct iscsi_cls_session *sess = ddb_entry->sess; 472 struct srb *srb; 473 int rval; 474 475 if (test_bit(AF_EEH_BUSY, &ha->flags)) { 476 if (test_bit(AF_PCI_CHANNEL_IO_PERM_FAILURE, &ha->flags)) 477 cmd->result = DID_NO_CONNECT << 16; 478 else 479 cmd->result = DID_REQUEUE << 16; 480 goto qc_fail_command; 481 } 482 483 if (!sess) { 484 cmd->result = DID_IMM_RETRY << 16; 485 goto qc_fail_command; 486 } 487 488 rval = iscsi_session_chkready(sess); 489 if (rval) { 490 cmd->result = rval; 491 goto qc_fail_command; 492 } 493 494 if (atomic_read(&ddb_entry->state) != DDB_STATE_ONLINE) { 495 if (atomic_read(&ddb_entry->state) == DDB_STATE_DEAD) { 496 cmd->result = DID_NO_CONNECT << 16; 497 goto qc_fail_command; 498 } 499 return SCSI_MLQUEUE_TARGET_BUSY; 500 } 501 502 if (test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags) || 503 test_bit(DPC_RESET_ACTIVE, &ha->dpc_flags) || 504 test_bit(DPC_RESET_HA, &ha->dpc_flags) || 505 test_bit(DPC_HA_UNRECOVERABLE, &ha->dpc_flags) || 506 test_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags) || 507 !test_bit(AF_ONLINE, &ha->flags) || 508 test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags)) 509 goto qc_host_busy; 510 511 spin_unlock_irq(ha->host->host_lock); 512 513 srb = qla4xxx_get_new_srb(ha, ddb_entry, cmd, done); 514 if (!srb) 515 goto qc_host_busy_lock; 516 517 rval = qla4xxx_send_command_to_isp(ha, srb); 518 if (rval != QLA_SUCCESS) 519 goto qc_host_busy_free_sp; 520 521 spin_lock_irq(ha->host->host_lock); 522 return 0; 523 524 qc_host_busy_free_sp: 525 qla4xxx_srb_free_dma(ha, srb); 526 mempool_free(srb, ha->srb_mempool); 527 528 qc_host_busy_lock: 529 spin_lock_irq(ha->host->host_lock); 530 531 qc_host_busy: 532 return SCSI_MLQUEUE_HOST_BUSY; 533 534 qc_fail_command: 535 done(cmd); 536 537 return 0; 538 } 539 540 static DEF_SCSI_QCMD(qla4xxx_queuecommand) 541 542 /** 543 * qla4xxx_mem_free - frees memory allocated to adapter 544 * @ha: Pointer to host adapter structure. 545 * 546 * Frees memory previously allocated by qla4xxx_mem_alloc 547 **/ 548 static void qla4xxx_mem_free(struct scsi_qla_host *ha) 549 { 550 if (ha->queues) 551 dma_free_coherent(&ha->pdev->dev, ha->queues_len, ha->queues, 552 ha->queues_dma); 553 554 ha->queues_len = 0; 555 ha->queues = NULL; 556 ha->queues_dma = 0; 557 ha->request_ring = NULL; 558 ha->request_dma = 0; 559 ha->response_ring = NULL; 560 ha->response_dma = 0; 561 ha->shadow_regs = NULL; 562 ha->shadow_regs_dma = 0; 563 564 /* Free srb pool. */ 565 if (ha->srb_mempool) 566 mempool_destroy(ha->srb_mempool); 567 568 ha->srb_mempool = NULL; 569 570 /* release io space registers */ 571 if (is_qla8022(ha)) { 572 if (ha->nx_pcibase) 573 iounmap( 574 (struct device_reg_82xx __iomem *)ha->nx_pcibase); 575 } else if (ha->reg) 576 iounmap(ha->reg); 577 pci_release_regions(ha->pdev); 578 } 579 580 /** 581 * qla4xxx_mem_alloc - allocates memory for use by adapter. 582 * @ha: Pointer to host adapter structure 583 * 584 * Allocates DMA memory for request and response queues. Also allocates memory 585 * for srbs. 586 **/ 587 static int qla4xxx_mem_alloc(struct scsi_qla_host *ha) 588 { 589 unsigned long align; 590 591 /* Allocate contiguous block of DMA memory for queues. */ 592 ha->queues_len = ((REQUEST_QUEUE_DEPTH * QUEUE_SIZE) + 593 (RESPONSE_QUEUE_DEPTH * QUEUE_SIZE) + 594 sizeof(struct shadow_regs) + 595 MEM_ALIGN_VALUE + 596 (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1); 597 ha->queues = dma_alloc_coherent(&ha->pdev->dev, ha->queues_len, 598 &ha->queues_dma, GFP_KERNEL); 599 if (ha->queues == NULL) { 600 ql4_printk(KERN_WARNING, ha, 601 "Memory Allocation failed - queues.\n"); 602 603 goto mem_alloc_error_exit; 604 } 605 memset(ha->queues, 0, ha->queues_len); 606 607 /* 608 * As per RISC alignment requirements -- the bus-address must be a 609 * multiple of the request-ring size (in bytes). 610 */ 611 align = 0; 612 if ((unsigned long)ha->queues_dma & (MEM_ALIGN_VALUE - 1)) 613 align = MEM_ALIGN_VALUE - ((unsigned long)ha->queues_dma & 614 (MEM_ALIGN_VALUE - 1)); 615 616 /* Update request and response queue pointers. */ 617 ha->request_dma = ha->queues_dma + align; 618 ha->request_ring = (struct queue_entry *) (ha->queues + align); 619 ha->response_dma = ha->queues_dma + align + 620 (REQUEST_QUEUE_DEPTH * QUEUE_SIZE); 621 ha->response_ring = (struct queue_entry *) (ha->queues + align + 622 (REQUEST_QUEUE_DEPTH * 623 QUEUE_SIZE)); 624 ha->shadow_regs_dma = ha->queues_dma + align + 625 (REQUEST_QUEUE_DEPTH * QUEUE_SIZE) + 626 (RESPONSE_QUEUE_DEPTH * QUEUE_SIZE); 627 ha->shadow_regs = (struct shadow_regs *) (ha->queues + align + 628 (REQUEST_QUEUE_DEPTH * 629 QUEUE_SIZE) + 630 (RESPONSE_QUEUE_DEPTH * 631 QUEUE_SIZE)); 632 633 /* Allocate memory for srb pool. */ 634 ha->srb_mempool = mempool_create(SRB_MIN_REQ, mempool_alloc_slab, 635 mempool_free_slab, srb_cachep); 636 if (ha->srb_mempool == NULL) { 637 ql4_printk(KERN_WARNING, ha, 638 "Memory Allocation failed - SRB Pool.\n"); 639 640 goto mem_alloc_error_exit; 641 } 642 643 return QLA_SUCCESS; 644 645 mem_alloc_error_exit: 646 qla4xxx_mem_free(ha); 647 return QLA_ERROR; 648 } 649 650 /** 651 * qla4_8xxx_check_fw_alive - Check firmware health 652 * @ha: Pointer to host adapter structure. 653 * 654 * Context: Interrupt 655 **/ 656 static void qla4_8xxx_check_fw_alive(struct scsi_qla_host *ha) 657 { 658 uint32_t fw_heartbeat_counter, halt_status; 659 660 fw_heartbeat_counter = qla4_8xxx_rd_32(ha, QLA82XX_PEG_ALIVE_COUNTER); 661 /* If PEG_ALIVE_COUNTER is 0xffffffff, AER/EEH is in progress, ignore */ 662 if (fw_heartbeat_counter == 0xffffffff) { 663 DEBUG2(printk(KERN_WARNING "scsi%ld: %s: Device in frozen " 664 "state, QLA82XX_PEG_ALIVE_COUNTER is 0xffffffff\n", 665 ha->host_no, __func__)); 666 return; 667 } 668 669 if (ha->fw_heartbeat_counter == fw_heartbeat_counter) { 670 ha->seconds_since_last_heartbeat++; 671 /* FW not alive after 2 seconds */ 672 if (ha->seconds_since_last_heartbeat == 2) { 673 ha->seconds_since_last_heartbeat = 0; 674 halt_status = qla4_8xxx_rd_32(ha, 675 QLA82XX_PEG_HALT_STATUS1); 676 677 /* Since we cannot change dev_state in interrupt 678 * context, set appropriate DPC flag then wakeup 679 * DPC */ 680 if (halt_status & HALT_STATUS_UNRECOVERABLE) 681 set_bit(DPC_HA_UNRECOVERABLE, &ha->dpc_flags); 682 else { 683 printk("scsi%ld: %s: detect abort needed!\n", 684 ha->host_no, __func__); 685 set_bit(DPC_RESET_HA, &ha->dpc_flags); 686 } 687 qla4xxx_wake_dpc(ha); 688 qla4xxx_mailbox_premature_completion(ha); 689 } 690 } else 691 ha->seconds_since_last_heartbeat = 0; 692 693 ha->fw_heartbeat_counter = fw_heartbeat_counter; 694 } 695 696 /** 697 * qla4_8xxx_watchdog - Poll dev state 698 * @ha: Pointer to host adapter structure. 699 * 700 * Context: Interrupt 701 **/ 702 void qla4_8xxx_watchdog(struct scsi_qla_host *ha) 703 { 704 uint32_t dev_state; 705 706 dev_state = qla4_8xxx_rd_32(ha, QLA82XX_CRB_DEV_STATE); 707 708 /* don't poll if reset is going on */ 709 if (!test_bit(DPC_RESET_ACTIVE, &ha->dpc_flags)) { 710 if (dev_state == QLA82XX_DEV_NEED_RESET && 711 !test_bit(DPC_RESET_HA, &ha->dpc_flags)) { 712 printk("scsi%ld: %s: HW State: NEED RESET!\n", 713 ha->host_no, __func__); 714 set_bit(DPC_RESET_HA, &ha->dpc_flags); 715 qla4xxx_wake_dpc(ha); 716 qla4xxx_mailbox_premature_completion(ha); 717 } else if (dev_state == QLA82XX_DEV_NEED_QUIESCENT && 718 !test_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags)) { 719 printk("scsi%ld: %s: HW State: NEED QUIES!\n", 720 ha->host_no, __func__); 721 set_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags); 722 qla4xxx_wake_dpc(ha); 723 } else { 724 /* Check firmware health */ 725 qla4_8xxx_check_fw_alive(ha); 726 } 727 } 728 } 729 730 /** 731 * qla4xxx_timer - checks every second for work to do. 732 * @ha: Pointer to host adapter structure. 733 **/ 734 static void qla4xxx_timer(struct scsi_qla_host *ha) 735 { 736 struct ddb_entry *ddb_entry, *dtemp; 737 int start_dpc = 0; 738 uint16_t w; 739 740 /* If we are in the middle of AER/EEH processing 741 * skip any processing and reschedule the timer 742 */ 743 if (test_bit(AF_EEH_BUSY, &ha->flags)) { 744 mod_timer(&ha->timer, jiffies + HZ); 745 return; 746 } 747 748 /* Hardware read to trigger an EEH error during mailbox waits. */ 749 if (!pci_channel_offline(ha->pdev)) 750 pci_read_config_word(ha->pdev, PCI_VENDOR_ID, &w); 751 752 if (test_bit(AF_HBA_GOING_AWAY, &ha->flags)) { 753 DEBUG2(ql4_printk(KERN_INFO, ha, "%s exited. HBA GOING AWAY\n", 754 __func__)); 755 return; 756 } 757 758 if (is_qla8022(ha)) { 759 qla4_8xxx_watchdog(ha); 760 } 761 762 /* Search for relogin's to time-out and port down retry. */ 763 list_for_each_entry_safe(ddb_entry, dtemp, &ha->ddb_list, list) { 764 /* Count down time between sending relogins */ 765 if (adapter_up(ha) && 766 !test_bit(DF_RELOGIN, &ddb_entry->flags) && 767 atomic_read(&ddb_entry->state) != DDB_STATE_ONLINE) { 768 if (atomic_read(&ddb_entry->retry_relogin_timer) != 769 INVALID_ENTRY) { 770 if (atomic_read(&ddb_entry->retry_relogin_timer) 771 == 0) { 772 atomic_set(&ddb_entry-> 773 retry_relogin_timer, 774 INVALID_ENTRY); 775 set_bit(DPC_RELOGIN_DEVICE, 776 &ha->dpc_flags); 777 set_bit(DF_RELOGIN, &ddb_entry->flags); 778 DEBUG2(printk("scsi%ld: %s: ddb [%d]" 779 " login device\n", 780 ha->host_no, __func__, 781 ddb_entry->fw_ddb_index)); 782 } else 783 atomic_dec(&ddb_entry-> 784 retry_relogin_timer); 785 } 786 } 787 788 /* Wait for relogin to timeout */ 789 if (atomic_read(&ddb_entry->relogin_timer) && 790 (atomic_dec_and_test(&ddb_entry->relogin_timer) != 0)) { 791 /* 792 * If the relogin times out and the device is 793 * still NOT ONLINE then try and relogin again. 794 */ 795 if (atomic_read(&ddb_entry->state) != 796 DDB_STATE_ONLINE && 797 ddb_entry->fw_ddb_device_state == 798 DDB_DS_SESSION_FAILED) { 799 /* Reset retry relogin timer */ 800 atomic_inc(&ddb_entry->relogin_retry_count); 801 DEBUG2(printk("scsi%ld: ddb [%d] relogin" 802 " timed out-retrying" 803 " relogin (%d)\n", 804 ha->host_no, 805 ddb_entry->fw_ddb_index, 806 atomic_read(&ddb_entry-> 807 relogin_retry_count)) 808 ); 809 start_dpc++; 810 DEBUG(printk("scsi%ld:%d:%d: ddb [%d] " 811 "initate relogin after" 812 " %d seconds\n", 813 ha->host_no, ddb_entry->bus, 814 ddb_entry->target, 815 ddb_entry->fw_ddb_index, 816 ddb_entry->default_time2wait + 4) 817 ); 818 819 atomic_set(&ddb_entry->retry_relogin_timer, 820 ddb_entry->default_time2wait + 4); 821 } 822 } 823 } 824 825 if (!is_qla8022(ha)) { 826 /* Check for heartbeat interval. */ 827 if (ha->firmware_options & FWOPT_HEARTBEAT_ENABLE && 828 ha->heartbeat_interval != 0) { 829 ha->seconds_since_last_heartbeat++; 830 if (ha->seconds_since_last_heartbeat > 831 ha->heartbeat_interval + 2) 832 set_bit(DPC_RESET_HA, &ha->dpc_flags); 833 } 834 } 835 836 /* Wakeup the dpc routine for this adapter, if needed. */ 837 if ((start_dpc || 838 test_bit(DPC_RESET_HA, &ha->dpc_flags) || 839 test_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags) || 840 test_bit(DPC_RELOGIN_DEVICE, &ha->dpc_flags) || 841 test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags) || 842 test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags) || 843 test_bit(DPC_GET_DHCP_IP_ADDR, &ha->dpc_flags) || 844 test_bit(DPC_LINK_CHANGED, &ha->dpc_flags) || 845 test_bit(DPC_HA_UNRECOVERABLE, &ha->dpc_flags) || 846 test_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags) || 847 test_bit(DPC_AEN, &ha->dpc_flags)) && 848 !test_bit(AF_DPC_SCHEDULED, &ha->flags) && 849 ha->dpc_thread) { 850 DEBUG2(printk("scsi%ld: %s: scheduling dpc routine" 851 " - dpc flags = 0x%lx\n", 852 ha->host_no, __func__, ha->dpc_flags)); 853 qla4xxx_wake_dpc(ha); 854 } 855 856 /* Reschedule timer thread to call us back in one second */ 857 mod_timer(&ha->timer, jiffies + HZ); 858 859 DEBUG2(ha->seconds_since_last_intr++); 860 } 861 862 /** 863 * qla4xxx_cmd_wait - waits for all outstanding commands to complete 864 * @ha: Pointer to host adapter structure. 865 * 866 * This routine stalls the driver until all outstanding commands are returned. 867 * Caller must release the Hardware Lock prior to calling this routine. 868 **/ 869 static int qla4xxx_cmd_wait(struct scsi_qla_host *ha) 870 { 871 uint32_t index = 0; 872 unsigned long flags; 873 struct scsi_cmnd *cmd; 874 875 unsigned long wtime = jiffies + (WAIT_CMD_TOV * HZ); 876 877 DEBUG2(ql4_printk(KERN_INFO, ha, "Wait up to %d seconds for cmds to " 878 "complete\n", WAIT_CMD_TOV)); 879 880 while (!time_after_eq(jiffies, wtime)) { 881 spin_lock_irqsave(&ha->hardware_lock, flags); 882 /* Find a command that hasn't completed. */ 883 for (index = 0; index < ha->host->can_queue; index++) { 884 cmd = scsi_host_find_tag(ha->host, index); 885 /* 886 * We cannot just check if the index is valid, 887 * becase if we are run from the scsi eh, then 888 * the scsi/block layer is going to prevent 889 * the tag from being released. 890 */ 891 if (cmd != NULL && CMD_SP(cmd)) 892 break; 893 } 894 spin_unlock_irqrestore(&ha->hardware_lock, flags); 895 896 /* If No Commands are pending, wait is complete */ 897 if (index == ha->host->can_queue) 898 return QLA_SUCCESS; 899 900 msleep(1000); 901 } 902 /* If we timed out on waiting for commands to come back 903 * return ERROR. */ 904 return QLA_ERROR; 905 } 906 907 int qla4xxx_hw_reset(struct scsi_qla_host *ha) 908 { 909 uint32_t ctrl_status; 910 unsigned long flags = 0; 911 912 DEBUG2(printk(KERN_ERR "scsi%ld: %s\n", ha->host_no, __func__)); 913 914 if (ql4xxx_lock_drvr_wait(ha) != QLA_SUCCESS) 915 return QLA_ERROR; 916 917 spin_lock_irqsave(&ha->hardware_lock, flags); 918 919 /* 920 * If the SCSI Reset Interrupt bit is set, clear it. 921 * Otherwise, the Soft Reset won't work. 922 */ 923 ctrl_status = readw(&ha->reg->ctrl_status); 924 if ((ctrl_status & CSR_SCSI_RESET_INTR) != 0) 925 writel(set_rmask(CSR_SCSI_RESET_INTR), &ha->reg->ctrl_status); 926 927 /* Issue Soft Reset */ 928 writel(set_rmask(CSR_SOFT_RESET), &ha->reg->ctrl_status); 929 readl(&ha->reg->ctrl_status); 930 931 spin_unlock_irqrestore(&ha->hardware_lock, flags); 932 return QLA_SUCCESS; 933 } 934 935 /** 936 * qla4xxx_soft_reset - performs soft reset. 937 * @ha: Pointer to host adapter structure. 938 **/ 939 int qla4xxx_soft_reset(struct scsi_qla_host *ha) 940 { 941 uint32_t max_wait_time; 942 unsigned long flags = 0; 943 int status; 944 uint32_t ctrl_status; 945 946 status = qla4xxx_hw_reset(ha); 947 if (status != QLA_SUCCESS) 948 return status; 949 950 status = QLA_ERROR; 951 /* Wait until the Network Reset Intr bit is cleared */ 952 max_wait_time = RESET_INTR_TOV; 953 do { 954 spin_lock_irqsave(&ha->hardware_lock, flags); 955 ctrl_status = readw(&ha->reg->ctrl_status); 956 spin_unlock_irqrestore(&ha->hardware_lock, flags); 957 958 if ((ctrl_status & CSR_NET_RESET_INTR) == 0) 959 break; 960 961 msleep(1000); 962 } while ((--max_wait_time)); 963 964 if ((ctrl_status & CSR_NET_RESET_INTR) != 0) { 965 DEBUG2(printk(KERN_WARNING 966 "scsi%ld: Network Reset Intr not cleared by " 967 "Network function, clearing it now!\n", 968 ha->host_no)); 969 spin_lock_irqsave(&ha->hardware_lock, flags); 970 writel(set_rmask(CSR_NET_RESET_INTR), &ha->reg->ctrl_status); 971 readl(&ha->reg->ctrl_status); 972 spin_unlock_irqrestore(&ha->hardware_lock, flags); 973 } 974 975 /* Wait until the firmware tells us the Soft Reset is done */ 976 max_wait_time = SOFT_RESET_TOV; 977 do { 978 spin_lock_irqsave(&ha->hardware_lock, flags); 979 ctrl_status = readw(&ha->reg->ctrl_status); 980 spin_unlock_irqrestore(&ha->hardware_lock, flags); 981 982 if ((ctrl_status & CSR_SOFT_RESET) == 0) { 983 status = QLA_SUCCESS; 984 break; 985 } 986 987 msleep(1000); 988 } while ((--max_wait_time)); 989 990 /* 991 * Also, make sure that the SCSI Reset Interrupt bit has been cleared 992 * after the soft reset has taken place. 993 */ 994 spin_lock_irqsave(&ha->hardware_lock, flags); 995 ctrl_status = readw(&ha->reg->ctrl_status); 996 if ((ctrl_status & CSR_SCSI_RESET_INTR) != 0) { 997 writel(set_rmask(CSR_SCSI_RESET_INTR), &ha->reg->ctrl_status); 998 readl(&ha->reg->ctrl_status); 999 } 1000 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1001 1002 /* If soft reset fails then most probably the bios on other 1003 * function is also enabled. 1004 * Since the initialization is sequential the other fn 1005 * wont be able to acknowledge the soft reset. 1006 * Issue a force soft reset to workaround this scenario. 1007 */ 1008 if (max_wait_time == 0) { 1009 /* Issue Force Soft Reset */ 1010 spin_lock_irqsave(&ha->hardware_lock, flags); 1011 writel(set_rmask(CSR_FORCE_SOFT_RESET), &ha->reg->ctrl_status); 1012 readl(&ha->reg->ctrl_status); 1013 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1014 /* Wait until the firmware tells us the Soft Reset is done */ 1015 max_wait_time = SOFT_RESET_TOV; 1016 do { 1017 spin_lock_irqsave(&ha->hardware_lock, flags); 1018 ctrl_status = readw(&ha->reg->ctrl_status); 1019 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1020 1021 if ((ctrl_status & CSR_FORCE_SOFT_RESET) == 0) { 1022 status = QLA_SUCCESS; 1023 break; 1024 } 1025 1026 msleep(1000); 1027 } while ((--max_wait_time)); 1028 } 1029 1030 return status; 1031 } 1032 1033 /** 1034 * qla4xxx_abort_active_cmds - returns all outstanding i/o requests to O.S. 1035 * @ha: Pointer to host adapter structure. 1036 * @res: returned scsi status 1037 * 1038 * This routine is called just prior to a HARD RESET to return all 1039 * outstanding commands back to the Operating System. 1040 * Caller should make sure that the following locks are released 1041 * before this calling routine: Hardware lock, and io_request_lock. 1042 **/ 1043 static void qla4xxx_abort_active_cmds(struct scsi_qla_host *ha, int res) 1044 { 1045 struct srb *srb; 1046 int i; 1047 unsigned long flags; 1048 1049 spin_lock_irqsave(&ha->hardware_lock, flags); 1050 for (i = 0; i < ha->host->can_queue; i++) { 1051 srb = qla4xxx_del_from_active_array(ha, i); 1052 if (srb != NULL) { 1053 srb->cmd->result = res; 1054 kref_put(&srb->srb_ref, qla4xxx_srb_compl); 1055 } 1056 } 1057 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1058 } 1059 1060 void qla4xxx_dead_adapter_cleanup(struct scsi_qla_host *ha) 1061 { 1062 clear_bit(AF_ONLINE, &ha->flags); 1063 1064 /* Disable the board */ 1065 ql4_printk(KERN_INFO, ha, "Disabling the board\n"); 1066 set_bit(AF_HBA_GOING_AWAY, &ha->flags); 1067 1068 qla4xxx_abort_active_cmds(ha, DID_NO_CONNECT << 16); 1069 qla4xxx_mark_all_devices_missing(ha); 1070 clear_bit(AF_INIT_DONE, &ha->flags); 1071 } 1072 1073 /** 1074 * qla4xxx_recover_adapter - recovers adapter after a fatal error 1075 * @ha: Pointer to host adapter structure. 1076 **/ 1077 static int qla4xxx_recover_adapter(struct scsi_qla_host *ha) 1078 { 1079 int status = QLA_ERROR; 1080 uint8_t reset_chip = 0; 1081 1082 /* Stall incoming I/O until we are done */ 1083 scsi_block_requests(ha->host); 1084 clear_bit(AF_ONLINE, &ha->flags); 1085 1086 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: adapter OFFLINE\n", __func__)); 1087 1088 set_bit(DPC_RESET_ACTIVE, &ha->dpc_flags); 1089 1090 if (test_bit(DPC_RESET_HA, &ha->dpc_flags)) 1091 reset_chip = 1; 1092 1093 /* For the DPC_RESET_HA_INTR case (ISP-4xxx specific) 1094 * do not reset adapter, jump to initialize_adapter */ 1095 if (test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags)) { 1096 status = QLA_SUCCESS; 1097 goto recover_ha_init_adapter; 1098 } 1099 1100 /* For the ISP-82xx adapter, issue a stop_firmware if invoked 1101 * from eh_host_reset or ioctl module */ 1102 if (is_qla8022(ha) && !reset_chip && 1103 test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags)) { 1104 1105 DEBUG2(ql4_printk(KERN_INFO, ha, 1106 "scsi%ld: %s - Performing stop_firmware...\n", 1107 ha->host_no, __func__)); 1108 status = ha->isp_ops->reset_firmware(ha); 1109 if (status == QLA_SUCCESS) { 1110 if (!test_bit(AF_FW_RECOVERY, &ha->flags)) 1111 qla4xxx_cmd_wait(ha); 1112 ha->isp_ops->disable_intrs(ha); 1113 qla4xxx_process_aen(ha, FLUSH_DDB_CHANGED_AENS); 1114 qla4xxx_abort_active_cmds(ha, DID_RESET << 16); 1115 } else { 1116 /* If the stop_firmware fails then 1117 * reset the entire chip */ 1118 reset_chip = 1; 1119 clear_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags); 1120 set_bit(DPC_RESET_HA, &ha->dpc_flags); 1121 } 1122 } 1123 1124 /* Issue full chip reset if recovering from a catastrophic error, 1125 * or if stop_firmware fails for ISP-82xx. 1126 * This is the default case for ISP-4xxx */ 1127 if (!is_qla8022(ha) || reset_chip) { 1128 if (!test_bit(AF_FW_RECOVERY, &ha->flags)) 1129 qla4xxx_cmd_wait(ha); 1130 qla4xxx_process_aen(ha, FLUSH_DDB_CHANGED_AENS); 1131 qla4xxx_abort_active_cmds(ha, DID_RESET << 16); 1132 DEBUG2(ql4_printk(KERN_INFO, ha, 1133 "scsi%ld: %s - Performing chip reset..\n", 1134 ha->host_no, __func__)); 1135 status = ha->isp_ops->reset_chip(ha); 1136 } 1137 1138 /* Flush any pending ddb changed AENs */ 1139 qla4xxx_process_aen(ha, FLUSH_DDB_CHANGED_AENS); 1140 1141 recover_ha_init_adapter: 1142 /* Upon successful firmware/chip reset, re-initialize the adapter */ 1143 if (status == QLA_SUCCESS) { 1144 /* For ISP-4xxx, force function 1 to always initialize 1145 * before function 3 to prevent both funcions from 1146 * stepping on top of the other */ 1147 if (!is_qla8022(ha) && (ha->mac_index == 3)) 1148 ssleep(6); 1149 1150 /* NOTE: AF_ONLINE flag set upon successful completion of 1151 * qla4xxx_initialize_adapter */ 1152 status = qla4xxx_initialize_adapter(ha, PRESERVE_DDB_LIST); 1153 } 1154 1155 /* Retry failed adapter initialization, if necessary 1156 * Do not retry initialize_adapter for RESET_HA_INTR (ISP-4xxx specific) 1157 * case to prevent ping-pong resets between functions */ 1158 if (!test_bit(AF_ONLINE, &ha->flags) && 1159 !test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags)) { 1160 /* Adapter initialization failed, see if we can retry 1161 * resetting the ha. 1162 * Since we don't want to block the DPC for too long 1163 * with multiple resets in the same thread, 1164 * utilize DPC to retry */ 1165 if (!test_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags)) { 1166 ha->retry_reset_ha_cnt = MAX_RESET_HA_RETRIES; 1167 DEBUG2(printk("scsi%ld: recover adapter - retrying " 1168 "(%d) more times\n", ha->host_no, 1169 ha->retry_reset_ha_cnt)); 1170 set_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags); 1171 status = QLA_ERROR; 1172 } else { 1173 if (ha->retry_reset_ha_cnt > 0) { 1174 /* Schedule another Reset HA--DPC will retry */ 1175 ha->retry_reset_ha_cnt--; 1176 DEBUG2(printk("scsi%ld: recover adapter - " 1177 "retry remaining %d\n", 1178 ha->host_no, 1179 ha->retry_reset_ha_cnt)); 1180 status = QLA_ERROR; 1181 } 1182 1183 if (ha->retry_reset_ha_cnt == 0) { 1184 /* Recover adapter retries have been exhausted. 1185 * Adapter DEAD */ 1186 DEBUG2(printk("scsi%ld: recover adapter " 1187 "failed - board disabled\n", 1188 ha->host_no)); 1189 qla4xxx_dead_adapter_cleanup(ha); 1190 clear_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags); 1191 clear_bit(DPC_RESET_HA, &ha->dpc_flags); 1192 clear_bit(DPC_RESET_HA_FW_CONTEXT, 1193 &ha->dpc_flags); 1194 status = QLA_ERROR; 1195 } 1196 } 1197 } else { 1198 clear_bit(DPC_RESET_HA, &ha->dpc_flags); 1199 clear_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags); 1200 clear_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags); 1201 } 1202 1203 ha->adapter_error_count++; 1204 1205 if (test_bit(AF_ONLINE, &ha->flags)) 1206 ha->isp_ops->enable_intrs(ha); 1207 1208 scsi_unblock_requests(ha->host); 1209 1210 clear_bit(DPC_RESET_ACTIVE, &ha->dpc_flags); 1211 DEBUG2(printk("scsi%ld: recover adapter: %s\n", ha->host_no, 1212 status == QLA_ERROR ? "FAILED" : "SUCCEDED")); 1213 1214 return status; 1215 } 1216 1217 void qla4xxx_wake_dpc(struct scsi_qla_host *ha) 1218 { 1219 if (ha->dpc_thread && 1220 !test_bit(AF_DPC_SCHEDULED, &ha->flags)) { 1221 set_bit(AF_DPC_SCHEDULED, &ha->flags); 1222 queue_work(ha->dpc_thread, &ha->dpc_work); 1223 } 1224 } 1225 1226 /** 1227 * qla4xxx_do_dpc - dpc routine 1228 * @data: in our case pointer to adapter structure 1229 * 1230 * This routine is a task that is schedule by the interrupt handler 1231 * to perform the background processing for interrupts. We put it 1232 * on a task queue that is consumed whenever the scheduler runs; that's 1233 * so you can do anything (i.e. put the process to sleep etc). In fact, 1234 * the mid-level tries to sleep when it reaches the driver threshold 1235 * "host->can_queue". This can cause a panic if we were in our interrupt code. 1236 **/ 1237 static void qla4xxx_do_dpc(struct work_struct *work) 1238 { 1239 struct scsi_qla_host *ha = 1240 container_of(work, struct scsi_qla_host, dpc_work); 1241 struct ddb_entry *ddb_entry, *dtemp; 1242 int status = QLA_ERROR; 1243 1244 DEBUG2(printk("scsi%ld: %s: DPC handler waking up." 1245 "flags = 0x%08lx, dpc_flags = 0x%08lx\n", 1246 ha->host_no, __func__, ha->flags, ha->dpc_flags)) 1247 1248 /* Initialization not yet finished. Don't do anything yet. */ 1249 if (!test_bit(AF_INIT_DONE, &ha->flags)) 1250 goto do_dpc_exit; 1251 1252 if (test_bit(AF_EEH_BUSY, &ha->flags)) { 1253 DEBUG2(printk(KERN_INFO "scsi%ld: %s: flags = %lx\n", 1254 ha->host_no, __func__, ha->flags)); 1255 goto do_dpc_exit; 1256 } 1257 1258 /* HBA is in the process of being permanently disabled. 1259 * Don't process anything */ 1260 if (test_bit(AF_HBA_GOING_AWAY, &ha->flags)) 1261 return; 1262 1263 if (is_qla8022(ha)) { 1264 if (test_bit(DPC_HA_UNRECOVERABLE, &ha->dpc_flags)) { 1265 qla4_8xxx_idc_lock(ha); 1266 qla4_8xxx_wr_32(ha, QLA82XX_CRB_DEV_STATE, 1267 QLA82XX_DEV_FAILED); 1268 qla4_8xxx_idc_unlock(ha); 1269 ql4_printk(KERN_INFO, ha, "HW State: FAILED\n"); 1270 qla4_8xxx_device_state_handler(ha); 1271 } 1272 if (test_and_clear_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags)) { 1273 qla4_8xxx_need_qsnt_handler(ha); 1274 } 1275 } 1276 1277 if (!test_bit(DPC_RESET_ACTIVE, &ha->dpc_flags) && 1278 (test_bit(DPC_RESET_HA, &ha->dpc_flags) || 1279 test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags) || 1280 test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags))) { 1281 if (ql4xdontresethba) { 1282 DEBUG2(printk("scsi%ld: %s: Don't Reset HBA\n", 1283 ha->host_no, __func__)); 1284 clear_bit(DPC_RESET_HA, &ha->dpc_flags); 1285 clear_bit(DPC_RESET_HA_INTR, &ha->dpc_flags); 1286 clear_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags); 1287 goto dpc_post_reset_ha; 1288 } 1289 if (test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags) || 1290 test_bit(DPC_RESET_HA, &ha->dpc_flags)) 1291 qla4xxx_recover_adapter(ha); 1292 1293 if (test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags)) { 1294 uint8_t wait_time = RESET_INTR_TOV; 1295 1296 while ((readw(&ha->reg->ctrl_status) & 1297 (CSR_SOFT_RESET | CSR_FORCE_SOFT_RESET)) != 0) { 1298 if (--wait_time == 0) 1299 break; 1300 msleep(1000); 1301 } 1302 if (wait_time == 0) 1303 DEBUG2(printk("scsi%ld: %s: SR|FSR " 1304 "bit not cleared-- resetting\n", 1305 ha->host_no, __func__)); 1306 qla4xxx_abort_active_cmds(ha, DID_RESET << 16); 1307 if (ql4xxx_lock_drvr_wait(ha) == QLA_SUCCESS) { 1308 qla4xxx_process_aen(ha, FLUSH_DDB_CHANGED_AENS); 1309 status = qla4xxx_recover_adapter(ha); 1310 } 1311 clear_bit(DPC_RESET_HA_INTR, &ha->dpc_flags); 1312 if (status == QLA_SUCCESS) 1313 ha->isp_ops->enable_intrs(ha); 1314 } 1315 } 1316 1317 dpc_post_reset_ha: 1318 /* ---- process AEN? --- */ 1319 if (test_and_clear_bit(DPC_AEN, &ha->dpc_flags)) 1320 qla4xxx_process_aen(ha, PROCESS_ALL_AENS); 1321 1322 /* ---- Get DHCP IP Address? --- */ 1323 if (test_and_clear_bit(DPC_GET_DHCP_IP_ADDR, &ha->dpc_flags)) 1324 qla4xxx_get_dhcp_ip_address(ha); 1325 1326 /* ---- link change? --- */ 1327 if (test_and_clear_bit(DPC_LINK_CHANGED, &ha->dpc_flags)) { 1328 if (!test_bit(AF_LINK_UP, &ha->flags)) { 1329 /* ---- link down? --- */ 1330 list_for_each_entry_safe(ddb_entry, dtemp, 1331 &ha->ddb_list, list) { 1332 if (atomic_read(&ddb_entry->state) == 1333 DDB_STATE_ONLINE) 1334 qla4xxx_mark_device_missing(ha, 1335 ddb_entry); 1336 } 1337 } else { 1338 /* ---- link up? --- * 1339 * F/W will auto login to all devices ONLY ONCE after 1340 * link up during driver initialization and runtime 1341 * fatal error recovery. Therefore, the driver must 1342 * manually relogin to devices when recovering from 1343 * connection failures, logouts, expired KATO, etc. */ 1344 1345 list_for_each_entry_safe(ddb_entry, dtemp, 1346 &ha->ddb_list, list) { 1347 if ((atomic_read(&ddb_entry->state) == 1348 DDB_STATE_MISSING) || 1349 (atomic_read(&ddb_entry->state) == 1350 DDB_STATE_DEAD)) { 1351 if (ddb_entry->fw_ddb_device_state == 1352 DDB_DS_SESSION_ACTIVE) { 1353 atomic_set(&ddb_entry->state, 1354 DDB_STATE_ONLINE); 1355 ql4_printk(KERN_INFO, ha, 1356 "scsi%ld: %s: ddb[%d]" 1357 " marked ONLINE\n", 1358 ha->host_no, __func__, 1359 ddb_entry->fw_ddb_index); 1360 1361 iscsi_unblock_session( 1362 ddb_entry->sess); 1363 } else 1364 qla4xxx_relogin_device( 1365 ha, ddb_entry); 1366 } 1367 1368 } 1369 } 1370 } 1371 1372 /* ---- relogin device? --- */ 1373 if (adapter_up(ha) && 1374 test_and_clear_bit(DPC_RELOGIN_DEVICE, &ha->dpc_flags)) { 1375 list_for_each_entry_safe(ddb_entry, dtemp, 1376 &ha->ddb_list, list) { 1377 if (test_and_clear_bit(DF_RELOGIN, &ddb_entry->flags) && 1378 atomic_read(&ddb_entry->state) != DDB_STATE_ONLINE) 1379 qla4xxx_relogin_device(ha, ddb_entry); 1380 1381 /* 1382 * If mbx cmd times out there is no point 1383 * in continuing further. 1384 * With large no of targets this can hang 1385 * the system. 1386 */ 1387 if (test_bit(DPC_RESET_HA, &ha->dpc_flags)) { 1388 printk(KERN_WARNING "scsi%ld: %s: " 1389 "need to reset hba\n", 1390 ha->host_no, __func__); 1391 break; 1392 } 1393 } 1394 } 1395 1396 do_dpc_exit: 1397 clear_bit(AF_DPC_SCHEDULED, &ha->flags); 1398 } 1399 1400 /** 1401 * qla4xxx_free_adapter - release the adapter 1402 * @ha: pointer to adapter structure 1403 **/ 1404 static void qla4xxx_free_adapter(struct scsi_qla_host *ha) 1405 { 1406 1407 if (test_bit(AF_INTERRUPTS_ON, &ha->flags)) { 1408 /* Turn-off interrupts on the card. */ 1409 ha->isp_ops->disable_intrs(ha); 1410 } 1411 1412 /* Remove timer thread, if present */ 1413 if (ha->timer_active) 1414 qla4xxx_stop_timer(ha); 1415 1416 /* Kill the kernel thread for this host */ 1417 if (ha->dpc_thread) 1418 destroy_workqueue(ha->dpc_thread); 1419 1420 /* Put firmware in known state */ 1421 ha->isp_ops->reset_firmware(ha); 1422 1423 if (is_qla8022(ha)) { 1424 qla4_8xxx_idc_lock(ha); 1425 qla4_8xxx_clear_drv_active(ha); 1426 qla4_8xxx_idc_unlock(ha); 1427 } 1428 1429 /* Detach interrupts */ 1430 if (test_and_clear_bit(AF_IRQ_ATTACHED, &ha->flags)) 1431 qla4xxx_free_irqs(ha); 1432 1433 /* free extra memory */ 1434 qla4xxx_mem_free(ha); 1435 } 1436 1437 int qla4_8xxx_iospace_config(struct scsi_qla_host *ha) 1438 { 1439 int status = 0; 1440 uint8_t revision_id; 1441 unsigned long mem_base, mem_len, db_base, db_len; 1442 struct pci_dev *pdev = ha->pdev; 1443 1444 status = pci_request_regions(pdev, DRIVER_NAME); 1445 if (status) { 1446 printk(KERN_WARNING 1447 "scsi(%ld) Failed to reserve PIO regions (%s) " 1448 "status=%d\n", ha->host_no, pci_name(pdev), status); 1449 goto iospace_error_exit; 1450 } 1451 1452 pci_read_config_byte(pdev, PCI_REVISION_ID, &revision_id); 1453 DEBUG2(printk(KERN_INFO "%s: revision-id=%d\n", 1454 __func__, revision_id)); 1455 ha->revision_id = revision_id; 1456 1457 /* remap phys address */ 1458 mem_base = pci_resource_start(pdev, 0); /* 0 is for BAR 0 */ 1459 mem_len = pci_resource_len(pdev, 0); 1460 DEBUG2(printk(KERN_INFO "%s: ioremap from %lx a size of %lx\n", 1461 __func__, mem_base, mem_len)); 1462 1463 /* mapping of pcibase pointer */ 1464 ha->nx_pcibase = (unsigned long)ioremap(mem_base, mem_len); 1465 if (!ha->nx_pcibase) { 1466 printk(KERN_ERR 1467 "cannot remap MMIO (%s), aborting\n", pci_name(pdev)); 1468 pci_release_regions(ha->pdev); 1469 goto iospace_error_exit; 1470 } 1471 1472 /* Mapping of IO base pointer, door bell read and write pointer */ 1473 1474 /* mapping of IO base pointer */ 1475 ha->qla4_8xxx_reg = 1476 (struct device_reg_82xx __iomem *)((uint8_t *)ha->nx_pcibase + 1477 0xbc000 + (ha->pdev->devfn << 11)); 1478 1479 db_base = pci_resource_start(pdev, 4); /* doorbell is on bar 4 */ 1480 db_len = pci_resource_len(pdev, 4); 1481 1482 ha->nx_db_wr_ptr = (ha->pdev->devfn == 4 ? QLA82XX_CAM_RAM_DB1 : 1483 QLA82XX_CAM_RAM_DB2); 1484 1485 return 0; 1486 iospace_error_exit: 1487 return -ENOMEM; 1488 } 1489 1490 /*** 1491 * qla4xxx_iospace_config - maps registers 1492 * @ha: pointer to adapter structure 1493 * 1494 * This routines maps HBA's registers from the pci address space 1495 * into the kernel virtual address space for memory mapped i/o. 1496 **/ 1497 int qla4xxx_iospace_config(struct scsi_qla_host *ha) 1498 { 1499 unsigned long pio, pio_len, pio_flags; 1500 unsigned long mmio, mmio_len, mmio_flags; 1501 1502 pio = pci_resource_start(ha->pdev, 0); 1503 pio_len = pci_resource_len(ha->pdev, 0); 1504 pio_flags = pci_resource_flags(ha->pdev, 0); 1505 if (pio_flags & IORESOURCE_IO) { 1506 if (pio_len < MIN_IOBASE_LEN) { 1507 ql4_printk(KERN_WARNING, ha, 1508 "Invalid PCI I/O region size\n"); 1509 pio = 0; 1510 } 1511 } else { 1512 ql4_printk(KERN_WARNING, ha, "region #0 not a PIO resource\n"); 1513 pio = 0; 1514 } 1515 1516 /* Use MMIO operations for all accesses. */ 1517 mmio = pci_resource_start(ha->pdev, 1); 1518 mmio_len = pci_resource_len(ha->pdev, 1); 1519 mmio_flags = pci_resource_flags(ha->pdev, 1); 1520 1521 if (!(mmio_flags & IORESOURCE_MEM)) { 1522 ql4_printk(KERN_ERR, ha, 1523 "region #0 not an MMIO resource, aborting\n"); 1524 1525 goto iospace_error_exit; 1526 } 1527 1528 if (mmio_len < MIN_IOBASE_LEN) { 1529 ql4_printk(KERN_ERR, ha, 1530 "Invalid PCI mem region size, aborting\n"); 1531 goto iospace_error_exit; 1532 } 1533 1534 if (pci_request_regions(ha->pdev, DRIVER_NAME)) { 1535 ql4_printk(KERN_WARNING, ha, 1536 "Failed to reserve PIO/MMIO regions\n"); 1537 1538 goto iospace_error_exit; 1539 } 1540 1541 ha->pio_address = pio; 1542 ha->pio_length = pio_len; 1543 ha->reg = ioremap(mmio, MIN_IOBASE_LEN); 1544 if (!ha->reg) { 1545 ql4_printk(KERN_ERR, ha, 1546 "cannot remap MMIO, aborting\n"); 1547 1548 goto iospace_error_exit; 1549 } 1550 1551 return 0; 1552 1553 iospace_error_exit: 1554 return -ENOMEM; 1555 } 1556 1557 static struct isp_operations qla4xxx_isp_ops = { 1558 .iospace_config = qla4xxx_iospace_config, 1559 .pci_config = qla4xxx_pci_config, 1560 .disable_intrs = qla4xxx_disable_intrs, 1561 .enable_intrs = qla4xxx_enable_intrs, 1562 .start_firmware = qla4xxx_start_firmware, 1563 .intr_handler = qla4xxx_intr_handler, 1564 .interrupt_service_routine = qla4xxx_interrupt_service_routine, 1565 .reset_chip = qla4xxx_soft_reset, 1566 .reset_firmware = qla4xxx_hw_reset, 1567 .queue_iocb = qla4xxx_queue_iocb, 1568 .complete_iocb = qla4xxx_complete_iocb, 1569 .rd_shdw_req_q_out = qla4xxx_rd_shdw_req_q_out, 1570 .rd_shdw_rsp_q_in = qla4xxx_rd_shdw_rsp_q_in, 1571 .get_sys_info = qla4xxx_get_sys_info, 1572 }; 1573 1574 static struct isp_operations qla4_8xxx_isp_ops = { 1575 .iospace_config = qla4_8xxx_iospace_config, 1576 .pci_config = qla4_8xxx_pci_config, 1577 .disable_intrs = qla4_8xxx_disable_intrs, 1578 .enable_intrs = qla4_8xxx_enable_intrs, 1579 .start_firmware = qla4_8xxx_load_risc, 1580 .intr_handler = qla4_8xxx_intr_handler, 1581 .interrupt_service_routine = qla4_8xxx_interrupt_service_routine, 1582 .reset_chip = qla4_8xxx_isp_reset, 1583 .reset_firmware = qla4_8xxx_stop_firmware, 1584 .queue_iocb = qla4_8xxx_queue_iocb, 1585 .complete_iocb = qla4_8xxx_complete_iocb, 1586 .rd_shdw_req_q_out = qla4_8xxx_rd_shdw_req_q_out, 1587 .rd_shdw_rsp_q_in = qla4_8xxx_rd_shdw_rsp_q_in, 1588 .get_sys_info = qla4_8xxx_get_sys_info, 1589 }; 1590 1591 uint16_t qla4xxx_rd_shdw_req_q_out(struct scsi_qla_host *ha) 1592 { 1593 return (uint16_t)le32_to_cpu(ha->shadow_regs->req_q_out); 1594 } 1595 1596 uint16_t qla4_8xxx_rd_shdw_req_q_out(struct scsi_qla_host *ha) 1597 { 1598 return (uint16_t)le32_to_cpu(readl(&ha->qla4_8xxx_reg->req_q_out)); 1599 } 1600 1601 uint16_t qla4xxx_rd_shdw_rsp_q_in(struct scsi_qla_host *ha) 1602 { 1603 return (uint16_t)le32_to_cpu(ha->shadow_regs->rsp_q_in); 1604 } 1605 1606 uint16_t qla4_8xxx_rd_shdw_rsp_q_in(struct scsi_qla_host *ha) 1607 { 1608 return (uint16_t)le32_to_cpu(readl(&ha->qla4_8xxx_reg->rsp_q_in)); 1609 } 1610 1611 /** 1612 * qla4xxx_probe_adapter - callback function to probe HBA 1613 * @pdev: pointer to pci_dev structure 1614 * @pci_device_id: pointer to pci_device entry 1615 * 1616 * This routine will probe for Qlogic 4xxx iSCSI host adapters. 1617 * It returns zero if successful. It also initializes all data necessary for 1618 * the driver. 1619 **/ 1620 static int __devinit qla4xxx_probe_adapter(struct pci_dev *pdev, 1621 const struct pci_device_id *ent) 1622 { 1623 int ret = -ENODEV, status; 1624 struct Scsi_Host *host; 1625 struct scsi_qla_host *ha; 1626 uint8_t init_retry_count = 0; 1627 char buf[34]; 1628 struct qla4_8xxx_legacy_intr_set *nx_legacy_intr; 1629 1630 if (pci_enable_device(pdev)) 1631 return -1; 1632 1633 host = scsi_host_alloc(&qla4xxx_driver_template, sizeof(*ha)); 1634 if (host == NULL) { 1635 printk(KERN_WARNING 1636 "qla4xxx: Couldn't allocate host from scsi layer!\n"); 1637 goto probe_disable_device; 1638 } 1639 1640 /* Clear our data area */ 1641 ha = (struct scsi_qla_host *) host->hostdata; 1642 memset(ha, 0, sizeof(*ha)); 1643 1644 /* Save the information from PCI BIOS. */ 1645 ha->pdev = pdev; 1646 ha->host = host; 1647 ha->host_no = host->host_no; 1648 1649 pci_enable_pcie_error_reporting(pdev); 1650 1651 /* Setup Runtime configurable options */ 1652 if (is_qla8022(ha)) { 1653 ha->isp_ops = &qla4_8xxx_isp_ops; 1654 rwlock_init(&ha->hw_lock); 1655 ha->qdr_sn_window = -1; 1656 ha->ddr_mn_window = -1; 1657 ha->curr_window = 255; 1658 ha->func_num = PCI_FUNC(ha->pdev->devfn); 1659 nx_legacy_intr = &legacy_intr[ha->func_num]; 1660 ha->nx_legacy_intr.int_vec_bit = nx_legacy_intr->int_vec_bit; 1661 ha->nx_legacy_intr.tgt_status_reg = 1662 nx_legacy_intr->tgt_status_reg; 1663 ha->nx_legacy_intr.tgt_mask_reg = nx_legacy_intr->tgt_mask_reg; 1664 ha->nx_legacy_intr.pci_int_reg = nx_legacy_intr->pci_int_reg; 1665 } else { 1666 ha->isp_ops = &qla4xxx_isp_ops; 1667 } 1668 1669 /* Set EEH reset type to fundamental if required by hba */ 1670 if (is_qla8022(ha)) 1671 pdev->needs_freset = 1; 1672 1673 /* Configure PCI I/O space. */ 1674 ret = ha->isp_ops->iospace_config(ha); 1675 if (ret) 1676 goto probe_failed_ioconfig; 1677 1678 ql4_printk(KERN_INFO, ha, "Found an ISP%04x, irq %d, iobase 0x%p\n", 1679 pdev->device, pdev->irq, ha->reg); 1680 1681 qla4xxx_config_dma_addressing(ha); 1682 1683 /* Initialize lists and spinlocks. */ 1684 INIT_LIST_HEAD(&ha->ddb_list); 1685 INIT_LIST_HEAD(&ha->free_srb_q); 1686 1687 mutex_init(&ha->mbox_sem); 1688 init_completion(&ha->mbx_intr_comp); 1689 1690 spin_lock_init(&ha->hardware_lock); 1691 1692 /* Allocate dma buffers */ 1693 if (qla4xxx_mem_alloc(ha)) { 1694 ql4_printk(KERN_WARNING, ha, 1695 "[ERROR] Failed to allocate memory for adapter\n"); 1696 1697 ret = -ENOMEM; 1698 goto probe_failed; 1699 } 1700 1701 if (is_qla8022(ha)) 1702 (void) qla4_8xxx_get_flash_info(ha); 1703 1704 /* 1705 * Initialize the Host adapter request/response queues and 1706 * firmware 1707 * NOTE: interrupts enabled upon successful completion 1708 */ 1709 status = qla4xxx_initialize_adapter(ha, REBUILD_DDB_LIST); 1710 while ((!test_bit(AF_ONLINE, &ha->flags)) && 1711 init_retry_count++ < MAX_INIT_RETRIES) { 1712 DEBUG2(printk("scsi: %s: retrying adapter initialization " 1713 "(%d)\n", __func__, init_retry_count)); 1714 1715 if (ha->isp_ops->reset_chip(ha) == QLA_ERROR) 1716 continue; 1717 1718 status = qla4xxx_initialize_adapter(ha, REBUILD_DDB_LIST); 1719 } 1720 1721 if (!test_bit(AF_ONLINE, &ha->flags)) { 1722 ql4_printk(KERN_WARNING, ha, "Failed to initialize adapter\n"); 1723 1724 ret = -ENODEV; 1725 goto probe_failed; 1726 } 1727 1728 host->cmd_per_lun = 3; 1729 host->max_channel = 0; 1730 host->max_lun = MAX_LUNS - 1; 1731 host->max_id = MAX_TARGETS; 1732 host->max_cmd_len = IOCB_MAX_CDB_LEN; 1733 host->can_queue = MAX_SRBS ; 1734 host->transportt = qla4xxx_scsi_transport; 1735 1736 ret = scsi_init_shared_tag_map(host, MAX_SRBS); 1737 if (ret) { 1738 ql4_printk(KERN_WARNING, ha, 1739 "scsi_init_shared_tag_map failed\n"); 1740 goto probe_failed; 1741 } 1742 1743 /* Startup the kernel thread for this host adapter. */ 1744 DEBUG2(printk("scsi: %s: Starting kernel thread for " 1745 "qla4xxx_dpc\n", __func__)); 1746 sprintf(buf, "qla4xxx_%lu_dpc", ha->host_no); 1747 ha->dpc_thread = create_singlethread_workqueue(buf); 1748 if (!ha->dpc_thread) { 1749 ql4_printk(KERN_WARNING, ha, "Unable to start DPC thread!\n"); 1750 ret = -ENODEV; 1751 goto probe_failed; 1752 } 1753 INIT_WORK(&ha->dpc_work, qla4xxx_do_dpc); 1754 1755 /* For ISP-82XX, request_irqs is called in qla4_8xxx_load_risc 1756 * (which is called indirectly by qla4xxx_initialize_adapter), 1757 * so that irqs will be registered after crbinit but before 1758 * mbx_intr_enable. 1759 */ 1760 if (!is_qla8022(ha)) { 1761 ret = qla4xxx_request_irqs(ha); 1762 if (ret) { 1763 ql4_printk(KERN_WARNING, ha, "Failed to reserve " 1764 "interrupt %d already in use.\n", pdev->irq); 1765 goto probe_failed; 1766 } 1767 } 1768 1769 pci_save_state(ha->pdev); 1770 ha->isp_ops->enable_intrs(ha); 1771 1772 /* Start timer thread. */ 1773 qla4xxx_start_timer(ha, qla4xxx_timer, 1); 1774 1775 set_bit(AF_INIT_DONE, &ha->flags); 1776 1777 pci_set_drvdata(pdev, ha); 1778 1779 ret = scsi_add_host(host, &pdev->dev); 1780 if (ret) 1781 goto probe_failed; 1782 1783 printk(KERN_INFO 1784 " QLogic iSCSI HBA Driver version: %s\n" 1785 " QLogic ISP%04x @ %s, host#=%ld, fw=%02d.%02d.%02d.%02d\n", 1786 qla4xxx_version_str, ha->pdev->device, pci_name(ha->pdev), 1787 ha->host_no, ha->firmware_version[0], ha->firmware_version[1], 1788 ha->patch_number, ha->build_number); 1789 scsi_scan_host(host); 1790 return 0; 1791 1792 probe_failed: 1793 qla4xxx_free_adapter(ha); 1794 1795 probe_failed_ioconfig: 1796 pci_disable_pcie_error_reporting(pdev); 1797 scsi_host_put(ha->host); 1798 1799 probe_disable_device: 1800 pci_disable_device(pdev); 1801 1802 return ret; 1803 } 1804 1805 /** 1806 * qla4xxx_remove_adapter - calback function to remove adapter. 1807 * @pci_dev: PCI device pointer 1808 **/ 1809 static void __devexit qla4xxx_remove_adapter(struct pci_dev *pdev) 1810 { 1811 struct scsi_qla_host *ha; 1812 1813 ha = pci_get_drvdata(pdev); 1814 1815 set_bit(AF_HBA_GOING_AWAY, &ha->flags); 1816 1817 /* remove devs from iscsi_sessions to scsi_devices */ 1818 qla4xxx_free_ddb_list(ha); 1819 1820 scsi_remove_host(ha->host); 1821 1822 qla4xxx_free_adapter(ha); 1823 1824 scsi_host_put(ha->host); 1825 1826 pci_disable_pcie_error_reporting(pdev); 1827 pci_disable_device(pdev); 1828 pci_set_drvdata(pdev, NULL); 1829 } 1830 1831 /** 1832 * qla4xxx_config_dma_addressing() - Configure OS DMA addressing method. 1833 * @ha: HA context 1834 * 1835 * At exit, the @ha's flags.enable_64bit_addressing set to indicated 1836 * supported addressing method. 1837 */ 1838 static void qla4xxx_config_dma_addressing(struct scsi_qla_host *ha) 1839 { 1840 int retval; 1841 1842 /* Update our PCI device dma_mask for full 64 bit mask */ 1843 if (pci_set_dma_mask(ha->pdev, DMA_BIT_MASK(64)) == 0) { 1844 if (pci_set_consistent_dma_mask(ha->pdev, DMA_BIT_MASK(64))) { 1845 dev_dbg(&ha->pdev->dev, 1846 "Failed to set 64 bit PCI consistent mask; " 1847 "using 32 bit.\n"); 1848 retval = pci_set_consistent_dma_mask(ha->pdev, 1849 DMA_BIT_MASK(32)); 1850 } 1851 } else 1852 retval = pci_set_dma_mask(ha->pdev, DMA_BIT_MASK(32)); 1853 } 1854 1855 static int qla4xxx_slave_alloc(struct scsi_device *sdev) 1856 { 1857 struct iscsi_cls_session *sess = starget_to_session(sdev->sdev_target); 1858 struct ddb_entry *ddb = sess->dd_data; 1859 1860 sdev->hostdata = ddb; 1861 sdev->tagged_supported = 1; 1862 scsi_activate_tcq(sdev, QL4_DEF_QDEPTH); 1863 return 0; 1864 } 1865 1866 static int qla4xxx_slave_configure(struct scsi_device *sdev) 1867 { 1868 sdev->tagged_supported = 1; 1869 return 0; 1870 } 1871 1872 static void qla4xxx_slave_destroy(struct scsi_device *sdev) 1873 { 1874 scsi_deactivate_tcq(sdev, 1); 1875 } 1876 1877 /** 1878 * qla4xxx_del_from_active_array - returns an active srb 1879 * @ha: Pointer to host adapter structure. 1880 * @index: index into the active_array 1881 * 1882 * This routine removes and returns the srb at the specified index 1883 **/ 1884 struct srb *qla4xxx_del_from_active_array(struct scsi_qla_host *ha, 1885 uint32_t index) 1886 { 1887 struct srb *srb = NULL; 1888 struct scsi_cmnd *cmd = NULL; 1889 1890 cmd = scsi_host_find_tag(ha->host, index); 1891 if (!cmd) 1892 return srb; 1893 1894 srb = (struct srb *)CMD_SP(cmd); 1895 if (!srb) 1896 return srb; 1897 1898 /* update counters */ 1899 if (srb->flags & SRB_DMA_VALID) { 1900 ha->req_q_count += srb->iocb_cnt; 1901 ha->iocb_cnt -= srb->iocb_cnt; 1902 if (srb->cmd) 1903 srb->cmd->host_scribble = 1904 (unsigned char *)(unsigned long) MAX_SRBS; 1905 } 1906 return srb; 1907 } 1908 1909 /** 1910 * qla4xxx_eh_wait_on_command - waits for command to be returned by firmware 1911 * @ha: Pointer to host adapter structure. 1912 * @cmd: Scsi Command to wait on. 1913 * 1914 * This routine waits for the command to be returned by the Firmware 1915 * for some max time. 1916 **/ 1917 static int qla4xxx_eh_wait_on_command(struct scsi_qla_host *ha, 1918 struct scsi_cmnd *cmd) 1919 { 1920 int done = 0; 1921 struct srb *rp; 1922 uint32_t max_wait_time = EH_WAIT_CMD_TOV; 1923 int ret = SUCCESS; 1924 1925 /* Dont wait on command if PCI error is being handled 1926 * by PCI AER driver 1927 */ 1928 if (unlikely(pci_channel_offline(ha->pdev)) || 1929 (test_bit(AF_EEH_BUSY, &ha->flags))) { 1930 ql4_printk(KERN_WARNING, ha, "scsi%ld: Return from %s\n", 1931 ha->host_no, __func__); 1932 return ret; 1933 } 1934 1935 do { 1936 /* Checking to see if its returned to OS */ 1937 rp = (struct srb *) CMD_SP(cmd); 1938 if (rp == NULL) { 1939 done++; 1940 break; 1941 } 1942 1943 msleep(2000); 1944 } while (max_wait_time--); 1945 1946 return done; 1947 } 1948 1949 /** 1950 * qla4xxx_wait_for_hba_online - waits for HBA to come online 1951 * @ha: Pointer to host adapter structure 1952 **/ 1953 static int qla4xxx_wait_for_hba_online(struct scsi_qla_host *ha) 1954 { 1955 unsigned long wait_online; 1956 1957 wait_online = jiffies + (HBA_ONLINE_TOV * HZ); 1958 while (time_before(jiffies, wait_online)) { 1959 1960 if (adapter_up(ha)) 1961 return QLA_SUCCESS; 1962 1963 msleep(2000); 1964 } 1965 1966 return QLA_ERROR; 1967 } 1968 1969 /** 1970 * qla4xxx_eh_wait_for_commands - wait for active cmds to finish. 1971 * @ha: pointer to HBA 1972 * @t: target id 1973 * @l: lun id 1974 * 1975 * This function waits for all outstanding commands to a lun to complete. It 1976 * returns 0 if all pending commands are returned and 1 otherwise. 1977 **/ 1978 static int qla4xxx_eh_wait_for_commands(struct scsi_qla_host *ha, 1979 struct scsi_target *stgt, 1980 struct scsi_device *sdev) 1981 { 1982 int cnt; 1983 int status = 0; 1984 struct scsi_cmnd *cmd; 1985 1986 /* 1987 * Waiting for all commands for the designated target or dev 1988 * in the active array 1989 */ 1990 for (cnt = 0; cnt < ha->host->can_queue; cnt++) { 1991 cmd = scsi_host_find_tag(ha->host, cnt); 1992 if (cmd && stgt == scsi_target(cmd->device) && 1993 (!sdev || sdev == cmd->device)) { 1994 if (!qla4xxx_eh_wait_on_command(ha, cmd)) { 1995 status++; 1996 break; 1997 } 1998 } 1999 } 2000 return status; 2001 } 2002 2003 /** 2004 * qla4xxx_eh_abort - callback for abort task. 2005 * @cmd: Pointer to Linux's SCSI command structure 2006 * 2007 * This routine is called by the Linux OS to abort the specified 2008 * command. 2009 **/ 2010 static int qla4xxx_eh_abort(struct scsi_cmnd *cmd) 2011 { 2012 struct scsi_qla_host *ha = to_qla_host(cmd->device->host); 2013 unsigned int id = cmd->device->id; 2014 unsigned int lun = cmd->device->lun; 2015 unsigned long serial = cmd->serial_number; 2016 unsigned long flags; 2017 struct srb *srb = NULL; 2018 int ret = SUCCESS; 2019 int wait = 0; 2020 2021 ql4_printk(KERN_INFO, ha, 2022 "scsi%ld:%d:%d: Abort command issued cmd=%p, pid=%ld\n", 2023 ha->host_no, id, lun, cmd, serial); 2024 2025 spin_lock_irqsave(&ha->hardware_lock, flags); 2026 srb = (struct srb *) CMD_SP(cmd); 2027 if (!srb) { 2028 spin_unlock_irqrestore(&ha->hardware_lock, flags); 2029 return SUCCESS; 2030 } 2031 kref_get(&srb->srb_ref); 2032 spin_unlock_irqrestore(&ha->hardware_lock, flags); 2033 2034 if (qla4xxx_abort_task(ha, srb) != QLA_SUCCESS) { 2035 DEBUG3(printk("scsi%ld:%d:%d: Abort_task mbx failed.\n", 2036 ha->host_no, id, lun)); 2037 ret = FAILED; 2038 } else { 2039 DEBUG3(printk("scsi%ld:%d:%d: Abort_task mbx success.\n", 2040 ha->host_no, id, lun)); 2041 wait = 1; 2042 } 2043 2044 kref_put(&srb->srb_ref, qla4xxx_srb_compl); 2045 2046 /* Wait for command to complete */ 2047 if (wait) { 2048 if (!qla4xxx_eh_wait_on_command(ha, cmd)) { 2049 DEBUG2(printk("scsi%ld:%d:%d: Abort handler timed out\n", 2050 ha->host_no, id, lun)); 2051 ret = FAILED; 2052 } 2053 } 2054 2055 ql4_printk(KERN_INFO, ha, 2056 "scsi%ld:%d:%d: Abort command - %s\n", 2057 ha->host_no, id, lun, (ret == SUCCESS) ? "succeded" : "failed"); 2058 2059 return ret; 2060 } 2061 2062 /** 2063 * qla4xxx_eh_device_reset - callback for target reset. 2064 * @cmd: Pointer to Linux's SCSI command structure 2065 * 2066 * This routine is called by the Linux OS to reset all luns on the 2067 * specified target. 2068 **/ 2069 static int qla4xxx_eh_device_reset(struct scsi_cmnd *cmd) 2070 { 2071 struct scsi_qla_host *ha = to_qla_host(cmd->device->host); 2072 struct ddb_entry *ddb_entry = cmd->device->hostdata; 2073 int ret = FAILED, stat; 2074 2075 if (!ddb_entry) 2076 return ret; 2077 2078 ret = iscsi_block_scsi_eh(cmd); 2079 if (ret) 2080 return ret; 2081 ret = FAILED; 2082 2083 ql4_printk(KERN_INFO, ha, 2084 "scsi%ld:%d:%d:%d: DEVICE RESET ISSUED.\n", ha->host_no, 2085 cmd->device->channel, cmd->device->id, cmd->device->lun); 2086 2087 DEBUG2(printk(KERN_INFO 2088 "scsi%ld: DEVICE_RESET cmd=%p jiffies = 0x%lx, to=%x," 2089 "dpc_flags=%lx, status=%x allowed=%d\n", ha->host_no, 2090 cmd, jiffies, cmd->request->timeout / HZ, 2091 ha->dpc_flags, cmd->result, cmd->allowed)); 2092 2093 /* FIXME: wait for hba to go online */ 2094 stat = qla4xxx_reset_lun(ha, ddb_entry, cmd->device->lun); 2095 if (stat != QLA_SUCCESS) { 2096 ql4_printk(KERN_INFO, ha, "DEVICE RESET FAILED. %d\n", stat); 2097 goto eh_dev_reset_done; 2098 } 2099 2100 if (qla4xxx_eh_wait_for_commands(ha, scsi_target(cmd->device), 2101 cmd->device)) { 2102 ql4_printk(KERN_INFO, ha, 2103 "DEVICE RESET FAILED - waiting for " 2104 "commands.\n"); 2105 goto eh_dev_reset_done; 2106 } 2107 2108 /* Send marker. */ 2109 if (qla4xxx_send_marker_iocb(ha, ddb_entry, cmd->device->lun, 2110 MM_LUN_RESET) != QLA_SUCCESS) 2111 goto eh_dev_reset_done; 2112 2113 ql4_printk(KERN_INFO, ha, 2114 "scsi(%ld:%d:%d:%d): DEVICE RESET SUCCEEDED.\n", 2115 ha->host_no, cmd->device->channel, cmd->device->id, 2116 cmd->device->lun); 2117 2118 ret = SUCCESS; 2119 2120 eh_dev_reset_done: 2121 2122 return ret; 2123 } 2124 2125 /** 2126 * qla4xxx_eh_target_reset - callback for target reset. 2127 * @cmd: Pointer to Linux's SCSI command structure 2128 * 2129 * This routine is called by the Linux OS to reset the target. 2130 **/ 2131 static int qla4xxx_eh_target_reset(struct scsi_cmnd *cmd) 2132 { 2133 struct scsi_qla_host *ha = to_qla_host(cmd->device->host); 2134 struct ddb_entry *ddb_entry = cmd->device->hostdata; 2135 int stat, ret; 2136 2137 if (!ddb_entry) 2138 return FAILED; 2139 2140 ret = iscsi_block_scsi_eh(cmd); 2141 if (ret) 2142 return ret; 2143 2144 starget_printk(KERN_INFO, scsi_target(cmd->device), 2145 "WARM TARGET RESET ISSUED.\n"); 2146 2147 DEBUG2(printk(KERN_INFO 2148 "scsi%ld: TARGET_DEVICE_RESET cmd=%p jiffies = 0x%lx, " 2149 "to=%x,dpc_flags=%lx, status=%x allowed=%d\n", 2150 ha->host_no, cmd, jiffies, cmd->request->timeout / HZ, 2151 ha->dpc_flags, cmd->result, cmd->allowed)); 2152 2153 stat = qla4xxx_reset_target(ha, ddb_entry); 2154 if (stat != QLA_SUCCESS) { 2155 starget_printk(KERN_INFO, scsi_target(cmd->device), 2156 "WARM TARGET RESET FAILED.\n"); 2157 return FAILED; 2158 } 2159 2160 if (qla4xxx_eh_wait_for_commands(ha, scsi_target(cmd->device), 2161 NULL)) { 2162 starget_printk(KERN_INFO, scsi_target(cmd->device), 2163 "WARM TARGET DEVICE RESET FAILED - " 2164 "waiting for commands.\n"); 2165 return FAILED; 2166 } 2167 2168 /* Send marker. */ 2169 if (qla4xxx_send_marker_iocb(ha, ddb_entry, cmd->device->lun, 2170 MM_TGT_WARM_RESET) != QLA_SUCCESS) { 2171 starget_printk(KERN_INFO, scsi_target(cmd->device), 2172 "WARM TARGET DEVICE RESET FAILED - " 2173 "marker iocb failed.\n"); 2174 return FAILED; 2175 } 2176 2177 starget_printk(KERN_INFO, scsi_target(cmd->device), 2178 "WARM TARGET RESET SUCCEEDED.\n"); 2179 return SUCCESS; 2180 } 2181 2182 /** 2183 * qla4xxx_eh_host_reset - kernel callback 2184 * @cmd: Pointer to Linux's SCSI command structure 2185 * 2186 * This routine is invoked by the Linux kernel to perform fatal error 2187 * recovery on the specified adapter. 2188 **/ 2189 static int qla4xxx_eh_host_reset(struct scsi_cmnd *cmd) 2190 { 2191 int return_status = FAILED; 2192 struct scsi_qla_host *ha; 2193 2194 ha = (struct scsi_qla_host *) cmd->device->host->hostdata; 2195 2196 if (ql4xdontresethba) { 2197 DEBUG2(printk("scsi%ld: %s: Don't Reset HBA\n", 2198 ha->host_no, __func__)); 2199 return FAILED; 2200 } 2201 2202 ql4_printk(KERN_INFO, ha, 2203 "scsi(%ld:%d:%d:%d): HOST RESET ISSUED.\n", ha->host_no, 2204 cmd->device->channel, cmd->device->id, cmd->device->lun); 2205 2206 if (qla4xxx_wait_for_hba_online(ha) != QLA_SUCCESS) { 2207 DEBUG2(printk("scsi%ld:%d: %s: Unable to reset host. Adapter " 2208 "DEAD.\n", ha->host_no, cmd->device->channel, 2209 __func__)); 2210 2211 return FAILED; 2212 } 2213 2214 if (!test_bit(DPC_RESET_HA, &ha->dpc_flags)) { 2215 if (is_qla8022(ha)) 2216 set_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags); 2217 else 2218 set_bit(DPC_RESET_HA, &ha->dpc_flags); 2219 } 2220 2221 if (qla4xxx_recover_adapter(ha) == QLA_SUCCESS) 2222 return_status = SUCCESS; 2223 2224 ql4_printk(KERN_INFO, ha, "HOST RESET %s.\n", 2225 return_status == FAILED ? "FAILED" : "SUCCEDED"); 2226 2227 return return_status; 2228 } 2229 2230 /* PCI AER driver recovers from all correctable errors w/o 2231 * driver intervention. For uncorrectable errors PCI AER 2232 * driver calls the following device driver's callbacks 2233 * 2234 * - Fatal Errors - link_reset 2235 * - Non-Fatal Errors - driver's pci_error_detected() which 2236 * returns CAN_RECOVER, NEED_RESET or DISCONNECT. 2237 * 2238 * PCI AER driver calls 2239 * CAN_RECOVER - driver's pci_mmio_enabled(), mmio_enabled 2240 * returns RECOVERED or NEED_RESET if fw_hung 2241 * NEED_RESET - driver's slot_reset() 2242 * DISCONNECT - device is dead & cannot recover 2243 * RECOVERED - driver's pci_resume() 2244 */ 2245 static pci_ers_result_t 2246 qla4xxx_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state) 2247 { 2248 struct scsi_qla_host *ha = pci_get_drvdata(pdev); 2249 2250 ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: error detected:state %x\n", 2251 ha->host_no, __func__, state); 2252 2253 if (!is_aer_supported(ha)) 2254 return PCI_ERS_RESULT_NONE; 2255 2256 switch (state) { 2257 case pci_channel_io_normal: 2258 clear_bit(AF_EEH_BUSY, &ha->flags); 2259 return PCI_ERS_RESULT_CAN_RECOVER; 2260 case pci_channel_io_frozen: 2261 set_bit(AF_EEH_BUSY, &ha->flags); 2262 qla4xxx_mailbox_premature_completion(ha); 2263 qla4xxx_free_irqs(ha); 2264 pci_disable_device(pdev); 2265 /* Return back all IOs */ 2266 qla4xxx_abort_active_cmds(ha, DID_RESET << 16); 2267 return PCI_ERS_RESULT_NEED_RESET; 2268 case pci_channel_io_perm_failure: 2269 set_bit(AF_EEH_BUSY, &ha->flags); 2270 set_bit(AF_PCI_CHANNEL_IO_PERM_FAILURE, &ha->flags); 2271 qla4xxx_abort_active_cmds(ha, DID_NO_CONNECT << 16); 2272 return PCI_ERS_RESULT_DISCONNECT; 2273 } 2274 return PCI_ERS_RESULT_NEED_RESET; 2275 } 2276 2277 /** 2278 * qla4xxx_pci_mmio_enabled() gets called if 2279 * qla4xxx_pci_error_detected() returns PCI_ERS_RESULT_CAN_RECOVER 2280 * and read/write to the device still works. 2281 **/ 2282 static pci_ers_result_t 2283 qla4xxx_pci_mmio_enabled(struct pci_dev *pdev) 2284 { 2285 struct scsi_qla_host *ha = pci_get_drvdata(pdev); 2286 2287 if (!is_aer_supported(ha)) 2288 return PCI_ERS_RESULT_NONE; 2289 2290 return PCI_ERS_RESULT_RECOVERED; 2291 } 2292 2293 static uint32_t qla4_8xxx_error_recovery(struct scsi_qla_host *ha) 2294 { 2295 uint32_t rval = QLA_ERROR; 2296 uint32_t ret = 0; 2297 int fn; 2298 struct pci_dev *other_pdev = NULL; 2299 2300 ql4_printk(KERN_WARNING, ha, "scsi%ld: In %s\n", ha->host_no, __func__); 2301 2302 set_bit(DPC_RESET_ACTIVE, &ha->dpc_flags); 2303 2304 if (test_bit(AF_ONLINE, &ha->flags)) { 2305 clear_bit(AF_ONLINE, &ha->flags); 2306 qla4xxx_mark_all_devices_missing(ha); 2307 qla4xxx_process_aen(ha, FLUSH_DDB_CHANGED_AENS); 2308 } 2309 2310 fn = PCI_FUNC(ha->pdev->devfn); 2311 while (fn > 0) { 2312 fn--; 2313 ql4_printk(KERN_INFO, ha, "scsi%ld: %s: Finding PCI device at " 2314 "func %x\n", ha->host_no, __func__, fn); 2315 /* Get the pci device given the domain, bus, 2316 * slot/function number */ 2317 other_pdev = 2318 pci_get_domain_bus_and_slot(pci_domain_nr(ha->pdev->bus), 2319 ha->pdev->bus->number, PCI_DEVFN(PCI_SLOT(ha->pdev->devfn), 2320 fn)); 2321 2322 if (!other_pdev) 2323 continue; 2324 2325 if (atomic_read(&other_pdev->enable_cnt)) { 2326 ql4_printk(KERN_INFO, ha, "scsi%ld: %s: Found PCI " 2327 "func in enabled state%x\n", ha->host_no, 2328 __func__, fn); 2329 pci_dev_put(other_pdev); 2330 break; 2331 } 2332 pci_dev_put(other_pdev); 2333 } 2334 2335 /* The first function on the card, the reset owner will 2336 * start & initialize the firmware. The other functions 2337 * on the card will reset the firmware context 2338 */ 2339 if (!fn) { 2340 ql4_printk(KERN_INFO, ha, "scsi%ld: %s: devfn being reset " 2341 "0x%x is the owner\n", ha->host_no, __func__, 2342 ha->pdev->devfn); 2343 2344 qla4_8xxx_idc_lock(ha); 2345 qla4_8xxx_wr_32(ha, QLA82XX_CRB_DEV_STATE, 2346 QLA82XX_DEV_COLD); 2347 2348 qla4_8xxx_wr_32(ha, QLA82XX_CRB_DRV_IDC_VERSION, 2349 QLA82XX_IDC_VERSION); 2350 2351 qla4_8xxx_idc_unlock(ha); 2352 clear_bit(AF_FW_RECOVERY, &ha->flags); 2353 rval = qla4xxx_initialize_adapter(ha, PRESERVE_DDB_LIST); 2354 qla4_8xxx_idc_lock(ha); 2355 2356 if (rval != QLA_SUCCESS) { 2357 ql4_printk(KERN_INFO, ha, "scsi%ld: %s: HW State: " 2358 "FAILED\n", ha->host_no, __func__); 2359 qla4_8xxx_clear_drv_active(ha); 2360 qla4_8xxx_wr_32(ha, QLA82XX_CRB_DEV_STATE, 2361 QLA82XX_DEV_FAILED); 2362 } else { 2363 ql4_printk(KERN_INFO, ha, "scsi%ld: %s: HW State: " 2364 "READY\n", ha->host_no, __func__); 2365 qla4_8xxx_wr_32(ha, QLA82XX_CRB_DEV_STATE, 2366 QLA82XX_DEV_READY); 2367 /* Clear driver state register */ 2368 qla4_8xxx_wr_32(ha, QLA82XX_CRB_DRV_STATE, 0); 2369 qla4_8xxx_set_drv_active(ha); 2370 ret = qla4xxx_request_irqs(ha); 2371 if (ret) { 2372 ql4_printk(KERN_WARNING, ha, "Failed to " 2373 "reserve interrupt %d already in use.\n", 2374 ha->pdev->irq); 2375 rval = QLA_ERROR; 2376 } else { 2377 ha->isp_ops->enable_intrs(ha); 2378 rval = QLA_SUCCESS; 2379 } 2380 } 2381 qla4_8xxx_idc_unlock(ha); 2382 } else { 2383 ql4_printk(KERN_INFO, ha, "scsi%ld: %s: devfn 0x%x is not " 2384 "the reset owner\n", ha->host_no, __func__, 2385 ha->pdev->devfn); 2386 if ((qla4_8xxx_rd_32(ha, QLA82XX_CRB_DEV_STATE) == 2387 QLA82XX_DEV_READY)) { 2388 clear_bit(AF_FW_RECOVERY, &ha->flags); 2389 rval = qla4xxx_initialize_adapter(ha, 2390 PRESERVE_DDB_LIST); 2391 if (rval == QLA_SUCCESS) { 2392 ret = qla4xxx_request_irqs(ha); 2393 if (ret) { 2394 ql4_printk(KERN_WARNING, ha, "Failed to" 2395 " reserve interrupt %d already in" 2396 " use.\n", ha->pdev->irq); 2397 rval = QLA_ERROR; 2398 } else { 2399 ha->isp_ops->enable_intrs(ha); 2400 rval = QLA_SUCCESS; 2401 } 2402 } 2403 qla4_8xxx_idc_lock(ha); 2404 qla4_8xxx_set_drv_active(ha); 2405 qla4_8xxx_idc_unlock(ha); 2406 } 2407 } 2408 clear_bit(DPC_RESET_ACTIVE, &ha->dpc_flags); 2409 return rval; 2410 } 2411 2412 static pci_ers_result_t 2413 qla4xxx_pci_slot_reset(struct pci_dev *pdev) 2414 { 2415 pci_ers_result_t ret = PCI_ERS_RESULT_DISCONNECT; 2416 struct scsi_qla_host *ha = pci_get_drvdata(pdev); 2417 int rc; 2418 2419 ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: slot_reset\n", 2420 ha->host_no, __func__); 2421 2422 if (!is_aer_supported(ha)) 2423 return PCI_ERS_RESULT_NONE; 2424 2425 /* Restore the saved state of PCIe device - 2426 * BAR registers, PCI Config space, PCIX, MSI, 2427 * IOV states 2428 */ 2429 pci_restore_state(pdev); 2430 2431 /* pci_restore_state() clears the saved_state flag of the device 2432 * save restored state which resets saved_state flag 2433 */ 2434 pci_save_state(pdev); 2435 2436 /* Initialize device or resume if in suspended state */ 2437 rc = pci_enable_device(pdev); 2438 if (rc) { 2439 ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: Cant re-enable " 2440 "device after reset\n", ha->host_no, __func__); 2441 goto exit_slot_reset; 2442 } 2443 2444 ha->isp_ops->disable_intrs(ha); 2445 2446 if (is_qla8022(ha)) { 2447 if (qla4_8xxx_error_recovery(ha) == QLA_SUCCESS) { 2448 ret = PCI_ERS_RESULT_RECOVERED; 2449 goto exit_slot_reset; 2450 } else 2451 goto exit_slot_reset; 2452 } 2453 2454 exit_slot_reset: 2455 ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: Return=%x\n" 2456 "device after reset\n", ha->host_no, __func__, ret); 2457 return ret; 2458 } 2459 2460 static void 2461 qla4xxx_pci_resume(struct pci_dev *pdev) 2462 { 2463 struct scsi_qla_host *ha = pci_get_drvdata(pdev); 2464 int ret; 2465 2466 ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: pci_resume\n", 2467 ha->host_no, __func__); 2468 2469 ret = qla4xxx_wait_for_hba_online(ha); 2470 if (ret != QLA_SUCCESS) { 2471 ql4_printk(KERN_ERR, ha, "scsi%ld: %s: the device failed to " 2472 "resume I/O from slot/link_reset\n", ha->host_no, 2473 __func__); 2474 } 2475 2476 pci_cleanup_aer_uncorrect_error_status(pdev); 2477 clear_bit(AF_EEH_BUSY, &ha->flags); 2478 } 2479 2480 static struct pci_error_handlers qla4xxx_err_handler = { 2481 .error_detected = qla4xxx_pci_error_detected, 2482 .mmio_enabled = qla4xxx_pci_mmio_enabled, 2483 .slot_reset = qla4xxx_pci_slot_reset, 2484 .resume = qla4xxx_pci_resume, 2485 }; 2486 2487 static struct pci_device_id qla4xxx_pci_tbl[] = { 2488 { 2489 .vendor = PCI_VENDOR_ID_QLOGIC, 2490 .device = PCI_DEVICE_ID_QLOGIC_ISP4010, 2491 .subvendor = PCI_ANY_ID, 2492 .subdevice = PCI_ANY_ID, 2493 }, 2494 { 2495 .vendor = PCI_VENDOR_ID_QLOGIC, 2496 .device = PCI_DEVICE_ID_QLOGIC_ISP4022, 2497 .subvendor = PCI_ANY_ID, 2498 .subdevice = PCI_ANY_ID, 2499 }, 2500 { 2501 .vendor = PCI_VENDOR_ID_QLOGIC, 2502 .device = PCI_DEVICE_ID_QLOGIC_ISP4032, 2503 .subvendor = PCI_ANY_ID, 2504 .subdevice = PCI_ANY_ID, 2505 }, 2506 { 2507 .vendor = PCI_VENDOR_ID_QLOGIC, 2508 .device = PCI_DEVICE_ID_QLOGIC_ISP8022, 2509 .subvendor = PCI_ANY_ID, 2510 .subdevice = PCI_ANY_ID, 2511 }, 2512 {0, 0}, 2513 }; 2514 MODULE_DEVICE_TABLE(pci, qla4xxx_pci_tbl); 2515 2516 static struct pci_driver qla4xxx_pci_driver = { 2517 .name = DRIVER_NAME, 2518 .id_table = qla4xxx_pci_tbl, 2519 .probe = qla4xxx_probe_adapter, 2520 .remove = qla4xxx_remove_adapter, 2521 .err_handler = &qla4xxx_err_handler, 2522 }; 2523 2524 static int __init qla4xxx_module_init(void) 2525 { 2526 int ret; 2527 2528 /* Allocate cache for SRBs. */ 2529 srb_cachep = kmem_cache_create("qla4xxx_srbs", sizeof(struct srb), 0, 2530 SLAB_HWCACHE_ALIGN, NULL); 2531 if (srb_cachep == NULL) { 2532 printk(KERN_ERR 2533 "%s: Unable to allocate SRB cache..." 2534 "Failing load!\n", DRIVER_NAME); 2535 ret = -ENOMEM; 2536 goto no_srp_cache; 2537 } 2538 2539 /* Derive version string. */ 2540 strcpy(qla4xxx_version_str, QLA4XXX_DRIVER_VERSION); 2541 if (ql4xextended_error_logging) 2542 strcat(qla4xxx_version_str, "-debug"); 2543 2544 qla4xxx_scsi_transport = 2545 iscsi_register_transport(&qla4xxx_iscsi_transport); 2546 if (!qla4xxx_scsi_transport){ 2547 ret = -ENODEV; 2548 goto release_srb_cache; 2549 } 2550 2551 ret = pci_register_driver(&qla4xxx_pci_driver); 2552 if (ret) 2553 goto unregister_transport; 2554 2555 printk(KERN_INFO "QLogic iSCSI HBA Driver\n"); 2556 return 0; 2557 2558 unregister_transport: 2559 iscsi_unregister_transport(&qla4xxx_iscsi_transport); 2560 release_srb_cache: 2561 kmem_cache_destroy(srb_cachep); 2562 no_srp_cache: 2563 return ret; 2564 } 2565 2566 static void __exit qla4xxx_module_exit(void) 2567 { 2568 pci_unregister_driver(&qla4xxx_pci_driver); 2569 iscsi_unregister_transport(&qla4xxx_iscsi_transport); 2570 kmem_cache_destroy(srb_cachep); 2571 } 2572 2573 module_init(qla4xxx_module_init); 2574 module_exit(qla4xxx_module_exit); 2575 2576 MODULE_AUTHOR("QLogic Corporation"); 2577 MODULE_DESCRIPTION("QLogic iSCSI HBA Driver"); 2578 MODULE_LICENSE("GPL"); 2579 MODULE_VERSION(QLA4XXX_DRIVER_VERSION); 2580