drivers/scsi/qla4xxx/ql4_os.c

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