7 files changed, 221 insertions, 86 deletions

diff --git a/drivers/scsi/be2iscsi/be.h b/drivers/scsi/be2iscsi/be.h
index 2e28f6c419fe..1bfb0bd01198 100644
--- a/drivers/scsi/be2iscsi/be.h
+++ b/drivers/scsi/be2iscsi/be.h
@@ -98,6 +98,14 @@ struct be_mcc_obj {
         struct be_queue_info cq;
 };
 
+struct beiscsi_mcc_tag_state {
+#define MCC_TAG_STATE_COMPLETED 0x00
+#define MCC_TAG_STATE_RUNNING   0x01
+#define MCC_TAG_STATE_TIMEOUT   0x02
+        uint8_t tag_state;
+        struct be_dma_mem tag_mem_state;
+};
+
 struct be_ctrl_info {
         u8 __iomem *csr;
         u8 __iomem *db;         /* Door Bell */
@@ -122,6 +130,8 @@ struct be_ctrl_info {
         unsigned short mcc_alloc_index;
         unsigned short mcc_free_index;
         unsigned int mcc_tag_available;
+
+        struct beiscsi_mcc_tag_state ptag_state[MAX_MCC_CMD + 1];
 };
 
 #include "be_cmds.h"
@@ -129,6 +139,7 @@ struct be_ctrl_info {
 #define PAGE_SHIFT_4K 12
 #define PAGE_SIZE_4K (1 << PAGE_SHIFT_4K)
 #define mcc_timeout             120000 /* 12s timeout */
+#define BEISCSI_LOGOUT_SYNC_DELAY       250
 
 /* Returns number of pages spanned by the data starting at the given addr */
 #define PAGES_4K_SPANNED(_address, size)                                \
diff --git a/drivers/scsi/be2iscsi/be_cmds.c b/drivers/scsi/be2iscsi/be_cmds.c
index 3338391b64de..1432ed5e9fc6 100644
--- a/drivers/scsi/be2iscsi/be_cmds.c
+++ b/drivers/scsi/be2iscsi/be_cmds.c
@@ -138,7 +138,7 @@ unsigned int alloc_mcc_tag(struct beiscsi_hba *phba)
  * @phba: Driver private structure
  * @tag: Tag for the MBX Command
  * @wrb: the WRB used for the MBX Command
- * @cmd_hdr: IOCTL Hdr for the MBX Cmd
+ * @mbx_cmd_mem: ptr to memory allocated for MBX Cmd
  *
  * Waits for MBX completion with the passed TAG.
  *
@@ -148,21 +148,26 @@ unsigned int alloc_mcc_tag(struct beiscsi_hba *phba)
  **/
 int beiscsi_mccq_compl(struct beiscsi_hba *phba,
                 uint32_t tag, struct be_mcc_wrb **wrb,
-                void *cmd_hdr)
+                struct be_dma_mem *mbx_cmd_mem)
 {
         int rc = 0;
         uint32_t mcc_tag_response;
         uint16_t status = 0, addl_status = 0, wrb_num = 0;
         struct be_mcc_wrb *temp_wrb;
-        struct be_cmd_req_hdr *ioctl_hdr;
-        struct be_cmd_resp_hdr *ioctl_resp_hdr;
+        struct be_cmd_req_hdr *mbx_hdr;
+        struct be_cmd_resp_hdr *mbx_resp_hdr;
         struct be_queue_info *mccq = &phba->ctrl.mcc_obj.q;
 
         if (beiscsi_error(phba)) {
                 free_mcc_tag(&phba->ctrl, tag);
-                return -EIO;
+                return -EPERM;
         }
 
+        /* Set MBX Tag state to Active */
+        spin_lock(&phba->ctrl.mbox_lock);
+        phba->ctrl.ptag_state[tag].tag_state = MCC_TAG_STATE_RUNNING;
+        spin_unlock(&phba->ctrl.mbox_lock);
+
         /* wait for the mccq completion */
         rc = wait_event_interruptible_timeout(
                                 phba->ctrl.mcc_wait[tag],
@@ -171,56 +176,71 @@ int beiscsi_mccq_compl(struct beiscsi_hba *phba,
                                 BEISCSI_HOST_MBX_TIMEOUT));
 
         if (rc <= 0) {
+                struct be_dma_mem *tag_mem;
+                /* Set MBX Tag state to timeout */
+                spin_lock(&phba->ctrl.mbox_lock);
+                phba->ctrl.ptag_state[tag].tag_state = MCC_TAG_STATE_TIMEOUT;
+                spin_unlock(&phba->ctrl.mbox_lock);
+
+                /* Store resource addr to be freed later */
+                tag_mem = &phba->ctrl.ptag_state[tag].tag_mem_state;
+                if (mbx_cmd_mem) {
+                        tag_mem->size = mbx_cmd_mem->size;
+                        tag_mem->va = mbx_cmd_mem->va;
+                        tag_mem->dma = mbx_cmd_mem->dma;
+                } else
+                        tag_mem->size = 0;
+
                 beiscsi_log(phba, KERN_ERR,
                             BEISCSI_LOG_INIT | BEISCSI_LOG_EH |
                             BEISCSI_LOG_CONFIG,
                             "BC_%d : MBX Cmd Completion timed out\n");
-                rc = -EBUSY;
-
-                /* decrement the mccq used count */
-                atomic_dec(&phba->ctrl.mcc_obj.q.used);
-
-                goto release_mcc_tag;
-        } else
+                return -EBUSY;
+        } else {
                 rc = 0;
+                /* Set MBX Tag state to completed */
+                spin_lock(&phba->ctrl.mbox_lock);
+                phba->ctrl.ptag_state[tag].tag_state = MCC_TAG_STATE_COMPLETED;
+                spin_unlock(&phba->ctrl.mbox_lock);
+        }
 
         mcc_tag_response = phba->ctrl.mcc_numtag[tag];
         status = (mcc_tag_response & CQE_STATUS_MASK);
         addl_status = ((mcc_tag_response & CQE_STATUS_ADDL_MASK) >>
                         CQE_STATUS_ADDL_SHIFT);
 
-        if (cmd_hdr) {
-                ioctl_hdr = (struct be_cmd_req_hdr *)cmd_hdr;
+        if (mbx_cmd_mem) {
+                mbx_hdr = (struct be_cmd_req_hdr *)mbx_cmd_mem->va;
         } else {
                 wrb_num = (mcc_tag_response & CQE_STATUS_WRB_MASK) >>
                            CQE_STATUS_WRB_SHIFT;
                 temp_wrb = (struct be_mcc_wrb *)queue_get_wrb(mccq, wrb_num);
-                ioctl_hdr = embedded_payload(temp_wrb);
+                mbx_hdr = embedded_payload(temp_wrb);
 
                 if (wrb)
                         *wrb = temp_wrb;
         }
 
         if (status || addl_status) {
-                beiscsi_log(phba, KERN_ERR,
+                beiscsi_log(phba, KERN_WARNING,
                             BEISCSI_LOG_INIT | BEISCSI_LOG_EH |
                             BEISCSI_LOG_CONFIG,
                             "BC_%d : MBX Cmd Failed for "
                             "Subsys : %d Opcode : %d with "
                             "Status : %d and Extd_Status : %d\n",
-                            ioctl_hdr->subsystem,
-                            ioctl_hdr->opcode,
+                            mbx_hdr->subsystem,
+                            mbx_hdr->opcode,
                             status, addl_status);
 
                 if (status == MCC_STATUS_INSUFFICIENT_BUFFER) {
-                        ioctl_resp_hdr = (struct be_cmd_resp_hdr *) ioctl_hdr;
+                        mbx_resp_hdr = (struct be_cmd_resp_hdr *) mbx_hdr;
                         beiscsi_log(phba, KERN_WARNING,
                                     BEISCSI_LOG_INIT | BEISCSI_LOG_EH |
                                     BEISCSI_LOG_CONFIG,
                                     "BC_%d : Insufficent Buffer Error "
                                     "Resp_Len : %d Actual_Resp_Len : %d\n",
-                                    ioctl_resp_hdr->response_length,
-                                    ioctl_resp_hdr->actual_resp_len);
+                                    mbx_resp_hdr->response_length,
+                                    mbx_resp_hdr->actual_resp_len);
 
                         rc = -EAGAIN;
                         goto release_mcc_tag;
@@ -319,6 +339,7 @@ static int be_mcc_compl_process(struct be_ctrl_info *ctrl,
 int be_mcc_compl_process_isr(struct be_ctrl_info *ctrl,
                                     struct be_mcc_compl *compl)
 {
+        struct beiscsi_hba *phba = pci_get_drvdata(ctrl->pdev);
         u16 compl_status, extd_status;
         unsigned short tag;
 
@@ -338,7 +359,32 @@ int be_mcc_compl_process_isr(struct be_ctrl_info *ctrl,
         ctrl->mcc_numtag[tag] |= (compl->tag0 & 0x00FF0000);
         ctrl->mcc_numtag[tag] |= (extd_status & 0x000000FF) << 8;
         ctrl->mcc_numtag[tag] |= (compl_status & 0x000000FF);
-        wake_up_interruptible(&ctrl->mcc_wait[tag]);
+
+        if (ctrl->ptag_state[tag].tag_state == MCC_TAG_STATE_RUNNING) {
+                wake_up_interruptible(&ctrl->mcc_wait[tag]);
+        } else if (ctrl->ptag_state[tag].tag_state == MCC_TAG_STATE_TIMEOUT) {
+                struct be_dma_mem *tag_mem;
+                tag_mem = &ctrl->ptag_state[tag].tag_mem_state;
+
+                beiscsi_log(phba, KERN_WARNING,
+                            BEISCSI_LOG_MBOX | BEISCSI_LOG_INIT |
+                            BEISCSI_LOG_CONFIG,
+                            "BC_%d : MBX Completion for timeout Command "
+                            "from FW\n");
+                /* Check if memory needs to be freed */
+                if (tag_mem->size)
+                        pci_free_consistent(ctrl->pdev, tag_mem->size,
+                                            tag_mem->va, tag_mem->dma);
+
+                /* Change tag state */
+                spin_lock(&phba->ctrl.mbox_lock);
+                ctrl->ptag_state[tag].tag_state = MCC_TAG_STATE_COMPLETED;
+                spin_unlock(&phba->ctrl.mbox_lock);
+
+                /* Free MCC Tag */
+                free_mcc_tag(ctrl, tag);
+        }
+
         return 0;
 }
 
@@ -354,8 +400,23 @@ static struct be_mcc_compl *be_mcc_compl_get(struct beiscsi_hba *phba)
         return NULL;
 }
 
-static void be2iscsi_fail_session(struct iscsi_cls_session *cls_session)
+/**
+ * be2iscsi_fail_session(): Closing session with appropriate error
+ * @cls_session: ptr to session
+ *
+ * Depending on adapter state appropriate error flag is passed.
+ **/
+void be2iscsi_fail_session(struct iscsi_cls_session *cls_session)
 {
+        struct Scsi_Host *shost = iscsi_session_to_shost(cls_session);
+        struct beiscsi_hba *phba = iscsi_host_priv(shost);
+        uint32_t iscsi_err_flag;
+
+        if (phba->state & BE_ADAPTER_STATE_SHUTDOWN)
+                iscsi_err_flag = ISCSI_ERR_INVALID_HOST;
+        else
+                iscsi_err_flag = ISCSI_ERR_CONN_FAILED;
+
         iscsi_session_failure(cls_session->dd_data, ISCSI_ERR_CONN_FAILED);
 }
 
@@ -386,18 +447,6 @@ void beiscsi_async_link_state_process(struct beiscsi_hba *phba,
         }
 }
 
-static void beiscsi_cq_notify(struct beiscsi_hba *phba, u16 qid, bool arm,
-                       u16 num_popped)
-{
-        u32 val = 0;
-        val |= qid & DB_CQ_RING_ID_MASK;
-        if (arm)
-                val |= 1 << DB_CQ_REARM_SHIFT;
-        val |= num_popped << DB_CQ_NUM_POPPED_SHIFT;
-        iowrite32(val, phba->db_va + DB_CQ_OFFSET);
-}
-
-
 int beiscsi_process_mcc(struct beiscsi_hba *phba)
 {
         struct be_mcc_compl *compl;
@@ -428,7 +477,7 @@ int beiscsi_process_mcc(struct beiscsi_hba *phba)
         }
 
         if (num)
-                beiscsi_cq_notify(phba, phba->ctrl.mcc_obj.cq.id, true, num);
+                hwi_ring_cq_db(phba, phba->ctrl.mcc_obj.cq.id, num, 1, 0);
 
         spin_unlock_bh(&phba->ctrl.mcc_cq_lock);
         return status;
diff --git a/drivers/scsi/be2iscsi/be_cmds.h b/drivers/scsi/be2iscsi/be_cmds.h
index 627ebbe0172c..7cf7f99ee442 100644
--- a/drivers/scsi/be2iscsi/be_cmds.h
+++ b/drivers/scsi/be2iscsi/be_cmds.h
@@ -103,7 +103,7 @@ struct be_mcc_compl {
 
 /********** MCC door bell ************/
 #define DB_MCCQ_OFFSET 0x140
-#define DB_MCCQ_RING_ID_MASK 0x7FF              /* bits 0 - 10 */
+#define DB_MCCQ_RING_ID_MASK 0xFFFF             /* bits 0 - 15 */
 /* Number of entries posted */
 #define DB_MCCQ_NUM_POSTED_SHIFT 16             /* bits 16 - 29 */
 
@@ -709,7 +709,8 @@ unsigned int be_cmd_get_port_speed(struct beiscsi_hba *phba);
 void free_mcc_tag(struct be_ctrl_info *ctrl, unsigned int tag);
 
 int beiscsi_mccq_compl(struct beiscsi_hba *phba,
-                        uint32_t tag, struct be_mcc_wrb **wrb, void *cmd_va);
+                        uint32_t tag, struct be_mcc_wrb **wrb,
+                        struct be_dma_mem *mbx_cmd_mem);
 /*ISCSI Functuions */
 int be_cmd_fw_initialize(struct be_ctrl_info *ctrl);
 int be_cmd_fw_uninit(struct be_ctrl_info *ctrl);
@@ -1017,8 +1018,8 @@ struct be_mcc_wrb_context {
         int *users_final_status;
 } __packed;
 
-#define DB_DEF_PDU_RING_ID_MASK         0x3FF   /* bits 0 - 9 */
-#define DB_DEF_PDU_CQPROC_MASK          0x3FFF  /* bits 0 - 9 */
+#define DB_DEF_PDU_RING_ID_MASK 0x3FFF  /* bits 0 - 13 */
+#define DB_DEF_PDU_CQPROC_MASK          0x3FFF  /* bits 16 - 29 */
 #define DB_DEF_PDU_REARM_SHIFT          14
 #define DB_DEF_PDU_EVENT_SHIFT          15
 #define DB_DEF_PDU_CQPROC_SHIFT         16
@@ -1317,4 +1318,5 @@ void be_wrb_hdr_prepare(struct be_mcc_wrb *wrb, int payload_len,
 void be_cmd_hdr_prepare(struct be_cmd_req_hdr *req_hdr,
                         u8 subsystem, u8 opcode, int cmd_len);
 
+void be2iscsi_fail_session(struct iscsi_cls_session *cls_session);
 #endif /* !BEISCSI_CMDS_H */
diff --git a/drivers/scsi/be2iscsi/be_iscsi.c b/drivers/scsi/be2iscsi/be_iscsi.c
index 889066d9d6fb..a3df43324c98 100644
--- a/drivers/scsi/be2iscsi/be_iscsi.c
+++ b/drivers/scsi/be2iscsi/be_iscsi.c
@@ -793,7 +793,7 @@ static int beiscsi_get_port_speed(struct Scsi_Host *shost)
                 ihost->port_speed = ISCSI_PORT_SPEED_10MBPS;
                 break;
         case BE2ISCSI_LINK_SPEED_100MBPS:
-                ihost->port_speed = BE2ISCSI_LINK_SPEED_100MBPS;
+                ihost->port_speed = ISCSI_PORT_SPEED_100MBPS;
                 break;
         case BE2ISCSI_LINK_SPEED_1GBPS:
                 ihost->port_speed = ISCSI_PORT_SPEED_1GBPS;
@@ -1153,16 +1153,18 @@ static int beiscsi_open_conn(struct iscsi_endpoint *ep,
                 return -EAGAIN;
         }
 
-        ret = beiscsi_mccq_compl(phba, tag, NULL, nonemb_cmd.va);
+        ret = beiscsi_mccq_compl(phba, tag, NULL, &nonemb_cmd);
         if (ret) {
                 beiscsi_log(phba, KERN_ERR,
                             BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
                             "BS_%d : mgmt_open_connection Failed");
 
-                pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
-                            nonemb_cmd.va, nonemb_cmd.dma);
+                if (ret != -EBUSY)
+                        pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
+                                            nonemb_cmd.va, nonemb_cmd.dma);
+
                 beiscsi_free_ep(beiscsi_ep);
-                return -EBUSY;
+                return ret;
         }
 
         ptcpcnct_out = (struct tcp_connect_and_offload_out *)nonemb_cmd.va;
@@ -1359,6 +1361,7 @@ void beiscsi_ep_disconnect(struct iscsi_endpoint *ep)
         beiscsi_mccq_compl(phba, tag, NULL, NULL);
         beiscsi_close_conn(beiscsi_ep, tcp_upload_flag);
 free_ep:
+        msleep(BEISCSI_LOGOUT_SYNC_DELAY);
         beiscsi_free_ep(beiscsi_ep);
         beiscsi_unbind_conn_to_cid(phba, beiscsi_ep->ep_cid);
         iscsi_destroy_endpoint(beiscsi_ep->openiscsi_ep);
diff --git a/drivers/scsi/be2iscsi/be_main.c b/drivers/scsi/be2iscsi/be_main.c
index a929c3c9aedc..0d822297aa80 100644
--- a/drivers/scsi/be2iscsi/be_main.c
+++ b/drivers/scsi/be2iscsi/be_main.c
@@ -228,24 +228,25 @@ static int beiscsi_eh_abort(struct scsi_cmnd *sc)
         struct invalidate_command_table *inv_tbl;
         struct be_dma_mem nonemb_cmd;
         unsigned int cid, tag, num_invalidate;
+        int rc;
 
         cls_session = starget_to_session(scsi_target(sc->device));
         session = cls_session->dd_data;
 
-        spin_lock_bh(&session->lock);
+        spin_lock_bh(&session->frwd_lock);
         if (!aborted_task || !aborted_task->sc) {
                 /* we raced */
-                spin_unlock_bh(&session->lock);
+                spin_unlock_bh(&session->frwd_lock);
                 return SUCCESS;
         }
 
         aborted_io_task = aborted_task->dd_data;
         if (!aborted_io_task->scsi_cmnd) {
                 /* raced or invalid command */
-                spin_unlock_bh(&session->lock);
+                spin_unlock_bh(&session->frwd_lock);
                 return SUCCESS;
         }
-        spin_unlock_bh(&session->lock);
+        spin_unlock_bh(&session->frwd_lock);
         /* Invalidate WRB Posted for this Task */
         AMAP_SET_BITS(struct amap_iscsi_wrb, invld,
                       aborted_io_task->pwrb_handle->pwrb,
@@ -285,9 +286,11 @@ static int beiscsi_eh_abort(struct scsi_cmnd *sc)
                 return FAILED;
         }
 
-        beiscsi_mccq_compl(phba, tag, NULL, nonemb_cmd.va);
-        pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
-                            nonemb_cmd.va, nonemb_cmd.dma);
+        rc = beiscsi_mccq_compl(phba, tag, NULL, &nonemb_cmd);
+        if (rc != -EBUSY)
+                pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
+                                    nonemb_cmd.va, nonemb_cmd.dma);
+
         return iscsi_eh_abort(sc);
 }
 
@@ -303,13 +306,14 @@ static int beiscsi_eh_device_reset(struct scsi_cmnd *sc)
         struct invalidate_command_table *inv_tbl;
         struct be_dma_mem nonemb_cmd;
         unsigned int cid, tag, i, num_invalidate;
+        int rc;
 
         /* invalidate iocbs */
         cls_session = starget_to_session(scsi_target(sc->device));
         session = cls_session->dd_data;
-        spin_lock_bh(&session->lock);
+        spin_lock_bh(&session->frwd_lock);
         if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN) {
-                spin_unlock_bh(&session->lock);
+                spin_unlock_bh(&session->frwd_lock);
                 return FAILED;
         }
         conn = session->leadconn;
@@ -325,7 +329,7 @@ static int beiscsi_eh_device_reset(struct scsi_cmnd *sc)
                 if (!abrt_task->sc || abrt_task->state == ISCSI_TASK_FREE)
                         continue;
 
-                if (abrt_task->sc->device->lun != abrt_task->sc->device->lun)
+                if (sc->device->lun != abrt_task->sc->device->lun)
                         continue;
 
                 /* Invalidate WRB Posted for this Task */
@@ -338,7 +342,7 @@ static int beiscsi_eh_device_reset(struct scsi_cmnd *sc)
                 num_invalidate++;
                 inv_tbl++;
         }
-        spin_unlock_bh(&session->lock);
+        spin_unlock_bh(&session->frwd_lock);
         inv_tbl = phba->inv_tbl;
 
         nonemb_cmd.va = pci_alloc_consistent(phba->ctrl.pdev,
@@ -363,9 +367,10 @@ static int beiscsi_eh_device_reset(struct scsi_cmnd *sc)
                 return FAILED;
         }
 
-        beiscsi_mccq_compl(phba, tag, NULL, nonemb_cmd.va);
-        pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
-                            nonemb_cmd.va, nonemb_cmd.dma);
+        rc = beiscsi_mccq_compl(phba, tag, NULL, &nonemb_cmd);
+        if (rc != -EBUSY)
+                pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
+                                    nonemb_cmd.va, nonemb_cmd.dma);
         return iscsi_eh_device_reset(sc);
 }
 
@@ -674,8 +679,19 @@ static int beiscsi_enable_pci(struct pci_dev *pcidev)
         }
 
         pci_set_master(pcidev);
-        if (pci_set_consistent_dma_mask(pcidev, DMA_BIT_MASK(64))) {
-                ret = pci_set_consistent_dma_mask(pcidev, DMA_BIT_MASK(32));
+        ret = pci_set_dma_mask(pcidev, DMA_BIT_MASK(64));
+        if (ret) {
+                ret = pci_set_dma_mask(pcidev, DMA_BIT_MASK(32));
+                if (ret) {
+                        dev_err(&pcidev->dev, "Could not set PCI DMA Mask\n");
+                        pci_disable_device(pcidev);
+                        return ret;
+                } else {
+                        ret = pci_set_consistent_dma_mask(pcidev,
+                                                          DMA_BIT_MASK(32));
+                }
+        } else {
+                ret = pci_set_consistent_dma_mask(pcidev, DMA_BIT_MASK(64));
                 if (ret) {
                         dev_err(&pcidev->dev, "Could not set PCI DMA Mask\n");
                         pci_disable_device(pcidev);
@@ -804,14 +820,23 @@ static void hwi_ring_eq_db(struct beiscsi_hba *phba,
                            unsigned char rearm, unsigned char event)
 {
         u32 val = 0;
-        val |= id & DB_EQ_RING_ID_MASK;
+
         if (rearm)
                 val |= 1 << DB_EQ_REARM_SHIFT;
         if (clr_interrupt)
                 val |= 1 << DB_EQ_CLR_SHIFT;
         if (event)
                 val |= 1 << DB_EQ_EVNT_SHIFT;
+
         val |= num_processed << DB_EQ_NUM_POPPED_SHIFT;
+        /* Setting lower order EQ_ID Bits */
+        val |= (id & DB_EQ_RING_ID_LOW_MASK);
+
+        /* Setting Higher order EQ_ID Bits */
+        val |= (((id >> DB_EQ_HIGH_FEILD_SHIFT) &
+                  DB_EQ_RING_ID_HIGH_MASK)
+                  << DB_EQ_HIGH_SET_SHIFT);
+
         iowrite32(val, phba->db_va + DB_EQ_OFFSET);
 }
 
@@ -1043,15 +1068,25 @@ free_msix_irqs:
         return ret;
 }
 
-static void hwi_ring_cq_db(struct beiscsi_hba *phba,
+void hwi_ring_cq_db(struct beiscsi_hba *phba,
                            unsigned int id, unsigned int num_processed,
                            unsigned char rearm, unsigned char event)
 {
         u32 val = 0;
-        val |= id & DB_CQ_RING_ID_MASK;
+
         if (rearm)
                 val |= 1 << DB_CQ_REARM_SHIFT;
+
         val |= num_processed << DB_CQ_NUM_POPPED_SHIFT;
+
+        /* Setting lower order CQ_ID Bits */
+        val |= (id & DB_CQ_RING_ID_LOW_MASK);
+
+        /* Setting Higher order CQ_ID Bits */
+        val |= (((id >> DB_CQ_HIGH_FEILD_SHIFT) &
+                  DB_CQ_RING_ID_HIGH_MASK)
+                  << DB_CQ_HIGH_SET_SHIFT);
+
         iowrite32(val, phba->db_va + DB_CQ_OFFSET);
 }
 
@@ -1100,9 +1135,9 @@ beiscsi_process_async_pdu(struct beiscsi_conn *beiscsi_conn,
                 return 1;
         }
 
-        spin_lock_bh(&session->lock);
+        spin_lock_bh(&session->back_lock);
         __iscsi_complete_pdu(conn, (struct iscsi_hdr *)ppdu, pbuffer, buf_len);
-        spin_unlock_bh(&session->lock);
+        spin_unlock_bh(&session->back_lock);
         return 0;
 }
 
@@ -1292,8 +1327,10 @@ be_complete_io(struct beiscsi_conn *beiscsi_conn,
         resid = csol_cqe->res_cnt;
 
         if (!task->sc) {
-                if (io_task->scsi_cmnd)
+                if (io_task->scsi_cmnd) {
                         scsi_dma_unmap(io_task->scsi_cmnd);
+                        io_task->scsi_cmnd = NULL;
+                }
 
                 return;
         }
@@ -1330,6 +1367,7 @@ be_complete_io(struct beiscsi_conn *beiscsi_conn,
                 conn->rxdata_octets += resid;
 unmap:
         scsi_dma_unmap(io_task->scsi_cmnd);
+        io_task->scsi_cmnd = NULL;
         iscsi_complete_scsi_task(task, exp_cmdsn, max_cmdsn);
 }
 
@@ -1518,7 +1556,7 @@ static void hwi_complete_cmd(struct beiscsi_conn *beiscsi_conn,
         pwrb = pwrb_handle->pwrb;
         type = ((struct beiscsi_io_task *)task->dd_data)->wrb_type;
 
-        spin_lock_bh(&session->lock);
+        spin_lock_bh(&session->back_lock);
         switch (type) {
         case HWH_TYPE_IO:
         case HWH_TYPE_IO_RD:
@@ -1557,7 +1595,7 @@ static void hwi_complete_cmd(struct beiscsi_conn *beiscsi_conn,
                 break;
         }
 
-        spin_unlock_bh(&session->lock);
+        spin_unlock_bh(&session->back_lock);
 }
 
 static struct list_head *hwi_get_async_busy_list(struct hwi_async_pdu_context
@@ -4310,12 +4348,16 @@ static int beiscsi_get_boot_info(struct beiscsi_hba *phba)
                 goto boot_freemem;
         }
 
-        ret = beiscsi_mccq_compl(phba, tag, NULL, nonemb_cmd.va);
+        ret = beiscsi_mccq_compl(phba, tag, NULL, &nonemb_cmd);
         if (ret) {
                 beiscsi_log(phba, KERN_ERR,
                             BEISCSI_LOG_INIT | BEISCSI_LOG_CONFIG,
                             "BM_%d : beiscsi_get_session_info Failed");
-                goto boot_freemem;
+
+                if (ret != -EBUSY)
+                        goto boot_freemem;
+                else
+                        return ret;
         }
 
         session_resp = nonemb_cmd.va ;
@@ -4575,6 +4617,11 @@ static void beiscsi_cleanup_task(struct iscsi_task *task)
                         spin_unlock(&phba->io_sgl_lock);
                         io_task->psgl_handle = NULL;
                 }
+
+                if (io_task->scsi_cmnd) {
+                        scsi_dma_unmap(io_task->scsi_cmnd);
+                        io_task->scsi_cmnd = NULL;
+                }
         } else {
                 if (!beiscsi_conn->login_in_progress)
                         beiscsi_free_mgmt_task_handles(beiscsi_conn, task);
@@ -4596,9 +4643,9 @@ beiscsi_offload_connection(struct beiscsi_conn *beiscsi_conn,
          * login/startup related tasks.
          */
         beiscsi_conn->login_in_progress = 0;
-        spin_lock_bh(&session->lock);
+        spin_lock_bh(&session->back_lock);
         beiscsi_cleanup_task(task);
-        spin_unlock_bh(&session->lock);
+        spin_unlock_bh(&session->back_lock);
 
         pwrb_handle = alloc_wrb_handle(phba, beiscsi_conn->beiscsi_conn_cid);
 
@@ -5222,6 +5269,8 @@ static void beiscsi_shutdown(struct pci_dev *pcidev)
                 return;
         }
 
+        phba->state = BE_ADAPTER_STATE_SHUTDOWN;
+        iscsi_host_for_each_session(phba->shost, be2iscsi_fail_session);
         beiscsi_quiesce(phba, BEISCSI_CLEAN_UNLOAD);
         pci_disable_device(pcidev);
 }
@@ -5529,6 +5578,8 @@ static int beiscsi_dev_probe(struct pci_dev *pcidev,
                 phba->ctrl.mcc_tag[i] = i + 1;
                 phba->ctrl.mcc_numtag[i + 1] = 0;
                 phba->ctrl.mcc_tag_available++;
+                memset(&phba->ctrl.ptag_state[i].tag_mem_state, 0,
+                       sizeof(struct beiscsi_mcc_tag_state));
         }
 
         phba->ctrl.mcc_alloc_index = phba->ctrl.mcc_free_index = 0;
diff --git a/drivers/scsi/be2iscsi/be_main.h b/drivers/scsi/be2iscsi/be_main.h
index 31fa27b4a9b2..9380b55bdeaf 100644
--- a/drivers/scsi/be2iscsi/be_main.h
+++ b/drivers/scsi/be2iscsi/be_main.h
@@ -36,7 +36,7 @@
 #include <scsi/scsi_transport_iscsi.h>
 
 #define DRV_NAME                "be2iscsi"
-#define BUILD_STR               "10.0.659.0"
+#define BUILD_STR               "10.2.125.0"
 #define BE_NAME                 "Emulex OneConnect" \
                                 "Open-iSCSI Driver version" BUILD_STR
 #define DRV_DESC                BE_NAME " " "Driver"
@@ -97,9 +97,14 @@
 
 #define INVALID_SESS_HANDLE     0xFFFFFFFF
 
+/**
+ * Adapter States
+ **/
 #define BE_ADAPTER_LINK_UP      0x001
 #define BE_ADAPTER_LINK_DOWN    0x002
 #define BE_ADAPTER_PCI_ERR      0x004
+#define BE_ADAPTER_STATE_SHUTDOWN       0x008
+
 
 #define BEISCSI_CLEAN_UNLOAD    0x01
 #define BEISCSI_EEH_UNLOAD      0x02
@@ -135,11 +140,15 @@
 #define DB_RXULP0_OFFSET 0xA0
 /********* Event Q door bell *************/
 #define DB_EQ_OFFSET                    DB_CQ_OFFSET
-#define DB_EQ_RING_ID_MASK              0x1FF   /* bits 0 - 8 */
+#define DB_EQ_RING_ID_LOW_MASK          0x1FF   /* bits 0 - 8 */
 /* Clear the interrupt for this eq */
 #define DB_EQ_CLR_SHIFT                 (9)     /* bit 9 */
 /* Must be 1 */
 #define DB_EQ_EVNT_SHIFT                (10)    /* bit 10 */
+/* Higher Order EQ_ID bit */
+#define DB_EQ_RING_ID_HIGH_MASK 0x1F /* bits 11 - 15 */
+#define DB_EQ_HIGH_SET_SHIFT    11
+#define DB_EQ_HIGH_FEILD_SHIFT  9
 /* Number of event entries processed */
 #define DB_EQ_NUM_POPPED_SHIFT          (16)    /* bits 16 - 28 */
 /* Rearm bit */
@@ -147,7 +156,12 @@
 
 /********* Compl Q door bell *************/
 #define DB_CQ_OFFSET                    0x120
-#define DB_CQ_RING_ID_MASK              0x3FF   /* bits 0 - 9 */
+#define DB_CQ_RING_ID_LOW_MASK          0x3FF   /* bits 0 - 9 */
+/* Higher Order CQ_ID bit */
+#define DB_CQ_RING_ID_HIGH_MASK 0x1F /* bits 11 - 15 */
+#define DB_CQ_HIGH_SET_SHIFT    11
+#define DB_CQ_HIGH_FEILD_SHIFT  10
+
 /* Number of event entries processed */
 #define DB_CQ_NUM_POPPED_SHIFT          (16)    /* bits 16 - 28 */
 /* Rearm bit */
@@ -821,6 +835,9 @@ void beiscsi_process_all_cqs(struct work_struct *work);
 void beiscsi_free_mgmt_task_handles(struct beiscsi_conn *beiscsi_conn,
                                      struct iscsi_task *task);
 
+void hwi_ring_cq_db(struct beiscsi_hba *phba,
+                     unsigned int id, unsigned int num_processed,
+                     unsigned char rearm, unsigned char event);
 static inline bool beiscsi_error(struct beiscsi_hba *phba)
 {
         return phba->ue_detected || phba->fw_timeout;
diff --git a/drivers/scsi/be2iscsi/be_mgmt.c b/drivers/scsi/be2iscsi/be_mgmt.c
index b2fcac78feaa..088bdf752cfa 100644
--- a/drivers/scsi/be2iscsi/be_mgmt.c
+++ b/drivers/scsi/be2iscsi/be_mgmt.c
@@ -828,22 +828,25 @@ static int mgmt_exec_nonemb_cmd(struct beiscsi_hba *phba,
         be_mcc_notify(phba);
         spin_unlock(&ctrl->mbox_lock);
 
-        rc = beiscsi_mccq_compl(phba, tag, NULL, nonemb_cmd->va);
+        rc = beiscsi_mccq_compl(phba, tag, NULL, nonemb_cmd);
+
+        if (resp_buf)
+                memcpy(resp_buf, nonemb_cmd->va, resp_buf_len);
+
         if (rc) {
-                /* Check if the IOCTL needs to be re-issued */
+                /* Check if the MBX Cmd needs to be re-issued */
                 if (rc == -EAGAIN)
                         return rc;
 
-                beiscsi_log(phba, KERN_ERR,
+                beiscsi_log(phba, KERN_WARNING,
                             BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
                             "BG_%d : mgmt_exec_nonemb_cmd Failed status\n");
 
-                goto free_cmd;
+                if (rc != -EBUSY)
+                        goto free_cmd;
+                else
+                        return rc;
         }
-
-        if (resp_buf)
-                memcpy(resp_buf, nonemb_cmd->va, resp_buf_len);
-
 free_cmd:
         pci_free_consistent(ctrl->pdev, nonemb_cmd->size,
                             nonemb_cmd->va, nonemb_cmd->dma);
@@ -1348,7 +1351,6 @@ int mgmt_set_vlan(struct beiscsi_hba *phba,
 {
         int rc;
         unsigned int tag;
-        struct be_mcc_wrb *wrb = NULL;
 
         tag = be_cmd_set_vlan(phba, vlan_tag);
         if (!tag) {
@@ -1358,7 +1360,7 @@ int mgmt_set_vlan(struct beiscsi_hba *phba,
                 return -EBUSY;
         }
 
-        rc = beiscsi_mccq_compl(phba, tag, &wrb, NULL);
+        rc = beiscsi_mccq_compl(phba, tag, NULL, NULL);
         if (rc) {
                 beiscsi_log(phba, KERN_ERR,
                             (BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX),