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: (170 commits)
  [SCSI] scsi_dh_rdac: Add MD36xxf into device list
  [SCSI] scsi_debug: add consecutive medium errors
  [SCSI] libsas: fix ata list corruption issue
  [SCSI] hpsa: export resettable host attribute
  [SCSI] hpsa: move device attributes to avoid forward declarations
  [SCSI] scsi_debug: Logical Block Provisioning (SBC3r26)
  [SCSI] sd: Logical Block Provisioning update
  [SCSI] Include protection operation in SCSI command trace
  [SCSI] hpsa: fix incorrect PCI IDs and add two new ones (2nd try)
  [SCSI] target: Fix volume size misreporting for volumes > 2TB
  [SCSI] bnx2fc: Broadcom FCoE offload driver
  [SCSI] fcoe: fix broken fcoe interface reset
  [SCSI] fcoe: precedence bug in fcoe_filter_frames()
  [SCSI] libfcoe: Remove stale fcoe-netdev entries
  [SCSI] libfcoe: Move FCOE_MTU definition from fcoe.h to libfcoe.h
  [SCSI] libfc: introduce __fc_fill_fc_hdr that accepts fc_hdr as an argument
  [SCSI] fcoe, libfc: initialize EM anchors list and then update npiv EMs
  [SCSI] Revert "[SCSI] libfc: fix exchange being deleted when the abort itself is timed out"
  [SCSI] libfc: Fixing a memory leak when destroying an interface
  [SCSI] megaraid_sas: Version and Changelog update
  ...

Fix up trivial conflicts due to whitespace differences in
drivers/scsi/libsas/{sas_ata.c,sas_scsi_host.c}

9 files changed, 301 insertions, 120 deletions

diff --git a/drivers/scsi/qla2xxx/qla_def.h b/drivers/scsi/qla2xxx/qla_def.h
index ccfc8e78be21..6c51c0a35b9e 100644
--- a/drivers/scsi/qla2xxx/qla_def.h
+++ b/drivers/scsi/qla2xxx/qla_def.h
@@ -2402,13 +2402,13 @@ struct qla_hw_data {
         volatile struct {
                 uint32_t        mbox_int                :1;
                 uint32_t        mbox_busy               :1;
-
                 uint32_t        disable_risc_code_load  :1;
                 uint32_t        enable_64bit_addressing :1;
                 uint32_t        enable_lip_reset        :1;
                 uint32_t        enable_target_reset     :1;
                 uint32_t        enable_lip_full_login   :1;
                 uint32_t        enable_led_scheme       :1;
+
                 uint32_t        msi_enabled             :1;
                 uint32_t        msix_enabled            :1;
                 uint32_t        disable_serdes          :1;
@@ -2417,6 +2417,7 @@ struct qla_hw_data {
                 uint32_t        pci_channel_io_perm_failure     :1;
                 uint32_t        fce_enabled             :1;
                 uint32_t        fac_supported           :1;
+
                 uint32_t        chip_reset_done         :1;
                 uint32_t        port0                   :1;
                 uint32_t        running_gold_fw         :1;
@@ -2424,9 +2425,11 @@ struct qla_hw_data {
                 uint32_t        cpu_affinity_enabled    :1;
                 uint32_t        disable_msix_handshake  :1;
                 uint32_t        fcp_prio_enabled        :1;
-                uint32_t        fw_hung :1;
-                uint32_t        quiesce_owner:1;
+                uint32_t        isp82xx_fw_hung:1;
+
+                uint32_t        quiesce_owner:1;
                 uint32_t        thermal_supported:1;
+                uint32_t        isp82xx_reset_hdlr_active:1;
                 /* 26 bits */
         } flags;
 
diff --git a/drivers/scsi/qla2xxx/qla_gbl.h b/drivers/scsi/qla2xxx/qla_gbl.h
index 89e900adb679..d48326ee3f61 100644
--- a/drivers/scsi/qla2xxx/qla_gbl.h
+++ b/drivers/scsi/qla2xxx/qla_gbl.h
@@ -565,6 +565,7 @@ extern int qla82xx_mbx_intr_enable(scsi_qla_host_t *);
 extern int qla82xx_mbx_intr_disable(scsi_qla_host_t *);
 extern void qla82xx_start_iocbs(srb_t *);
 extern int qla82xx_fcoe_ctx_reset(scsi_qla_host_t *);
+extern void qla82xx_chip_reset_cleanup(scsi_qla_host_t *);
 
 /* BSG related functions */
 extern int qla24xx_bsg_request(struct fc_bsg_job *);
diff --git a/drivers/scsi/qla2xxx/qla_gs.c b/drivers/scsi/qla2xxx/qla_gs.c
index 4c083928c2fb..74a91b6dfc68 100644
--- a/drivers/scsi/qla2xxx/qla_gs.c
+++ b/drivers/scsi/qla2xxx/qla_gs.c
@@ -121,8 +121,11 @@ qla2x00_chk_ms_status(scsi_qla_host_t *vha, ms_iocb_entry_t *ms_pkt,
 
         rval = QLA_FUNCTION_FAILED;
         if (ms_pkt->entry_status != 0) {
-                DEBUG2_3(printk("scsi(%ld): %s failed, error status (%x).\n",
-                    vha->host_no, routine, ms_pkt->entry_status));
+                DEBUG2_3(printk(KERN_WARNING "scsi(%ld): %s failed, error status "
+                    "(%x) on port_id: %02x%02x%02x.\n",
+                    vha->host_no, routine, ms_pkt->entry_status,
+                    vha->d_id.b.domain, vha->d_id.b.area,
+                    vha->d_id.b.al_pa));
         } else {
                 if (IS_FWI2_CAPABLE(ha))
                         comp_status = le16_to_cpu(
@@ -136,8 +139,10 @@ qla2x00_chk_ms_status(scsi_qla_host_t *vha, ms_iocb_entry_t *ms_pkt,
                         if (ct_rsp->header.response !=
                             __constant_cpu_to_be16(CT_ACCEPT_RESPONSE)) {
                                 DEBUG2_3(printk("scsi(%ld): %s failed, "
-                                    "rejected request:\n", vha->host_no,
-                                    routine));
+                                    "rejected request on port_id: %02x%02x%02x\n",
+                                    vha->host_no, routine,
+                                    vha->d_id.b.domain, vha->d_id.b.area,
+                                    vha->d_id.b.al_pa));
                                 DEBUG2_3(qla2x00_dump_buffer(
                                     (uint8_t *)&ct_rsp->header,
                                     sizeof(struct ct_rsp_hdr)));
@@ -147,8 +152,10 @@ qla2x00_chk_ms_status(scsi_qla_host_t *vha, ms_iocb_entry_t *ms_pkt,
                         break;
                 default:
                         DEBUG2_3(printk("scsi(%ld): %s failed, completion "
-                            "status (%x).\n", vha->host_no, routine,
-                            comp_status));
+                            "status (%x) on port_id: %02x%02x%02x.\n",
+                            vha->host_no, routine, comp_status,
+                            vha->d_id.b.domain, vha->d_id.b.area,
+                            vha->d_id.b.al_pa));
                         break;
                 }
         }
@@ -1965,7 +1972,7 @@ qla2x00_gff_id(scsi_qla_host_t *vha, sw_info_t *list)
                             "scsi(%ld): GFF_ID issue IOCB failed "
                             "(%d).\n", vha->host_no, rval));
                 } else if (qla2x00_chk_ms_status(vha, ms_pkt, ct_rsp,
-                               "GPN_ID") != QLA_SUCCESS) {
+                               "GFF_ID") != QLA_SUCCESS) {
                         DEBUG2_3(printk(KERN_INFO
                             "scsi(%ld): GFF_ID IOCB status had a "
                             "failure status code\n", vha->host_no));
diff --git a/drivers/scsi/qla2xxx/qla_init.c b/drivers/scsi/qla2xxx/qla_init.c
index d9479c3fe5f8..8575808dbae0 100644
--- a/drivers/scsi/qla2xxx/qla_init.c
+++ b/drivers/scsi/qla2xxx/qla_init.c
@@ -1967,7 +1967,7 @@ qla2x00_fw_ready(scsi_qla_host_t *vha)
                 } else {
                         /* Mailbox cmd failed. Timeout on min_wait. */
                         if (time_after_eq(jiffies, mtime) ||
-                            (IS_QLA82XX(ha) && ha->flags.fw_hung))
+                                ha->flags.isp82xx_fw_hung)
                                 break;
                 }
 
@@ -3945,8 +3945,13 @@ qla2x00_abort_isp_cleanup(scsi_qla_host_t *vha)
         struct qla_hw_data *ha = vha->hw;
         struct scsi_qla_host *vp;
         unsigned long flags;
+        fc_port_t *fcport;
 
-        vha->flags.online = 0;
+        /* For ISP82XX, driver waits for completion of the commands.
+         * online flag should be set.
+         */
+        if (!IS_QLA82XX(ha))
+                vha->flags.online = 0;
         ha->flags.chip_reset_done = 0;
         clear_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
         ha->qla_stats.total_isp_aborts++;
@@ -3954,7 +3959,10 @@ qla2x00_abort_isp_cleanup(scsi_qla_host_t *vha)
         qla_printk(KERN_INFO, ha,
             "Performing ISP error recovery - ha= %p.\n", ha);
 
-        /* Chip reset does not apply to 82XX */
+        /* For ISP82XX, reset_chip is just disabling interrupts.
+         * Driver waits for the completion of the commands.
+         * the interrupts need to be enabled.
+         */
         if (!IS_QLA82XX(ha))
                 ha->isp_ops->reset_chip(vha);
 
@@ -3980,14 +3988,31 @@ qla2x00_abort_isp_cleanup(scsi_qla_host_t *vha)
                             LOOP_DOWN_TIME);
         }
 
+        /* Clear all async request states across all VPs. */
+        list_for_each_entry(fcport, &vha->vp_fcports, list)
+                fcport->flags &= ~(FCF_LOGIN_NEEDED | FCF_ASYNC_SENT);
+        spin_lock_irqsave(&ha->vport_slock, flags);
+        list_for_each_entry(vp, &ha->vp_list, list) {
+                atomic_inc(&vp->vref_count);
+                spin_unlock_irqrestore(&ha->vport_slock, flags);
+
+                list_for_each_entry(fcport, &vp->vp_fcports, list)
+                        fcport->flags &= ~(FCF_LOGIN_NEEDED | FCF_ASYNC_SENT);
+
+                spin_lock_irqsave(&ha->vport_slock, flags);
+                atomic_dec(&vp->vref_count);
+        }
+        spin_unlock_irqrestore(&ha->vport_slock, flags);
+
         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"));
-                        }
+                        qla82xx_chip_reset_cleanup(vha);
+
+                        /* Done waiting for pending commands.
+                         * Reset the online flag.
+                         */
+                        vha->flags.online = 0;
                 }
 
                 /* Requeue all commands in outstanding command list. */
diff --git a/drivers/scsi/qla2xxx/qla_iocb.c b/drivers/scsi/qla2xxx/qla_iocb.c
index 4c1ba6263eb3..d78d5896fc33 100644
--- a/drivers/scsi/qla2xxx/qla_iocb.c
+++ b/drivers/scsi/qla2xxx/qla_iocb.c
@@ -328,6 +328,7 @@ qla2x00_start_scsi(srb_t *sp)
         struct qla_hw_data *ha;
         struct req_que *req;
         struct rsp_que *rsp;
+        char            tag[2];
 
         /* Setup device pointers. */
         ret = 0;
@@ -406,7 +407,22 @@ qla2x00_start_scsi(srb_t *sp)
         cmd_pkt->lun = cpu_to_le16(sp->cmd->device->lun);
 
         /* Update tagged queuing modifier */
-        cmd_pkt->control_flags = __constant_cpu_to_le16(CF_SIMPLE_TAG);
+        if (scsi_populate_tag_msg(cmd, tag)) {
+                switch (tag[0]) {
+                case HEAD_OF_QUEUE_TAG:
+                        cmd_pkt->control_flags =
+                            __constant_cpu_to_le16(CF_HEAD_TAG);
+                        break;
+                case ORDERED_QUEUE_TAG:
+                        cmd_pkt->control_flags =
+                            __constant_cpu_to_le16(CF_ORDERED_TAG);
+                        break;
+                default:
+                        cmd_pkt->control_flags =
+                            __constant_cpu_to_le16(CF_SIMPLE_TAG);
+                        break;
+                }
+        }
 
         /* Load SCSI command packet. */
         memcpy(cmd_pkt->scsi_cdb, cmd->cmnd, cmd->cmd_len);
@@ -971,6 +987,7 @@ qla24xx_build_scsi_crc_2_iocbs(srb_t *sp, struct cmd_type_crc_2 *cmd_pkt,
         uint16_t                fcp_cmnd_len;
         struct fcp_cmnd         *fcp_cmnd;
         dma_addr_t              crc_ctx_dma;
+        char                    tag[2];
 
         cmd = sp->cmd;
 
@@ -1068,9 +1085,27 @@ qla24xx_build_scsi_crc_2_iocbs(srb_t *sp, struct cmd_type_crc_2 *cmd_pkt,
             LSD(crc_ctx_dma + CRC_CONTEXT_FCPCMND_OFF));
         cmd_pkt->fcp_cmnd_dseg_address[1] = cpu_to_le32(
             MSD(crc_ctx_dma + CRC_CONTEXT_FCPCMND_OFF));
-        fcp_cmnd->task_attribute = 0;
         fcp_cmnd->task_management = 0;
 
+        /*
+         * Update tagged queuing modifier if using command tag queuing
+         */
+        if (scsi_populate_tag_msg(cmd, tag)) {
+                switch (tag[0]) {
+                case HEAD_OF_QUEUE_TAG:
+                    fcp_cmnd->task_attribute = TSK_HEAD_OF_QUEUE;
+                    break;
+                case ORDERED_QUEUE_TAG:
+                    fcp_cmnd->task_attribute = TSK_ORDERED;
+                    break;
+                default:
+                    fcp_cmnd->task_attribute = 0;
+                    break;
+                }
+        } else {
+                fcp_cmnd->task_attribute = 0;
+        }
+
         cmd_pkt->fcp_rsp_dseg_len = 0; /* Let response come in status iocb */
 
         DEBUG18(printk(KERN_INFO "%s(%ld): Total SG(s) Entries %d, Data"
@@ -1177,6 +1212,7 @@ qla24xx_start_scsi(srb_t *sp)
         struct scsi_cmnd *cmd = sp->cmd;
         struct scsi_qla_host *vha = sp->fcport->vha;
         struct qla_hw_data *ha = vha->hw;
+        char            tag[2];
 
         /* Setup device pointers. */
         ret = 0;
@@ -1260,6 +1296,18 @@ qla24xx_start_scsi(srb_t *sp)
         int_to_scsilun(sp->cmd->device->lun, &cmd_pkt->lun);
         host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun));
 
+        /* Update tagged queuing modifier -- default is TSK_SIMPLE (0). */
+        if (scsi_populate_tag_msg(cmd, tag)) {
+                switch (tag[0]) {
+                case HEAD_OF_QUEUE_TAG:
+                        cmd_pkt->task = TSK_HEAD_OF_QUEUE;
+                        break;
+                case ORDERED_QUEUE_TAG:
+                        cmd_pkt->task = TSK_ORDERED;
+                        break;
+                }
+        }
+
         /* Load SCSI command packet. */
         memcpy(cmd_pkt->fcp_cdb, cmd->cmnd, cmd->cmd_len);
         host_to_fcp_swap(cmd_pkt->fcp_cdb, sizeof(cmd_pkt->fcp_cdb));
diff --git a/drivers/scsi/qla2xxx/qla_mbx.c b/drivers/scsi/qla2xxx/qla_mbx.c
index e473e9fb363c..7a7c0ecfe7dd 100644
--- a/drivers/scsi/qla2xxx/qla_mbx.c
+++ b/drivers/scsi/qla2xxx/qla_mbx.c
@@ -71,6 +71,13 @@ qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)
                 return QLA_FUNCTION_TIMEOUT;
         }
 
+        if (ha->flags.isp82xx_fw_hung) {
+                /* Setting Link-Down error */
+                mcp->mb[0] = MBS_LINK_DOWN_ERROR;
+                rval = QLA_FUNCTION_FAILED;
+                goto premature_exit;
+        }
+
         /*
          * Wait for active mailbox commands to finish by waiting at most tov
          * seconds. This is to serialize actual issuing of mailbox cmds during
@@ -83,13 +90,6 @@ qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)
                 return QLA_FUNCTION_TIMEOUT;
         }
 
-        if (IS_QLA82XX(ha) && ha->flags.fw_hung) {
-                /* Setting Link-Down error */
-                mcp->mb[0] = MBS_LINK_DOWN_ERROR;
-                rval = QLA_FUNCTION_FAILED;
-                goto premature_exit;
-        }
-
         ha->flags.mbox_busy = 1;
         /* Save mailbox command for debug */
         ha->mcp = mcp;
@@ -223,7 +223,7 @@ qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)
                 ha->flags.mbox_int = 0;
                 clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
 
-                if (IS_QLA82XX(ha) && ha->flags.fw_hung) {
+                if (ha->flags.isp82xx_fw_hung) {
                         ha->flags.mbox_busy = 0;
                         /* Setting Link-Down error */
                         mcp->mb[0] = MBS_LINK_DOWN_ERROR;
@@ -2462,22 +2462,19 @@ __qla24xx_issue_tmf(char *name, uint32_t type, struct fc_port *fcport,
                     "-- completion status (%x).\n", __func__,
                     vha->host_no, le16_to_cpu(sts->comp_status)));
                 rval = QLA_FUNCTION_FAILED;
-        } else if (!(le16_to_cpu(sts->scsi_status) &
-            SS_RESPONSE_INFO_LEN_VALID)) {
-                DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
-                    "-- no response info (%x).\n", __func__, vha->host_no,
-                    le16_to_cpu(sts->scsi_status)));
-                rval = QLA_FUNCTION_FAILED;
-        } else if (le32_to_cpu(sts->rsp_data_len) < 4) {
-                DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
-                    "-- not enough response info (%d).\n", __func__,
-                    vha->host_no, le32_to_cpu(sts->rsp_data_len)));
-                rval = QLA_FUNCTION_FAILED;
-        } else if (sts->data[3]) {
-                DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
-                    "-- response (%x).\n", __func__,
-                    vha->host_no, sts->data[3]));
-                rval = QLA_FUNCTION_FAILED;
+        } else if (le16_to_cpu(sts->scsi_status) &
+            SS_RESPONSE_INFO_LEN_VALID) {
+                if (le32_to_cpu(sts->rsp_data_len) < 4) {
+                        DEBUG2_3_11(printk("%s(%ld): ignoring inconsistent "
+                            "data length -- not enough response info (%d).\n",
+                            __func__, vha->host_no,
+                            le32_to_cpu(sts->rsp_data_len)));
+                } else if (sts->data[3]) {
+                        DEBUG2_3_11(printk("%s(%ld): failed to complete IOCB "
+                            "-- response (%x).\n", __func__,
+                            vha->host_no, sts->data[3]));
+                        rval = QLA_FUNCTION_FAILED;
+                }
         }
 
         /* Issue marker IOCB. */
diff --git a/drivers/scsi/qla2xxx/qla_nx.c b/drivers/scsi/qla2xxx/qla_nx.c
index fdb96a3584a5..76ec876e6b21 100644
--- a/drivers/scsi/qla2xxx/qla_nx.c
+++ b/drivers/scsi/qla2xxx/qla_nx.c
@@ -7,6 +7,7 @@
 #include "qla_def.h"
 #include <linux/delay.h>
 #include <linux/pci.h>
+#include <scsi/scsi_tcq.h>
 
 #define MASK(n)                 ((1ULL<<(n))-1)
 #define MN_WIN(addr) (((addr & 0x1fc0000) >> 1) | \
@@ -2547,7 +2548,7 @@ qla2xx_build_scsi_type_6_iocbs(srb_t *sp, struct cmd_type_6 *cmd_pkt,
                         dsd_seg = (uint32_t *)&cmd_pkt->fcp_data_dseg_address;
                         *dsd_seg++ = cpu_to_le32(LSD(dsd_ptr->dsd_list_dma));
                         *dsd_seg++ = cpu_to_le32(MSD(dsd_ptr->dsd_list_dma));
-                        *dsd_seg++ = dsd_list_len;
+                        cmd_pkt->fcp_data_dseg_len = dsd_list_len;
                 } else {
                         *cur_dsd++ = cpu_to_le32(LSD(dsd_ptr->dsd_list_dma));
                         *cur_dsd++ = cpu_to_le32(MSD(dsd_ptr->dsd_list_dma));
@@ -2620,6 +2621,7 @@ qla82xx_start_scsi(srb_t *sp)
         struct qla_hw_data *ha = vha->hw;
         struct req_que *req = NULL;
         struct rsp_que *rsp = NULL;
+        char            tag[2];
 
         /* Setup device pointers. */
         ret = 0;
@@ -2770,6 +2772,22 @@ sufficient_dsds:
                 int_to_scsilun(sp->cmd->device->lun, &cmd_pkt->lun);
                 host_to_fcp_swap((uint8_t *)&cmd_pkt->lun, sizeof(cmd_pkt->lun));
 
+                /*
+                 * Update tagged queuing modifier -- default is TSK_SIMPLE (0).
+                 */
+                if (scsi_populate_tag_msg(cmd, tag)) {
+                        switch (tag[0]) {
+                        case HEAD_OF_QUEUE_TAG:
+                                ctx->fcp_cmnd->task_attribute =
+                                    TSK_HEAD_OF_QUEUE;
+                                break;
+                        case ORDERED_QUEUE_TAG:
+                                ctx->fcp_cmnd->task_attribute =
+                                    TSK_ORDERED;
+                                break;
+                        }
+                }
+
                 /* build FCP_CMND IU */
                 memset(ctx->fcp_cmnd, 0, sizeof(struct fcp_cmnd));
                 int_to_scsilun(sp->cmd->device->lun, &ctx->fcp_cmnd->lun);
@@ -2835,6 +2853,20 @@ sufficient_dsds:
                 host_to_fcp_swap((uint8_t *)&cmd_pkt->lun,
                         sizeof(cmd_pkt->lun));
 
+                /*
+                 * Update tagged queuing modifier -- default is TSK_SIMPLE (0).
+                 */
+                if (scsi_populate_tag_msg(cmd, tag)) {
+                        switch (tag[0]) {
+                        case HEAD_OF_QUEUE_TAG:
+                                cmd_pkt->task = TSK_HEAD_OF_QUEUE;
+                                break;
+                        case ORDERED_QUEUE_TAG:
+                                cmd_pkt->task = TSK_ORDERED;
+                                break;
+                        }
+                }
+
                 /* Load SCSI command packet. */
                 memcpy(cmd_pkt->fcp_cdb, cmd->cmnd, cmd->cmd_len);
                 host_to_fcp_swap(cmd_pkt->fcp_cdb, sizeof(cmd_pkt->fcp_cdb));
@@ -3457,46 +3489,28 @@ qla82xx_need_reset_handler(scsi_qla_host_t *vha)
         }
 }
 
-static void
+int
 qla82xx_check_fw_alive(scsi_qla_host_t *vha)
 {
-        uint32_t fw_heartbeat_counter, halt_status;
-        struct qla_hw_data *ha = vha->hw;
+        uint32_t fw_heartbeat_counter;
+        int status = 0;
 
-        fw_heartbeat_counter = qla82xx_rd_32(ha, QLA82XX_PEG_ALIVE_COUNTER);
+        fw_heartbeat_counter = qla82xx_rd_32(vha->hw,
+                QLA82XX_PEG_ALIVE_COUNTER);
         /* all 0xff, assume AER/EEH in progress, ignore */
         if (fw_heartbeat_counter == 0xffffffff)
-                return;
+                return status;
         if (vha->fw_heartbeat_counter == fw_heartbeat_counter) {
                 vha->seconds_since_last_heartbeat++;
                 /* FW not alive after 2 seconds */
                 if (vha->seconds_since_last_heartbeat == 2) {
                         vha->seconds_since_last_heartbeat = 0;
-                        halt_status = qla82xx_rd_32(ha,
-                                QLA82XX_PEG_HALT_STATUS1);
-                        if (halt_status & HALT_STATUS_UNRECOVERABLE) {
-                                set_bit(ISP_UNRECOVERABLE, &vha->dpc_flags);
-                        } else {
-                                qla_printk(KERN_INFO, ha,
-                                        "scsi(%ld): %s - detect abort needed\n",
-                                        vha->host_no, __func__);
-                                set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
-                        }
-                        qla2xxx_wake_dpc(vha);
-                        ha->flags.fw_hung = 1;
-                        if (ha->flags.mbox_busy) {
-                                ha->flags.mbox_int = 1;
-                                DEBUG2(qla_printk(KERN_ERR, ha,
-                                        "Due to fw hung, doing premature "
-                                        "completion of mbx command\n"));
-                                if (test_bit(MBX_INTR_WAIT,
-                                        &ha->mbx_cmd_flags))
-                                        complete(&ha->mbx_intr_comp);
-                        }
+                        status = 1;
                 }
         } else
                 vha->seconds_since_last_heartbeat = 0;
         vha->fw_heartbeat_counter = fw_heartbeat_counter;
+        return status;
 }
 
 /*
@@ -3557,6 +3571,8 @@ qla82xx_device_state_handler(scsi_qla_host_t *vha)
                         break;
                 case QLA82XX_DEV_NEED_RESET:
                         qla82xx_need_reset_handler(vha);
+                        dev_init_timeout = jiffies +
+                                (ha->nx_dev_init_timeout * HZ);
                         break;
                 case QLA82XX_DEV_NEED_QUIESCENT:
                         qla82xx_need_qsnt_handler(vha);
@@ -3596,30 +3612,18 @@ exit:
 
 void qla82xx_watchdog(scsi_qla_host_t *vha)
 {
-        uint32_t dev_state;
+        uint32_t dev_state, halt_status;
         struct qla_hw_data *ha = vha->hw;
 
-        dev_state = qla82xx_rd_32(ha, QLA82XX_CRB_DEV_STATE);
-
         /* don't poll if reset is going on */
-        if (!(test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags) ||
-                test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags) ||
-                test_bit(ISP_ABORT_RETRY, &vha->dpc_flags))) {
-                if (dev_state == QLA82XX_DEV_NEED_RESET) {
+        if (!ha->flags.isp82xx_reset_hdlr_active) {
+                dev_state = qla82xx_rd_32(ha, QLA82XX_CRB_DEV_STATE);
+                if (dev_state == QLA82XX_DEV_NEED_RESET &&
+                    !test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags)) {
                         qla_printk(KERN_WARNING, ha,
-                                "%s(): Adapter reset needed!\n", __func__);
+                            "%s(): Adapter reset needed!\n", __func__);
                         set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
                         qla2xxx_wake_dpc(vha);
-                        ha->flags.fw_hung = 1;
-                        if (ha->flags.mbox_busy) {
-                                ha->flags.mbox_int = 1;
-                                DEBUG2(qla_printk(KERN_ERR, ha,
-                                        "Need reset, doing premature "
-                                        "completion of mbx command\n"));
-                                if (test_bit(MBX_INTR_WAIT,
-                                        &ha->mbx_cmd_flags))
-                                        complete(&ha->mbx_intr_comp);
-                        }
                 } else if (dev_state == QLA82XX_DEV_NEED_QUIESCENT &&
                         !test_bit(ISP_QUIESCE_NEEDED, &vha->dpc_flags)) {
                         DEBUG(qla_printk(KERN_INFO, ha,
@@ -3629,6 +3633,31 @@ void qla82xx_watchdog(scsi_qla_host_t *vha)
                         qla2xxx_wake_dpc(vha);
                 } else {
                         qla82xx_check_fw_alive(vha);
+                        if (qla82xx_check_fw_alive(vha)) {
+                                halt_status = qla82xx_rd_32(ha,
+                                    QLA82XX_PEG_HALT_STATUS1);
+                                if (halt_status & HALT_STATUS_UNRECOVERABLE) {
+                                        set_bit(ISP_UNRECOVERABLE,
+                                            &vha->dpc_flags);
+                                } else {
+                                        qla_printk(KERN_INFO, ha,
+                                            "scsi(%ld): %s - detect abort needed\n",
+                                            vha->host_no, __func__);
+                                        set_bit(ISP_ABORT_NEEDED,
+                                            &vha->dpc_flags);
+                                }
+                                qla2xxx_wake_dpc(vha);
+                                ha->flags.isp82xx_fw_hung = 1;
+                                if (ha->flags.mbox_busy) {
+                                        ha->flags.mbox_int = 1;
+                                        DEBUG2(qla_printk(KERN_ERR, ha,
+                                            "Due to fw hung, doing premature "
+                                            "completion of mbx command\n"));
+                                        if (test_bit(MBX_INTR_WAIT,
+                                            &ha->mbx_cmd_flags))
+                                                complete(&ha->mbx_intr_comp);
+                                }
+                        }
                 }
         }
 }
@@ -3663,6 +3692,7 @@ qla82xx_abort_isp(scsi_qla_host_t *vha)
                         "Exiting.\n", __func__, vha->host_no);
                 return QLA_SUCCESS;
         }
+        ha->flags.isp82xx_reset_hdlr_active = 1;
 
         qla82xx_idc_lock(ha);
         dev_state = qla82xx_rd_32(ha, QLA82XX_CRB_DEV_STATE);
@@ -3683,7 +3713,8 @@ qla82xx_abort_isp(scsi_qla_host_t *vha)
         qla82xx_idc_unlock(ha);
 
         if (rval == QLA_SUCCESS) {
-                ha->flags.fw_hung = 0;
+                ha->flags.isp82xx_fw_hung = 0;
+                ha->flags.isp82xx_reset_hdlr_active = 0;
                 qla82xx_restart_isp(vha);
         }
 
@@ -3791,3 +3822,71 @@ int qla2x00_wait_for_fcoe_ctx_reset(scsi_qla_host_t *vha)
 
         return status;
 }
+
+void
+qla82xx_chip_reset_cleanup(scsi_qla_host_t *vha)
+{
+        int i;
+        unsigned long flags;
+        struct qla_hw_data *ha = vha->hw;
+
+        /* Check if 82XX firmware is alive or not
+         * We may have arrived here from NEED_RESET
+         * detection only
+         */
+        if (!ha->flags.isp82xx_fw_hung) {
+                for (i = 0; i < 2; i++) {
+                        msleep(1000);
+                        if (qla82xx_check_fw_alive(vha)) {
+                                ha->flags.isp82xx_fw_hung = 1;
+                                if (ha->flags.mbox_busy) {
+                                        ha->flags.mbox_int = 1;
+                                        complete(&ha->mbx_intr_comp);
+                                }
+                                break;
+                        }
+                }
+        }
+
+        /* Abort all commands gracefully if fw NOT hung */
+        if (!ha->flags.isp82xx_fw_hung) {
+                int cnt, que;
+                srb_t *sp;
+                struct req_que *req;
+
+                spin_lock_irqsave(&ha->hardware_lock, flags);
+                for (que = 0; que < ha->max_req_queues; que++) {
+                        req = ha->req_q_map[que];
+                        if (!req)
+                                continue;
+                        for (cnt = 1; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
+                                sp = req->outstanding_cmds[cnt];
+                                if (sp) {
+                                        if (!sp->ctx ||
+                                            (sp->flags & SRB_FCP_CMND_DMA_VALID)) {
+                                                spin_unlock_irqrestore(
+                                                    &ha->hardware_lock, flags);
+                                                if (ha->isp_ops->abort_command(sp)) {
+                                                        qla_printk(KERN_INFO, ha,
+                                                            "scsi(%ld): mbx abort command failed in %s\n",
+                                                            vha->host_no, __func__);
+                                                } else {
+                                                        qla_printk(KERN_INFO, ha,
+                                                            "scsi(%ld): mbx abort command success in %s\n",
+                                                            vha->host_no, __func__);
+                                                }
+                                                spin_lock_irqsave(&ha->hardware_lock, flags);
+                                        }
+                                }
+                        }
+                }
+                spin_unlock_irqrestore(&ha->hardware_lock, flags);
+
+                /* Wait for pending cmds (physical and virtual) to complete */
+                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"));
+                }
+        }
+}
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index e90f7c16b956..75a966c94860 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -506,7 +506,7 @@ qla24xx_fw_version_str(struct scsi_qla_host *vha, char *str)
 
 static inline srb_t *
 qla2x00_get_new_sp(scsi_qla_host_t *vha, fc_port_t *fcport,
-    struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
+        struct scsi_cmnd *cmd)
 {
         srb_t *sp;
         struct qla_hw_data *ha = vha->hw;
@@ -520,14 +520,13 @@ qla2x00_get_new_sp(scsi_qla_host_t *vha, fc_port_t *fcport,
         sp->cmd = cmd;
         sp->flags = 0;
         CMD_SP(cmd) = (void *)sp;
-        cmd->scsi_done = done;
         sp->ctx = NULL;
 
         return sp;
 }
 
 static int
-qla2xxx_queuecommand_lck(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *))
+qla2xxx_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
 {
         scsi_qla_host_t *vha = shost_priv(cmd->device->host);
         fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata;
@@ -537,7 +536,6 @@ qla2xxx_queuecommand_lck(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *)
         srb_t *sp;
         int rval;
 
-        spin_unlock_irq(vha->host->host_lock);
         if (ha->flags.eeh_busy) {
                 if (ha->flags.pci_channel_io_perm_failure)
                         cmd->result = DID_NO_CONNECT << 16;
@@ -569,40 +567,32 @@ qla2xxx_queuecommand_lck(struct scsi_cmnd *cmd, void (*done)(struct scsi_cmnd *)
                 goto qc24_target_busy;
         }
 
-        sp = qla2x00_get_new_sp(base_vha, fcport, cmd, done);
+        sp = qla2x00_get_new_sp(base_vha, fcport, cmd);
         if (!sp)
-                goto qc24_host_busy_lock;
+                goto qc24_host_busy;
 
         rval = ha->isp_ops->start_scsi(sp);
         if (rval != QLA_SUCCESS)
                 goto qc24_host_busy_free_sp;
 
-        spin_lock_irq(vha->host->host_lock);
-
         return 0;
 
 qc24_host_busy_free_sp:
         qla2x00_sp_free_dma(sp);
         mempool_free(sp, ha->srb_mempool);
 
-qc24_host_busy_lock:
-        spin_lock_irq(vha->host->host_lock);
+qc24_host_busy:
         return SCSI_MLQUEUE_HOST_BUSY;
 
 qc24_target_busy:
-        spin_lock_irq(vha->host->host_lock);
         return SCSI_MLQUEUE_TARGET_BUSY;
 
 qc24_fail_command:
-        spin_lock_irq(vha->host->host_lock);
-        done(cmd);
+        cmd->scsi_done(cmd);
 
         return 0;
 }
 
-static DEF_SCSI_QCMD(qla2xxx_queuecommand)
-
-
 /*
  * qla2x00_eh_wait_on_command
  *    Waits for the command to be returned by the Firmware for some
@@ -821,17 +811,20 @@ qla2xxx_eh_abort(struct scsi_cmnd *cmd)
 {
         scsi_qla_host_t *vha = shost_priv(cmd->device->host);
         srb_t *sp;
-        int ret = SUCCESS;
+        int ret;
         unsigned int id, lun;
         unsigned long flags;
         int wait = 0;
         struct qla_hw_data *ha = vha->hw;
 
-        fc_block_scsi_eh(cmd);
-
         if (!CMD_SP(cmd))
                 return SUCCESS;
 
+        ret = fc_block_scsi_eh(cmd);
+        if (ret != 0)
+                return ret;
+        ret = SUCCESS;
+
         id = cmd->device->id;
         lun = cmd->device->lun;
 
@@ -940,11 +933,13 @@ __qla2xxx_eh_generic_reset(char *name, enum nexus_wait_type type,
         fc_port_t *fcport = (struct fc_port *) cmd->device->hostdata;
         int err;
 
-        fc_block_scsi_eh(cmd);
-
         if (!fcport)
                 return FAILED;
 
+        err = fc_block_scsi_eh(cmd);
+        if (err != 0)
+                return err;
+
         qla_printk(KERN_INFO, vha->hw, "scsi(%ld:%d:%d): %s RESET ISSUED.\n",
             vha->host_no, cmd->device->id, cmd->device->lun, name);
 
@@ -1018,14 +1013,17 @@ qla2xxx_eh_bus_reset(struct scsi_cmnd *cmd)
         int ret = FAILED;
         unsigned int id, lun;
 
-        fc_block_scsi_eh(cmd);
-
         id = cmd->device->id;
         lun = cmd->device->lun;
 
         if (!fcport)
                 return ret;
 
+        ret = fc_block_scsi_eh(cmd);
+        if (ret != 0)
+                return ret;
+        ret = FAILED;
+
         qla_printk(KERN_INFO, vha->hw,
             "scsi(%ld:%d:%d): BUS RESET ISSUED.\n", vha->host_no, id, lun);
 
@@ -1078,14 +1076,17 @@ qla2xxx_eh_host_reset(struct scsi_cmnd *cmd)
         unsigned int id, lun;
         scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
 
-        fc_block_scsi_eh(cmd);
-
         id = cmd->device->id;
         lun = cmd->device->lun;
 
         if (!fcport)
                 return ret;
 
+        ret = fc_block_scsi_eh(cmd);
+        if (ret != 0)
+                return ret;
+        ret = FAILED;
+
         qla_printk(KERN_INFO, ha,
             "scsi(%ld:%d:%d): ADAPTER RESET ISSUED.\n", vha->host_no, id, lun);
 
@@ -3805,7 +3806,7 @@ qla2xxx_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
                 ha->flags.eeh_busy = 1;
                 /* For ISP82XX complete any pending mailbox cmd */
                 if (IS_QLA82XX(ha)) {
-                        ha->flags.fw_hung = 1;
+                        ha->flags.isp82xx_fw_hung = 1;
                         if (ha->flags.mbox_busy) {
                                 ha->flags.mbox_int = 1;
                                 DEBUG2(qla_printk(KERN_ERR, ha,
@@ -3945,7 +3946,7 @@ uint32_t qla82xx_error_recovery(scsi_qla_host_t *base_vha)
                         qla82xx_wr_32(ha, QLA82XX_CRB_DEV_STATE,
                             QLA82XX_DEV_READY);
                         qla82xx_idc_unlock(ha);
-                        ha->flags.fw_hung = 0;
+                        ha->flags.isp82xx_fw_hung = 0;
                         rval = qla82xx_restart_isp(base_vha);
                         qla82xx_idc_lock(ha);
                         /* Clear driver state register */
@@ -3958,7 +3959,7 @@ uint32_t qla82xx_error_recovery(scsi_qla_host_t *base_vha)
                     "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;
+                        ha->flags.isp82xx_fw_hung = 0;
                         rval = qla82xx_restart_isp(base_vha);
                         qla82xx_idc_lock(ha);
                         qla82xx_set_drv_active(base_vha);
diff --git a/drivers/scsi/qla2xxx/qla_version.h b/drivers/scsi/qla2xxx/qla_version.h
index cf0075a2d0c2..3a260c3f055a 100644
--- a/drivers/scsi/qla2xxx/qla_version.h
+++ b/drivers/scsi/qla2xxx/qla_version.h
@@ -7,9 +7,9 @@
 /*
  * Driver version
  */
-#define QLA2XXX_VERSION      "8.03.05-k0"
+#define QLA2XXX_VERSION      "8.03.07.00"
 
 #define QLA_DRIVER_MAJOR_VER    8
 #define QLA_DRIVER_MINOR_VER    3
-#define QLA_DRIVER_PATCH_VER    5
+#define QLA_DRIVER_PATCH_VER    7
 #define QLA_DRIVER_BETA_VER     0