1 /* 2 * QLogic iSCSI HBA Driver 3 * Copyright (c) 2003-2010 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 test_bit(DPC_RESET_HA, &ha->dpc_flags) || 711 test_bit(DPC_RESET_ACTIVE, &ha->dpc_flags))) { 712 if (dev_state == QLA82XX_DEV_NEED_RESET && 713 !test_bit(DPC_RESET_HA, &ha->dpc_flags)) { 714 if (!ql4xdontresethba) { 715 ql4_printk(KERN_INFO, ha, "%s: HW State: " 716 "NEED RESET!\n", __func__); 717 set_bit(DPC_RESET_HA, &ha->dpc_flags); 718 qla4xxx_wake_dpc(ha); 719 qla4xxx_mailbox_premature_completion(ha); 720 } 721 } else if (dev_state == QLA82XX_DEV_NEED_QUIESCENT && 722 !test_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags)) { 723 ql4_printk(KERN_INFO, ha, "%s: HW State: NEED QUIES!\n", 724 __func__); 725 set_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags); 726 qla4xxx_wake_dpc(ha); 727 } else { 728 /* Check firmware health */ 729 qla4_8xxx_check_fw_alive(ha); 730 } 731 } 732 } 733 734 /** 735 * qla4xxx_timer - checks every second for work to do. 736 * @ha: Pointer to host adapter structure. 737 **/ 738 static void qla4xxx_timer(struct scsi_qla_host *ha) 739 { 740 struct ddb_entry *ddb_entry, *dtemp; 741 int start_dpc = 0; 742 uint16_t w; 743 744 /* If we are in the middle of AER/EEH processing 745 * skip any processing and reschedule the timer 746 */ 747 if (test_bit(AF_EEH_BUSY, &ha->flags)) { 748 mod_timer(&ha->timer, jiffies + HZ); 749 return; 750 } 751 752 /* Hardware read to trigger an EEH error during mailbox waits. */ 753 if (!pci_channel_offline(ha->pdev)) 754 pci_read_config_word(ha->pdev, PCI_VENDOR_ID, &w); 755 756 if (test_bit(AF_HBA_GOING_AWAY, &ha->flags)) { 757 DEBUG2(ql4_printk(KERN_INFO, ha, "%s exited. HBA GOING AWAY\n", 758 __func__)); 759 return; 760 } 761 762 if (is_qla8022(ha)) { 763 qla4_8xxx_watchdog(ha); 764 } 765 766 /* Search for relogin's to time-out and port down retry. */ 767 list_for_each_entry_safe(ddb_entry, dtemp, &ha->ddb_list, list) { 768 /* Count down time between sending relogins */ 769 if (adapter_up(ha) && 770 !test_bit(DF_RELOGIN, &ddb_entry->flags) && 771 atomic_read(&ddb_entry->state) != DDB_STATE_ONLINE) { 772 if (atomic_read(&ddb_entry->retry_relogin_timer) != 773 INVALID_ENTRY) { 774 if (atomic_read(&ddb_entry->retry_relogin_timer) 775 == 0) { 776 atomic_set(&ddb_entry-> 777 retry_relogin_timer, 778 INVALID_ENTRY); 779 set_bit(DPC_RELOGIN_DEVICE, 780 &ha->dpc_flags); 781 set_bit(DF_RELOGIN, &ddb_entry->flags); 782 DEBUG2(printk("scsi%ld: %s: ddb [%d]" 783 " login device\n", 784 ha->host_no, __func__, 785 ddb_entry->fw_ddb_index)); 786 } else 787 atomic_dec(&ddb_entry-> 788 retry_relogin_timer); 789 } 790 } 791 792 /* Wait for relogin to timeout */ 793 if (atomic_read(&ddb_entry->relogin_timer) && 794 (atomic_dec_and_test(&ddb_entry->relogin_timer) != 0)) { 795 /* 796 * If the relogin times out and the device is 797 * still NOT ONLINE then try and relogin again. 798 */ 799 if (atomic_read(&ddb_entry->state) != 800 DDB_STATE_ONLINE && 801 ddb_entry->fw_ddb_device_state == 802 DDB_DS_SESSION_FAILED) { 803 /* Reset retry relogin timer */ 804 atomic_inc(&ddb_entry->relogin_retry_count); 805 DEBUG2(printk("scsi%ld: ddb [%d] relogin" 806 " timed out-retrying" 807 " relogin (%d)\n", 808 ha->host_no, 809 ddb_entry->fw_ddb_index, 810 atomic_read(&ddb_entry-> 811 relogin_retry_count)) 812 ); 813 start_dpc++; 814 DEBUG(printk("scsi%ld:%d:%d: ddb [%d] " 815 "initiate relogin after" 816 " %d seconds\n", 817 ha->host_no, ddb_entry->bus, 818 ddb_entry->target, 819 ddb_entry->fw_ddb_index, 820 ddb_entry->default_time2wait + 4) 821 ); 822 823 atomic_set(&ddb_entry->retry_relogin_timer, 824 ddb_entry->default_time2wait + 4); 825 } 826 } 827 } 828 829 if (!is_qla8022(ha)) { 830 /* Check for heartbeat interval. */ 831 if (ha->firmware_options & FWOPT_HEARTBEAT_ENABLE && 832 ha->heartbeat_interval != 0) { 833 ha->seconds_since_last_heartbeat++; 834 if (ha->seconds_since_last_heartbeat > 835 ha->heartbeat_interval + 2) 836 set_bit(DPC_RESET_HA, &ha->dpc_flags); 837 } 838 } 839 840 /* Wakeup the dpc routine for this adapter, if needed. */ 841 if ((start_dpc || 842 test_bit(DPC_RESET_HA, &ha->dpc_flags) || 843 test_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags) || 844 test_bit(DPC_RELOGIN_DEVICE, &ha->dpc_flags) || 845 test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags) || 846 test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags) || 847 test_bit(DPC_GET_DHCP_IP_ADDR, &ha->dpc_flags) || 848 test_bit(DPC_LINK_CHANGED, &ha->dpc_flags) || 849 test_bit(DPC_HA_UNRECOVERABLE, &ha->dpc_flags) || 850 test_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags) || 851 test_bit(DPC_AEN, &ha->dpc_flags)) && 852 !test_bit(AF_DPC_SCHEDULED, &ha->flags) && 853 ha->dpc_thread) { 854 DEBUG2(printk("scsi%ld: %s: scheduling dpc routine" 855 " - dpc flags = 0x%lx\n", 856 ha->host_no, __func__, ha->dpc_flags)); 857 qla4xxx_wake_dpc(ha); 858 } 859 860 /* Reschedule timer thread to call us back in one second */ 861 mod_timer(&ha->timer, jiffies + HZ); 862 863 DEBUG2(ha->seconds_since_last_intr++); 864 } 865 866 /** 867 * qla4xxx_cmd_wait - waits for all outstanding commands to complete 868 * @ha: Pointer to host adapter structure. 869 * 870 * This routine stalls the driver until all outstanding commands are returned. 871 * Caller must release the Hardware Lock prior to calling this routine. 872 **/ 873 static int qla4xxx_cmd_wait(struct scsi_qla_host *ha) 874 { 875 uint32_t index = 0; 876 unsigned long flags; 877 struct scsi_cmnd *cmd; 878 879 unsigned long wtime = jiffies + (WAIT_CMD_TOV * HZ); 880 881 DEBUG2(ql4_printk(KERN_INFO, ha, "Wait up to %d seconds for cmds to " 882 "complete\n", WAIT_CMD_TOV)); 883 884 while (!time_after_eq(jiffies, wtime)) { 885 spin_lock_irqsave(&ha->hardware_lock, flags); 886 /* Find a command that hasn't completed. */ 887 for (index = 0; index < ha->host->can_queue; index++) { 888 cmd = scsi_host_find_tag(ha->host, index); 889 /* 890 * We cannot just check if the index is valid, 891 * becase if we are run from the scsi eh, then 892 * the scsi/block layer is going to prevent 893 * the tag from being released. 894 */ 895 if (cmd != NULL && CMD_SP(cmd)) 896 break; 897 } 898 spin_unlock_irqrestore(&ha->hardware_lock, flags); 899 900 /* If No Commands are pending, wait is complete */ 901 if (index == ha->host->can_queue) 902 return QLA_SUCCESS; 903 904 msleep(1000); 905 } 906 /* If we timed out on waiting for commands to come back 907 * return ERROR. */ 908 return QLA_ERROR; 909 } 910 911 int qla4xxx_hw_reset(struct scsi_qla_host *ha) 912 { 913 uint32_t ctrl_status; 914 unsigned long flags = 0; 915 916 DEBUG2(printk(KERN_ERR "scsi%ld: %s\n", ha->host_no, __func__)); 917 918 if (ql4xxx_lock_drvr_wait(ha) != QLA_SUCCESS) 919 return QLA_ERROR; 920 921 spin_lock_irqsave(&ha->hardware_lock, flags); 922 923 /* 924 * If the SCSI Reset Interrupt bit is set, clear it. 925 * Otherwise, the Soft Reset won't work. 926 */ 927 ctrl_status = readw(&ha->reg->ctrl_status); 928 if ((ctrl_status & CSR_SCSI_RESET_INTR) != 0) 929 writel(set_rmask(CSR_SCSI_RESET_INTR), &ha->reg->ctrl_status); 930 931 /* Issue Soft Reset */ 932 writel(set_rmask(CSR_SOFT_RESET), &ha->reg->ctrl_status); 933 readl(&ha->reg->ctrl_status); 934 935 spin_unlock_irqrestore(&ha->hardware_lock, flags); 936 return QLA_SUCCESS; 937 } 938 939 /** 940 * qla4xxx_soft_reset - performs soft reset. 941 * @ha: Pointer to host adapter structure. 942 **/ 943 int qla4xxx_soft_reset(struct scsi_qla_host *ha) 944 { 945 uint32_t max_wait_time; 946 unsigned long flags = 0; 947 int status; 948 uint32_t ctrl_status; 949 950 status = qla4xxx_hw_reset(ha); 951 if (status != QLA_SUCCESS) 952 return status; 953 954 status = QLA_ERROR; 955 /* Wait until the Network Reset Intr bit is cleared */ 956 max_wait_time = RESET_INTR_TOV; 957 do { 958 spin_lock_irqsave(&ha->hardware_lock, flags); 959 ctrl_status = readw(&ha->reg->ctrl_status); 960 spin_unlock_irqrestore(&ha->hardware_lock, flags); 961 962 if ((ctrl_status & CSR_NET_RESET_INTR) == 0) 963 break; 964 965 msleep(1000); 966 } while ((--max_wait_time)); 967 968 if ((ctrl_status & CSR_NET_RESET_INTR) != 0) { 969 DEBUG2(printk(KERN_WARNING 970 "scsi%ld: Network Reset Intr not cleared by " 971 "Network function, clearing it now!\n", 972 ha->host_no)); 973 spin_lock_irqsave(&ha->hardware_lock, flags); 974 writel(set_rmask(CSR_NET_RESET_INTR), &ha->reg->ctrl_status); 975 readl(&ha->reg->ctrl_status); 976 spin_unlock_irqrestore(&ha->hardware_lock, flags); 977 } 978 979 /* Wait until the firmware tells us the Soft Reset is done */ 980 max_wait_time = SOFT_RESET_TOV; 981 do { 982 spin_lock_irqsave(&ha->hardware_lock, flags); 983 ctrl_status = readw(&ha->reg->ctrl_status); 984 spin_unlock_irqrestore(&ha->hardware_lock, flags); 985 986 if ((ctrl_status & CSR_SOFT_RESET) == 0) { 987 status = QLA_SUCCESS; 988 break; 989 } 990 991 msleep(1000); 992 } while ((--max_wait_time)); 993 994 /* 995 * Also, make sure that the SCSI Reset Interrupt bit has been cleared 996 * after the soft reset has taken place. 997 */ 998 spin_lock_irqsave(&ha->hardware_lock, flags); 999 ctrl_status = readw(&ha->reg->ctrl_status); 1000 if ((ctrl_status & CSR_SCSI_RESET_INTR) != 0) { 1001 writel(set_rmask(CSR_SCSI_RESET_INTR), &ha->reg->ctrl_status); 1002 readl(&ha->reg->ctrl_status); 1003 } 1004 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1005 1006 /* If soft reset fails then most probably the bios on other 1007 * function is also enabled. 1008 * Since the initialization is sequential the other fn 1009 * wont be able to acknowledge the soft reset. 1010 * Issue a force soft reset to workaround this scenario. 1011 */ 1012 if (max_wait_time == 0) { 1013 /* Issue Force Soft Reset */ 1014 spin_lock_irqsave(&ha->hardware_lock, flags); 1015 writel(set_rmask(CSR_FORCE_SOFT_RESET), &ha->reg->ctrl_status); 1016 readl(&ha->reg->ctrl_status); 1017 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1018 /* Wait until the firmware tells us the Soft Reset is done */ 1019 max_wait_time = SOFT_RESET_TOV; 1020 do { 1021 spin_lock_irqsave(&ha->hardware_lock, flags); 1022 ctrl_status = readw(&ha->reg->ctrl_status); 1023 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1024 1025 if ((ctrl_status & CSR_FORCE_SOFT_RESET) == 0) { 1026 status = QLA_SUCCESS; 1027 break; 1028 } 1029 1030 msleep(1000); 1031 } while ((--max_wait_time)); 1032 } 1033 1034 return status; 1035 } 1036 1037 /** 1038 * qla4xxx_abort_active_cmds - returns all outstanding i/o requests to O.S. 1039 * @ha: Pointer to host adapter structure. 1040 * @res: returned scsi status 1041 * 1042 * This routine is called just prior to a HARD RESET to return all 1043 * outstanding commands back to the Operating System. 1044 * Caller should make sure that the following locks are released 1045 * before this calling routine: Hardware lock, and io_request_lock. 1046 **/ 1047 static void qla4xxx_abort_active_cmds(struct scsi_qla_host *ha, int res) 1048 { 1049 struct srb *srb; 1050 int i; 1051 unsigned long flags; 1052 1053 spin_lock_irqsave(&ha->hardware_lock, flags); 1054 for (i = 0; i < ha->host->can_queue; i++) { 1055 srb = qla4xxx_del_from_active_array(ha, i); 1056 if (srb != NULL) { 1057 srb->cmd->result = res; 1058 kref_put(&srb->srb_ref, qla4xxx_srb_compl); 1059 } 1060 } 1061 spin_unlock_irqrestore(&ha->hardware_lock, flags); 1062 } 1063 1064 void qla4xxx_dead_adapter_cleanup(struct scsi_qla_host *ha) 1065 { 1066 clear_bit(AF_ONLINE, &ha->flags); 1067 1068 /* Disable the board */ 1069 ql4_printk(KERN_INFO, ha, "Disabling the board\n"); 1070 set_bit(AF_HBA_GOING_AWAY, &ha->flags); 1071 1072 qla4xxx_abort_active_cmds(ha, DID_NO_CONNECT << 16); 1073 qla4xxx_mark_all_devices_missing(ha); 1074 clear_bit(AF_INIT_DONE, &ha->flags); 1075 } 1076 1077 /** 1078 * qla4xxx_recover_adapter - recovers adapter after a fatal error 1079 * @ha: Pointer to host adapter structure. 1080 **/ 1081 static int qla4xxx_recover_adapter(struct scsi_qla_host *ha) 1082 { 1083 int status = QLA_ERROR; 1084 uint8_t reset_chip = 0; 1085 1086 /* Stall incoming I/O until we are done */ 1087 scsi_block_requests(ha->host); 1088 clear_bit(AF_ONLINE, &ha->flags); 1089 1090 DEBUG2(ql4_printk(KERN_INFO, ha, "%s: adapter OFFLINE\n", __func__)); 1091 1092 set_bit(DPC_RESET_ACTIVE, &ha->dpc_flags); 1093 1094 if (test_bit(DPC_RESET_HA, &ha->dpc_flags)) 1095 reset_chip = 1; 1096 1097 /* For the DPC_RESET_HA_INTR case (ISP-4xxx specific) 1098 * do not reset adapter, jump to initialize_adapter */ 1099 if (test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags)) { 1100 status = QLA_SUCCESS; 1101 goto recover_ha_init_adapter; 1102 } 1103 1104 /* For the ISP-82xx adapter, issue a stop_firmware if invoked 1105 * from eh_host_reset or ioctl module */ 1106 if (is_qla8022(ha) && !reset_chip && 1107 test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags)) { 1108 1109 DEBUG2(ql4_printk(KERN_INFO, ha, 1110 "scsi%ld: %s - Performing stop_firmware...\n", 1111 ha->host_no, __func__)); 1112 status = ha->isp_ops->reset_firmware(ha); 1113 if (status == QLA_SUCCESS) { 1114 if (!test_bit(AF_FW_RECOVERY, &ha->flags)) 1115 qla4xxx_cmd_wait(ha); 1116 ha->isp_ops->disable_intrs(ha); 1117 qla4xxx_process_aen(ha, FLUSH_DDB_CHANGED_AENS); 1118 qla4xxx_abort_active_cmds(ha, DID_RESET << 16); 1119 } else { 1120 /* If the stop_firmware fails then 1121 * reset the entire chip */ 1122 reset_chip = 1; 1123 clear_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags); 1124 set_bit(DPC_RESET_HA, &ha->dpc_flags); 1125 } 1126 } 1127 1128 /* Issue full chip reset if recovering from a catastrophic error, 1129 * or if stop_firmware fails for ISP-82xx. 1130 * This is the default case for ISP-4xxx */ 1131 if (!is_qla8022(ha) || reset_chip) { 1132 if (!test_bit(AF_FW_RECOVERY, &ha->flags)) 1133 qla4xxx_cmd_wait(ha); 1134 qla4xxx_process_aen(ha, FLUSH_DDB_CHANGED_AENS); 1135 qla4xxx_abort_active_cmds(ha, DID_RESET << 16); 1136 DEBUG2(ql4_printk(KERN_INFO, ha, 1137 "scsi%ld: %s - Performing chip reset..\n", 1138 ha->host_no, __func__)); 1139 status = ha->isp_ops->reset_chip(ha); 1140 } 1141 1142 /* Flush any pending ddb changed AENs */ 1143 qla4xxx_process_aen(ha, FLUSH_DDB_CHANGED_AENS); 1144 1145 recover_ha_init_adapter: 1146 /* Upon successful firmware/chip reset, re-initialize the adapter */ 1147 if (status == QLA_SUCCESS) { 1148 /* For ISP-4xxx, force function 1 to always initialize 1149 * before function 3 to prevent both funcions from 1150 * stepping on top of the other */ 1151 if (!is_qla8022(ha) && (ha->mac_index == 3)) 1152 ssleep(6); 1153 1154 /* NOTE: AF_ONLINE flag set upon successful completion of 1155 * qla4xxx_initialize_adapter */ 1156 status = qla4xxx_initialize_adapter(ha, PRESERVE_DDB_LIST); 1157 } 1158 1159 /* Retry failed adapter initialization, if necessary 1160 * Do not retry initialize_adapter for RESET_HA_INTR (ISP-4xxx specific) 1161 * case to prevent ping-pong resets between functions */ 1162 if (!test_bit(AF_ONLINE, &ha->flags) && 1163 !test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags)) { 1164 /* Adapter initialization failed, see if we can retry 1165 * resetting the ha. 1166 * Since we don't want to block the DPC for too long 1167 * with multiple resets in the same thread, 1168 * utilize DPC to retry */ 1169 if (!test_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags)) { 1170 ha->retry_reset_ha_cnt = MAX_RESET_HA_RETRIES; 1171 DEBUG2(printk("scsi%ld: recover adapter - retrying " 1172 "(%d) more times\n", ha->host_no, 1173 ha->retry_reset_ha_cnt)); 1174 set_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags); 1175 status = QLA_ERROR; 1176 } else { 1177 if (ha->retry_reset_ha_cnt > 0) { 1178 /* Schedule another Reset HA--DPC will retry */ 1179 ha->retry_reset_ha_cnt--; 1180 DEBUG2(printk("scsi%ld: recover adapter - " 1181 "retry remaining %d\n", 1182 ha->host_no, 1183 ha->retry_reset_ha_cnt)); 1184 status = QLA_ERROR; 1185 } 1186 1187 if (ha->retry_reset_ha_cnt == 0) { 1188 /* Recover adapter retries have been exhausted. 1189 * Adapter DEAD */ 1190 DEBUG2(printk("scsi%ld: recover adapter " 1191 "failed - board disabled\n", 1192 ha->host_no)); 1193 qla4xxx_dead_adapter_cleanup(ha); 1194 clear_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags); 1195 clear_bit(DPC_RESET_HA, &ha->dpc_flags); 1196 clear_bit(DPC_RESET_HA_FW_CONTEXT, 1197 &ha->dpc_flags); 1198 status = QLA_ERROR; 1199 } 1200 } 1201 } else { 1202 clear_bit(DPC_RESET_HA, &ha->dpc_flags); 1203 clear_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags); 1204 clear_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags); 1205 } 1206 1207 ha->adapter_error_count++; 1208 1209 if (test_bit(AF_ONLINE, &ha->flags)) 1210 ha->isp_ops->enable_intrs(ha); 1211 1212 scsi_unblock_requests(ha->host); 1213 1214 clear_bit(DPC_RESET_ACTIVE, &ha->dpc_flags); 1215 DEBUG2(printk("scsi%ld: recover adapter: %s\n", ha->host_no, 1216 status == QLA_ERROR ? "FAILED" : "SUCCEDED")); 1217 1218 return status; 1219 } 1220 1221 void qla4xxx_wake_dpc(struct scsi_qla_host *ha) 1222 { 1223 if (ha->dpc_thread && 1224 !test_bit(AF_DPC_SCHEDULED, &ha->flags)) { 1225 set_bit(AF_DPC_SCHEDULED, &ha->flags); 1226 queue_work(ha->dpc_thread, &ha->dpc_work); 1227 } 1228 } 1229 1230 /** 1231 * qla4xxx_do_dpc - dpc routine 1232 * @data: in our case pointer to adapter structure 1233 * 1234 * This routine is a task that is schedule by the interrupt handler 1235 * to perform the background processing for interrupts. We put it 1236 * on a task queue that is consumed whenever the scheduler runs; that's 1237 * so you can do anything (i.e. put the process to sleep etc). In fact, 1238 * the mid-level tries to sleep when it reaches the driver threshold 1239 * "host->can_queue". This can cause a panic if we were in our interrupt code. 1240 **/ 1241 static void qla4xxx_do_dpc(struct work_struct *work) 1242 { 1243 struct scsi_qla_host *ha = 1244 container_of(work, struct scsi_qla_host, dpc_work); 1245 struct ddb_entry *ddb_entry, *dtemp; 1246 int status = QLA_ERROR; 1247 1248 DEBUG2(printk("scsi%ld: %s: DPC handler waking up." 1249 "flags = 0x%08lx, dpc_flags = 0x%08lx\n", 1250 ha->host_no, __func__, ha->flags, ha->dpc_flags)) 1251 1252 /* Initialization not yet finished. Don't do anything yet. */ 1253 if (!test_bit(AF_INIT_DONE, &ha->flags)) 1254 goto do_dpc_exit; 1255 1256 if (test_bit(AF_EEH_BUSY, &ha->flags)) { 1257 DEBUG2(printk(KERN_INFO "scsi%ld: %s: flags = %lx\n", 1258 ha->host_no, __func__, ha->flags)); 1259 goto do_dpc_exit; 1260 } 1261 1262 /* HBA is in the process of being permanently disabled. 1263 * Don't process anything */ 1264 if (test_bit(AF_HBA_GOING_AWAY, &ha->flags)) 1265 return; 1266 1267 if (is_qla8022(ha)) { 1268 if (test_bit(DPC_HA_UNRECOVERABLE, &ha->dpc_flags)) { 1269 qla4_8xxx_idc_lock(ha); 1270 qla4_8xxx_wr_32(ha, QLA82XX_CRB_DEV_STATE, 1271 QLA82XX_DEV_FAILED); 1272 qla4_8xxx_idc_unlock(ha); 1273 ql4_printk(KERN_INFO, ha, "HW State: FAILED\n"); 1274 qla4_8xxx_device_state_handler(ha); 1275 } 1276 if (test_and_clear_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags)) { 1277 qla4_8xxx_need_qsnt_handler(ha); 1278 } 1279 } 1280 1281 if (!test_bit(DPC_RESET_ACTIVE, &ha->dpc_flags) && 1282 (test_bit(DPC_RESET_HA, &ha->dpc_flags) || 1283 test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags) || 1284 test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags))) { 1285 if (ql4xdontresethba) { 1286 DEBUG2(printk("scsi%ld: %s: Don't Reset HBA\n", 1287 ha->host_no, __func__)); 1288 clear_bit(DPC_RESET_HA, &ha->dpc_flags); 1289 clear_bit(DPC_RESET_HA_INTR, &ha->dpc_flags); 1290 clear_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags); 1291 goto dpc_post_reset_ha; 1292 } 1293 if (test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags) || 1294 test_bit(DPC_RESET_HA, &ha->dpc_flags)) 1295 qla4xxx_recover_adapter(ha); 1296 1297 if (test_bit(DPC_RESET_HA_INTR, &ha->dpc_flags)) { 1298 uint8_t wait_time = RESET_INTR_TOV; 1299 1300 while ((readw(&ha->reg->ctrl_status) & 1301 (CSR_SOFT_RESET | CSR_FORCE_SOFT_RESET)) != 0) { 1302 if (--wait_time == 0) 1303 break; 1304 msleep(1000); 1305 } 1306 if (wait_time == 0) 1307 DEBUG2(printk("scsi%ld: %s: SR|FSR " 1308 "bit not cleared-- resetting\n", 1309 ha->host_no, __func__)); 1310 qla4xxx_abort_active_cmds(ha, DID_RESET << 16); 1311 if (ql4xxx_lock_drvr_wait(ha) == QLA_SUCCESS) { 1312 qla4xxx_process_aen(ha, FLUSH_DDB_CHANGED_AENS); 1313 status = qla4xxx_recover_adapter(ha); 1314 } 1315 clear_bit(DPC_RESET_HA_INTR, &ha->dpc_flags); 1316 if (status == QLA_SUCCESS) 1317 ha->isp_ops->enable_intrs(ha); 1318 } 1319 } 1320 1321 dpc_post_reset_ha: 1322 /* ---- process AEN? --- */ 1323 if (test_and_clear_bit(DPC_AEN, &ha->dpc_flags)) 1324 qla4xxx_process_aen(ha, PROCESS_ALL_AENS); 1325 1326 /* ---- Get DHCP IP Address? --- */ 1327 if (test_and_clear_bit(DPC_GET_DHCP_IP_ADDR, &ha->dpc_flags)) 1328 qla4xxx_get_dhcp_ip_address(ha); 1329 1330 /* ---- link change? --- */ 1331 if (test_and_clear_bit(DPC_LINK_CHANGED, &ha->dpc_flags)) { 1332 if (!test_bit(AF_LINK_UP, &ha->flags)) { 1333 /* ---- link down? --- */ 1334 list_for_each_entry_safe(ddb_entry, dtemp, 1335 &ha->ddb_list, list) { 1336 if (atomic_read(&ddb_entry->state) == 1337 DDB_STATE_ONLINE) 1338 qla4xxx_mark_device_missing(ha, 1339 ddb_entry); 1340 } 1341 } else { 1342 /* ---- link up? --- * 1343 * F/W will auto login to all devices ONLY ONCE after 1344 * link up during driver initialization and runtime 1345 * fatal error recovery. Therefore, the driver must 1346 * manually relogin to devices when recovering from 1347 * connection failures, logouts, expired KATO, etc. */ 1348 1349 list_for_each_entry_safe(ddb_entry, dtemp, 1350 &ha->ddb_list, list) { 1351 if ((atomic_read(&ddb_entry->state) == 1352 DDB_STATE_MISSING) || 1353 (atomic_read(&ddb_entry->state) == 1354 DDB_STATE_DEAD)) { 1355 if (ddb_entry->fw_ddb_device_state == 1356 DDB_DS_SESSION_ACTIVE) { 1357 atomic_set(&ddb_entry->state, 1358 DDB_STATE_ONLINE); 1359 ql4_printk(KERN_INFO, ha, 1360 "scsi%ld: %s: ddb[%d]" 1361 " marked ONLINE\n", 1362 ha->host_no, __func__, 1363 ddb_entry->fw_ddb_index); 1364 1365 iscsi_unblock_session( 1366 ddb_entry->sess); 1367 } else 1368 qla4xxx_relogin_device( 1369 ha, ddb_entry); 1370 } 1371 1372 } 1373 } 1374 } 1375 1376 /* ---- relogin device? --- */ 1377 if (adapter_up(ha) && 1378 test_and_clear_bit(DPC_RELOGIN_DEVICE, &ha->dpc_flags)) { 1379 list_for_each_entry_safe(ddb_entry, dtemp, 1380 &ha->ddb_list, list) { 1381 if (test_and_clear_bit(DF_RELOGIN, &ddb_entry->flags) && 1382 atomic_read(&ddb_entry->state) != DDB_STATE_ONLINE) 1383 qla4xxx_relogin_device(ha, ddb_entry); 1384 1385 /* 1386 * If mbx cmd times out there is no point 1387 * in continuing further. 1388 * With large no of targets this can hang 1389 * the system. 1390 */ 1391 if (test_bit(DPC_RESET_HA, &ha->dpc_flags)) { 1392 printk(KERN_WARNING "scsi%ld: %s: " 1393 "need to reset hba\n", 1394 ha->host_no, __func__); 1395 break; 1396 } 1397 } 1398 } 1399 1400 do_dpc_exit: 1401 clear_bit(AF_DPC_SCHEDULED, &ha->flags); 1402 } 1403 1404 /** 1405 * qla4xxx_free_adapter - release the adapter 1406 * @ha: pointer to adapter structure 1407 **/ 1408 static void qla4xxx_free_adapter(struct scsi_qla_host *ha) 1409 { 1410 1411 if (test_bit(AF_INTERRUPTS_ON, &ha->flags)) { 1412 /* Turn-off interrupts on the card. */ 1413 ha->isp_ops->disable_intrs(ha); 1414 } 1415 1416 /* Remove timer thread, if present */ 1417 if (ha->timer_active) 1418 qla4xxx_stop_timer(ha); 1419 1420 /* Kill the kernel thread for this host */ 1421 if (ha->dpc_thread) 1422 destroy_workqueue(ha->dpc_thread); 1423 1424 /* Put firmware in known state */ 1425 ha->isp_ops->reset_firmware(ha); 1426 1427 if (is_qla8022(ha)) { 1428 qla4_8xxx_idc_lock(ha); 1429 qla4_8xxx_clear_drv_active(ha); 1430 qla4_8xxx_idc_unlock(ha); 1431 } 1432 1433 /* Detach interrupts */ 1434 if (test_and_clear_bit(AF_IRQ_ATTACHED, &ha->flags)) 1435 qla4xxx_free_irqs(ha); 1436 1437 /* free extra memory */ 1438 qla4xxx_mem_free(ha); 1439 } 1440 1441 int qla4_8xxx_iospace_config(struct scsi_qla_host *ha) 1442 { 1443 int status = 0; 1444 uint8_t revision_id; 1445 unsigned long mem_base, mem_len, db_base, db_len; 1446 struct pci_dev *pdev = ha->pdev; 1447 1448 status = pci_request_regions(pdev, DRIVER_NAME); 1449 if (status) { 1450 printk(KERN_WARNING 1451 "scsi(%ld) Failed to reserve PIO regions (%s) " 1452 "status=%d\n", ha->host_no, pci_name(pdev), status); 1453 goto iospace_error_exit; 1454 } 1455 1456 pci_read_config_byte(pdev, PCI_REVISION_ID, &revision_id); 1457 DEBUG2(printk(KERN_INFO "%s: revision-id=%d\n", 1458 __func__, revision_id)); 1459 ha->revision_id = revision_id; 1460 1461 /* remap phys address */ 1462 mem_base = pci_resource_start(pdev, 0); /* 0 is for BAR 0 */ 1463 mem_len = pci_resource_len(pdev, 0); 1464 DEBUG2(printk(KERN_INFO "%s: ioremap from %lx a size of %lx\n", 1465 __func__, mem_base, mem_len)); 1466 1467 /* mapping of pcibase pointer */ 1468 ha->nx_pcibase = (unsigned long)ioremap(mem_base, mem_len); 1469 if (!ha->nx_pcibase) { 1470 printk(KERN_ERR 1471 "cannot remap MMIO (%s), aborting\n", pci_name(pdev)); 1472 pci_release_regions(ha->pdev); 1473 goto iospace_error_exit; 1474 } 1475 1476 /* Mapping of IO base pointer, door bell read and write pointer */ 1477 1478 /* mapping of IO base pointer */ 1479 ha->qla4_8xxx_reg = 1480 (struct device_reg_82xx __iomem *)((uint8_t *)ha->nx_pcibase + 1481 0xbc000 + (ha->pdev->devfn << 11)); 1482 1483 db_base = pci_resource_start(pdev, 4); /* doorbell is on bar 4 */ 1484 db_len = pci_resource_len(pdev, 4); 1485 1486 ha->nx_db_wr_ptr = (ha->pdev->devfn == 4 ? QLA82XX_CAM_RAM_DB1 : 1487 QLA82XX_CAM_RAM_DB2); 1488 1489 return 0; 1490 iospace_error_exit: 1491 return -ENOMEM; 1492 } 1493 1494 /*** 1495 * qla4xxx_iospace_config - maps registers 1496 * @ha: pointer to adapter structure 1497 * 1498 * This routines maps HBA's registers from the pci address space 1499 * into the kernel virtual address space for memory mapped i/o. 1500 **/ 1501 int qla4xxx_iospace_config(struct scsi_qla_host *ha) 1502 { 1503 unsigned long pio, pio_len, pio_flags; 1504 unsigned long mmio, mmio_len, mmio_flags; 1505 1506 pio = pci_resource_start(ha->pdev, 0); 1507 pio_len = pci_resource_len(ha->pdev, 0); 1508 pio_flags = pci_resource_flags(ha->pdev, 0); 1509 if (pio_flags & IORESOURCE_IO) { 1510 if (pio_len < MIN_IOBASE_LEN) { 1511 ql4_printk(KERN_WARNING, ha, 1512 "Invalid PCI I/O region size\n"); 1513 pio = 0; 1514 } 1515 } else { 1516 ql4_printk(KERN_WARNING, ha, "region #0 not a PIO resource\n"); 1517 pio = 0; 1518 } 1519 1520 /* Use MMIO operations for all accesses. */ 1521 mmio = pci_resource_start(ha->pdev, 1); 1522 mmio_len = pci_resource_len(ha->pdev, 1); 1523 mmio_flags = pci_resource_flags(ha->pdev, 1); 1524 1525 if (!(mmio_flags & IORESOURCE_MEM)) { 1526 ql4_printk(KERN_ERR, ha, 1527 "region #0 not an MMIO resource, aborting\n"); 1528 1529 goto iospace_error_exit; 1530 } 1531 1532 if (mmio_len < MIN_IOBASE_LEN) { 1533 ql4_printk(KERN_ERR, ha, 1534 "Invalid PCI mem region size, aborting\n"); 1535 goto iospace_error_exit; 1536 } 1537 1538 if (pci_request_regions(ha->pdev, DRIVER_NAME)) { 1539 ql4_printk(KERN_WARNING, ha, 1540 "Failed to reserve PIO/MMIO regions\n"); 1541 1542 goto iospace_error_exit; 1543 } 1544 1545 ha->pio_address = pio; 1546 ha->pio_length = pio_len; 1547 ha->reg = ioremap(mmio, MIN_IOBASE_LEN); 1548 if (!ha->reg) { 1549 ql4_printk(KERN_ERR, ha, 1550 "cannot remap MMIO, aborting\n"); 1551 1552 goto iospace_error_exit; 1553 } 1554 1555 return 0; 1556 1557 iospace_error_exit: 1558 return -ENOMEM; 1559 } 1560 1561 static struct isp_operations qla4xxx_isp_ops = { 1562 .iospace_config = qla4xxx_iospace_config, 1563 .pci_config = qla4xxx_pci_config, 1564 .disable_intrs = qla4xxx_disable_intrs, 1565 .enable_intrs = qla4xxx_enable_intrs, 1566 .start_firmware = qla4xxx_start_firmware, 1567 .intr_handler = qla4xxx_intr_handler, 1568 .interrupt_service_routine = qla4xxx_interrupt_service_routine, 1569 .reset_chip = qla4xxx_soft_reset, 1570 .reset_firmware = qla4xxx_hw_reset, 1571 .queue_iocb = qla4xxx_queue_iocb, 1572 .complete_iocb = qla4xxx_complete_iocb, 1573 .rd_shdw_req_q_out = qla4xxx_rd_shdw_req_q_out, 1574 .rd_shdw_rsp_q_in = qla4xxx_rd_shdw_rsp_q_in, 1575 .get_sys_info = qla4xxx_get_sys_info, 1576 }; 1577 1578 static struct isp_operations qla4_8xxx_isp_ops = { 1579 .iospace_config = qla4_8xxx_iospace_config, 1580 .pci_config = qla4_8xxx_pci_config, 1581 .disable_intrs = qla4_8xxx_disable_intrs, 1582 .enable_intrs = qla4_8xxx_enable_intrs, 1583 .start_firmware = qla4_8xxx_load_risc, 1584 .intr_handler = qla4_8xxx_intr_handler, 1585 .interrupt_service_routine = qla4_8xxx_interrupt_service_routine, 1586 .reset_chip = qla4_8xxx_isp_reset, 1587 .reset_firmware = qla4_8xxx_stop_firmware, 1588 .queue_iocb = qla4_8xxx_queue_iocb, 1589 .complete_iocb = qla4_8xxx_complete_iocb, 1590 .rd_shdw_req_q_out = qla4_8xxx_rd_shdw_req_q_out, 1591 .rd_shdw_rsp_q_in = qla4_8xxx_rd_shdw_rsp_q_in, 1592 .get_sys_info = qla4_8xxx_get_sys_info, 1593 }; 1594 1595 uint16_t qla4xxx_rd_shdw_req_q_out(struct scsi_qla_host *ha) 1596 { 1597 return (uint16_t)le32_to_cpu(ha->shadow_regs->req_q_out); 1598 } 1599 1600 uint16_t qla4_8xxx_rd_shdw_req_q_out(struct scsi_qla_host *ha) 1601 { 1602 return (uint16_t)le32_to_cpu(readl(&ha->qla4_8xxx_reg->req_q_out)); 1603 } 1604 1605 uint16_t qla4xxx_rd_shdw_rsp_q_in(struct scsi_qla_host *ha) 1606 { 1607 return (uint16_t)le32_to_cpu(ha->shadow_regs->rsp_q_in); 1608 } 1609 1610 uint16_t qla4_8xxx_rd_shdw_rsp_q_in(struct scsi_qla_host *ha) 1611 { 1612 return (uint16_t)le32_to_cpu(readl(&ha->qla4_8xxx_reg->rsp_q_in)); 1613 } 1614 1615 /** 1616 * qla4xxx_probe_adapter - callback function to probe HBA 1617 * @pdev: pointer to pci_dev structure 1618 * @pci_device_id: pointer to pci_device entry 1619 * 1620 * This routine will probe for Qlogic 4xxx iSCSI host adapters. 1621 * It returns zero if successful. It also initializes all data necessary for 1622 * the driver. 1623 **/ 1624 static int __devinit qla4xxx_probe_adapter(struct pci_dev *pdev, 1625 const struct pci_device_id *ent) 1626 { 1627 int ret = -ENODEV, status; 1628 struct Scsi_Host *host; 1629 struct scsi_qla_host *ha; 1630 uint8_t init_retry_count = 0; 1631 char buf[34]; 1632 struct qla4_8xxx_legacy_intr_set *nx_legacy_intr; 1633 1634 if (pci_enable_device(pdev)) 1635 return -1; 1636 1637 host = scsi_host_alloc(&qla4xxx_driver_template, sizeof(*ha)); 1638 if (host == NULL) { 1639 printk(KERN_WARNING 1640 "qla4xxx: Couldn't allocate host from scsi layer!\n"); 1641 goto probe_disable_device; 1642 } 1643 1644 /* Clear our data area */ 1645 ha = (struct scsi_qla_host *) host->hostdata; 1646 memset(ha, 0, sizeof(*ha)); 1647 1648 /* Save the information from PCI BIOS. */ 1649 ha->pdev = pdev; 1650 ha->host = host; 1651 ha->host_no = host->host_no; 1652 1653 pci_enable_pcie_error_reporting(pdev); 1654 1655 /* Setup Runtime configurable options */ 1656 if (is_qla8022(ha)) { 1657 ha->isp_ops = &qla4_8xxx_isp_ops; 1658 rwlock_init(&ha->hw_lock); 1659 ha->qdr_sn_window = -1; 1660 ha->ddr_mn_window = -1; 1661 ha->curr_window = 255; 1662 ha->func_num = PCI_FUNC(ha->pdev->devfn); 1663 nx_legacy_intr = &legacy_intr[ha->func_num]; 1664 ha->nx_legacy_intr.int_vec_bit = nx_legacy_intr->int_vec_bit; 1665 ha->nx_legacy_intr.tgt_status_reg = 1666 nx_legacy_intr->tgt_status_reg; 1667 ha->nx_legacy_intr.tgt_mask_reg = nx_legacy_intr->tgt_mask_reg; 1668 ha->nx_legacy_intr.pci_int_reg = nx_legacy_intr->pci_int_reg; 1669 } else { 1670 ha->isp_ops = &qla4xxx_isp_ops; 1671 } 1672 1673 /* Set EEH reset type to fundamental if required by hba */ 1674 if (is_qla8022(ha)) 1675 pdev->needs_freset = 1; 1676 1677 /* Configure PCI I/O space. */ 1678 ret = ha->isp_ops->iospace_config(ha); 1679 if (ret) 1680 goto probe_failed_ioconfig; 1681 1682 ql4_printk(KERN_INFO, ha, "Found an ISP%04x, irq %d, iobase 0x%p\n", 1683 pdev->device, pdev->irq, ha->reg); 1684 1685 qla4xxx_config_dma_addressing(ha); 1686 1687 /* Initialize lists and spinlocks. */ 1688 INIT_LIST_HEAD(&ha->ddb_list); 1689 INIT_LIST_HEAD(&ha->free_srb_q); 1690 1691 mutex_init(&ha->mbox_sem); 1692 init_completion(&ha->mbx_intr_comp); 1693 1694 spin_lock_init(&ha->hardware_lock); 1695 1696 /* Allocate dma buffers */ 1697 if (qla4xxx_mem_alloc(ha)) { 1698 ql4_printk(KERN_WARNING, ha, 1699 "[ERROR] Failed to allocate memory for adapter\n"); 1700 1701 ret = -ENOMEM; 1702 goto probe_failed; 1703 } 1704 1705 if (is_qla8022(ha)) 1706 (void) qla4_8xxx_get_flash_info(ha); 1707 1708 /* 1709 * Initialize the Host adapter request/response queues and 1710 * firmware 1711 * NOTE: interrupts enabled upon successful completion 1712 */ 1713 status = qla4xxx_initialize_adapter(ha, REBUILD_DDB_LIST); 1714 while ((!test_bit(AF_ONLINE, &ha->flags)) && 1715 init_retry_count++ < MAX_INIT_RETRIES) { 1716 DEBUG2(printk("scsi: %s: retrying adapter initialization " 1717 "(%d)\n", __func__, init_retry_count)); 1718 1719 if (ha->isp_ops->reset_chip(ha) == QLA_ERROR) 1720 continue; 1721 1722 status = qla4xxx_initialize_adapter(ha, REBUILD_DDB_LIST); 1723 } 1724 1725 if (!test_bit(AF_ONLINE, &ha->flags)) { 1726 ql4_printk(KERN_WARNING, ha, "Failed to initialize adapter\n"); 1727 1728 if (is_qla8022(ha) && ql4xdontresethba) { 1729 /* Put the device in failed state. */ 1730 DEBUG2(printk(KERN_ERR "HW STATE: FAILED\n")); 1731 qla4_8xxx_idc_lock(ha); 1732 qla4_8xxx_wr_32(ha, QLA82XX_CRB_DEV_STATE, 1733 QLA82XX_DEV_FAILED); 1734 qla4_8xxx_idc_unlock(ha); 1735 } 1736 ret = -ENODEV; 1737 goto probe_failed; 1738 } 1739 1740 host->cmd_per_lun = 3; 1741 host->max_channel = 0; 1742 host->max_lun = MAX_LUNS - 1; 1743 host->max_id = MAX_TARGETS; 1744 host->max_cmd_len = IOCB_MAX_CDB_LEN; 1745 host->can_queue = MAX_SRBS ; 1746 host->transportt = qla4xxx_scsi_transport; 1747 1748 ret = scsi_init_shared_tag_map(host, MAX_SRBS); 1749 if (ret) { 1750 ql4_printk(KERN_WARNING, ha, 1751 "scsi_init_shared_tag_map failed\n"); 1752 goto probe_failed; 1753 } 1754 1755 /* Startup the kernel thread for this host adapter. */ 1756 DEBUG2(printk("scsi: %s: Starting kernel thread for " 1757 "qla4xxx_dpc\n", __func__)); 1758 sprintf(buf, "qla4xxx_%lu_dpc", ha->host_no); 1759 ha->dpc_thread = create_singlethread_workqueue(buf); 1760 if (!ha->dpc_thread) { 1761 ql4_printk(KERN_WARNING, ha, "Unable to start DPC thread!\n"); 1762 ret = -ENODEV; 1763 goto probe_failed; 1764 } 1765 INIT_WORK(&ha->dpc_work, qla4xxx_do_dpc); 1766 1767 /* For ISP-82XX, request_irqs is called in qla4_8xxx_load_risc 1768 * (which is called indirectly by qla4xxx_initialize_adapter), 1769 * so that irqs will be registered after crbinit but before 1770 * mbx_intr_enable. 1771 */ 1772 if (!is_qla8022(ha)) { 1773 ret = qla4xxx_request_irqs(ha); 1774 if (ret) { 1775 ql4_printk(KERN_WARNING, ha, "Failed to reserve " 1776 "interrupt %d already in use.\n", pdev->irq); 1777 goto probe_failed; 1778 } 1779 } 1780 1781 pci_save_state(ha->pdev); 1782 ha->isp_ops->enable_intrs(ha); 1783 1784 /* Start timer thread. */ 1785 qla4xxx_start_timer(ha, qla4xxx_timer, 1); 1786 1787 set_bit(AF_INIT_DONE, &ha->flags); 1788 1789 pci_set_drvdata(pdev, ha); 1790 1791 ret = scsi_add_host(host, &pdev->dev); 1792 if (ret) 1793 goto probe_failed; 1794 1795 printk(KERN_INFO 1796 " QLogic iSCSI HBA Driver version: %s\n" 1797 " QLogic ISP%04x @ %s, host#=%ld, fw=%02d.%02d.%02d.%02d\n", 1798 qla4xxx_version_str, ha->pdev->device, pci_name(ha->pdev), 1799 ha->host_no, ha->firmware_version[0], ha->firmware_version[1], 1800 ha->patch_number, ha->build_number); 1801 scsi_scan_host(host); 1802 return 0; 1803 1804 probe_failed: 1805 qla4xxx_free_adapter(ha); 1806 1807 probe_failed_ioconfig: 1808 pci_disable_pcie_error_reporting(pdev); 1809 scsi_host_put(ha->host); 1810 1811 probe_disable_device: 1812 pci_disable_device(pdev); 1813 1814 return ret; 1815 } 1816 1817 /** 1818 * qla4xxx_remove_adapter - calback function to remove adapter. 1819 * @pci_dev: PCI device pointer 1820 **/ 1821 static void __devexit qla4xxx_remove_adapter(struct pci_dev *pdev) 1822 { 1823 struct scsi_qla_host *ha; 1824 1825 ha = pci_get_drvdata(pdev); 1826 1827 set_bit(AF_HBA_GOING_AWAY, &ha->flags); 1828 1829 /* remove devs from iscsi_sessions to scsi_devices */ 1830 qla4xxx_free_ddb_list(ha); 1831 1832 scsi_remove_host(ha->host); 1833 1834 qla4xxx_free_adapter(ha); 1835 1836 scsi_host_put(ha->host); 1837 1838 pci_disable_pcie_error_reporting(pdev); 1839 pci_disable_device(pdev); 1840 pci_set_drvdata(pdev, NULL); 1841 } 1842 1843 /** 1844 * qla4xxx_config_dma_addressing() - Configure OS DMA addressing method. 1845 * @ha: HA context 1846 * 1847 * At exit, the @ha's flags.enable_64bit_addressing set to indicated 1848 * supported addressing method. 1849 */ 1850 static void qla4xxx_config_dma_addressing(struct scsi_qla_host *ha) 1851 { 1852 int retval; 1853 1854 /* Update our PCI device dma_mask for full 64 bit mask */ 1855 if (pci_set_dma_mask(ha->pdev, DMA_BIT_MASK(64)) == 0) { 1856 if (pci_set_consistent_dma_mask(ha->pdev, DMA_BIT_MASK(64))) { 1857 dev_dbg(&ha->pdev->dev, 1858 "Failed to set 64 bit PCI consistent mask; " 1859 "using 32 bit.\n"); 1860 retval = pci_set_consistent_dma_mask(ha->pdev, 1861 DMA_BIT_MASK(32)); 1862 } 1863 } else 1864 retval = pci_set_dma_mask(ha->pdev, DMA_BIT_MASK(32)); 1865 } 1866 1867 static int qla4xxx_slave_alloc(struct scsi_device *sdev) 1868 { 1869 struct iscsi_cls_session *sess = starget_to_session(sdev->sdev_target); 1870 struct ddb_entry *ddb = sess->dd_data; 1871 1872 sdev->hostdata = ddb; 1873 sdev->tagged_supported = 1; 1874 scsi_activate_tcq(sdev, QL4_DEF_QDEPTH); 1875 return 0; 1876 } 1877 1878 static int qla4xxx_slave_configure(struct scsi_device *sdev) 1879 { 1880 sdev->tagged_supported = 1; 1881 return 0; 1882 } 1883 1884 static void qla4xxx_slave_destroy(struct scsi_device *sdev) 1885 { 1886 scsi_deactivate_tcq(sdev, 1); 1887 } 1888 1889 /** 1890 * qla4xxx_del_from_active_array - returns an active srb 1891 * @ha: Pointer to host adapter structure. 1892 * @index: index into the active_array 1893 * 1894 * This routine removes and returns the srb at the specified index 1895 **/ 1896 struct srb *qla4xxx_del_from_active_array(struct scsi_qla_host *ha, 1897 uint32_t index) 1898 { 1899 struct srb *srb = NULL; 1900 struct scsi_cmnd *cmd = NULL; 1901 1902 cmd = scsi_host_find_tag(ha->host, index); 1903 if (!cmd) 1904 return srb; 1905 1906 srb = (struct srb *)CMD_SP(cmd); 1907 if (!srb) 1908 return srb; 1909 1910 /* update counters */ 1911 if (srb->flags & SRB_DMA_VALID) { 1912 ha->req_q_count += srb->iocb_cnt; 1913 ha->iocb_cnt -= srb->iocb_cnt; 1914 if (srb->cmd) 1915 srb->cmd->host_scribble = 1916 (unsigned char *)(unsigned long) MAX_SRBS; 1917 } 1918 return srb; 1919 } 1920 1921 /** 1922 * qla4xxx_eh_wait_on_command - waits for command to be returned by firmware 1923 * @ha: Pointer to host adapter structure. 1924 * @cmd: Scsi Command to wait on. 1925 * 1926 * This routine waits for the command to be returned by the Firmware 1927 * for some max time. 1928 **/ 1929 static int qla4xxx_eh_wait_on_command(struct scsi_qla_host *ha, 1930 struct scsi_cmnd *cmd) 1931 { 1932 int done = 0; 1933 struct srb *rp; 1934 uint32_t max_wait_time = EH_WAIT_CMD_TOV; 1935 int ret = SUCCESS; 1936 1937 /* Dont wait on command if PCI error is being handled 1938 * by PCI AER driver 1939 */ 1940 if (unlikely(pci_channel_offline(ha->pdev)) || 1941 (test_bit(AF_EEH_BUSY, &ha->flags))) { 1942 ql4_printk(KERN_WARNING, ha, "scsi%ld: Return from %s\n", 1943 ha->host_no, __func__); 1944 return ret; 1945 } 1946 1947 do { 1948 /* Checking to see if its returned to OS */ 1949 rp = (struct srb *) CMD_SP(cmd); 1950 if (rp == NULL) { 1951 done++; 1952 break; 1953 } 1954 1955 msleep(2000); 1956 } while (max_wait_time--); 1957 1958 return done; 1959 } 1960 1961 /** 1962 * qla4xxx_wait_for_hba_online - waits for HBA to come online 1963 * @ha: Pointer to host adapter structure 1964 **/ 1965 static int qla4xxx_wait_for_hba_online(struct scsi_qla_host *ha) 1966 { 1967 unsigned long wait_online; 1968 1969 wait_online = jiffies + (HBA_ONLINE_TOV * HZ); 1970 while (time_before(jiffies, wait_online)) { 1971 1972 if (adapter_up(ha)) 1973 return QLA_SUCCESS; 1974 1975 msleep(2000); 1976 } 1977 1978 return QLA_ERROR; 1979 } 1980 1981 /** 1982 * qla4xxx_eh_wait_for_commands - wait for active cmds to finish. 1983 * @ha: pointer to HBA 1984 * @t: target id 1985 * @l: lun id 1986 * 1987 * This function waits for all outstanding commands to a lun to complete. It 1988 * returns 0 if all pending commands are returned and 1 otherwise. 1989 **/ 1990 static int qla4xxx_eh_wait_for_commands(struct scsi_qla_host *ha, 1991 struct scsi_target *stgt, 1992 struct scsi_device *sdev) 1993 { 1994 int cnt; 1995 int status = 0; 1996 struct scsi_cmnd *cmd; 1997 1998 /* 1999 * Waiting for all commands for the designated target or dev 2000 * in the active array 2001 */ 2002 for (cnt = 0; cnt < ha->host->can_queue; cnt++) { 2003 cmd = scsi_host_find_tag(ha->host, cnt); 2004 if (cmd && stgt == scsi_target(cmd->device) && 2005 (!sdev || sdev == cmd->device)) { 2006 if (!qla4xxx_eh_wait_on_command(ha, cmd)) { 2007 status++; 2008 break; 2009 } 2010 } 2011 } 2012 return status; 2013 } 2014 2015 /** 2016 * qla4xxx_eh_abort - callback for abort task. 2017 * @cmd: Pointer to Linux's SCSI command structure 2018 * 2019 * This routine is called by the Linux OS to abort the specified 2020 * command. 2021 **/ 2022 static int qla4xxx_eh_abort(struct scsi_cmnd *cmd) 2023 { 2024 struct scsi_qla_host *ha = to_qla_host(cmd->device->host); 2025 unsigned int id = cmd->device->id; 2026 unsigned int lun = cmd->device->lun; 2027 unsigned long serial = cmd->serial_number; 2028 unsigned long flags; 2029 struct srb *srb = NULL; 2030 int ret = SUCCESS; 2031 int wait = 0; 2032 2033 ql4_printk(KERN_INFO, ha, 2034 "scsi%ld:%d:%d: Abort command issued cmd=%p, pid=%ld\n", 2035 ha->host_no, id, lun, cmd, serial); 2036 2037 spin_lock_irqsave(&ha->hardware_lock, flags); 2038 srb = (struct srb *) CMD_SP(cmd); 2039 if (!srb) { 2040 spin_unlock_irqrestore(&ha->hardware_lock, flags); 2041 return SUCCESS; 2042 } 2043 kref_get(&srb->srb_ref); 2044 spin_unlock_irqrestore(&ha->hardware_lock, flags); 2045 2046 if (qla4xxx_abort_task(ha, srb) != QLA_SUCCESS) { 2047 DEBUG3(printk("scsi%ld:%d:%d: Abort_task mbx failed.\n", 2048 ha->host_no, id, lun)); 2049 ret = FAILED; 2050 } else { 2051 DEBUG3(printk("scsi%ld:%d:%d: Abort_task mbx success.\n", 2052 ha->host_no, id, lun)); 2053 wait = 1; 2054 } 2055 2056 kref_put(&srb->srb_ref, qla4xxx_srb_compl); 2057 2058 /* Wait for command to complete */ 2059 if (wait) { 2060 if (!qla4xxx_eh_wait_on_command(ha, cmd)) { 2061 DEBUG2(printk("scsi%ld:%d:%d: Abort handler timed out\n", 2062 ha->host_no, id, lun)); 2063 ret = FAILED; 2064 } 2065 } 2066 2067 ql4_printk(KERN_INFO, ha, 2068 "scsi%ld:%d:%d: Abort command - %s\n", 2069 ha->host_no, id, lun, (ret == SUCCESS) ? "succeded" : "failed"); 2070 2071 return ret; 2072 } 2073 2074 /** 2075 * qla4xxx_eh_device_reset - callback for target reset. 2076 * @cmd: Pointer to Linux's SCSI command structure 2077 * 2078 * This routine is called by the Linux OS to reset all luns on the 2079 * specified target. 2080 **/ 2081 static int qla4xxx_eh_device_reset(struct scsi_cmnd *cmd) 2082 { 2083 struct scsi_qla_host *ha = to_qla_host(cmd->device->host); 2084 struct ddb_entry *ddb_entry = cmd->device->hostdata; 2085 int ret = FAILED, stat; 2086 2087 if (!ddb_entry) 2088 return ret; 2089 2090 ret = iscsi_block_scsi_eh(cmd); 2091 if (ret) 2092 return ret; 2093 ret = FAILED; 2094 2095 ql4_printk(KERN_INFO, ha, 2096 "scsi%ld:%d:%d:%d: DEVICE RESET ISSUED.\n", ha->host_no, 2097 cmd->device->channel, cmd->device->id, cmd->device->lun); 2098 2099 DEBUG2(printk(KERN_INFO 2100 "scsi%ld: DEVICE_RESET cmd=%p jiffies = 0x%lx, to=%x," 2101 "dpc_flags=%lx, status=%x allowed=%d\n", ha->host_no, 2102 cmd, jiffies, cmd->request->timeout / HZ, 2103 ha->dpc_flags, cmd->result, cmd->allowed)); 2104 2105 /* FIXME: wait for hba to go online */ 2106 stat = qla4xxx_reset_lun(ha, ddb_entry, cmd->device->lun); 2107 if (stat != QLA_SUCCESS) { 2108 ql4_printk(KERN_INFO, ha, "DEVICE RESET FAILED. %d\n", stat); 2109 goto eh_dev_reset_done; 2110 } 2111 2112 if (qla4xxx_eh_wait_for_commands(ha, scsi_target(cmd->device), 2113 cmd->device)) { 2114 ql4_printk(KERN_INFO, ha, 2115 "DEVICE RESET FAILED - waiting for " 2116 "commands.\n"); 2117 goto eh_dev_reset_done; 2118 } 2119 2120 /* Send marker. */ 2121 if (qla4xxx_send_marker_iocb(ha, ddb_entry, cmd->device->lun, 2122 MM_LUN_RESET) != QLA_SUCCESS) 2123 goto eh_dev_reset_done; 2124 2125 ql4_printk(KERN_INFO, ha, 2126 "scsi(%ld:%d:%d:%d): DEVICE RESET SUCCEEDED.\n", 2127 ha->host_no, cmd->device->channel, cmd->device->id, 2128 cmd->device->lun); 2129 2130 ret = SUCCESS; 2131 2132 eh_dev_reset_done: 2133 2134 return ret; 2135 } 2136 2137 /** 2138 * qla4xxx_eh_target_reset - callback for target reset. 2139 * @cmd: Pointer to Linux's SCSI command structure 2140 * 2141 * This routine is called by the Linux OS to reset the target. 2142 **/ 2143 static int qla4xxx_eh_target_reset(struct scsi_cmnd *cmd) 2144 { 2145 struct scsi_qla_host *ha = to_qla_host(cmd->device->host); 2146 struct ddb_entry *ddb_entry = cmd->device->hostdata; 2147 int stat, ret; 2148 2149 if (!ddb_entry) 2150 return FAILED; 2151 2152 ret = iscsi_block_scsi_eh(cmd); 2153 if (ret) 2154 return ret; 2155 2156 starget_printk(KERN_INFO, scsi_target(cmd->device), 2157 "WARM TARGET RESET ISSUED.\n"); 2158 2159 DEBUG2(printk(KERN_INFO 2160 "scsi%ld: TARGET_DEVICE_RESET cmd=%p jiffies = 0x%lx, " 2161 "to=%x,dpc_flags=%lx, status=%x allowed=%d\n", 2162 ha->host_no, cmd, jiffies, cmd->request->timeout / HZ, 2163 ha->dpc_flags, cmd->result, cmd->allowed)); 2164 2165 stat = qla4xxx_reset_target(ha, ddb_entry); 2166 if (stat != QLA_SUCCESS) { 2167 starget_printk(KERN_INFO, scsi_target(cmd->device), 2168 "WARM TARGET RESET FAILED.\n"); 2169 return FAILED; 2170 } 2171 2172 if (qla4xxx_eh_wait_for_commands(ha, scsi_target(cmd->device), 2173 NULL)) { 2174 starget_printk(KERN_INFO, scsi_target(cmd->device), 2175 "WARM TARGET DEVICE RESET FAILED - " 2176 "waiting for commands.\n"); 2177 return FAILED; 2178 } 2179 2180 /* Send marker. */ 2181 if (qla4xxx_send_marker_iocb(ha, ddb_entry, cmd->device->lun, 2182 MM_TGT_WARM_RESET) != QLA_SUCCESS) { 2183 starget_printk(KERN_INFO, scsi_target(cmd->device), 2184 "WARM TARGET DEVICE RESET FAILED - " 2185 "marker iocb failed.\n"); 2186 return FAILED; 2187 } 2188 2189 starget_printk(KERN_INFO, scsi_target(cmd->device), 2190 "WARM TARGET RESET SUCCEEDED.\n"); 2191 return SUCCESS; 2192 } 2193 2194 /** 2195 * qla4xxx_eh_host_reset - kernel callback 2196 * @cmd: Pointer to Linux's SCSI command structure 2197 * 2198 * This routine is invoked by the Linux kernel to perform fatal error 2199 * recovery on the specified adapter. 2200 **/ 2201 static int qla4xxx_eh_host_reset(struct scsi_cmnd *cmd) 2202 { 2203 int return_status = FAILED; 2204 struct scsi_qla_host *ha; 2205 2206 ha = (struct scsi_qla_host *) cmd->device->host->hostdata; 2207 2208 if (ql4xdontresethba) { 2209 DEBUG2(printk("scsi%ld: %s: Don't Reset HBA\n", 2210 ha->host_no, __func__)); 2211 return FAILED; 2212 } 2213 2214 ql4_printk(KERN_INFO, ha, 2215 "scsi(%ld:%d:%d:%d): HOST RESET ISSUED.\n", ha->host_no, 2216 cmd->device->channel, cmd->device->id, cmd->device->lun); 2217 2218 if (qla4xxx_wait_for_hba_online(ha) != QLA_SUCCESS) { 2219 DEBUG2(printk("scsi%ld:%d: %s: Unable to reset host. Adapter " 2220 "DEAD.\n", ha->host_no, cmd->device->channel, 2221 __func__)); 2222 2223 return FAILED; 2224 } 2225 2226 if (!test_bit(DPC_RESET_HA, &ha->dpc_flags)) { 2227 if (is_qla8022(ha)) 2228 set_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags); 2229 else 2230 set_bit(DPC_RESET_HA, &ha->dpc_flags); 2231 } 2232 2233 if (qla4xxx_recover_adapter(ha) == QLA_SUCCESS) 2234 return_status = SUCCESS; 2235 2236 ql4_printk(KERN_INFO, ha, "HOST RESET %s.\n", 2237 return_status == FAILED ? "FAILED" : "SUCCEDED"); 2238 2239 return return_status; 2240 } 2241 2242 /* PCI AER driver recovers from all correctable errors w/o 2243 * driver intervention. For uncorrectable errors PCI AER 2244 * driver calls the following device driver's callbacks 2245 * 2246 * - Fatal Errors - link_reset 2247 * - Non-Fatal Errors - driver's pci_error_detected() which 2248 * returns CAN_RECOVER, NEED_RESET or DISCONNECT. 2249 * 2250 * PCI AER driver calls 2251 * CAN_RECOVER - driver's pci_mmio_enabled(), mmio_enabled 2252 * returns RECOVERED or NEED_RESET if fw_hung 2253 * NEED_RESET - driver's slot_reset() 2254 * DISCONNECT - device is dead & cannot recover 2255 * RECOVERED - driver's pci_resume() 2256 */ 2257 static pci_ers_result_t 2258 qla4xxx_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state) 2259 { 2260 struct scsi_qla_host *ha = pci_get_drvdata(pdev); 2261 2262 ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: error detected:state %x\n", 2263 ha->host_no, __func__, state); 2264 2265 if (!is_aer_supported(ha)) 2266 return PCI_ERS_RESULT_NONE; 2267 2268 switch (state) { 2269 case pci_channel_io_normal: 2270 clear_bit(AF_EEH_BUSY, &ha->flags); 2271 return PCI_ERS_RESULT_CAN_RECOVER; 2272 case pci_channel_io_frozen: 2273 set_bit(AF_EEH_BUSY, &ha->flags); 2274 qla4xxx_mailbox_premature_completion(ha); 2275 qla4xxx_free_irqs(ha); 2276 pci_disable_device(pdev); 2277 /* Return back all IOs */ 2278 qla4xxx_abort_active_cmds(ha, DID_RESET << 16); 2279 return PCI_ERS_RESULT_NEED_RESET; 2280 case pci_channel_io_perm_failure: 2281 set_bit(AF_EEH_BUSY, &ha->flags); 2282 set_bit(AF_PCI_CHANNEL_IO_PERM_FAILURE, &ha->flags); 2283 qla4xxx_abort_active_cmds(ha, DID_NO_CONNECT << 16); 2284 return PCI_ERS_RESULT_DISCONNECT; 2285 } 2286 return PCI_ERS_RESULT_NEED_RESET; 2287 } 2288 2289 /** 2290 * qla4xxx_pci_mmio_enabled() gets called if 2291 * qla4xxx_pci_error_detected() returns PCI_ERS_RESULT_CAN_RECOVER 2292 * and read/write to the device still works. 2293 **/ 2294 static pci_ers_result_t 2295 qla4xxx_pci_mmio_enabled(struct pci_dev *pdev) 2296 { 2297 struct scsi_qla_host *ha = pci_get_drvdata(pdev); 2298 2299 if (!is_aer_supported(ha)) 2300 return PCI_ERS_RESULT_NONE; 2301 2302 return PCI_ERS_RESULT_RECOVERED; 2303 } 2304 2305 static uint32_t qla4_8xxx_error_recovery(struct scsi_qla_host *ha) 2306 { 2307 uint32_t rval = QLA_ERROR; 2308 uint32_t ret = 0; 2309 int fn; 2310 struct pci_dev *other_pdev = NULL; 2311 2312 ql4_printk(KERN_WARNING, ha, "scsi%ld: In %s\n", ha->host_no, __func__); 2313 2314 set_bit(DPC_RESET_ACTIVE, &ha->dpc_flags); 2315 2316 if (test_bit(AF_ONLINE, &ha->flags)) { 2317 clear_bit(AF_ONLINE, &ha->flags); 2318 qla4xxx_mark_all_devices_missing(ha); 2319 qla4xxx_process_aen(ha, FLUSH_DDB_CHANGED_AENS); 2320 } 2321 2322 fn = PCI_FUNC(ha->pdev->devfn); 2323 while (fn > 0) { 2324 fn--; 2325 ql4_printk(KERN_INFO, ha, "scsi%ld: %s: Finding PCI device at " 2326 "func %x\n", ha->host_no, __func__, fn); 2327 /* Get the pci device given the domain, bus, 2328 * slot/function number */ 2329 other_pdev = 2330 pci_get_domain_bus_and_slot(pci_domain_nr(ha->pdev->bus), 2331 ha->pdev->bus->number, PCI_DEVFN(PCI_SLOT(ha->pdev->devfn), 2332 fn)); 2333 2334 if (!other_pdev) 2335 continue; 2336 2337 if (atomic_read(&other_pdev->enable_cnt)) { 2338 ql4_printk(KERN_INFO, ha, "scsi%ld: %s: Found PCI " 2339 "func in enabled state%x\n", ha->host_no, 2340 __func__, fn); 2341 pci_dev_put(other_pdev); 2342 break; 2343 } 2344 pci_dev_put(other_pdev); 2345 } 2346 2347 /* The first function on the card, the reset owner will 2348 * start & initialize the firmware. The other functions 2349 * on the card will reset the firmware context 2350 */ 2351 if (!fn) { 2352 ql4_printk(KERN_INFO, ha, "scsi%ld: %s: devfn being reset " 2353 "0x%x is the owner\n", ha->host_no, __func__, 2354 ha->pdev->devfn); 2355 2356 qla4_8xxx_idc_lock(ha); 2357 qla4_8xxx_wr_32(ha, QLA82XX_CRB_DEV_STATE, 2358 QLA82XX_DEV_COLD); 2359 2360 qla4_8xxx_wr_32(ha, QLA82XX_CRB_DRV_IDC_VERSION, 2361 QLA82XX_IDC_VERSION); 2362 2363 qla4_8xxx_idc_unlock(ha); 2364 clear_bit(AF_FW_RECOVERY, &ha->flags); 2365 rval = qla4xxx_initialize_adapter(ha, PRESERVE_DDB_LIST); 2366 qla4_8xxx_idc_lock(ha); 2367 2368 if (rval != QLA_SUCCESS) { 2369 ql4_printk(KERN_INFO, ha, "scsi%ld: %s: HW State: " 2370 "FAILED\n", ha->host_no, __func__); 2371 qla4_8xxx_clear_drv_active(ha); 2372 qla4_8xxx_wr_32(ha, QLA82XX_CRB_DEV_STATE, 2373 QLA82XX_DEV_FAILED); 2374 } else { 2375 ql4_printk(KERN_INFO, ha, "scsi%ld: %s: HW State: " 2376 "READY\n", ha->host_no, __func__); 2377 qla4_8xxx_wr_32(ha, QLA82XX_CRB_DEV_STATE, 2378 QLA82XX_DEV_READY); 2379 /* Clear driver state register */ 2380 qla4_8xxx_wr_32(ha, QLA82XX_CRB_DRV_STATE, 0); 2381 qla4_8xxx_set_drv_active(ha); 2382 ret = qla4xxx_request_irqs(ha); 2383 if (ret) { 2384 ql4_printk(KERN_WARNING, ha, "Failed to " 2385 "reserve interrupt %d already in use.\n", 2386 ha->pdev->irq); 2387 rval = QLA_ERROR; 2388 } else { 2389 ha->isp_ops->enable_intrs(ha); 2390 rval = QLA_SUCCESS; 2391 } 2392 } 2393 qla4_8xxx_idc_unlock(ha); 2394 } else { 2395 ql4_printk(KERN_INFO, ha, "scsi%ld: %s: devfn 0x%x is not " 2396 "the reset owner\n", ha->host_no, __func__, 2397 ha->pdev->devfn); 2398 if ((qla4_8xxx_rd_32(ha, QLA82XX_CRB_DEV_STATE) == 2399 QLA82XX_DEV_READY)) { 2400 clear_bit(AF_FW_RECOVERY, &ha->flags); 2401 rval = qla4xxx_initialize_adapter(ha, 2402 PRESERVE_DDB_LIST); 2403 if (rval == QLA_SUCCESS) { 2404 ret = qla4xxx_request_irqs(ha); 2405 if (ret) { 2406 ql4_printk(KERN_WARNING, ha, "Failed to" 2407 " reserve interrupt %d already in" 2408 " use.\n", ha->pdev->irq); 2409 rval = QLA_ERROR; 2410 } else { 2411 ha->isp_ops->enable_intrs(ha); 2412 rval = QLA_SUCCESS; 2413 } 2414 } 2415 qla4_8xxx_idc_lock(ha); 2416 qla4_8xxx_set_drv_active(ha); 2417 qla4_8xxx_idc_unlock(ha); 2418 } 2419 } 2420 clear_bit(DPC_RESET_ACTIVE, &ha->dpc_flags); 2421 return rval; 2422 } 2423 2424 static pci_ers_result_t 2425 qla4xxx_pci_slot_reset(struct pci_dev *pdev) 2426 { 2427 pci_ers_result_t ret = PCI_ERS_RESULT_DISCONNECT; 2428 struct scsi_qla_host *ha = pci_get_drvdata(pdev); 2429 int rc; 2430 2431 ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: slot_reset\n", 2432 ha->host_no, __func__); 2433 2434 if (!is_aer_supported(ha)) 2435 return PCI_ERS_RESULT_NONE; 2436 2437 /* Restore the saved state of PCIe device - 2438 * BAR registers, PCI Config space, PCIX, MSI, 2439 * IOV states 2440 */ 2441 pci_restore_state(pdev); 2442 2443 /* pci_restore_state() clears the saved_state flag of the device 2444 * save restored state which resets saved_state flag 2445 */ 2446 pci_save_state(pdev); 2447 2448 /* Initialize device or resume if in suspended state */ 2449 rc = pci_enable_device(pdev); 2450 if (rc) { 2451 ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: Cant re-enable " 2452 "device after reset\n", ha->host_no, __func__); 2453 goto exit_slot_reset; 2454 } 2455 2456 ha->isp_ops->disable_intrs(ha); 2457 2458 if (is_qla8022(ha)) { 2459 if (qla4_8xxx_error_recovery(ha) == QLA_SUCCESS) { 2460 ret = PCI_ERS_RESULT_RECOVERED; 2461 goto exit_slot_reset; 2462 } else 2463 goto exit_slot_reset; 2464 } 2465 2466 exit_slot_reset: 2467 ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: Return=%x\n" 2468 "device after reset\n", ha->host_no, __func__, ret); 2469 return ret; 2470 } 2471 2472 static void 2473 qla4xxx_pci_resume(struct pci_dev *pdev) 2474 { 2475 struct scsi_qla_host *ha = pci_get_drvdata(pdev); 2476 int ret; 2477 2478 ql4_printk(KERN_WARNING, ha, "scsi%ld: %s: pci_resume\n", 2479 ha->host_no, __func__); 2480 2481 ret = qla4xxx_wait_for_hba_online(ha); 2482 if (ret != QLA_SUCCESS) { 2483 ql4_printk(KERN_ERR, ha, "scsi%ld: %s: the device failed to " 2484 "resume I/O from slot/link_reset\n", ha->host_no, 2485 __func__); 2486 } 2487 2488 pci_cleanup_aer_uncorrect_error_status(pdev); 2489 clear_bit(AF_EEH_BUSY, &ha->flags); 2490 } 2491 2492 static struct pci_error_handlers qla4xxx_err_handler = { 2493 .error_detected = qla4xxx_pci_error_detected, 2494 .mmio_enabled = qla4xxx_pci_mmio_enabled, 2495 .slot_reset = qla4xxx_pci_slot_reset, 2496 .resume = qla4xxx_pci_resume, 2497 }; 2498 2499 static struct pci_device_id qla4xxx_pci_tbl[] = { 2500 { 2501 .vendor = PCI_VENDOR_ID_QLOGIC, 2502 .device = PCI_DEVICE_ID_QLOGIC_ISP4010, 2503 .subvendor = PCI_ANY_ID, 2504 .subdevice = PCI_ANY_ID, 2505 }, 2506 { 2507 .vendor = PCI_VENDOR_ID_QLOGIC, 2508 .device = PCI_DEVICE_ID_QLOGIC_ISP4022, 2509 .subvendor = PCI_ANY_ID, 2510 .subdevice = PCI_ANY_ID, 2511 }, 2512 { 2513 .vendor = PCI_VENDOR_ID_QLOGIC, 2514 .device = PCI_DEVICE_ID_QLOGIC_ISP4032, 2515 .subvendor = PCI_ANY_ID, 2516 .subdevice = PCI_ANY_ID, 2517 }, 2518 { 2519 .vendor = PCI_VENDOR_ID_QLOGIC, 2520 .device = PCI_DEVICE_ID_QLOGIC_ISP8022, 2521 .subvendor = PCI_ANY_ID, 2522 .subdevice = PCI_ANY_ID, 2523 }, 2524 {0, 0}, 2525 }; 2526 MODULE_DEVICE_TABLE(pci, qla4xxx_pci_tbl); 2527 2528 static struct pci_driver qla4xxx_pci_driver = { 2529 .name = DRIVER_NAME, 2530 .id_table = qla4xxx_pci_tbl, 2531 .probe = qla4xxx_probe_adapter, 2532 .remove = qla4xxx_remove_adapter, 2533 .err_handler = &qla4xxx_err_handler, 2534 }; 2535 2536 static int __init qla4xxx_module_init(void) 2537 { 2538 int ret; 2539 2540 /* Allocate cache for SRBs. */ 2541 srb_cachep = kmem_cache_create("qla4xxx_srbs", sizeof(struct srb), 0, 2542 SLAB_HWCACHE_ALIGN, NULL); 2543 if (srb_cachep == NULL) { 2544 printk(KERN_ERR 2545 "%s: Unable to allocate SRB cache..." 2546 "Failing load!\n", DRIVER_NAME); 2547 ret = -ENOMEM; 2548 goto no_srp_cache; 2549 } 2550 2551 /* Derive version string. */ 2552 strcpy(qla4xxx_version_str, QLA4XXX_DRIVER_VERSION); 2553 if (ql4xextended_error_logging) 2554 strcat(qla4xxx_version_str, "-debug"); 2555 2556 qla4xxx_scsi_transport = 2557 iscsi_register_transport(&qla4xxx_iscsi_transport); 2558 if (!qla4xxx_scsi_transport){ 2559 ret = -ENODEV; 2560 goto release_srb_cache; 2561 } 2562 2563 ret = pci_register_driver(&qla4xxx_pci_driver); 2564 if (ret) 2565 goto unregister_transport; 2566 2567 printk(KERN_INFO "QLogic iSCSI HBA Driver\n"); 2568 return 0; 2569 2570 unregister_transport: 2571 iscsi_unregister_transport(&qla4xxx_iscsi_transport); 2572 release_srb_cache: 2573 kmem_cache_destroy(srb_cachep); 2574 no_srp_cache: 2575 return ret; 2576 } 2577 2578 static void __exit qla4xxx_module_exit(void) 2579 { 2580 pci_unregister_driver(&qla4xxx_pci_driver); 2581 iscsi_unregister_transport(&qla4xxx_iscsi_transport); 2582 kmem_cache_destroy(srb_cachep); 2583 } 2584 2585 module_init(qla4xxx_module_init); 2586 module_exit(qla4xxx_module_exit); 2587 2588 MODULE_AUTHOR("QLogic Corporation"); 2589 MODULE_DESCRIPTION("QLogic iSCSI HBA Driver"); 2590 MODULE_LICENSE("GPL"); 2591 MODULE_VERSION(QLA4XXX_DRIVER_VERSION); 2592