Merge git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi-misc-2.6

* git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi-misc-2.6: (84 commits)
  [SCSI] be2iscsi: SGE Len == 64K
  [SCSI] be2iscsi: Remove premature free of cid
  [SCSI] be2iscsi: More time for FW
  [SCSI] libsas: fix bug for vacant phy
  [SCSI] sd: Fix overflow with big physical blocks
  [SCSI] st: add MTWEOFI to write filemarks without flushing drive buffer
  [SCSI] libsas: Don't issue commands to devices that have been hot-removed
  [SCSI] megaraid_sas: Add Online Controller Reset to MegaRAID SAS drive
  [SCSI] lpfc 8.3.17: Update lpfc driver version to 8.3.17
  [SCSI] lpfc 8.3.17: Replace function reset methodology
  [SCSI] lpfc 8.3.17: SCSI fixes
  [SCSI] lpfc 8.3.17: BSG fixes
  [SCSI] lpfc 8.3.17: SLI Additions and Fixes
  [SCSI] lpfc 8.3.17: Code Cleanup and Locking fixes
  [SCSI] zfcp: Remove scsi_cmnd->serial_number from debug traces
  [SCSI] ipr: fix array error logging
  [SCSI] aha152x: enable PCMCIA on 64bit
  [SCSI] scsi_dh_alua: Handle all states correctly
  [SCSI] cxgb4i: connection and ddp setting update
  [SCSI] cxgb3i: fixed connection over vlan
  ...

10 files changed, 535 insertions, 245 deletions

diff --git a/drivers/scsi/qla2xxx/qla_attr.c b/drivers/scsi/qla2xxx/qla_attr.c
index 114bc5a81171..2ff4342ae362 100644
--- a/drivers/scsi/qla2xxx/qla_attr.c
+++ b/drivers/scsi/qla2xxx/qla_attr.c
@@ -1538,22 +1538,22 @@ qla2x00_dev_loss_tmo_callbk(struct fc_rport *rport)
         if (!fcport)
                 return;
 
-        if (test_bit(ABORT_ISP_ACTIVE, &fcport->vha->dpc_flags))
-                return;
-
-        if (unlikely(pci_channel_offline(fcport->vha->hw->pdev))) {
-                qla2x00_abort_all_cmds(fcport->vha, DID_NO_CONNECT << 16);
-                return;
-        }
-
         /*
          * Transport has effectively 'deleted' the rport, clear
          * all local references.
          */
         spin_lock_irq(host->host_lock);
-        fcport->rport = NULL;
+        fcport->rport = fcport->drport = NULL;
         *((fc_port_t **)rport->dd_data) = NULL;
         spin_unlock_irq(host->host_lock);
+
+        if (test_bit(ABORT_ISP_ACTIVE, &fcport->vha->dpc_flags))
+                return;
+
+        if (unlikely(pci_channel_offline(fcport->vha->hw->pdev))) {
+                qla2x00_abort_all_cmds(fcport->vha, DID_NO_CONNECT << 16);
+                return;
+        }
 }
 
 static void
@@ -1676,14 +1676,14 @@ static void
 qla2x00_get_host_fabric_name(struct Scsi_Host *shost)
 {
         scsi_qla_host_t *vha = shost_priv(shost);
-        u64 node_name;
+        uint8_t node_name[WWN_SIZE] = { 0xFF, 0xFF, 0xFF, 0xFF, \
+                0xFF, 0xFF, 0xFF, 0xFF};
+        u64 fabric_name = wwn_to_u64(node_name);
 
         if (vha->device_flags & SWITCH_FOUND)
-                node_name = wwn_to_u64(vha->fabric_node_name);
-        else
-                node_name = wwn_to_u64(vha->node_name);
+                fabric_name = wwn_to_u64(vha->fabric_node_name);
 
-        fc_host_fabric_name(shost) = node_name;
+        fc_host_fabric_name(shost) = fabric_name;
 }
 
 static void
@@ -1776,6 +1776,7 @@ qla24xx_vport_create(struct fc_vport *fc_vport, bool disable)
         }
 
         /* initialize attributes */
+        fc_host_dev_loss_tmo(vha->host) = ha->port_down_retry_count;
         fc_host_node_name(vha->host) = wwn_to_u64(vha->node_name);
         fc_host_port_name(vha->host) = wwn_to_u64(vha->port_name);
         fc_host_supported_classes(vha->host) =
@@ -1984,6 +1985,7 @@ qla2x00_init_host_attr(scsi_qla_host_t *vha)
         struct qla_hw_data *ha = vha->hw;
         u32 speed = FC_PORTSPEED_UNKNOWN;
 
+        fc_host_dev_loss_tmo(vha->host) = ha->port_down_retry_count;
         fc_host_node_name(vha->host) = wwn_to_u64(vha->node_name);
         fc_host_port_name(vha->host) = wwn_to_u64(vha->port_name);
         fc_host_supported_classes(vha->host) = FC_COS_CLASS3;
diff --git a/drivers/scsi/qla2xxx/qla_bsg.c b/drivers/scsi/qla2xxx/qla_bsg.c
index 9067629817ea..fdfbf83a6330 100644
--- a/drivers/scsi/qla2xxx/qla_bsg.c
+++ b/drivers/scsi/qla2xxx/qla_bsg.c
@@ -1254,10 +1254,9 @@ qla24xx_iidma(struct fc_bsg_job *bsg_job)
                 return -EINVAL;
         }
 
-        if (fcport->loop_id == FC_NO_LOOP_ID) {
-                DEBUG2(printk(KERN_ERR "%s(%ld): Invalid port loop id, "
-                        "loop_id = 0x%x\n",
-                        __func__, vha->host_no, fcport->loop_id));
+        if (atomic_read(&fcport->state) != FCS_ONLINE) {
+                DEBUG2(printk(KERN_ERR "%s(%ld): Port not online\n",
+                        __func__, vha->host_no));
                 return -EINVAL;
         }
 
diff --git a/drivers/scsi/qla2xxx/qla_def.h b/drivers/scsi/qla2xxx/qla_def.h
index d2a4e1530708..e1d3ad40a946 100644
--- a/drivers/scsi/qla2xxx/qla_def.h
+++ b/drivers/scsi/qla2xxx/qla_def.h
@@ -706,6 +706,11 @@ typedef struct {
 #define MBC_SET_PORT_CONFIG             0x122   /* Set port configuration */
 #define MBC_GET_PORT_CONFIG             0x123   /* Get port configuration */
 
+/*
+ * ISP81xx mailbox commands
+ */
+#define MBC_WRITE_MPI_REGISTER          0x01    /* Write MPI Register. */
+
 /* Firmware return data sizes */
 #define FCAL_MAP_SIZE   128
 
@@ -2860,6 +2865,7 @@ typedef struct scsi_qla_host {
 #define NPIV_CONFIG_NEEDED      16
 #define ISP_UNRECOVERABLE       17
 #define FCOE_CTX_RESET_NEEDED   18      /* Initiate FCoE context reset */
+#define MPI_RESET_NEEDED        19      /* Initiate MPI FW reset */
 
         uint32_t        device_flags;
 #define SWITCH_FOUND            BIT_0
@@ -3003,6 +3009,8 @@ typedef struct scsi_qla_host {
 
 #define CMD_SP(Cmnd)            ((Cmnd)->SCp.ptr)
 
+#define QLA_SG_ALL      1024
+
 enum nexus_wait_type {
         WAIT_HOST = 0,
         WAIT_TARGET,
diff --git a/drivers/scsi/qla2xxx/qla_gbl.h b/drivers/scsi/qla2xxx/qla_gbl.h
index 1a1b281cea33..c33dec827e1e 100644
--- a/drivers/scsi/qla2xxx/qla_gbl.h
+++ b/drivers/scsi/qla2xxx/qla_gbl.h
@@ -352,6 +352,8 @@ qla2x00_read_ram_word(scsi_qla_host_t *, uint32_t, uint32_t *);
 extern int
 qla2x00_write_ram_word(scsi_qla_host_t *, uint32_t, uint32_t);
 
+extern int
+qla81xx_write_mpi_register(scsi_qla_host_t *, uint16_t *);
 extern int qla2x00_get_data_rate(scsi_qla_host_t *);
 extern int qla24xx_set_fcp_prio(scsi_qla_host_t *, uint16_t, uint16_t,
         uint16_t *);
@@ -501,7 +503,6 @@ extern void qla24xx_wrt_rsp_reg(struct qla_hw_data *, uint16_t, uint16_t);
 /* PCI related functions */
 extern int qla82xx_pci_config(struct scsi_qla_host *);
 extern int qla82xx_pci_mem_read_2M(struct qla_hw_data *, u64, void *, int);
-extern int qla82xx_pci_mem_write_2M(struct qla_hw_data *, u64, void *, int);
 extern char *qla82xx_pci_info_str(struct scsi_qla_host *, char *);
 extern int qla82xx_pci_region_offset(struct pci_dev *, int);
 extern int qla82xx_iospace_config(struct qla_hw_data *);
@@ -509,8 +510,8 @@ extern int qla82xx_iospace_config(struct qla_hw_data *);
 /* Initialization related functions */
 extern void qla82xx_reset_chip(struct scsi_qla_host *);
 extern void qla82xx_config_rings(struct scsi_qla_host *);
-extern int qla82xx_pinit_from_rom(scsi_qla_host_t *);
 extern void qla82xx_watchdog(scsi_qla_host_t *);
+extern int qla82xx_start_firmware(scsi_qla_host_t *);
 
 /* Firmware and flash related functions */
 extern int qla82xx_load_risc(scsi_qla_host_t *, uint32_t *);
@@ -533,25 +534,17 @@ extern irqreturn_t qla82xx_msix_default(int, void *);
 extern irqreturn_t qla82xx_msix_rsp_q(int, void *);
 extern void qla82xx_enable_intrs(struct qla_hw_data *);
 extern void qla82xx_disable_intrs(struct qla_hw_data *);
-extern void qla82xx_mbx_completion(scsi_qla_host_t *, uint16_t);
 extern void qla82xx_poll(int, void *);
 extern void qla82xx_init_flags(struct qla_hw_data *);
 
 /* ISP 8021 hardware related */
-extern int qla82xx_crb_win_lock(struct qla_hw_data *);
+extern void qla82xx_set_drv_active(scsi_qla_host_t *);
 extern void qla82xx_crb_win_unlock(struct qla_hw_data *);
-extern int qla82xx_pci_get_crb_addr_2M(struct qla_hw_data *, ulong *);
 extern int qla82xx_wr_32(struct qla_hw_data *, ulong, u32);
 extern int qla82xx_rd_32(struct qla_hw_data *, ulong);
 extern int qla82xx_rdmem(struct qla_hw_data *, u64, void *, int);
 extern int qla82xx_wrmem(struct qla_hw_data *, u64, void *, int);
-extern int qla82xx_check_for_bad_spd(struct qla_hw_data *);
-extern int qla82xx_load_fw(scsi_qla_host_t *);
-extern int qla82xx_rom_lock(struct qla_hw_data *);
 extern void qla82xx_rom_unlock(struct qla_hw_data *);
-extern int qla82xx_rom_fast_read(struct qla_hw_data *, int , int *);
-extern int qla82xx_do_rom_fast_read(struct qla_hw_data *, int, int *);
-extern unsigned long qla82xx_decode_crb_addr(unsigned long);
 
 /* ISP 8021 IDC */
 extern void qla82xx_clear_drv_active(struct qla_hw_data *);
diff --git a/drivers/scsi/qla2xxx/qla_init.c b/drivers/scsi/qla2xxx/qla_init.c
index 9c383baebe27..3cafbef40737 100644
--- a/drivers/scsi/qla2xxx/qla_init.c
+++ b/drivers/scsi/qla2xxx/qla_init.c
@@ -954,6 +954,19 @@ qla2x00_reset_chip(scsi_qla_host_t *vha)
 }
 
 /**
+ * qla81xx_reset_mpi() - Reset's MPI FW via Write MPI Register MBC.
+ *
+ * Returns 0 on success.
+ */
+int
+qla81xx_reset_mpi(scsi_qla_host_t *vha)
+{
+        uint16_t mb[4] = {0x1010, 0, 1, 0};
+
+        return qla81xx_write_mpi_register(vha, mb);
+}
+
+/**
  * qla24xx_reset_risc() - Perform full reset of ISP24xx RISC.
  * @ha: HA context
  *
@@ -967,6 +980,7 @@ qla24xx_reset_risc(scsi_qla_host_t *vha)
         struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
         uint32_t cnt, d2;
         uint16_t wd;
+        static int abts_cnt; /* ISP abort retry counts */
 
         spin_lock_irqsave(&ha->hardware_lock, flags);
 
@@ -1000,6 +1014,23 @@ qla24xx_reset_risc(scsi_qla_host_t *vha)
                 barrier();
         }
 
+        /* If required, do an MPI FW reset now */
+        if (test_and_clear_bit(MPI_RESET_NEEDED, &vha->dpc_flags)) {
+                if (qla81xx_reset_mpi(vha) != QLA_SUCCESS) {
+                        if (++abts_cnt < 5) {
+                                set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
+                                set_bit(MPI_RESET_NEEDED, &vha->dpc_flags);
+                        } else {
+                                /*
+                                 * We exhausted the ISP abort retries. We have to
+                                 * set the board offline.
+                                 */
+                                abts_cnt = 0;
+                                vha->flags.online = 0;
+                        }
+                }
+        }
+
         WRT_REG_DWORD(&reg->hccr, HCCRX_SET_RISC_RESET);
         RD_REG_DWORD(&reg->hccr);
 
@@ -2799,6 +2830,9 @@ qla2x00_iidma_fcport(scsi_qla_host_t *vha, fc_port_t *fcport)
         if (!IS_IIDMA_CAPABLE(ha))
                 return;
 
+        if (atomic_read(&fcport->state) != FCS_ONLINE)
+                return;
+
         if (fcport->fp_speed == PORT_SPEED_UNKNOWN ||
             fcport->fp_speed > ha->link_data_rate)
                 return;
@@ -3878,17 +3912,19 @@ qla2x00_abort_isp_cleanup(scsi_qla_host_t *vha)
                             LOOP_DOWN_TIME);
         }
 
-        /* Make sure for ISP 82XX IO DMA is complete */
-        if (IS_QLA82XX(ha)) {
-                if (qla2x00_eh_wait_for_pending_commands(vha, 0, 0,
-                        WAIT_HOST) == QLA_SUCCESS) {
-                        DEBUG2(qla_printk(KERN_INFO, ha,
-                        "Done wait for pending commands\n"));
+        if (!ha->flags.eeh_busy) {
+                /* Make sure for ISP 82XX IO DMA is complete */
+                if (IS_QLA82XX(ha)) {
+                        if (qla2x00_eh_wait_for_pending_commands(vha, 0, 0,
+                                WAIT_HOST) == QLA_SUCCESS) {
+                                DEBUG2(qla_printk(KERN_INFO, ha,
+                                "Done wait for pending commands\n"));
+                        }
                 }
-        }
 
-        /* Requeue all commands in outstanding command list. */
-        qla2x00_abort_all_cmds(vha, DID_RESET << 16);
+                /* Requeue all commands in outstanding command list. */
+                qla2x00_abort_all_cmds(vha, DID_RESET << 16);
+        }
 }
 
 /*
diff --git a/drivers/scsi/qla2xxx/qla_isr.c b/drivers/scsi/qla2xxx/qla_isr.c
index 28f65be19dad..e0e43d9e7ed1 100644
--- a/drivers/scsi/qla2xxx/qla_isr.c
+++ b/drivers/scsi/qla2xxx/qla_isr.c
@@ -412,8 +412,14 @@ skip_rio:
                                     "Unrecoverable Hardware Error: adapter "
                                     "marked OFFLINE!\n");
                                 vha->flags.online = 0;
-                        } else
+                        } else {
+                                /* Check to see if MPI timeout occured */
+                                if ((mbx & MBX_3) && (ha->flags.port0))
+                                        set_bit(MPI_RESET_NEEDED,
+                                            &vha->dpc_flags);
+
                                 set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
+                        }
                 } else if (mb[1] == 0) {
                         qla_printk(KERN_INFO, ha,
                             "Unrecoverable Hardware Error: adapter marked "
diff --git a/drivers/scsi/qla2xxx/qla_mbx.c b/drivers/scsi/qla2xxx/qla_mbx.c
index a595ec8264f8..effd8a1403d9 100644
--- a/drivers/scsi/qla2xxx/qla_mbx.c
+++ b/drivers/scsi/qla2xxx/qla_mbx.c
@@ -3828,8 +3828,6 @@ qla2x00_loopback_test(scsi_qla_host_t *vha, struct msg_echo_lb *mreq,
 
         /* Copy mailbox information */
         memcpy( mresp, mcp->mb, 64);
-        mresp[3] = mcp->mb[18];
-        mresp[4] = mcp->mb[19];
         return rval;
 }
 
@@ -3890,9 +3888,10 @@ qla2x00_echo_test(scsi_qla_host_t *vha, struct msg_echo_lb *mreq,
         }
 
         /* Copy mailbox information */
-        memcpy( mresp, mcp->mb, 32);
+        memcpy(mresp, mcp->mb, 64);
         return rval;
 }
+
 int
 qla84xx_reset_chip(scsi_qla_host_t *ha, uint16_t enable_diagnostic)
 {
@@ -3953,6 +3952,67 @@ qla2x00_write_ram_word(scsi_qla_host_t *vha, uint32_t risc_addr, uint32_t data)
 }
 
 int
+qla81xx_write_mpi_register(scsi_qla_host_t *vha, uint16_t *mb)
+{
+        int rval;
+        uint32_t stat, timer;
+        uint16_t mb0 = 0;
+        struct qla_hw_data *ha = vha->hw;
+        struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
+
+        rval = QLA_SUCCESS;
+
+        DEBUG11(qla_printk(KERN_INFO, ha,
+            "%s(%ld): entered.\n", __func__, vha->host_no));
+
+        clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
+
+        /* Write the MBC data to the registers */
+        WRT_REG_WORD(&reg->mailbox0, MBC_WRITE_MPI_REGISTER);
+        WRT_REG_WORD(&reg->mailbox1, mb[0]);
+        WRT_REG_WORD(&reg->mailbox2, mb[1]);
+        WRT_REG_WORD(&reg->mailbox3, mb[2]);
+        WRT_REG_WORD(&reg->mailbox4, mb[3]);
+
+        WRT_REG_DWORD(&reg->hccr, HCCRX_SET_HOST_INT);
+
+        /* Poll for MBC interrupt */
+        for (timer = 6000000; timer; timer--) {
+                /* Check for pending interrupts. */
+                stat = RD_REG_DWORD(&reg->host_status);
+                if (stat & HSRX_RISC_INT) {
+                        stat &= 0xff;
+
+                        if (stat == 0x1 || stat == 0x2 ||
+                            stat == 0x10 || stat == 0x11) {
+                                set_bit(MBX_INTERRUPT,
+                                    &ha->mbx_cmd_flags);
+                                mb0 = RD_REG_WORD(&reg->mailbox0);
+                                WRT_REG_DWORD(&reg->hccr,
+                                    HCCRX_CLR_RISC_INT);
+                                RD_REG_DWORD(&reg->hccr);
+                                break;
+                        }
+                }
+                udelay(5);
+        }
+
+        if (test_and_clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags))
+                rval = mb0 & MBS_MASK;
+        else
+                rval = QLA_FUNCTION_FAILED;
+
+        if (rval != QLA_SUCCESS) {
+                DEBUG2_3_11(printk(KERN_INFO "%s(%ld): failed=%x mb[0]=%x.\n",
+                    __func__, vha->host_no, rval, mb[0]));
+        } else {
+                DEBUG11(printk(KERN_INFO
+                    "%s(%ld): done.\n", __func__, vha->host_no));
+        }
+
+        return rval;
+}
+int
 qla2x00_get_data_rate(scsi_qla_host_t *vha)
 {
         int rval;
diff --git a/drivers/scsi/qla2xxx/qla_nx.c b/drivers/scsi/qla2xxx/qla_nx.c
index 0a71cc71eab2..8d9edfb39803 100644
--- a/drivers/scsi/qla2xxx/qla_nx.c
+++ b/drivers/scsi/qla2xxx/qla_nx.c
@@ -403,6 +403,54 @@ qla82xx_pci_set_crbwindow(struct qla_hw_data *ha, u64 off)
         return off;
 }
 
+static int
+qla82xx_pci_get_crb_addr_2M(struct qla_hw_data *ha, ulong *off)
+{
+        struct crb_128M_2M_sub_block_map *m;
+
+        if (*off >= QLA82XX_CRB_MAX)
+                return -1;
+
+        if (*off >= QLA82XX_PCI_CAMQM && (*off < QLA82XX_PCI_CAMQM_2M_END)) {
+                *off = (*off - QLA82XX_PCI_CAMQM) +
+                    QLA82XX_PCI_CAMQM_2M_BASE + ha->nx_pcibase;
+                return 0;
+        }
+
+        if (*off < QLA82XX_PCI_CRBSPACE)
+                return -1;
+
+        *off -= QLA82XX_PCI_CRBSPACE;
+
+        /* Try direct map */
+        m = &crb_128M_2M_map[CRB_BLK(*off)].sub_block[CRB_SUBBLK(*off)];
+
+        if (m->valid && (m->start_128M <= *off) && (m->end_128M > *off)) {
+                *off = *off + m->start_2M - m->start_128M + ha->nx_pcibase;
+                return 0;
+        }
+        /* Not in direct map, use crb window */
+        return 1;
+}
+
+#define CRB_WIN_LOCK_TIMEOUT 100000000
+static int qla82xx_crb_win_lock(struct qla_hw_data *ha)
+{
+        int done = 0, timeout = 0;
+
+        while (!done) {
+                /* acquire semaphore3 from PCI HW block */
+                done = qla82xx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM7_LOCK));
+                if (done == 1)
+                        break;
+                if (timeout >= CRB_WIN_LOCK_TIMEOUT)
+                        return -1;
+                timeout++;
+        }
+        qla82xx_wr_32(ha, QLA82XX_CRB_WIN_LOCK_ID, ha->portnum);
+        return 0;
+}
+
 int
 qla82xx_wr_32(struct qla_hw_data *ha, ulong off, u32 data)
 {
@@ -453,24 +501,6 @@ qla82xx_rd_32(struct qla_hw_data *ha, ulong off)
         return data;
 }
 
-#define CRB_WIN_LOCK_TIMEOUT 100000000
-int qla82xx_crb_win_lock(struct qla_hw_data *ha)
-{
-        int done = 0, timeout = 0;
-
-        while (!done) {
-                /* acquire semaphore3 from PCI HW block */
-                done = qla82xx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM7_LOCK));
-                if (done == 1)
-                        break;
-                if (timeout >= CRB_WIN_LOCK_TIMEOUT)
-                        return -1;
-                timeout++;
-        }
-        qla82xx_wr_32(ha, QLA82XX_CRB_WIN_LOCK_ID, ha->portnum);
-        return 0;
-}
-
 #define IDC_LOCK_TIMEOUT 100000000
 int qla82xx_idc_lock(struct qla_hw_data *ha)
 {
@@ -504,36 +534,6 @@ void qla82xx_idc_unlock(struct qla_hw_data *ha)
         qla82xx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM5_UNLOCK));
 }
 
-int
-qla82xx_pci_get_crb_addr_2M(struct qla_hw_data *ha, ulong *off)
-{
-        struct crb_128M_2M_sub_block_map *m;
-
-        if (*off >= QLA82XX_CRB_MAX)
-                return -1;
-
-        if (*off >= QLA82XX_PCI_CAMQM && (*off < QLA82XX_PCI_CAMQM_2M_END)) {
-                *off = (*off - QLA82XX_PCI_CAMQM) +
-                    QLA82XX_PCI_CAMQM_2M_BASE + ha->nx_pcibase;
-                return 0;
-        }
-
-        if (*off < QLA82XX_PCI_CRBSPACE)
-                return -1;
-
-        *off -= QLA82XX_PCI_CRBSPACE;
-
-        /* Try direct map */
-        m = &crb_128M_2M_map[CRB_BLK(*off)].sub_block[CRB_SUBBLK(*off)];
-
-        if (m->valid && (m->start_128M <= *off) && (m->end_128M > *off)) {
-                *off = *off + m->start_2M - m->start_128M + ha->nx_pcibase;
-                return 0;
-        }
-        /* Not in direct map, use crb window */
-        return 1;
-}
-
 /*  PCI Windowing for DDR regions.  */
 #define QLA82XX_ADDR_IN_RANGE(addr, low, high) \
         (((addr) <= (high)) && ((addr) >= (low)))
@@ -557,7 +557,7 @@ qla82xx_pci_mem_bound_check(struct qla_hw_data *ha,
 
 int qla82xx_pci_set_window_warning_count;
 
-unsigned long
+static unsigned long
 qla82xx_pci_set_window(struct qla_hw_data *ha, unsigned long long addr)
 {
         int window;
@@ -798,7 +798,8 @@ qla82xx_pci_mem_write_direct(struct qla_hw_data *ha,
 }
 
 #define MTU_FUDGE_FACTOR 100
-unsigned long qla82xx_decode_crb_addr(unsigned long addr)
+static unsigned long
+qla82xx_decode_crb_addr(unsigned long addr)
 {
         int i;
         unsigned long base_addr, offset, pci_base;
@@ -824,7 +825,7 @@ unsigned long qla82xx_decode_crb_addr(unsigned long addr)
 static long rom_max_timeout = 100;
 static long qla82xx_rom_lock_timeout = 100;
 
-int
+static int
 qla82xx_rom_lock(struct qla_hw_data *ha)
 {
         int done = 0, timeout = 0;
@@ -842,7 +843,7 @@ qla82xx_rom_lock(struct qla_hw_data *ha)
         return 0;
 }
 
-int
+static int
 qla82xx_wait_rom_busy(struct qla_hw_data *ha)
 {
         long timeout = 0;
@@ -862,7 +863,7 @@ qla82xx_wait_rom_busy(struct qla_hw_data *ha)
         return 0;
 }
 
-int
+static int
 qla82xx_wait_rom_done(struct qla_hw_data *ha)
 {
         long timeout = 0;
@@ -882,7 +883,7 @@ qla82xx_wait_rom_done(struct qla_hw_data *ha)
         return 0;
 }
 
-int
+static int
 qla82xx_do_rom_fast_read(struct qla_hw_data *ha, int addr, int *valp)
 {
         qla82xx_wr_32(ha, QLA82XX_ROMUSB_ROM_ADDRESS, addr);
@@ -905,7 +906,7 @@ qla82xx_do_rom_fast_read(struct qla_hw_data *ha, int addr, int *valp)
         return 0;
 }
 
-int
+static int
 qla82xx_rom_fast_read(struct qla_hw_data *ha, int addr, int *valp)
 {
         int ret, loops = 0;
@@ -926,7 +927,7 @@ qla82xx_rom_fast_read(struct qla_hw_data *ha, int addr, int *valp)
         return ret;
 }
 
-int
+static int
 qla82xx_read_status_reg(struct qla_hw_data *ha, uint32_t *val)
 {
         qla82xx_wr_32(ha, QLA82XX_ROMUSB_ROM_INSTR_OPCODE, M25P_INSTR_RDSR);
@@ -940,7 +941,7 @@ qla82xx_read_status_reg(struct qla_hw_data *ha, uint32_t *val)
         return 0;
 }
 
-int
+static int
 qla82xx_flash_wait_write_finish(struct qla_hw_data *ha)
 {
         long timeout = 0;
@@ -964,7 +965,7 @@ qla82xx_flash_wait_write_finish(struct qla_hw_data *ha)
         return ret;
 }
 
-int
+static int
 qla82xx_flash_set_write_enable(struct qla_hw_data *ha)
 {
         uint32_t val;
@@ -981,7 +982,7 @@ qla82xx_flash_set_write_enable(struct qla_hw_data *ha)
         return 0;
 }
 
-int
+static int
 qla82xx_write_status_reg(struct qla_hw_data *ha, uint32_t val)
 {
         if (qla82xx_flash_set_write_enable(ha))
@@ -996,7 +997,7 @@ qla82xx_write_status_reg(struct qla_hw_data *ha, uint32_t val)
         return qla82xx_flash_wait_write_finish(ha);
 }
 
-int
+static int
 qla82xx_write_disable_flash(struct qla_hw_data *ha)
 {
         qla82xx_wr_32(ha, QLA82XX_ROMUSB_ROM_INSTR_OPCODE, M25P_INSTR_WRDI);
@@ -1008,7 +1009,7 @@ qla82xx_write_disable_flash(struct qla_hw_data *ha)
         return 0;
 }
 
-int
+static int
 ql82xx_rom_lock_d(struct qla_hw_data *ha)
 {
         int loops = 0;
@@ -1024,7 +1025,7 @@ ql82xx_rom_lock_d(struct qla_hw_data *ha)
         return 0;;
 }
 
-int
+static int
 qla82xx_write_flash_dword(struct qla_hw_data *ha, uint32_t flashaddr,
         uint32_t data)
 {
@@ -1061,7 +1062,8 @@ done_write:
 /* This routine does CRB initialize sequence
  *  to put the ISP into operational state
  */
-int qla82xx_pinit_from_rom(scsi_qla_host_t *vha)
+static int
+qla82xx_pinit_from_rom(scsi_qla_host_t *vha)
 {
         int addr, val;
         int i ;
@@ -1207,7 +1209,8 @@ int qla82xx_pinit_from_rom(scsi_qla_host_t *vha)
         return 0;
 }
 
-int qla82xx_check_for_bad_spd(struct qla_hw_data *ha)
+static int
+qla82xx_check_for_bad_spd(struct qla_hw_data *ha)
 {
         u32 val = 0;
         val = qla82xx_rd_32(ha, BOOT_LOADER_DIMM_STATUS);
@@ -1225,7 +1228,116 @@ int qla82xx_check_for_bad_spd(struct qla_hw_data *ha)
         return 0;
 }
 
-int
+static int
+qla82xx_pci_mem_write_2M(struct qla_hw_data *ha,
+                u64 off, void *data, int size)
+{
+        int i, j, ret = 0, loop, sz[2], off0;
+        int scale, shift_amount, startword;
+        uint32_t temp;
+        uint64_t off8, mem_crb, tmpw, word[2] = {0, 0};
+
+        /*
+         * If not MN, go check for MS or invalid.
+         */
+        if (off >= QLA82XX_ADDR_QDR_NET && off <= QLA82XX_P3_ADDR_QDR_NET_MAX)
+                mem_crb = QLA82XX_CRB_QDR_NET;
+        else {
+                mem_crb = QLA82XX_CRB_DDR_NET;
+                if (qla82xx_pci_mem_bound_check(ha, off, size) == 0)
+                        return qla82xx_pci_mem_write_direct(ha,
+                            off, data, size);
+        }
+
+        off0 = off & 0x7;
+        sz[0] = (size < (8 - off0)) ? size : (8 - off0);
+        sz[1] = size - sz[0];
+
+        off8 = off & 0xfffffff0;
+        loop = (((off & 0xf) + size - 1) >> 4) + 1;
+        shift_amount = 4;
+        scale = 2;
+        startword = (off & 0xf)/8;
+
+        for (i = 0; i < loop; i++) {
+                if (qla82xx_pci_mem_read_2M(ha, off8 +
+                    (i << shift_amount), &word[i * scale], 8))
+                        return -1;
+        }
+
+        switch (size) {
+        case 1:
+                tmpw = *((uint8_t *)data);
+                break;
+        case 2:
+                tmpw = *((uint16_t *)data);
+                break;
+        case 4:
+                tmpw = *((uint32_t *)data);
+                break;
+        case 8:
+        default:
+                tmpw = *((uint64_t *)data);
+                break;
+        }
+
+        if (sz[0] == 8) {
+                word[startword] = tmpw;
+        } else {
+                word[startword] &=
+                        ~((~(~0ULL << (sz[0] * 8))) << (off0 * 8));
+                word[startword] |= tmpw << (off0 * 8);
+        }
+        if (sz[1] != 0) {
+                word[startword+1] &= ~(~0ULL << (sz[1] * 8));
+                word[startword+1] |= tmpw >> (sz[0] * 8);
+        }
+
+        /*
+         * don't lock here - write_wx gets the lock if each time
+         * write_lock_irqsave(&adapter->adapter_lock, flags);
+         * netxen_nic_pci_change_crbwindow_128M(adapter, 0);
+         */
+        for (i = 0; i < loop; i++) {
+                temp = off8 + (i << shift_amount);
+                qla82xx_wr_32(ha, mem_crb+MIU_TEST_AGT_ADDR_LO, temp);
+                temp = 0;
+                qla82xx_wr_32(ha, mem_crb+MIU_TEST_AGT_ADDR_HI, temp);
+                temp = word[i * scale] & 0xffffffff;
+                qla82xx_wr_32(ha, mem_crb+MIU_TEST_AGT_WRDATA_LO, temp);
+                temp = (word[i * scale] >> 32) & 0xffffffff;
+                qla82xx_wr_32(ha, mem_crb+MIU_TEST_AGT_WRDATA_HI, temp);
+                temp = word[i*scale + 1] & 0xffffffff;
+                qla82xx_wr_32(ha, mem_crb +
+                    MIU_TEST_AGT_WRDATA_UPPER_LO, temp);
+                temp = (word[i*scale + 1] >> 32) & 0xffffffff;
+                qla82xx_wr_32(ha, mem_crb +
+                    MIU_TEST_AGT_WRDATA_UPPER_HI, temp);
+
+                temp = MIU_TA_CTL_ENABLE | MIU_TA_CTL_WRITE;
+                qla82xx_wr_32(ha, mem_crb + MIU_TEST_AGT_CTRL, temp);
+                temp = MIU_TA_CTL_START | MIU_TA_CTL_ENABLE | MIU_TA_CTL_WRITE;
+                qla82xx_wr_32(ha, mem_crb + MIU_TEST_AGT_CTRL, temp);
+
+                for (j = 0; j < MAX_CTL_CHECK; j++) {
+                        temp = qla82xx_rd_32(ha, mem_crb + MIU_TEST_AGT_CTRL);
+                        if ((temp & MIU_TA_CTL_BUSY) == 0)
+                                break;
+                }
+
+                if (j >= MAX_CTL_CHECK) {
+                        if (printk_ratelimit())
+                                dev_err(&ha->pdev->dev,
+                                    "failed to write through agent\n");
+                        ret = -1;
+                        break;
+                }
+        }
+
+        return ret;
+}
+
+static int
 qla82xx_fw_load_from_flash(struct qla_hw_data *ha)
 {
         int  i;
@@ -1357,114 +1469,6 @@ qla82xx_pci_mem_read_2M(struct qla_hw_data *ha,
         return 0;
 }
 
-int
-qla82xx_pci_mem_write_2M(struct qla_hw_data *ha,
-                u64 off, void *data, int size)
-{
-        int i, j, ret = 0, loop, sz[2], off0;
-        int scale, shift_amount, startword;
-        uint32_t temp;
-        uint64_t off8, mem_crb, tmpw, word[2] = {0, 0};
-
-        /*
-         * If not MN, go check for MS or invalid.
-         */
-        if (off >= QLA82XX_ADDR_QDR_NET && off <= QLA82XX_P3_ADDR_QDR_NET_MAX)
-                mem_crb = QLA82XX_CRB_QDR_NET;
-        else {
-                mem_crb = QLA82XX_CRB_DDR_NET;
-                if (qla82xx_pci_mem_bound_check(ha, off, size) == 0)
-                        return qla82xx_pci_mem_write_direct(ha,
-                            off, data, size);
-        }
-
-        off0 = off & 0x7;
-        sz[0] = (size < (8 - off0)) ? size : (8 - off0);
-        sz[1] = size - sz[0];
-
-        off8 = off & 0xfffffff0;
-        loop = (((off & 0xf) + size - 1) >> 4) + 1;
-        shift_amount = 4;
-        scale = 2;
-        startword = (off & 0xf)/8;
-
-        for (i = 0; i < loop; i++) {
-                if (qla82xx_pci_mem_read_2M(ha, off8 +
-                    (i << shift_amount), &word[i * scale], 8))
-                        return -1;
-        }
-
-        switch (size) {
-        case 1:
-                tmpw = *((uint8_t *)data);
-                break;
-        case 2:
-                tmpw = *((uint16_t *)data);
-                break;
-        case 4:
-                tmpw = *((uint32_t *)data);
-                break;
-        case 8:
-        default:
-                tmpw = *((uint64_t *)data);
-                break;
-        }
-
-        if (sz[0] == 8) {
-                word[startword] = tmpw;
-        } else {
-                word[startword] &=
-                        ~((~(~0ULL << (sz[0] * 8))) << (off0 * 8));
-                word[startword] |= tmpw << (off0 * 8);
-        }
-        if (sz[1] != 0) {
-                word[startword+1] &= ~(~0ULL << (sz[1] * 8));
-                word[startword+1] |= tmpw >> (sz[0] * 8);
-        }
-
-        /*
-         * don't lock here - write_wx gets the lock if each time
-         * write_lock_irqsave(&adapter->adapter_lock, flags);
-         * netxen_nic_pci_change_crbwindow_128M(adapter, 0);
-         */
-        for (i = 0; i < loop; i++) {
-                temp = off8 + (i << shift_amount);
-                qla82xx_wr_32(ha, mem_crb+MIU_TEST_AGT_ADDR_LO, temp);
-                temp = 0;
-                qla82xx_wr_32(ha, mem_crb+MIU_TEST_AGT_ADDR_HI, temp);
-                temp = word[i * scale] & 0xffffffff;
-                qla82xx_wr_32(ha, mem_crb+MIU_TEST_AGT_WRDATA_LO, temp);
-                temp = (word[i * scale] >> 32) & 0xffffffff;
-                qla82xx_wr_32(ha, mem_crb+MIU_TEST_AGT_WRDATA_HI, temp);
-                temp = word[i*scale + 1] & 0xffffffff;
-                qla82xx_wr_32(ha, mem_crb +
-                    MIU_TEST_AGT_WRDATA_UPPER_LO, temp);
-                temp = (word[i*scale + 1] >> 32) & 0xffffffff;
-                qla82xx_wr_32(ha, mem_crb +
-                    MIU_TEST_AGT_WRDATA_UPPER_HI, temp);
-
-                temp = MIU_TA_CTL_ENABLE | MIU_TA_CTL_WRITE;
-                qla82xx_wr_32(ha, mem_crb + MIU_TEST_AGT_CTRL, temp);
-                temp = MIU_TA_CTL_START | MIU_TA_CTL_ENABLE | MIU_TA_CTL_WRITE;
-                qla82xx_wr_32(ha, mem_crb + MIU_TEST_AGT_CTRL, temp);
-
-                for (j = 0; j < MAX_CTL_CHECK; j++) {
-                        temp = qla82xx_rd_32(ha, mem_crb + MIU_TEST_AGT_CTRL);
-                        if ((temp & MIU_TA_CTL_BUSY) == 0)
-                                break;
-                }
-
-                if (j >= MAX_CTL_CHECK) {
-                        if (printk_ratelimit())
-                                dev_err(&ha->pdev->dev,
-                                    "failed to write through agent\n");
-                        ret = -1;
-                        break;
-                }
-        }
-
-        return ret;
-}
 
 static struct qla82xx_uri_table_desc *
 qla82xx_get_table_desc(const u8 *unirom, int section)
@@ -1725,7 +1729,8 @@ void qla82xx_reset_adapter(struct scsi_qla_host *vha)
         ha->isp_ops->disable_intrs(ha);
 }
 
-int qla82xx_fw_load_from_blob(struct qla_hw_data *ha)
+static int
+qla82xx_fw_load_from_blob(struct qla_hw_data *ha)
 {
         u64 *ptr64;
         u32 i, flashaddr, size;
@@ -1836,7 +1841,8 @@ qla82xx_validate_firmware_blob(scsi_qla_host_t *vha, uint8_t fw_type)
         return 0;
 }
 
-int qla82xx_check_cmdpeg_state(struct qla_hw_data *ha)
+static int
+qla82xx_check_cmdpeg_state(struct qla_hw_data *ha)
 {
         u32 val = 0;
         int retries = 60;
@@ -1874,7 +1880,8 @@ int qla82xx_check_cmdpeg_state(struct qla_hw_data *ha)
         return QLA_FUNCTION_FAILED;
 }
 
-int qla82xx_check_rcvpeg_state(struct qla_hw_data *ha)
+static int
+qla82xx_check_rcvpeg_state(struct qla_hw_data *ha)
 {
         u32 val = 0;
         int retries = 60;
@@ -1933,7 +1940,7 @@ static struct qla82xx_legacy_intr_set legacy_intr[] = \
  * @ha: SCSI driver HA context
  * @mb0: Mailbox0 register
  */
-void
+static void
 qla82xx_mbx_completion(scsi_qla_host_t *vha, uint16_t mb0)
 {
         uint16_t        cnt;
@@ -2257,7 +2264,7 @@ void qla82xx_init_flags(struct qla_hw_data *ha)
         ha->nx_legacy_intr.pci_int_reg = nx_legacy_intr->pci_int_reg;
 }
 
-static inline void
+inline void
 qla82xx_set_drv_active(scsi_qla_host_t *vha)
 {
         uint32_t drv_active;
@@ -2267,10 +2274,11 @@ qla82xx_set_drv_active(scsi_qla_host_t *vha)
 
         /* If reset value is all FF's, initialize DRV_ACTIVE */
         if (drv_active == 0xffffffff) {
-                qla82xx_wr_32(ha, QLA82XX_CRB_DRV_ACTIVE, 0);
+                qla82xx_wr_32(ha, QLA82XX_CRB_DRV_ACTIVE,
+                        QLA82XX_DRV_NOT_ACTIVE);
                 drv_active = qla82xx_rd_32(ha, QLA82XX_CRB_DRV_ACTIVE);
         }
-        drv_active |= (1 << (ha->portnum * 4));
+        drv_active |= (QLA82XX_DRV_ACTIVE << (ha->portnum * 4));
         qla82xx_wr_32(ha, QLA82XX_CRB_DRV_ACTIVE, drv_active);
 }
 
@@ -2280,7 +2288,7 @@ qla82xx_clear_drv_active(struct qla_hw_data *ha)
         uint32_t drv_active;
 
         drv_active = qla82xx_rd_32(ha, QLA82XX_CRB_DRV_ACTIVE);
-        drv_active &= ~(1 << (ha->portnum * 4));
+        drv_active &= ~(QLA82XX_DRV_ACTIVE << (ha->portnum * 4));
         qla82xx_wr_32(ha, QLA82XX_CRB_DRV_ACTIVE, drv_active);
 }
 
@@ -2291,7 +2299,7 @@ qla82xx_need_reset(struct qla_hw_data *ha)
         int rval;
 
         drv_state = qla82xx_rd_32(ha, QLA82XX_CRB_DRV_STATE);
-        rval = drv_state & (1 << (ha->portnum * 4));
+        rval = drv_state & (QLA82XX_DRVST_RST_RDY << (ha->portnum * 4));
         return rval;
 }
 
@@ -2305,7 +2313,7 @@ qla82xx_set_rst_ready(struct qla_hw_data *ha)
 
         /* If reset value is all FF's, initialize DRV_STATE */
         if (drv_state == 0xffffffff) {
-                qla82xx_wr_32(ha, QLA82XX_CRB_DRV_STATE, 0);
+                qla82xx_wr_32(ha, QLA82XX_CRB_DRV_STATE, QLA82XX_DRVST_NOT_RDY);
                 drv_state = qla82xx_rd_32(ha, QLA82XX_CRB_DRV_STATE);
         }
         drv_state |= (QLA82XX_DRVST_RST_RDY << (ha->portnum * 4));
@@ -2335,7 +2343,8 @@ qla82xx_set_qsnt_ready(struct qla_hw_data *ha)
         qla82xx_wr_32(ha, QLA82XX_CRB_DRV_STATE, qsnt_state);
 }
 
-int qla82xx_load_fw(scsi_qla_host_t *vha)
+static int
+qla82xx_load_fw(scsi_qla_host_t *vha)
 {
         int rst;
         struct fw_blob *blob;
@@ -2411,7 +2420,7 @@ fw_load_failed:
         return QLA_FUNCTION_FAILED;
 }
 
-static int
+int
 qla82xx_start_firmware(scsi_qla_host_t *vha)
 {
         int           pcie_cap;
@@ -2419,7 +2428,7 @@ qla82xx_start_firmware(scsi_qla_host_t *vha)
         struct qla_hw_data *ha = vha->hw;
 
         /* scrub dma mask expansion register */
-        qla82xx_wr_32(ha, CRB_DMA_SHIFT, 0x55555555);
+        qla82xx_wr_32(ha, CRB_DMA_SHIFT, QLA82XX_DMA_SHIFT_VALUE);
 
         /* Put both the PEG CMD and RCV PEG to default state
          * of 0 before resetting the hardware
@@ -2882,7 +2891,7 @@ queuing_error:
         return QLA_FUNCTION_FAILED;
 }
 
-uint32_t *
+static uint32_t *
 qla82xx_read_flash_data(scsi_qla_host_t *vha, uint32_t *dwptr, uint32_t faddr,
         uint32_t length)
 {
@@ -2903,7 +2912,7 @@ done_read:
         return dwptr;
 }
 
-int
+static int
 qla82xx_unprotect_flash(struct qla_hw_data *ha)
 {
         int ret;
@@ -2934,7 +2943,7 @@ done_unprotect:
         return ret;
 }
 
-int
+static int
 qla82xx_protect_flash(struct qla_hw_data *ha)
 {
         int ret;
@@ -2963,7 +2972,7 @@ done_protect:
         return ret;
 }
 
-int
+static int
 qla82xx_erase_sector(struct qla_hw_data *ha, int addr)
 {
         int ret = 0;
@@ -3156,6 +3165,20 @@ qla82xx_start_iocbs(srb_t *sp)
         }
 }
 
+void qla82xx_rom_lock_recovery(struct qla_hw_data *ha)
+{
+        if (qla82xx_rom_lock(ha))
+                /* Someone else is holding the lock. */
+                qla_printk(KERN_INFO, ha, "Resetting rom_lock\n");
+
+        /*
+         * Either we got the lock, or someone
+         * else died while holding it.
+         * In either case, unlock.
+         */
+        qla82xx_rd_32(ha, QLA82XX_PCIE_REG(PCIE_SEM2_UNLOCK));
+}
+
 /*
  * qla82xx_device_bootstrap
  *    Initialize device, set DEV_READY, start fw
@@ -3170,12 +3193,13 @@ qla82xx_start_iocbs(srb_t *sp)
 static int
 qla82xx_device_bootstrap(scsi_qla_host_t *vha)
 {
-        int rval, i, timeout;
+        int rval = QLA_SUCCESS;
+        int i, timeout;
         uint32_t old_count, count;
         struct qla_hw_data *ha = vha->hw;
+        int need_reset = 0, peg_stuck = 1;
 
-        if (qla82xx_need_reset(ha))
-                goto dev_initialize;
+        need_reset = qla82xx_need_reset(ha);
 
         old_count = qla82xx_rd_32(ha, QLA82XX_PEG_ALIVE_COUNTER);
 
@@ -3189,9 +3213,27 @@ qla82xx_device_bootstrap(scsi_qla_host_t *vha)
 
                 count = qla82xx_rd_32(ha, QLA82XX_PEG_ALIVE_COUNTER);
                 if (count != old_count)
+                        peg_stuck = 0;
+        }
+
+        if (need_reset) {
+                /* We are trying to perform a recovery here. */
+                if (peg_stuck)
+                        qla82xx_rom_lock_recovery(ha);
+                goto dev_initialize;
+        } else  {
+                /* Start of day for this ha context. */
+                if (peg_stuck) {
+                        /* Either we are the first or recovery in progress. */
+                        qla82xx_rom_lock_recovery(ha);
+                        goto dev_initialize;
+                } else
+                        /* Firmware already running. */
                         goto dev_ready;
         }
 
+        return rval;
+
 dev_initialize:
         /* set to DEV_INITIALIZING */
         qla_printk(KERN_INFO, ha, "HW State: INITIALIZING\n");
@@ -3304,6 +3346,9 @@ qla82xx_check_fw_alive(scsi_qla_host_t *vha)
         struct qla_hw_data *ha = vha->hw;
 
         fw_heartbeat_counter = qla82xx_rd_32(ha, QLA82XX_PEG_ALIVE_COUNTER);
+        /* all 0xff, assume AER/EEH in progress, ignore */
+        if (fw_heartbeat_counter == 0xffffffff)
+                return;
         if (vha->fw_heartbeat_counter == fw_heartbeat_counter) {
                 vha->seconds_since_last_heartbeat++;
                 /* FW not alive after 2 seconds */
diff --git a/drivers/scsi/qla2xxx/qla_nx.h b/drivers/scsi/qla2xxx/qla_nx.h
index 15559cab39f8..51ec0c5380e8 100644
--- a/drivers/scsi/qla2xxx/qla_nx.h
+++ b/drivers/scsi/qla2xxx/qla_nx.h
@@ -26,6 +26,7 @@
 #define CRB_RCVPEG_STATE                QLA82XX_REG(0x13c)
 #define BOOT_LOADER_DIMM_STATUS         QLA82XX_REG(0x54)
 #define CRB_DMA_SHIFT                   QLA82XX_REG(0xcc)
+#define QLA82XX_DMA_SHIFT_VALUE         0x55555555
 
 #define QLA82XX_HW_H0_CH_HUB_ADR    0x05
 #define QLA82XX_HW_H1_CH_HUB_ADR    0x0E
@@ -583,6 +584,10 @@
 #define QLA82XX_DRVST_RST_RDY           1
 #define QLA82XX_DRVST_QSNT_RDY          2
 
+/* Different drive active state */
+#define QLA82XX_DRV_NOT_ACTIVE          0
+#define QLA82XX_DRV_ACTIVE              1
+
 /*
  * The PCI VendorID and DeviceID for our board.
  */
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index 9946fac54255..800ea9269752 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -1295,17 +1295,12 @@ static int
 qla2xxx_slave_configure(struct scsi_device *sdev)
 {
         scsi_qla_host_t *vha = shost_priv(sdev->host);
-        struct qla_hw_data *ha = vha->hw;
-        struct fc_rport *rport = starget_to_rport(sdev->sdev_target);
         struct req_que *req = vha->req;
 
         if (sdev->tagged_supported)
                 scsi_activate_tcq(sdev, req->max_q_depth);
         else
                 scsi_deactivate_tcq(sdev, req->max_q_depth);
-
-        rport->dev_loss_tmo = ha->port_down_retry_count;
-
         return 0;
 }
 
@@ -2141,8 +2136,16 @@ qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
         else
                 base_vha->mgmt_svr_loop_id = MANAGEMENT_SERVER +
                                                 base_vha->vp_idx;
-        if (IS_QLA2100(ha))
-                host->sg_tablesize = 32;
+
+        /* Set the SG table size based on ISP type */
+        if (!IS_FWI2_CAPABLE(ha)) {
+                if (IS_QLA2100(ha))
+                        host->sg_tablesize = 32;
+        } else {
+                if (!IS_QLA82XX(ha))
+                        host->sg_tablesize = QLA_SG_ALL;
+        }
+
         host->max_id = max_id;
         host->this_id = 255;
         host->cmd_per_lun = 3;
@@ -3553,6 +3556,11 @@ qla2x00_timer(scsi_qla_host_t *vha)
         struct qla_hw_data *ha = vha->hw;
         struct req_que *req;
 
+        if (ha->flags.eeh_busy) {
+                qla2x00_restart_timer(vha, WATCH_INTERVAL);
+                return;
+        }
+
         if (IS_QLA82XX(ha))
                 qla82xx_watchdog(vha);
 
@@ -3782,8 +3790,21 @@ qla2xxx_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
                 return PCI_ERS_RESULT_CAN_RECOVER;
         case pci_channel_io_frozen:
                 ha->flags.eeh_busy = 1;
+                /* For ISP82XX complete any pending mailbox cmd */
+                if (IS_QLA82XX(ha)) {
+                        ha->flags.fw_hung = 1;
+                        if (ha->flags.mbox_busy) {
+                                ha->flags.mbox_int = 1;
+                                DEBUG2(qla_printk(KERN_ERR, ha,
+                                        "Due to pci channel io frozen, doing premature "
+                                        "completion of mbx command\n"));
+                                complete(&ha->mbx_intr_comp);
+                        }
+                }
                 qla2x00_free_irqs(vha);
                 pci_disable_device(pdev);
+                /* Return back all IOs */
+                qla2x00_abort_all_cmds(vha, DID_RESET << 16);
                 return PCI_ERS_RESULT_NEED_RESET;
         case pci_channel_io_perm_failure:
                 ha->flags.pci_channel_io_perm_failure = 1;
@@ -3804,6 +3825,9 @@ qla2xxx_pci_mmio_enabled(struct pci_dev *pdev)
         struct device_reg_2xxx __iomem *reg = &ha->iobase->isp;
         struct device_reg_24xx __iomem *reg24 = &ha->iobase->isp24;
 
+        if (IS_QLA82XX(ha))
+                return PCI_ERS_RESULT_RECOVERED;
+
         spin_lock_irqsave(&ha->hardware_lock, flags);
         if (IS_QLA2100(ha) || IS_QLA2200(ha)){
                 stat = RD_REG_DWORD(&reg->hccr);
@@ -3830,6 +3854,109 @@ qla2xxx_pci_mmio_enabled(struct pci_dev *pdev)
                 return PCI_ERS_RESULT_RECOVERED;
 }
 
+uint32_t qla82xx_error_recovery(scsi_qla_host_t *base_vha)
+{
+        uint32_t rval = QLA_FUNCTION_FAILED;
+        uint32_t drv_active = 0;
+        struct qla_hw_data *ha = base_vha->hw;
+        int fn;
+        struct pci_dev *other_pdev = NULL;
+
+        DEBUG17(qla_printk(KERN_INFO, ha,
+            "scsi(%ld): In qla82xx_error_recovery\n", base_vha->host_no));
+
+        set_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
+
+        if (base_vha->flags.online) {
+                /* Abort all outstanding commands,
+                 * so as to be requeued later */
+                qla2x00_abort_isp_cleanup(base_vha);
+        }
+
+
+        fn = PCI_FUNC(ha->pdev->devfn);
+        while (fn > 0) {
+                fn--;
+                DEBUG17(qla_printk(KERN_INFO, ha,
+                    "Finding pci device at function = 0x%x\n", fn));
+                other_pdev =
+                    pci_get_domain_bus_and_slot(pci_domain_nr(ha->pdev->bus),
+                    ha->pdev->bus->number, PCI_DEVFN(PCI_SLOT(ha->pdev->devfn),
+                    fn));
+
+                if (!other_pdev)
+                        continue;
+                if (atomic_read(&other_pdev->enable_cnt)) {
+                        DEBUG17(qla_printk(KERN_INFO, ha,
+                            "Found PCI func availabe and enabled at 0x%x\n",
+                            fn));
+                        pci_dev_put(other_pdev);
+                        break;
+                }
+                pci_dev_put(other_pdev);
+        }
+
+        if (!fn) {
+                /* Reset owner */
+                DEBUG17(qla_printk(KERN_INFO, ha,
+                    "This devfn is reset owner = 0x%x\n", ha->pdev->devfn));
+                qla82xx_idc_lock(ha);
+
+                qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE,
+                    QLA82XX_DEV_INITIALIZING);
+
+                qla82xx_wr_32(ha, QLA82XX_CRB_DRV_IDC_VERSION,
+                    QLA82XX_IDC_VERSION);
+
+                drv_active = qla82xx_rd_32(ha, QLA82XX_CRB_DRV_ACTIVE);
+                DEBUG17(qla_printk(KERN_INFO, ha,
+                    "drv_active = 0x%x\n", drv_active));
+
+                qla82xx_idc_unlock(ha);
+                /* Reset if device is not already reset
+                 * drv_active would be 0 if a reset has already been done
+                 */
+                if (drv_active)
+                        rval = qla82xx_start_firmware(base_vha);
+                else
+                        rval = QLA_SUCCESS;
+                qla82xx_idc_lock(ha);
+
+                if (rval != QLA_SUCCESS) {
+                        qla_printk(KERN_INFO, ha, "HW State: FAILED\n");
+                        qla82xx_clear_drv_active(ha);
+                        qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE,
+                            QLA82XX_DEV_FAILED);
+                } else {
+                        qla_printk(KERN_INFO, ha, "HW State: READY\n");
+                        qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE,
+                            QLA82XX_DEV_READY);
+                        qla82xx_idc_unlock(ha);
+                        ha->flags.fw_hung = 0;
+                        rval = qla82xx_restart_isp(base_vha);
+                        qla82xx_idc_lock(ha);
+                        /* Clear driver state register */
+                        qla82xx_wr_32(ha, QLA82XX_CRB_DRV_STATE, 0);
+                        qla82xx_set_drv_active(base_vha);
+                }
+                qla82xx_idc_unlock(ha);
+        } else {
+                DEBUG17(qla_printk(KERN_INFO, ha,
+                    "This devfn is not reset owner = 0x%x\n", ha->pdev->devfn));
+                if ((qla82xx_rd_32(ha, QLA82XX_CRB_DEV_STATE) ==
+                    QLA82XX_DEV_READY)) {
+                        ha->flags.fw_hung = 0;
+                        rval = qla82xx_restart_isp(base_vha);
+                        qla82xx_idc_lock(ha);
+                        qla82xx_set_drv_active(base_vha);
+                        qla82xx_idc_unlock(ha);
+                }
+        }
+        clear_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
+
+        return rval;
+}
+
 static pci_ers_result_t
 qla2xxx_pci_slot_reset(struct pci_dev *pdev)
 {
@@ -3862,15 +3989,23 @@ qla2xxx_pci_slot_reset(struct pci_dev *pdev)
         if (rc) {
                 qla_printk(KERN_WARNING, ha,
                     "Can't re-enable PCI device after reset.\n");
-                return ret;
+                goto exit_slot_reset;
         }
 
         rsp = ha->rsp_q_map[0];
         if (qla2x00_request_irqs(ha, rsp))
-                return ret;
+                goto exit_slot_reset;
 
         if (ha->isp_ops->pci_config(base_vha))
-                return ret;
+                goto exit_slot_reset;
+
+        if (IS_QLA82XX(ha)) {
+                if (qla82xx_error_recovery(base_vha) == QLA_SUCCESS) {
+                        ret = PCI_ERS_RESULT_RECOVERED;
+                        goto exit_slot_reset;
+                } else
+                        goto exit_slot_reset;
+        }
 
         while (ha->flags.mbox_busy && retries--)
                 msleep(1000);
@@ -3881,6 +4016,7 @@ qla2xxx_pci_slot_reset(struct pci_dev *pdev)
         clear_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
 
 
+exit_slot_reset:
         DEBUG17(qla_printk(KERN_WARNING, ha,
             "slot_reset-return:ret=%x\n", ret));