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