93 files changed, 10533 insertions, 1448 deletions

diff --git a/drivers/scsi/Kconfig b/drivers/scsi/Kconfig
index db95c547c09d..86af29f53bbe 100644
--- a/drivers/scsi/Kconfig
+++ b/drivers/scsi/Kconfig
@@ -1353,6 +1353,8 @@ config SCSI_LPFC
         tristate "Emulex LightPulse Fibre Channel Support"
         depends on PCI && SCSI
         select SCSI_FC_ATTRS
+        select GENERIC_CSUM
+        select CRC_T10DIF
         help
           This lpfc driver supports the Emulex LightPulse
           Family of Fibre Channel PCI host adapters.
diff --git a/drivers/scsi/aic94xx/aic94xx_dev.c b/drivers/scsi/aic94xx/aic94xx_dev.c
index 64136c56e706..33072388ea16 100644
--- a/drivers/scsi/aic94xx/aic94xx_dev.c
+++ b/drivers/scsi/aic94xx/aic94xx_dev.c
@@ -84,7 +84,7 @@ static void asd_set_ddb_type(struct domain_device *dev)
         struct asd_ha_struct *asd_ha = dev->port->ha->lldd_ha;
         int ddb = (int) (unsigned long) dev->lldd_dev;
 
-        if (dev->dev_type == SATA_PM_PORT)
+        if (dev->dev_type == SAS_SATA_PM_PORT)
                 asd_ddbsite_write_byte(asd_ha,ddb, DDB_TYPE, DDB_TYPE_PM_PORT);
         else if (dev->tproto)
                 asd_ddbsite_write_byte(asd_ha,ddb, DDB_TYPE, DDB_TYPE_TARGET);
@@ -116,7 +116,7 @@ void asd_set_dmamode(struct domain_device *dev)
         int ddb = (int) (unsigned long) dev->lldd_dev;
         u32 qdepth = 0;
 
-        if (dev->dev_type == SATA_DEV || dev->dev_type == SATA_PM_PORT) {
+        if (dev->dev_type == SAS_SATA_DEV || dev->dev_type == SAS_SATA_PM_PORT) {
                 if (ata_id_has_ncq(ata_dev->id))
                         qdepth = ata_id_queue_depth(ata_dev->id);
                 asd_ddbsite_write_dword(asd_ha, ddb, SATA_TAG_ALLOC_MASK,
@@ -140,8 +140,8 @@ static int asd_init_sata(struct domain_device *dev)
         int ddb = (int) (unsigned long) dev->lldd_dev;
 
         asd_ddbsite_write_word(asd_ha, ddb, ATA_CMD_SCBPTR, 0xFFFF);
-        if (dev->dev_type == SATA_DEV || dev->dev_type == SATA_PM ||
-            dev->dev_type == SATA_PM_PORT) {
+        if (dev->dev_type == SAS_SATA_DEV || dev->dev_type == SAS_SATA_PM ||
+            dev->dev_type == SAS_SATA_PM_PORT) {
                 struct dev_to_host_fis *fis = (struct dev_to_host_fis *)
                         dev->frame_rcvd;
                 asd_ddbsite_write_byte(asd_ha, ddb, SATA_STATUS, fis->status);
@@ -174,7 +174,7 @@ static int asd_init_target_ddb(struct domain_device *dev)
         asd_ddbsite_write_byte(asd_ha, ddb, CONN_MASK, dev->port->phy_mask);
         if (dev->port->oob_mode != SATA_OOB_MODE) {
                 flags |= OPEN_REQUIRED;
-                if ((dev->dev_type == SATA_DEV) ||
+                if ((dev->dev_type == SAS_SATA_DEV) ||
                     (dev->tproto & SAS_PROTOCOL_STP)) {
                         struct smp_resp *rps_resp = &dev->sata_dev.rps_resp;
                         if (rps_resp->frame_type == SMP_RESPONSE &&
@@ -188,8 +188,8 @@ static int asd_init_target_ddb(struct domain_device *dev)
                 } else {
                         flags |= CONCURRENT_CONN_SUPP;
                         if (!dev->parent &&
-                            (dev->dev_type == EDGE_DEV ||
-                             dev->dev_type == FANOUT_DEV))
+                            (dev->dev_type == SAS_EDGE_EXPANDER_DEVICE ||
+                             dev->dev_type == SAS_FANOUT_EXPANDER_DEVICE))
                                 asd_ddbsite_write_byte(asd_ha, ddb, MAX_CCONN,
                                                        4);
                         else
@@ -198,7 +198,7 @@ static int asd_init_target_ddb(struct domain_device *dev)
                         asd_ddbsite_write_byte(asd_ha, ddb, NUM_CTX, 1);
                 }
         }
-        if (dev->dev_type == SATA_PM)
+        if (dev->dev_type == SAS_SATA_PM)
                 flags |= SATA_MULTIPORT;
         asd_ddbsite_write_byte(asd_ha, ddb, DDB_TARG_FLAGS, flags);
 
@@ -211,7 +211,7 @@ static int asd_init_target_ddb(struct domain_device *dev)
         asd_ddbsite_write_word(asd_ha, ddb, SEND_QUEUE_TAIL, 0xFFFF);
         asd_ddbsite_write_word(asd_ha, ddb, SISTER_DDB, 0xFFFF);
 
-        if (dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP)) {
+        if (dev->dev_type == SAS_SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP)) {
                 i = asd_init_sata(dev);
                 if (i < 0) {
                         asd_free_ddb(asd_ha, ddb);
@@ -219,7 +219,7 @@ static int asd_init_target_ddb(struct domain_device *dev)
                 }
         }
 
-        if (dev->dev_type == SAS_END_DEV) {
+        if (dev->dev_type == SAS_END_DEVICE) {
                 struct sas_end_device *rdev = rphy_to_end_device(dev->rphy);
                 if (rdev->I_T_nexus_loss_timeout > 0)
                         asd_ddbsite_write_word(asd_ha, ddb, ITNL_TIMEOUT,
@@ -328,10 +328,10 @@ int asd_dev_found(struct domain_device *dev)
 
         spin_lock_irqsave(&asd_ha->hw_prof.ddb_lock, flags);
         switch (dev->dev_type) {
-        case SATA_PM:
+        case SAS_SATA_PM:
                 res = asd_init_sata_pm_ddb(dev);
                 break;
-        case SATA_PM_PORT:
+        case SAS_SATA_PM_PORT:
                 res = asd_init_sata_pm_port_ddb(dev);
                 break;
         default:
diff --git a/drivers/scsi/aic94xx/aic94xx_hwi.c b/drivers/scsi/aic94xx/aic94xx_hwi.c
index 81b736c76fff..4df867e07b20 100644
--- a/drivers/scsi/aic94xx/aic94xx_hwi.c
+++ b/drivers/scsi/aic94xx/aic94xx_hwi.c
@@ -74,7 +74,7 @@ static void asd_init_phy_identify(struct asd_phy *phy)
 
         memset(phy->identify_frame, 0, sizeof(*phy->identify_frame));
 
-        phy->identify_frame->dev_type = SAS_END_DEV;
+        phy->identify_frame->dev_type = SAS_END_DEVICE;
         if (phy->sas_phy.role & PHY_ROLE_INITIATOR)
                 phy->identify_frame->initiator_bits = phy->sas_phy.iproto;
         if (phy->sas_phy.role & PHY_ROLE_TARGET)
diff --git a/drivers/scsi/aic94xx/aic94xx_tmf.c b/drivers/scsi/aic94xx/aic94xx_tmf.c
index cf9040933da6..d4c35df3d4ae 100644
--- a/drivers/scsi/aic94xx/aic94xx_tmf.c
+++ b/drivers/scsi/aic94xx/aic94xx_tmf.c
@@ -184,7 +184,7 @@ int asd_I_T_nexus_reset(struct domain_device *dev)
         struct sas_phy *phy = sas_get_local_phy(dev);
         /* Standard mandates link reset for ATA  (type 0) and
          * hard reset for SSP (type 1) */
-        int reset_type = (dev->dev_type == SATA_DEV ||
+        int reset_type = (dev->dev_type == SAS_SATA_DEV ||
                           (dev->tproto & SAS_PROTOCOL_STP)) ? 0 : 1;
 
         asd_clear_nexus_I_T(dev, NEXUS_PHASE_PRE);
diff --git a/drivers/scsi/be2iscsi/be.h b/drivers/scsi/be2iscsi/be.h
index f1733dfa3ae2..777e7c0bbb4b 100644
--- a/drivers/scsi/be2iscsi/be.h
+++ b/drivers/scsi/be2iscsi/be.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2012 Emulex
+ * Copyright (C) 2005 - 2013 Emulex
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
diff --git a/drivers/scsi/be2iscsi/be_cmds.c b/drivers/scsi/be2iscsi/be_cmds.c
index 5c87768c109c..e66aa7c11a8a 100644
--- a/drivers/scsi/be2iscsi/be_cmds.c
+++ b/drivers/scsi/be2iscsi/be_cmds.c
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2012 Emulex
+ * Copyright (C) 2005 - 2013 Emulex
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -155,6 +155,7 @@ int beiscsi_mccq_compl(struct beiscsi_hba *phba,
         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_queue_info *mccq = &phba->ctrl.mcc_obj.q;
 
         if (beiscsi_error(phba))
@@ -204,6 +205,12 @@ int beiscsi_mccq_compl(struct beiscsi_hba *phba,
                             ioctl_hdr->subsystem,
                             ioctl_hdr->opcode,
                             status, addl_status);
+
+                if (status == MCC_STATUS_INSUFFICIENT_BUFFER) {
+                        ioctl_resp_hdr = (struct be_cmd_resp_hdr *) ioctl_hdr;
+                        if (ioctl_resp_hdr->response_length)
+                                goto release_mcc_tag;
+                }
                 rc = -EAGAIN;
         }
 
@@ -267,6 +274,7 @@ static int be_mcc_compl_process(struct be_ctrl_info *ctrl,
         struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
         struct beiscsi_hba *phba = pci_get_drvdata(ctrl->pdev);
         struct be_cmd_req_hdr *hdr = embedded_payload(wrb);
+        struct be_cmd_resp_hdr *resp_hdr;
 
         be_dws_le_to_cpu(compl, 4);
 
@@ -284,6 +292,11 @@ static int be_mcc_compl_process(struct be_ctrl_info *ctrl,
                             hdr->subsystem, hdr->opcode,
                             compl_status, extd_status);
 
+                if (compl_status == MCC_STATUS_INSUFFICIENT_BUFFER) {
+                        resp_hdr = (struct be_cmd_resp_hdr *) hdr;
+                        if (resp_hdr->response_length)
+                                return 0;
+                }
                 return -EBUSY;
         }
         return 0;
@@ -335,30 +348,26 @@ static void be2iscsi_fail_session(struct iscsi_cls_session *cls_session)
 void beiscsi_async_link_state_process(struct beiscsi_hba *phba,
                 struct be_async_event_link_state *evt)
 {
-        switch (evt->port_link_status) {
-        case ASYNC_EVENT_LINK_DOWN:
+        if ((evt->port_link_status == ASYNC_EVENT_LINK_DOWN) ||
+            ((evt->port_link_status & ASYNC_EVENT_LOGICAL) &&
+             (evt->port_fault != BEISCSI_PHY_LINK_FAULT_NONE))) {
+                phba->state = BE_ADAPTER_LINK_DOWN;
+
                 beiscsi_log(phba, KERN_ERR,
                             BEISCSI_LOG_CONFIG | BEISCSI_LOG_INIT,
-                            "BC_%d : Link Down on Physical Port %d\n",
+                            "BC_%d : Link Down on Port %d\n",
                             evt->physical_port);
 
-                phba->state |= BE_ADAPTER_LINK_DOWN;
                 iscsi_host_for_each_session(phba->shost,
                                             be2iscsi_fail_session);
-                break;
-        case ASYNC_EVENT_LINK_UP:
+        } else if ((evt->port_link_status & ASYNC_EVENT_LINK_UP) ||
+                    ((evt->port_link_status & ASYNC_EVENT_LOGICAL) &&
+                     (evt->port_fault == BEISCSI_PHY_LINK_FAULT_NONE))) {
                 phba->state = BE_ADAPTER_UP;
+
                 beiscsi_log(phba, KERN_ERR,
                             BEISCSI_LOG_CONFIG | BEISCSI_LOG_INIT,
-                            "BC_%d : Link UP on Physical Port %d\n",
-                            evt->physical_port);
-                break;
-        default:
-                beiscsi_log(phba, KERN_ERR,
-                            BEISCSI_LOG_CONFIG | BEISCSI_LOG_INIT,
-                            "BC_%d : Unexpected Async Notification %d on"
-                            "Physical Port %d\n",
-                            evt->port_link_status,
+                            "BC_%d : Link UP on Port %d\n",
                             evt->physical_port);
         }
 }
@@ -479,7 +488,7 @@ static int be_mbox_db_ready_wait(struct be_ctrl_info *ctrl)
 {
         void __iomem *db = ctrl->db + MPU_MAILBOX_DB_OFFSET;
         struct beiscsi_hba *phba = pci_get_drvdata(ctrl->pdev);
-        int wait = 0;
+        uint32_t wait = 0;
         u32 ready;
 
         do {
@@ -527,6 +536,10 @@ int be_mbox_notify(struct be_ctrl_info *ctrl)
         struct be_mcc_compl *compl = &mbox->compl;
         struct beiscsi_hba *phba = pci_get_drvdata(ctrl->pdev);
 
+        status = be_mbox_db_ready_wait(ctrl);
+        if (status)
+                return status;
+
         val &= ~MPU_MAILBOX_DB_RDY_MASK;
         val |= MPU_MAILBOX_DB_HI_MASK;
         val |= (upper_32_bits(mbox_mem->dma) >> 2) << 2;
@@ -580,6 +593,10 @@ static int be_mbox_notify_wait(struct beiscsi_hba *phba)
         struct be_mcc_compl *compl = &mbox->compl;
         struct be_ctrl_info *ctrl = &phba->ctrl;
 
+        status = be_mbox_db_ready_wait(ctrl);
+        if (status)
+                return status;
+
         val |= MPU_MAILBOX_DB_HI_MASK;
         /* at bits 2 - 31 place mbox dma addr msb bits 34 - 63 */
         val |= (upper_32_bits(mbox_mem->dma) >> 2) << 2;
@@ -732,6 +749,16 @@ int beiscsi_cmd_eq_create(struct be_ctrl_info *ctrl,
         return status;
 }
 
+/**
+ * be_cmd_fw_initialize()- Initialize FW
+ * @ctrl: Pointer to function control structure
+ *
+ * Send FW initialize pattern for the function.
+ *
+ * return
+ * Success: 0
+ * Failure: Non-Zero value
+ **/
 int be_cmd_fw_initialize(struct be_ctrl_info *ctrl)
 {
         struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
@@ -762,6 +789,47 @@ int be_cmd_fw_initialize(struct be_ctrl_info *ctrl)
         return status;
 }
 
+/**
+ * be_cmd_fw_uninit()- Uinitialize FW
+ * @ctrl: Pointer to function control structure
+ *
+ * Send FW uninitialize pattern for the function
+ *
+ * return
+ * Success: 0
+ * Failure: Non-Zero value
+ **/
+int be_cmd_fw_uninit(struct be_ctrl_info *ctrl)
+{
+        struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
+        struct beiscsi_hba *phba = pci_get_drvdata(ctrl->pdev);
+        int status;
+        u8 *endian_check;
+
+        spin_lock(&ctrl->mbox_lock);
+        memset(wrb, 0, sizeof(*wrb));
+
+        endian_check = (u8 *) wrb;
+        *endian_check++ = 0xFF;
+        *endian_check++ = 0xAA;
+        *endian_check++ = 0xBB;
+        *endian_check++ = 0xFF;
+        *endian_check++ = 0xFF;
+        *endian_check++ = 0xCC;
+        *endian_check++ = 0xDD;
+        *endian_check = 0xFF;
+
+        be_dws_cpu_to_le(wrb, sizeof(*wrb));
+
+        status = be_mbox_notify(ctrl);
+        if (status)
+                beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
+                            "BC_%d : be_cmd_fw_uninit Failed\n");
+
+        spin_unlock(&ctrl->mbox_lock);
+        return status;
+}
+
 int beiscsi_cmd_cq_create(struct be_ctrl_info *ctrl,
                           struct be_queue_info *cq, struct be_queue_info *eq,
                           bool sol_evts, bool no_delay, int coalesce_wm)
@@ -783,20 +851,7 @@ int beiscsi_cmd_cq_create(struct be_ctrl_info *ctrl,
                         OPCODE_COMMON_CQ_CREATE, sizeof(*req));
 
         req->num_pages = cpu_to_le16(PAGES_4K_SPANNED(q_mem->va, q_mem->size));
-        if (chip_skh_r(ctrl->pdev)) {
-                req->hdr.version = MBX_CMD_VER2;
-                req->page_size = 1;
-                AMAP_SET_BITS(struct amap_cq_context_v2, coalescwm,
-                              ctxt, coalesce_wm);
-                AMAP_SET_BITS(struct amap_cq_context_v2, nodelay,
-                              ctxt, no_delay);
-                AMAP_SET_BITS(struct amap_cq_context_v2, count, ctxt,
-                              __ilog2_u32(cq->len / 256));
-                AMAP_SET_BITS(struct amap_cq_context_v2, valid, ctxt, 1);
-                AMAP_SET_BITS(struct amap_cq_context_v2, eventable, ctxt, 1);
-                AMAP_SET_BITS(struct amap_cq_context_v2, eqid, ctxt, eq->id);
-                AMAP_SET_BITS(struct amap_cq_context_v2, armed, ctxt, 1);
-        } else {
+        if (is_chip_be2_be3r(phba)) {
                 AMAP_SET_BITS(struct amap_cq_context, coalescwm,
                               ctxt, coalesce_wm);
                 AMAP_SET_BITS(struct amap_cq_context, nodelay, ctxt, no_delay);
@@ -809,6 +864,19 @@ int beiscsi_cmd_cq_create(struct be_ctrl_info *ctrl,
                 AMAP_SET_BITS(struct amap_cq_context, armed, ctxt, 1);
                 AMAP_SET_BITS(struct amap_cq_context, func, ctxt,
                               PCI_FUNC(ctrl->pdev->devfn));
+        } else {
+                req->hdr.version = MBX_CMD_VER2;
+                req->page_size = 1;
+                AMAP_SET_BITS(struct amap_cq_context_v2, coalescwm,
+                              ctxt, coalesce_wm);
+                AMAP_SET_BITS(struct amap_cq_context_v2, nodelay,
+                              ctxt, no_delay);
+                AMAP_SET_BITS(struct amap_cq_context_v2, count, ctxt,
+                              __ilog2_u32(cq->len / 256));
+                AMAP_SET_BITS(struct amap_cq_context_v2, valid, ctxt, 1);
+                AMAP_SET_BITS(struct amap_cq_context_v2, eventable, ctxt, 1);
+                AMAP_SET_BITS(struct amap_cq_context_v2, eqid, ctxt, eq->id);
+                AMAP_SET_BITS(struct amap_cq_context_v2, armed, ctxt, 1);
         }
 
         be_dws_cpu_to_le(ctxt, sizeof(req->context));
@@ -949,6 +1017,7 @@ int be_cmd_create_default_pdu_queue(struct be_ctrl_info *ctrl,
         struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
         struct be_defq_create_req *req = embedded_payload(wrb);
         struct be_dma_mem *q_mem = &dq->dma_mem;
+        struct beiscsi_hba *phba = pci_get_drvdata(ctrl->pdev);
         void *ctxt = &req->context;
         int status;
 
@@ -961,17 +1030,36 @@ int be_cmd_create_default_pdu_queue(struct be_ctrl_info *ctrl,
                            OPCODE_COMMON_ISCSI_DEFQ_CREATE, sizeof(*req));
 
         req->num_pages = PAGES_4K_SPANNED(q_mem->va, q_mem->size);
-        AMAP_SET_BITS(struct amap_be_default_pdu_context, rx_pdid, ctxt, 0);
-        AMAP_SET_BITS(struct amap_be_default_pdu_context, rx_pdid_valid, ctxt,
-                      1);
-        AMAP_SET_BITS(struct amap_be_default_pdu_context, pci_func_id, ctxt,
-                      PCI_FUNC(ctrl->pdev->devfn));
-        AMAP_SET_BITS(struct amap_be_default_pdu_context, ring_size, ctxt,
-                      be_encoded_q_len(length / sizeof(struct phys_addr)));
-        AMAP_SET_BITS(struct amap_be_default_pdu_context, default_buffer_size,
-                      ctxt, entry_size);
-        AMAP_SET_BITS(struct amap_be_default_pdu_context, cq_id_recv, ctxt,
-                      cq->id);
+
+        if (is_chip_be2_be3r(phba)) {
+                AMAP_SET_BITS(struct amap_be_default_pdu_context,
+                              rx_pdid, ctxt, 0);
+                AMAP_SET_BITS(struct amap_be_default_pdu_context,
+                              rx_pdid_valid, ctxt, 1);
+                AMAP_SET_BITS(struct amap_be_default_pdu_context,
+                              pci_func_id, ctxt, PCI_FUNC(ctrl->pdev->devfn));
+                AMAP_SET_BITS(struct amap_be_default_pdu_context,
+                              ring_size, ctxt,
+                              be_encoded_q_len(length /
+                              sizeof(struct phys_addr)));
+                AMAP_SET_BITS(struct amap_be_default_pdu_context,
+                              default_buffer_size, ctxt, entry_size);
+                AMAP_SET_BITS(struct amap_be_default_pdu_context,
+                              cq_id_recv, ctxt, cq->id);
+        } else {
+                AMAP_SET_BITS(struct amap_default_pdu_context_ext,
+                              rx_pdid, ctxt, 0);
+                AMAP_SET_BITS(struct amap_default_pdu_context_ext,
+                              rx_pdid_valid, ctxt, 1);
+                AMAP_SET_BITS(struct amap_default_pdu_context_ext,
+                              ring_size, ctxt,
+                              be_encoded_q_len(length /
+                              sizeof(struct phys_addr)));
+                AMAP_SET_BITS(struct amap_default_pdu_context_ext,
+                              default_buffer_size, ctxt, entry_size);
+                AMAP_SET_BITS(struct amap_default_pdu_context_ext,
+                              cq_id_recv, ctxt, cq->id);
+        }
 
         be_dws_cpu_to_le(ctxt, sizeof(req->context));
 
diff --git a/drivers/scsi/be2iscsi/be_cmds.h b/drivers/scsi/be2iscsi/be_cmds.h
index 23397d51ac54..99073086dfe0 100644
--- a/drivers/scsi/be2iscsi/be_cmds.h
+++ b/drivers/scsi/be2iscsi/be_cmds.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2012 Emulex
+ * Copyright (C) 2005 - 2013 Emulex
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -52,6 +52,10 @@ struct be_mcc_wrb {
 
 /* Completion Status */
 #define MCC_STATUS_SUCCESS 0x0
+#define MCC_STATUS_FAILED 0x1
+#define MCC_STATUS_ILLEGAL_REQUEST 0x2
+#define MCC_STATUS_ILLEGAL_FIELD 0x3
+#define MCC_STATUS_INSUFFICIENT_BUFFER 0x4
 
 #define CQE_STATUS_COMPL_MASK 0xFFFF
 #define CQE_STATUS_COMPL_SHIFT 0        /* bits 0 - 15 */
@@ -118,7 +122,8 @@ struct be_async_event_trailer {
 
 enum {
         ASYNC_EVENT_LINK_DOWN = 0x0,
-        ASYNC_EVENT_LINK_UP = 0x1
+        ASYNC_EVENT_LINK_UP = 0x1,
+        ASYNC_EVENT_LOGICAL = 0x2
 };
 
 /**
@@ -130,6 +135,9 @@ struct be_async_event_link_state {
         u8 port_link_status;
         u8 port_duplex;
         u8 port_speed;
+#define BEISCSI_PHY_LINK_FAULT_NONE     0x00
+#define BEISCSI_PHY_LINK_FAULT_LOCAL    0x01
+#define BEISCSI_PHY_LINK_FAULT_REMOTE   0x02
         u8 port_fault;
         u8 rsvd0[7];
         struct be_async_event_trailer trailer;
@@ -697,6 +705,7 @@ int beiscsi_mccq_compl(struct beiscsi_hba *phba,
                         uint32_t tag, struct be_mcc_wrb **wrb, void *cmd_va);
 /*ISCSI Functuions */
 int be_cmd_fw_initialize(struct be_ctrl_info *ctrl);
+int be_cmd_fw_uninit(struct be_ctrl_info *ctrl);
 
 struct be_mcc_wrb *wrb_from_mbox(struct be_dma_mem *mbox_mem);
 struct be_mcc_wrb *wrb_from_mccq(struct beiscsi_hba *phba);
@@ -751,6 +760,18 @@ struct amap_be_default_pdu_context {
         u8 rsvd4[32];           /* dword 3 */
 } __packed;
 
+struct amap_default_pdu_context_ext {
+        u8 rsvd0[16];   /* dword 0 */
+        u8 ring_size[4];    /* dword 0 */
+        u8 rsvd1[12];   /* dword 0 */
+        u8 rsvd2[22];   /* dword 1 */
+        u8 rx_pdid[9];  /* dword 1 */
+        u8 rx_pdid_valid;   /* dword 1 */
+        u8 default_buffer_size[16]; /* dword 2 */
+        u8 cq_id_recv[16];  /* dword 2 */
+        u8 rsvd3[32];   /* dword 3 */
+} __packed;
+
 struct be_defq_create_req {
         struct be_cmd_req_hdr hdr;
         u16 num_pages;
@@ -896,7 +917,7 @@ struct amap_it_dmsg_cqe_v2 {
  * stack to notify the
  * controller of a posted Work Request Block
  */
-#define DB_WRB_POST_CID_MASK            0x3FF   /* bits 0 - 9 */
+#define DB_WRB_POST_CID_MASK            0xFFFF  /* bits 0 - 16 */
 #define DB_DEF_PDU_WRB_INDEX_MASK       0xFF    /* bits 0 - 9 */
 
 #define DB_DEF_PDU_WRB_INDEX_SHIFT      16
diff --git a/drivers/scsi/be2iscsi/be_iscsi.c b/drivers/scsi/be2iscsi/be_iscsi.c
index 9014690fe841..ef36be003f67 100644
--- a/drivers/scsi/be2iscsi/be_iscsi.c
+++ b/drivers/scsi/be2iscsi/be_iscsi.c
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2012 Emulex
+ * Copyright (C) 2005 - 2013 Emulex
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -161,7 +161,9 @@ static int beiscsi_bindconn_cid(struct beiscsi_hba *phba,
                                 struct beiscsi_conn *beiscsi_conn,
                                 unsigned int cid)
 {
-        if (phba->conn_table[cid]) {
+        uint16_t cri_index = BE_GET_CRI_FROM_CID(cid);
+
+        if (phba->conn_table[cri_index]) {
                 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
                             "BS_%d : Connection table already occupied. Detected clash\n");
 
@@ -169,9 +171,9 @@ static int beiscsi_bindconn_cid(struct beiscsi_hba *phba,
         } else {
                 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
                             "BS_%d : phba->conn_table[%d]=%p(beiscsi_conn)\n",
-                            cid, beiscsi_conn);
+                            cri_index, beiscsi_conn);
 
-                phba->conn_table[cid] = beiscsi_conn;
+                phba->conn_table[cri_index] = beiscsi_conn;
         }
         return 0;
 }
@@ -990,9 +992,27 @@ static void beiscsi_put_cid(struct beiscsi_hba *phba, unsigned short cid)
 static void beiscsi_free_ep(struct beiscsi_endpoint *beiscsi_ep)
 {
         struct beiscsi_hba *phba = beiscsi_ep->phba;
+        struct beiscsi_conn *beiscsi_conn;
 
         beiscsi_put_cid(phba, beiscsi_ep->ep_cid);
         beiscsi_ep->phba = NULL;
+        phba->ep_array[BE_GET_CRI_FROM_CID
+                       (beiscsi_ep->ep_cid)] = NULL;
+
+        /**
+         * Check if any connection resource allocated by driver
+         * is to be freed.This case occurs when target redirection
+         * or connection retry is done.
+         **/
+        if (!beiscsi_ep->conn)
+                return;
+
+        beiscsi_conn = beiscsi_ep->conn;
+        if (beiscsi_conn->login_in_progress) {
+                beiscsi_free_mgmt_task_handles(beiscsi_conn,
+                                               beiscsi_conn->task);
+                beiscsi_conn->login_in_progress = 0;
+        }
 }
 
 /**
@@ -1009,7 +1029,6 @@ static int beiscsi_open_conn(struct iscsi_endpoint *ep,
 {
         struct beiscsi_endpoint *beiscsi_ep = ep->dd_data;
         struct beiscsi_hba *phba = beiscsi_ep->phba;
-        struct be_mcc_wrb *wrb;
         struct tcp_connect_and_offload_out *ptcpcnct_out;
         struct be_dma_mem nonemb_cmd;
         unsigned int tag;
@@ -1029,15 +1048,8 @@ static int beiscsi_open_conn(struct iscsi_endpoint *ep,
                     "BS_%d : In beiscsi_open_conn, ep_cid=%d\n",
                     beiscsi_ep->ep_cid);
 
-        phba->ep_array[beiscsi_ep->ep_cid -
-                       phba->fw_config.iscsi_cid_start] = ep;
-        if (beiscsi_ep->ep_cid > (phba->fw_config.iscsi_cid_start +
-                                  phba->params.cxns_per_ctrl * 2)) {
-
-                beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
-                            "BS_%d : Failed in allocate iscsi cid\n");
-                goto free_ep;
-        }
+        phba->ep_array[BE_GET_CRI_FROM_CID
+                       (beiscsi_ep->ep_cid)] = ep;
 
         beiscsi_ep->cid_vld = 0;
         nonemb_cmd.va = pci_alloc_consistent(phba->ctrl.pdev,
@@ -1049,24 +1061,24 @@ static int beiscsi_open_conn(struct iscsi_endpoint *ep,
                             "BS_%d : Failed to allocate memory for"
                             " mgmt_open_connection\n");
 
-                beiscsi_put_cid(phba, beiscsi_ep->ep_cid);
+                beiscsi_free_ep(beiscsi_ep);
                 return -ENOMEM;
         }
         nonemb_cmd.size = sizeof(struct tcp_connect_and_offload_in);
         memset(nonemb_cmd.va, 0, nonemb_cmd.size);
         tag = mgmt_open_connection(phba, dst_addr, beiscsi_ep, &nonemb_cmd);
-        if (!tag) {
+        if (tag <= 0) {
                 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
                             "BS_%d : mgmt_open_connection Failed for cid=%d\n",
                             beiscsi_ep->ep_cid);
 
-                beiscsi_put_cid(phba, beiscsi_ep->ep_cid);
                 pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
                                     nonemb_cmd.va, nonemb_cmd.dma);
+                beiscsi_free_ep(beiscsi_ep);
                 return -EAGAIN;
         }
 
-        ret = beiscsi_mccq_compl(phba, tag, &wrb, NULL);
+        ret = beiscsi_mccq_compl(phba, tag, NULL, nonemb_cmd.va);
         if (ret) {
                 beiscsi_log(phba, KERN_ERR,
                             BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
@@ -1074,10 +1086,11 @@ static int beiscsi_open_conn(struct iscsi_endpoint *ep,
 
                 pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
                             nonemb_cmd.va, nonemb_cmd.dma);
-                goto free_ep;
+                beiscsi_free_ep(beiscsi_ep);
+                return -EBUSY;
         }
 
-        ptcpcnct_out = embedded_payload(wrb);
+        ptcpcnct_out = (struct tcp_connect_and_offload_out *)nonemb_cmd.va;
         beiscsi_ep = ep->dd_data;
         beiscsi_ep->fw_handle = ptcpcnct_out->connection_handle;
         beiscsi_ep->cid_vld = 1;
@@ -1087,10 +1100,6 @@ static int beiscsi_open_conn(struct iscsi_endpoint *ep,
         pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
                             nonemb_cmd.va, nonemb_cmd.dma);
         return 0;
-
-free_ep:
-        beiscsi_free_ep(beiscsi_ep);
-        return -EBUSY;
 }
 
 /**
@@ -1119,6 +1128,13 @@ beiscsi_ep_connect(struct Scsi_Host *shost, struct sockaddr *dst_addr,
                 return ERR_PTR(ret);
         }
 
+        if (beiscsi_error(phba)) {
+                ret = -EIO;
+                beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
+                            "BS_%d : The FW state Not Stable!!!\n");
+                return ERR_PTR(ret);
+        }
+
         if (phba->state != BE_ADAPTER_UP) {
                 ret = -EBUSY;
                 beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
@@ -1201,8 +1217,10 @@ static int beiscsi_close_conn(struct  beiscsi_endpoint *beiscsi_ep, int flag)
 static int beiscsi_unbind_conn_to_cid(struct beiscsi_hba *phba,
                                       unsigned int cid)
 {
-        if (phba->conn_table[cid])
-                phba->conn_table[cid] = NULL;
+        uint16_t cri_index = BE_GET_CRI_FROM_CID(cid);
+
+        if (phba->conn_table[cri_index])
+                phba->conn_table[cri_index] = NULL;
         else {
                 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
                             "BS_%d : Connection table Not occupied.\n");
diff --git a/drivers/scsi/be2iscsi/be_iscsi.h b/drivers/scsi/be2iscsi/be_iscsi.h
index 38eab7232159..31ddc8494398 100644
--- a/drivers/scsi/be2iscsi/be_iscsi.h
+++ b/drivers/scsi/be2iscsi/be_iscsi.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2012 Emulex
+ * Copyright (C) 2005 - 2013 Emulex
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
diff --git a/drivers/scsi/be2iscsi/be_main.c b/drivers/scsi/be2iscsi/be_main.c
index 4e2733d23003..d24a2867bc21 100644
--- a/drivers/scsi/be2iscsi/be_main.c
+++ b/drivers/scsi/be2iscsi/be_main.c
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2012 Emulex
+ * Copyright (C) 2005 - 2013 Emulex
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -153,10 +153,14 @@ BEISCSI_RW_ATTR(log_enable, 0x00,
 
 DEVICE_ATTR(beiscsi_drvr_ver, S_IRUGO, beiscsi_drvr_ver_disp, NULL);
 DEVICE_ATTR(beiscsi_adapter_family, S_IRUGO, beiscsi_adap_family_disp, NULL);
+DEVICE_ATTR(beiscsi_fw_ver, S_IRUGO, beiscsi_fw_ver_disp, NULL);
+DEVICE_ATTR(beiscsi_active_cid_count, S_IRUGO, beiscsi_active_cid_disp, NULL);
 struct device_attribute *beiscsi_attrs[] = {
         &dev_attr_beiscsi_log_enable,
         &dev_attr_beiscsi_drvr_ver,
         &dev_attr_beiscsi_adapter_family,
+        &dev_attr_beiscsi_fw_ver,
+        &dev_attr_beiscsi_active_cid_count,
         NULL,
 };
 
@@ -702,7 +706,7 @@ static void beiscsi_get_params(struct beiscsi_hba *phba)
                                     + BE2_TMFS
                                     + BE2_NOPOUT_REQ));
         phba->params.cxns_per_ctrl = phba->fw_config.iscsi_cid_count;
-        phba->params.asyncpdus_per_ctrl = phba->fw_config.iscsi_cid_count * 2;
+        phba->params.asyncpdus_per_ctrl = phba->fw_config.iscsi_cid_count;
         phba->params.icds_per_ctrl = phba->fw_config.iscsi_icd_count;
         phba->params.num_sge_per_io = BE2_SGE;
         phba->params.defpdu_hdr_sz = BE2_DEFPDU_HDR_SZ;
@@ -1032,7 +1036,6 @@ static void hwi_ring_cq_db(struct beiscsi_hba *phba,
 static unsigned int
 beiscsi_process_async_pdu(struct beiscsi_conn *beiscsi_conn,
                           struct beiscsi_hba *phba,
-                          unsigned short cid,
                           struct pdu_base *ppdu,
                           unsigned long pdu_len,
                           void *pbuffer, unsigned long buf_len)
@@ -1144,9 +1147,10 @@ struct wrb_handle *alloc_wrb_handle(struct beiscsi_hba *phba, unsigned int cid)
         struct hwi_wrb_context *pwrb_context;
         struct hwi_controller *phwi_ctrlr;
         struct wrb_handle *pwrb_handle, *pwrb_handle_tmp;
+        uint16_t cri_index = BE_GET_CRI_FROM_CID(cid);
 
         phwi_ctrlr = phba->phwi_ctrlr;
-        pwrb_context = &phwi_ctrlr->wrb_context[cid];
+        pwrb_context = &phwi_ctrlr->wrb_context[cri_index];
         if (pwrb_context->wrb_handles_available >= 2) {
                 pwrb_handle = pwrb_context->pwrb_handle_base[
                                             pwrb_context->alloc_index];
@@ -1322,8 +1326,9 @@ be_complete_logout(struct beiscsi_conn *beiscsi_conn,
         hdr->t2retain = 0;
         hdr->flags = csol_cqe->i_flags;
         hdr->response = csol_cqe->i_resp;
-        hdr->exp_cmdsn = csol_cqe->exp_cmdsn;
-        hdr->max_cmdsn = (csol_cqe->exp_cmdsn + csol_cqe->cmd_wnd - 1);
+        hdr->exp_cmdsn = cpu_to_be32(csol_cqe->exp_cmdsn);
+        hdr->max_cmdsn = cpu_to_be32(csol_cqe->exp_cmdsn +
+                                     csol_cqe->cmd_wnd - 1);
 
         hdr->dlength[0] = 0;
         hdr->dlength[1] = 0;
@@ -1346,9 +1351,9 @@ be_complete_tmf(struct beiscsi_conn *beiscsi_conn,
         hdr->opcode = ISCSI_OP_SCSI_TMFUNC_RSP;
         hdr->flags = csol_cqe->i_flags;
         hdr->response = csol_cqe->i_resp;
-        hdr->exp_cmdsn = csol_cqe->exp_cmdsn;
-        hdr->max_cmdsn = (csol_cqe->exp_cmdsn +
-                          csol_cqe->cmd_wnd - 1);
+        hdr->exp_cmdsn = cpu_to_be32(csol_cqe->exp_cmdsn);
+        hdr->max_cmdsn = cpu_to_be32(csol_cqe->exp_cmdsn +
+                                     csol_cqe->cmd_wnd - 1);
 
         hdr->itt = io_task->libiscsi_itt;
         __iscsi_complete_pdu(conn, (struct iscsi_hdr *)hdr, NULL, 0);
@@ -1363,35 +1368,29 @@ hwi_complete_drvr_msgs(struct beiscsi_conn *beiscsi_conn,
         struct hwi_controller *phwi_ctrlr;
         struct iscsi_task *task;
         struct beiscsi_io_task *io_task;
-        struct iscsi_conn *conn = beiscsi_conn->conn;
-        struct iscsi_session *session = conn->session;
-        uint16_t wrb_index, cid;
+        uint16_t wrb_index, cid, cri_index;
 
         phwi_ctrlr = phba->phwi_ctrlr;
-        if (chip_skh_r(phba->pcidev)) {
-                wrb_index = AMAP_GET_BITS(struct amap_it_dmsg_cqe_v2,
+        if (is_chip_be2_be3r(phba)) {
+                wrb_index = AMAP_GET_BITS(struct amap_it_dmsg_cqe,
                                           wrb_idx, psol);
-                cid = AMAP_GET_BITS(struct amap_it_dmsg_cqe_v2,
+                cid = AMAP_GET_BITS(struct amap_it_dmsg_cqe,
                                     cid, psol);
         } else {
-                wrb_index = AMAP_GET_BITS(struct amap_it_dmsg_cqe,
+                wrb_index = AMAP_GET_BITS(struct amap_it_dmsg_cqe_v2,
                                           wrb_idx, psol);
-                cid = AMAP_GET_BITS(struct amap_it_dmsg_cqe,
+                cid = AMAP_GET_BITS(struct amap_it_dmsg_cqe_v2,
                                     cid, psol);
         }
 
-        pwrb_context = &phwi_ctrlr->wrb_context[
-                        cid - phba->fw_config.iscsi_cid_start];
+        cri_index = BE_GET_CRI_FROM_CID(cid);
+        pwrb_context = &phwi_ctrlr->wrb_context[cri_index];
         pwrb_handle = pwrb_context->pwrb_handle_basestd[wrb_index];
         task = pwrb_handle->pio_handle;
 
         io_task = task->dd_data;
-        spin_lock_bh(&phba->mgmt_sgl_lock);
-        free_mgmt_sgl_handle(phba, io_task->psgl_handle);
-        spin_unlock_bh(&phba->mgmt_sgl_lock);
-        spin_lock_bh(&session->lock);
-        free_wrb_handle(phba, pwrb_context, pwrb_handle);
-        spin_unlock_bh(&session->lock);
+        memset(io_task->pwrb_handle->pwrb, 0, sizeof(struct iscsi_wrb));
+        iscsi_put_task(task);
 }
 
 static void
@@ -1406,8 +1405,8 @@ be_complete_nopin_resp(struct beiscsi_conn *beiscsi_conn,
         hdr = (struct iscsi_nopin *)task->hdr;
         hdr->flags = csol_cqe->i_flags;
         hdr->exp_cmdsn = cpu_to_be32(csol_cqe->exp_cmdsn);
-        hdr->max_cmdsn = be32_to_cpu(hdr->exp_cmdsn +
-                         csol_cqe->cmd_wnd - 1);
+        hdr->max_cmdsn = cpu_to_be32(csol_cqe->exp_cmdsn +
+                                     csol_cqe->cmd_wnd - 1);
 
         hdr->opcode = ISCSI_OP_NOOP_IN;
         hdr->itt = io_task->libiscsi_itt;
@@ -1418,7 +1417,26 @@ static void adapter_get_sol_cqe(struct beiscsi_hba *phba,
                 struct sol_cqe *psol,
                 struct common_sol_cqe *csol_cqe)
 {
-        if (chip_skh_r(phba->pcidev)) {
+        if (is_chip_be2_be3r(phba)) {
+                csol_cqe->exp_cmdsn = AMAP_GET_BITS(struct amap_sol_cqe,
+                                                    i_exp_cmd_sn, psol);
+                csol_cqe->res_cnt = AMAP_GET_BITS(struct amap_sol_cqe,
+                                                  i_res_cnt, psol);
+                csol_cqe->cmd_wnd = AMAP_GET_BITS(struct amap_sol_cqe,
+                                                  i_cmd_wnd, psol);
+                csol_cqe->wrb_index = AMAP_GET_BITS(struct amap_sol_cqe,
+                                                    wrb_index, psol);
+                csol_cqe->cid = AMAP_GET_BITS(struct amap_sol_cqe,
+                                              cid, psol);
+                csol_cqe->hw_sts = AMAP_GET_BITS(struct amap_sol_cqe,
+                                                 hw_sts, psol);
+                csol_cqe->i_resp = AMAP_GET_BITS(struct amap_sol_cqe,
+                                                 i_resp, psol);
+                csol_cqe->i_sts = AMAP_GET_BITS(struct amap_sol_cqe,
+                                                i_sts, psol);
+                csol_cqe->i_flags = AMAP_GET_BITS(struct amap_sol_cqe,
+                                                  i_flags, psol);
+        } else {
                 csol_cqe->exp_cmdsn = AMAP_GET_BITS(struct amap_sol_cqe_v2,
                                                     i_exp_cmd_sn, psol);
                 csol_cqe->res_cnt = AMAP_GET_BITS(struct amap_sol_cqe_v2,
@@ -1429,7 +1447,7 @@ static void adapter_get_sol_cqe(struct beiscsi_hba *phba,
                                               cid, psol);
                 csol_cqe->hw_sts = AMAP_GET_BITS(struct amap_sol_cqe_v2,
                                                  hw_sts, psol);
-                csol_cqe->cmd_wnd = AMAP_GET_BITS(struct amap_sol_cqe,
+                csol_cqe->cmd_wnd = AMAP_GET_BITS(struct amap_sol_cqe_v2,
                                                   i_cmd_wnd, psol);
                 if (AMAP_GET_BITS(struct amap_sol_cqe_v2,
                                   cmd_cmpl, psol))
@@ -1445,25 +1463,6 @@ static void adapter_get_sol_cqe(struct beiscsi_hba *phba,
                 if (AMAP_GET_BITS(struct amap_sol_cqe_v2,
                                   o, psol))
                         csol_cqe->i_flags |= ISCSI_FLAG_CMD_OVERFLOW;
-        } else {
-                csol_cqe->exp_cmdsn = AMAP_GET_BITS(struct amap_sol_cqe,
-                                                    i_exp_cmd_sn, psol);
-                csol_cqe->res_cnt = AMAP_GET_BITS(struct amap_sol_cqe,
-                                                  i_res_cnt, psol);
-                csol_cqe->cmd_wnd = AMAP_GET_BITS(struct amap_sol_cqe,
-                                                  i_cmd_wnd, psol);
-                csol_cqe->wrb_index = AMAP_GET_BITS(struct amap_sol_cqe,
-                                                    wrb_index, psol);
-                csol_cqe->cid = AMAP_GET_BITS(struct amap_sol_cqe,
-                                              cid, psol);
-                csol_cqe->hw_sts = AMAP_GET_BITS(struct amap_sol_cqe,
-                                                 hw_sts, psol);
-                csol_cqe->i_resp = AMAP_GET_BITS(struct amap_sol_cqe,
-                                                 i_resp, psol);
-                csol_cqe->i_sts = AMAP_GET_BITS(struct amap_sol_cqe,
-                                                i_sts, psol);
-                csol_cqe->i_flags = AMAP_GET_BITS(struct amap_sol_cqe,
-                                                  i_flags, psol);
         }
 }
 
@@ -1480,14 +1479,15 @@ static void hwi_complete_cmd(struct beiscsi_conn *beiscsi_conn,
         struct iscsi_conn *conn = beiscsi_conn->conn;
         struct iscsi_session *session = conn->session;
         struct common_sol_cqe csol_cqe = {0};
+        uint16_t cri_index = 0;
 
         phwi_ctrlr = phba->phwi_ctrlr;
 
         /* Copy the elements to a common structure */
         adapter_get_sol_cqe(phba, psol, &csol_cqe);
 
-        pwrb_context = &phwi_ctrlr->wrb_context[
-                        csol_cqe.cid - phba->fw_config.iscsi_cid_start];
+        cri_index = BE_GET_CRI_FROM_CID(csol_cqe.cid);
+        pwrb_context = &phwi_ctrlr->wrb_context[cri_index];
 
         pwrb_handle = pwrb_context->pwrb_handle_basestd[
                       csol_cqe.wrb_index];
@@ -1561,15 +1561,15 @@ hwi_get_async_handle(struct beiscsi_hba *phba,
         unsigned char is_header = 0;
         unsigned int index, dpl;
 
-        if (chip_skh_r(phba->pcidev)) {
-                dpl = AMAP_GET_BITS(struct amap_i_t_dpdu_cqe_v2,
+        if (is_chip_be2_be3r(phba)) {
+                dpl = AMAP_GET_BITS(struct amap_i_t_dpdu_cqe,
                                     dpl, pdpdu_cqe);
-                index = AMAP_GET_BITS(struct amap_i_t_dpdu_cqe_v2,
+                index = AMAP_GET_BITS(struct amap_i_t_dpdu_cqe,
                                       index, pdpdu_cqe);
         } else {
-                dpl = AMAP_GET_BITS(struct amap_i_t_dpdu_cqe,
+                dpl = AMAP_GET_BITS(struct amap_i_t_dpdu_cqe_v2,
                                     dpl, pdpdu_cqe);
-                index = AMAP_GET_BITS(struct amap_i_t_dpdu_cqe,
+                index = AMAP_GET_BITS(struct amap_i_t_dpdu_cqe_v2,
                                       index, pdpdu_cqe);
         }
 
@@ -1613,8 +1613,8 @@ hwi_get_async_handle(struct beiscsi_hba *phba,
 
         WARN_ON(!pasync_handle);
 
-        pasync_handle->cri = (unsigned short)beiscsi_conn->beiscsi_conn_cid -
-                                             phba->fw_config.iscsi_cid_start;
+        pasync_handle->cri =
+                        BE_GET_CRI_FROM_CID(beiscsi_conn->beiscsi_conn_cid);
         pasync_handle->is_header = is_header;
         pasync_handle->buffer_len = dpl;
         *pcq_index = index;
@@ -1856,8 +1856,6 @@ hwi_fwd_async_msg(struct beiscsi_conn *beiscsi_conn,
         }
 
         status = beiscsi_process_async_pdu(beiscsi_conn, phba,
-                                           (beiscsi_conn->beiscsi_conn_cid -
-                                            phba->fw_config.iscsi_cid_start),
                                             phdr, hdr_len, pfirst_buffer,
                                             offset);
 
@@ -2011,6 +2009,7 @@ static unsigned int beiscsi_process_cq(struct be_eq_obj *pbe_eq)
         unsigned int num_processed = 0;
         unsigned int tot_nump = 0;
         unsigned short code = 0, cid = 0;
+        uint16_t cri_index = 0;
         struct beiscsi_conn *beiscsi_conn;
         struct beiscsi_endpoint *beiscsi_ep;
         struct iscsi_endpoint *ep;
@@ -2028,7 +2027,9 @@ static unsigned int beiscsi_process_cq(struct be_eq_obj *pbe_eq)
                          32] & CQE_CODE_MASK);
 
                  /* Get the CID */
-                if (chip_skh_r(phba->pcidev)) {
+                if (is_chip_be2_be3r(phba)) {
+                        cid = AMAP_GET_BITS(struct amap_sol_cqe, cid, sol);
+                } else {
                         if ((code == DRIVERMSG_NOTIFY) ||
                             (code == UNSOL_HDR_NOTIFY) ||
                             (code == UNSOL_DATA_NOTIFY))
@@ -2038,10 +2039,10 @@ static unsigned int beiscsi_process_cq(struct be_eq_obj *pbe_eq)
                          else
                                  cid = AMAP_GET_BITS(struct amap_sol_cqe_v2,
                                                      cid, sol);
-                   } else
-                         cid = AMAP_GET_BITS(struct amap_sol_cqe, cid, sol);
+                }
 
-                ep = phba->ep_array[cid - phba->fw_config.iscsi_cid_start];
+                cri_index = BE_GET_CRI_FROM_CID(cid);
+                ep = phba->ep_array[cri_index];
                 beiscsi_ep = ep->dd_data;
                 beiscsi_conn = beiscsi_ep->conn;
 
@@ -2191,7 +2192,7 @@ void beiscsi_process_all_cqs(struct work_struct *work)
 
 static int be_iopoll(struct blk_iopoll *iop, int budget)
 {
-        static unsigned int ret;
+        unsigned int ret;
         struct beiscsi_hba *phba;
         struct be_eq_obj *pbe_eq;
 
@@ -2416,11 +2417,11 @@ static void hwi_write_buffer(struct iscsi_wrb *pwrb, struct iscsi_task *task)
                 /* Check for the data_count */
                 dsp_value = (task->data_count) ? 1 : 0;
 
-                if (chip_skh_r(phba->pcidev))
-                        AMAP_SET_BITS(struct amap_iscsi_wrb_v2, dsp,
+                if (is_chip_be2_be3r(phba))
+                        AMAP_SET_BITS(struct amap_iscsi_wrb, dsp,
                                       pwrb, dsp_value);
                 else
-                        AMAP_SET_BITS(struct amap_iscsi_wrb, dsp,
+                        AMAP_SET_BITS(struct amap_iscsi_wrb_v2, dsp,
                                       pwrb, dsp_value);
 
                 /* Map addr only if there is data_count */
@@ -2538,8 +2539,9 @@ static void beiscsi_find_mem_req(struct beiscsi_hba *phba)
 
 static int beiscsi_alloc_mem(struct beiscsi_hba *phba)
 {
-        struct be_mem_descriptor *mem_descr;
         dma_addr_t bus_add;
+        struct hwi_controller *phwi_ctrlr;
+        struct be_mem_descriptor *mem_descr;
         struct mem_array *mem_arr, *mem_arr_orig;
         unsigned int i, j, alloc_size, curr_alloc_size;
 
@@ -2547,9 +2549,18 @@ static int beiscsi_alloc_mem(struct beiscsi_hba *phba)
         if (!phba->phwi_ctrlr)
                 return -ENOMEM;
 
+        /* Allocate memory for wrb_context */
+        phwi_ctrlr = phba->phwi_ctrlr;
+        phwi_ctrlr->wrb_context = kzalloc(sizeof(struct hwi_wrb_context) *
+                                          phba->params.cxns_per_ctrl,
+                                          GFP_KERNEL);
+        if (!phwi_ctrlr->wrb_context)
+                return -ENOMEM;
+
         phba->init_mem = kcalloc(SE_MEM_MAX, sizeof(*mem_descr),
                                  GFP_KERNEL);
         if (!phba->init_mem) {
+                kfree(phwi_ctrlr->wrb_context);
                 kfree(phba->phwi_ctrlr);
                 return -ENOMEM;
         }
@@ -2558,6 +2569,7 @@ static int beiscsi_alloc_mem(struct beiscsi_hba *phba)
                                GFP_KERNEL);
         if (!mem_arr_orig) {
                 kfree(phba->init_mem);
+                kfree(phwi_ctrlr->wrb_context);
                 kfree(phba->phwi_ctrlr);
                 return -ENOMEM;
         }
@@ -2628,6 +2640,7 @@ free_mem:
         }
         kfree(mem_arr_orig);
         kfree(phba->init_mem);
+        kfree(phba->phwi_ctrlr->wrb_context);
         kfree(phba->phwi_ctrlr);
         return -ENOMEM;
 }
@@ -2666,6 +2679,7 @@ static void iscsi_init_global_templates(struct beiscsi_hba *phba)
 static int beiscsi_init_wrb_handle(struct beiscsi_hba *phba)
 {
         struct be_mem_descriptor *mem_descr_wrbh, *mem_descr_wrb;
+        struct hwi_context_memory *phwi_ctxt;
         struct wrb_handle *pwrb_handle = NULL;
         struct hwi_controller *phwi_ctrlr;
         struct hwi_wrb_context *pwrb_context;
@@ -2680,7 +2694,18 @@ static int beiscsi_init_wrb_handle(struct beiscsi_hba *phba)
         mem_descr_wrb += HWI_MEM_WRB;
         phwi_ctrlr = phba->phwi_ctrlr;
 
-        for (index = 0; index < phba->params.cxns_per_ctrl * 2; index += 2) {
+        /* Allocate memory for WRBQ */
+        phwi_ctxt = phwi_ctrlr->phwi_ctxt;
+        phwi_ctxt->be_wrbq = kzalloc(sizeof(struct be_queue_info) *
+                                     phba->fw_config.iscsi_cid_count,
+                                     GFP_KERNEL);
+        if (!phwi_ctxt->be_wrbq) {
+                beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
+                            "BM_%d : WRBQ Mem Alloc Failed\n");
+                return -ENOMEM;
+        }
+
+        for (index = 0; index < phba->params.cxns_per_ctrl; index++) {
                 pwrb_context = &phwi_ctrlr->wrb_context[index];
                 pwrb_context->pwrb_handle_base =
                                 kzalloc(sizeof(struct wrb_handle *) *
@@ -2723,7 +2748,7 @@ static int beiscsi_init_wrb_handle(struct beiscsi_hba *phba)
                 }
         }
         idx = 0;
-        for (index = 0; index < phba->params.cxns_per_ctrl * 2; index += 2) {
+        for (index = 0; index < phba->params.cxns_per_ctrl; index++) {
                 pwrb_context = &phwi_ctrlr->wrb_context[index];
                 if (!num_cxn_wrb) {
                         pwrb = mem_descr_wrb->mem_array[idx].virtual_address;
@@ -2752,7 +2777,7 @@ init_wrb_hndl_failed:
         return -ENOMEM;
 }
 
-static void hwi_init_async_pdu_ctx(struct beiscsi_hba *phba)
+static int hwi_init_async_pdu_ctx(struct beiscsi_hba *phba)
 {
         struct hwi_controller *phwi_ctrlr;
         struct hba_parameters *p = &phba->params;
@@ -2770,6 +2795,15 @@ static void hwi_init_async_pdu_ctx(struct beiscsi_hba *phba)
         pasync_ctx = phwi_ctrlr->phwi_ctxt->pasync_ctx;
         memset(pasync_ctx, 0, sizeof(*pasync_ctx));
 
+        pasync_ctx->async_entry = kzalloc(sizeof(struct hwi_async_entry) *
+                                          phba->fw_config.iscsi_cid_count,
+                                          GFP_KERNEL);
+        if (!pasync_ctx->async_entry) {
+                beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
+                            "BM_%d : hwi_init_async_pdu_ctx Mem Alloc Failed\n");
+                return -ENOMEM;
+        }
+
         pasync_ctx->num_entries = p->asyncpdus_per_ctrl;
         pasync_ctx->buffer_size = p->defpdu_hdr_sz;
 
@@ -2934,6 +2968,8 @@ static void hwi_init_async_pdu_ctx(struct beiscsi_hba *phba)
         pasync_ctx->async_header.ep_read_ptr = -1;
         pasync_ctx->async_data.host_write_ptr = 0;
         pasync_ctx->async_data.ep_read_ptr = -1;
+
+        return 0;
 }
 
 static int
@@ -3293,6 +3329,7 @@ beiscsi_create_wrb_rings(struct beiscsi_hba *phba,
         void *wrb_vaddr;
         struct be_dma_mem sgl;
         struct be_mem_descriptor *mem_descr;
+        struct hwi_wrb_context *pwrb_context;
         int status;
 
         idx = 0;
@@ -3351,8 +3388,9 @@ beiscsi_create_wrb_rings(struct beiscsi_hba *phba,
                         kfree(pwrb_arr);
                         return status;
                 }
-                phwi_ctrlr->wrb_context[i * 2].cid = phwi_context->be_wrbq[i].
-                                                                   id;
+                pwrb_context = &phwi_ctrlr->wrb_context[i];
+                pwrb_context->cid = phwi_context->be_wrbq[i].id;
+                BE_SET_CID_TO_CRI(i, pwrb_context->cid);
         }
         kfree(pwrb_arr);
         return 0;
@@ -3365,7 +3403,7 @@ static void free_wrb_handles(struct beiscsi_hba *phba)
         struct hwi_wrb_context *pwrb_context;
 
         phwi_ctrlr = phba->phwi_ctrlr;
-        for (index = 0; index < phba->params.cxns_per_ctrl * 2; index += 2) {
+        for (index = 0; index < phba->params.cxns_per_ctrl; index++) {
                 pwrb_context = &phwi_ctrlr->wrb_context[index];
                 kfree(pwrb_context->pwrb_handle_base);
                 kfree(pwrb_context->pwrb_handle_basestd);
@@ -3394,6 +3432,7 @@ static void hwi_cleanup(struct beiscsi_hba *phba)
         struct be_ctrl_info *ctrl = &phba->ctrl;
         struct hwi_controller *phwi_ctrlr;
         struct hwi_context_memory *phwi_context;
+        struct hwi_async_pdu_context *pasync_ctx;
         int i, eq_num;
 
         phwi_ctrlr = phba->phwi_ctrlr;
@@ -3403,6 +3442,7 @@ static void hwi_cleanup(struct beiscsi_hba *phba)
                 if (q->created)
                         beiscsi_cmd_q_destroy(ctrl, q, QTYPE_WRBQ);
         }
+        kfree(phwi_context->be_wrbq);
         free_wrb_handles(phba);
 
         q = &phwi_context->be_def_hdrq;
@@ -3430,6 +3470,10 @@ static void hwi_cleanup(struct beiscsi_hba *phba)
                         beiscsi_cmd_q_destroy(ctrl, q, QTYPE_EQ);
         }
         be_mcc_queues_destroy(phba);
+
+        pasync_ctx = phwi_ctrlr->phwi_ctxt->pasync_ctx;
+        kfree(pasync_ctx->async_entry);
+        be_cmd_fw_uninit(ctrl);
 }
 
 static int be_mcc_queues_create(struct beiscsi_hba *phba,
@@ -3607,7 +3651,12 @@ static int hwi_init_controller(struct beiscsi_hba *phba)
         if (beiscsi_init_wrb_handle(phba))
                 return -ENOMEM;
 
-        hwi_init_async_pdu_ctx(phba);
+        if (hwi_init_async_pdu_ctx(phba)) {
+                beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
+                            "BM_%d : hwi_init_async_pdu_ctx failed\n");
+                return -ENOMEM;
+        }
+
         if (hwi_init_port(phba) != 0) {
                 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
                             "BM_%d : hwi_init_controller failed\n");
@@ -3637,6 +3686,7 @@ static void beiscsi_free_mem(struct beiscsi_hba *phba)
                 mem_descr++;
         }
         kfree(phba->init_mem);
+        kfree(phba->phwi_ctrlr->wrb_context);
         kfree(phba->phwi_ctrlr);
 }
 
@@ -3769,7 +3819,7 @@ static int beiscsi_init_sgl_handle(struct beiscsi_hba *phba)
 
 static int hba_setup_cid_tbls(struct beiscsi_hba *phba)
 {
-        int i, new_cid;
+        int i;
 
         phba->cid_array = kzalloc(sizeof(void *) * phba->params.cxns_per_ctrl,
                                   GFP_KERNEL);
@@ -3780,19 +3830,33 @@ static int hba_setup_cid_tbls(struct beiscsi_hba *phba)
                 return -ENOMEM;
         }
         phba->ep_array = kzalloc(sizeof(struct iscsi_endpoint *) *
-                                 phba->params.cxns_per_ctrl * 2, GFP_KERNEL);
+                                 phba->params.cxns_per_ctrl, GFP_KERNEL);
         if (!phba->ep_array) {
                 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
                             "BM_%d : Failed to allocate memory in "
                             "hba_setup_cid_tbls\n");
                 kfree(phba->cid_array);
+                phba->cid_array = NULL;
                 return -ENOMEM;
         }
-        new_cid = phba->fw_config.iscsi_cid_start;
-        for (i = 0; i < phba->params.cxns_per_ctrl; i++) {
-                phba->cid_array[i] = new_cid;
-                new_cid += 2;
+
+        phba->conn_table = kzalloc(sizeof(struct beiscsi_conn *) *
+                                   phba->params.cxns_per_ctrl, GFP_KERNEL);
+        if (!phba->conn_table) {
+                beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
+                            "BM_%d : Failed to allocate memory in"
+                            "hba_setup_cid_tbls\n");
+
+                kfree(phba->cid_array);
+                kfree(phba->ep_array);
+                phba->cid_array = NULL;
+                phba->ep_array = NULL;
+                return -ENOMEM;
         }
+
+        for (i = 0; i < phba->params.cxns_per_ctrl; i++)
+                phba->cid_array[i] = phba->phwi_ctrlr->wrb_context[i].cid;
+
         phba->avlbl_cids = phba->params.cxns_per_ctrl;
         return 0;
 }
@@ -4062,6 +4126,53 @@ static void beiscsi_clean_port(struct beiscsi_hba *phba)
         kfree(phba->eh_sgl_hndl_base);
         kfree(phba->cid_array);
         kfree(phba->ep_array);
+        kfree(phba->conn_table);
+}
+
+/**
+ * beiscsi_free_mgmt_task_handles()- Free driver CXN resources
+ * @beiscsi_conn: ptr to the conn to be cleaned up
+ * @task: ptr to iscsi_task resource to be freed.
+ *
+ * Free driver mgmt resources binded to CXN.
+ **/
+void
+beiscsi_free_mgmt_task_handles(struct beiscsi_conn *beiscsi_conn,
+                                struct iscsi_task *task)
+{
+        struct beiscsi_io_task *io_task;
+        struct beiscsi_hba *phba = beiscsi_conn->phba;
+        struct hwi_wrb_context *pwrb_context;
+        struct hwi_controller *phwi_ctrlr;
+        uint16_t cri_index = BE_GET_CRI_FROM_CID(
+                                beiscsi_conn->beiscsi_conn_cid);
+
+        phwi_ctrlr = phba->phwi_ctrlr;
+        pwrb_context = &phwi_ctrlr->wrb_context[cri_index];
+
+        io_task = task->dd_data;
+
+        if (io_task->pwrb_handle) {
+                memset(io_task->pwrb_handle->pwrb, 0,
+                       sizeof(struct iscsi_wrb));
+                free_wrb_handle(phba, pwrb_context,
+                                io_task->pwrb_handle);
+                io_task->pwrb_handle = NULL;
+        }
+
+        if (io_task->psgl_handle) {
+                spin_lock_bh(&phba->mgmt_sgl_lock);
+                free_mgmt_sgl_handle(phba,
+                                     io_task->psgl_handle);
+                io_task->psgl_handle = NULL;
+                spin_unlock_bh(&phba->mgmt_sgl_lock);
+        }
+
+        if (io_task->mtask_addr)
+                pci_unmap_single(phba->pcidev,
+                                 io_task->mtask_addr,
+                                 io_task->mtask_data_count,
+                                 PCI_DMA_TODEVICE);
 }
 
 /**
@@ -4078,10 +4189,11 @@ static void beiscsi_cleanup_task(struct iscsi_task *task)
         struct beiscsi_session *beiscsi_sess = beiscsi_conn->beiscsi_sess;
         struct hwi_wrb_context *pwrb_context;
         struct hwi_controller *phwi_ctrlr;
+        uint16_t cri_index = BE_GET_CRI_FROM_CID(
+                             beiscsi_conn->beiscsi_conn_cid);
 
         phwi_ctrlr = phba->phwi_ctrlr;
-        pwrb_context = &phwi_ctrlr->wrb_context[beiscsi_conn->beiscsi_conn_cid
-                        - phba->fw_config.iscsi_cid_start];
+        pwrb_context = &phwi_ctrlr->wrb_context[cri_index];
 
         if (io_task->cmd_bhs) {
                 pci_pool_free(beiscsi_sess->bhs_pool, io_task->cmd_bhs,
@@ -4103,27 +4215,8 @@ static void beiscsi_cleanup_task(struct iscsi_task *task)
                         io_task->psgl_handle = NULL;
                 }
         } else {
-                if (!beiscsi_conn->login_in_progress) {
-                        if (io_task->pwrb_handle) {
-                                free_wrb_handle(phba, pwrb_context,
-                                                io_task->pwrb_handle);
-                                io_task->pwrb_handle = NULL;
-                        }
-                        if (io_task->psgl_handle) {
-                                spin_lock(&phba->mgmt_sgl_lock);
-                                free_mgmt_sgl_handle(phba,
-                                                     io_task->psgl_handle);
-                                spin_unlock(&phba->mgmt_sgl_lock);
-                                io_task->psgl_handle = NULL;
-                        }
-                        if (io_task->mtask_addr) {
-                                pci_unmap_single(phba->pcidev,
-                                                 io_task->mtask_addr,
-                                                 io_task->mtask_data_count,
-                                                 PCI_DMA_TODEVICE);
-                                io_task->mtask_addr = 0;
-                        }
-                }
+                if (!beiscsi_conn->login_in_progress)
+                        beiscsi_free_mgmt_task_handles(beiscsi_conn, task);
         }
 }
 
@@ -4146,15 +4239,14 @@ beiscsi_offload_connection(struct beiscsi_conn *beiscsi_conn,
         beiscsi_cleanup_task(task);
         spin_unlock_bh(&session->lock);
 
-        pwrb_handle = alloc_wrb_handle(phba, (beiscsi_conn->beiscsi_conn_cid -
-                                       phba->fw_config.iscsi_cid_start));
+        pwrb_handle = alloc_wrb_handle(phba, beiscsi_conn->beiscsi_conn_cid);
 
         /* Check for the adapter family */
-        if (chip_skh_r(phba->pcidev))
-                beiscsi_offload_cxn_v2(params, pwrb_handle);
-        else
+        if (is_chip_be2_be3r(phba))
                 beiscsi_offload_cxn_v0(params, pwrb_handle,
                                        phba->init_mem);
+        else
+                beiscsi_offload_cxn_v2(params, pwrb_handle);
 
         be_dws_le_to_cpu(pwrb_handle->pwrb,
                          sizeof(struct iscsi_target_context_update_wrb));
@@ -4194,6 +4286,7 @@ static int beiscsi_alloc_pdu(struct iscsi_task *task, uint8_t opcode)
         struct hwi_wrb_context *pwrb_context;
         struct hwi_controller *phwi_ctrlr;
         itt_t itt;
+        uint16_t cri_index = 0;
         struct beiscsi_session *beiscsi_sess = beiscsi_conn->beiscsi_sess;
         dma_addr_t paddr;
 
@@ -4223,8 +4316,7 @@ static int beiscsi_alloc_pdu(struct iscsi_task *task, uint8_t opcode)
                         goto free_hndls;
                 }
                 io_task->pwrb_handle = alloc_wrb_handle(phba,
-                                        beiscsi_conn->beiscsi_conn_cid -
-                                        phba->fw_config.iscsi_cid_start);
+                                        beiscsi_conn->beiscsi_conn_cid);
                 if (!io_task->pwrb_handle) {
                         beiscsi_log(phba, KERN_ERR,
                                     BEISCSI_LOG_IO | BEISCSI_LOG_CONFIG,
@@ -4236,6 +4328,7 @@ static int beiscsi_alloc_pdu(struct iscsi_task *task, uint8_t opcode)
         } else {
                 io_task->scsi_cmnd = NULL;
                 if ((opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGIN) {
+                        beiscsi_conn->task = task;
                         if (!beiscsi_conn->login_in_progress) {
                                 spin_lock(&phba->mgmt_sgl_lock);
                                 io_task->psgl_handle = (struct sgl_handle *)
@@ -4257,8 +4350,7 @@ static int beiscsi_alloc_pdu(struct iscsi_task *task, uint8_t opcode)
                                                         io_task->psgl_handle;
                                 io_task->pwrb_handle =
                                         alloc_wrb_handle(phba,
-                                        beiscsi_conn->beiscsi_conn_cid -
-                                        phba->fw_config.iscsi_cid_start);
+                                        beiscsi_conn->beiscsi_conn_cid);
                                 if (!io_task->pwrb_handle) {
                                         beiscsi_log(phba, KERN_ERR,
                                                     BEISCSI_LOG_IO |
@@ -4278,7 +4370,6 @@ static int beiscsi_alloc_pdu(struct iscsi_task *task, uint8_t opcode)
                                 io_task->pwrb_handle =
                                                 beiscsi_conn->plogin_wrb_handle;
                         }
-                        beiscsi_conn->task = task;
                 } else {
                         spin_lock(&phba->mgmt_sgl_lock);
                         io_task->psgl_handle = alloc_mgmt_sgl_handle(phba);
@@ -4295,8 +4386,7 @@ static int beiscsi_alloc_pdu(struct iscsi_task *task, uint8_t opcode)
                         }
                         io_task->pwrb_handle =
                                         alloc_wrb_handle(phba,
-                                        beiscsi_conn->beiscsi_conn_cid -
-                                        phba->fw_config.iscsi_cid_start);
+                                        beiscsi_conn->beiscsi_conn_cid);
                         if (!io_task->pwrb_handle) {
                                 beiscsi_log(phba, KERN_ERR,
                                             BEISCSI_LOG_IO | BEISCSI_LOG_CONFIG,
@@ -4324,12 +4414,13 @@ free_io_hndls:
 free_mgmt_hndls:
         spin_lock(&phba->mgmt_sgl_lock);
         free_mgmt_sgl_handle(phba, io_task->psgl_handle);
+        io_task->psgl_handle = NULL;
         spin_unlock(&phba->mgmt_sgl_lock);
 free_hndls:
         phwi_ctrlr = phba->phwi_ctrlr;
-        pwrb_context = &phwi_ctrlr->wrb_context[
-                        beiscsi_conn->beiscsi_conn_cid -
-                        phba->fw_config.iscsi_cid_start];
+        cri_index = BE_GET_CRI_FROM_CID(
+        beiscsi_conn->beiscsi_conn_cid);
+        pwrb_context = &phwi_ctrlr->wrb_context[cri_index];
         if (io_task->pwrb_handle)
                 free_wrb_handle(phba, pwrb_context, io_task->pwrb_handle);
         io_task->pwrb_handle = NULL;
@@ -4351,7 +4442,6 @@ int beiscsi_iotask_v2(struct iscsi_task *task, struct scatterlist *sg,
         unsigned int doorbell = 0;
 
         pwrb = io_task->pwrb_handle->pwrb;
-        memset(pwrb, 0, sizeof(*pwrb));
 
         io_task->cmd_bhs->iscsi_hdr.exp_statsn = 0;
         io_task->bhs_len = sizeof(struct be_cmd_bhs);
@@ -4465,19 +4555,7 @@ static int beiscsi_mtask(struct iscsi_task *task)
         pwrb = io_task->pwrb_handle->pwrb;
         memset(pwrb, 0, sizeof(*pwrb));
 
-        if (chip_skh_r(phba->pcidev)) {
-                AMAP_SET_BITS(struct amap_iscsi_wrb_v2, cmdsn_itt, pwrb,
-                              be32_to_cpu(task->cmdsn));
-                AMAP_SET_BITS(struct amap_iscsi_wrb_v2, wrb_idx, pwrb,
-                              io_task->pwrb_handle->wrb_index);
-                AMAP_SET_BITS(struct amap_iscsi_wrb_v2, sgl_idx, pwrb,
-                              io_task->psgl_handle->sgl_index);
-                AMAP_SET_BITS(struct amap_iscsi_wrb_v2, r2t_exp_dtl, pwrb,
-                              task->data_count);
-                AMAP_SET_BITS(struct amap_iscsi_wrb_v2, ptr2nextwrb, pwrb,
-                              io_task->pwrb_handle->nxt_wrb_index);
-                pwrb_typeoffset = SKH_WRB_TYPE_OFFSET;
-        } else {
+        if (is_chip_be2_be3r(phba)) {
                 AMAP_SET_BITS(struct amap_iscsi_wrb, cmdsn_itt, pwrb,
                               be32_to_cpu(task->cmdsn));
                 AMAP_SET_BITS(struct amap_iscsi_wrb, wrb_idx, pwrb,
@@ -4489,6 +4567,18 @@ static int beiscsi_mtask(struct iscsi_task *task)
                 AMAP_SET_BITS(struct amap_iscsi_wrb, ptr2nextwrb, pwrb,
                               io_task->pwrb_handle->nxt_wrb_index);
                 pwrb_typeoffset = BE_WRB_TYPE_OFFSET;
+        } else {
+                AMAP_SET_BITS(struct amap_iscsi_wrb_v2, cmdsn_itt, pwrb,
+                              be32_to_cpu(task->cmdsn));
+                AMAP_SET_BITS(struct amap_iscsi_wrb_v2, wrb_idx, pwrb,
+                              io_task->pwrb_handle->wrb_index);
+                AMAP_SET_BITS(struct amap_iscsi_wrb_v2, sgl_idx, pwrb,
+                              io_task->psgl_handle->sgl_index);
+                AMAP_SET_BITS(struct amap_iscsi_wrb_v2, r2t_exp_dtl, pwrb,
+                              task->data_count);
+                AMAP_SET_BITS(struct amap_iscsi_wrb_v2, ptr2nextwrb, pwrb,
+                              io_task->pwrb_handle->nxt_wrb_index);
+                pwrb_typeoffset = SKH_WRB_TYPE_OFFSET;
         }
 
 
@@ -4501,19 +4591,19 @@ static int beiscsi_mtask(struct iscsi_task *task)
         case ISCSI_OP_NOOP_OUT:
                 if (task->hdr->ttt != ISCSI_RESERVED_TAG) {
                         ADAPTER_SET_WRB_TYPE(pwrb, TGT_DM_CMD, pwrb_typeoffset);
-                        if (chip_skh_r(phba->pcidev))
-                                AMAP_SET_BITS(struct amap_iscsi_wrb_v2,
+                        if (is_chip_be2_be3r(phba))
+                                AMAP_SET_BITS(struct amap_iscsi_wrb,
                                               dmsg, pwrb, 1);
                         else
-                                AMAP_SET_BITS(struct amap_iscsi_wrb,
+                                AMAP_SET_BITS(struct amap_iscsi_wrb_v2,
                                               dmsg, pwrb, 1);
                 } else {
                         ADAPTER_SET_WRB_TYPE(pwrb, INI_RD_CMD, pwrb_typeoffset);
-                        if (chip_skh_r(phba->pcidev))
-                                AMAP_SET_BITS(struct amap_iscsi_wrb_v2,
+                        if (is_chip_be2_be3r(phba))
+                                AMAP_SET_BITS(struct amap_iscsi_wrb,
                                               dmsg, pwrb, 0);
                         else
-                                AMAP_SET_BITS(struct amap_iscsi_wrb,
+                                AMAP_SET_BITS(struct amap_iscsi_wrb_v2,
                                               dmsg, pwrb, 0);
                 }
                 hwi_write_buffer(pwrb, task);
@@ -4540,9 +4630,9 @@ static int beiscsi_mtask(struct iscsi_task *task)
         }
 
         /* Set the task type */
-        io_task->wrb_type = (chip_skh_r(phba->pcidev)) ?
-                AMAP_GET_BITS(struct amap_iscsi_wrb_v2, type, pwrb) :
-                AMAP_GET_BITS(struct amap_iscsi_wrb, type, pwrb);
+        io_task->wrb_type = (is_chip_be2_be3r(phba)) ?
+                AMAP_GET_BITS(struct amap_iscsi_wrb, type, pwrb) :
+                AMAP_GET_BITS(struct amap_iscsi_wrb_v2, type, pwrb);
 
         doorbell |= cid & DB_WRB_POST_CID_MASK;
         doorbell |= (io_task->pwrb_handle->wrb_index &
@@ -4834,6 +4924,7 @@ static int beiscsi_dev_probe(struct pci_dev *pcidev,
         case OC_SKH_ID1:
                 phba->generation = BE_GEN4;
                 phba->iotask_fn = beiscsi_iotask_v2;
+                break;
         default:
                 phba->generation = 0;
         }
diff --git a/drivers/scsi/be2iscsi/be_main.h b/drivers/scsi/be2iscsi/be_main.h
index 5946577d79d6..2c06ef3c02ac 100644
--- a/drivers/scsi/be2iscsi/be_main.h
+++ b/drivers/scsi/be2iscsi/be_main.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2012 Emulex
+ * Copyright (C) 2005 - 2013 Emulex
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -36,7 +36,7 @@
 
 #include "be.h"
 #define DRV_NAME                "be2iscsi"
-#define BUILD_STR               "10.0.272.0"
+#define BUILD_STR               "10.0.467.0"
 #define BE_NAME                 "Emulex OneConnect" \
                                 "Open-iSCSI Driver version" BUILD_STR
 #define DRV_DESC                BE_NAME " " "Driver"
@@ -66,8 +66,9 @@
 
 #define MAX_CPUS                64
 #define BEISCSI_MAX_NUM_CPUS    7
-#define OC_SKH_MAX_NUM_CPUS     63
+#define OC_SKH_MAX_NUM_CPUS     31
 
+#define BEISCSI_VER_STRLEN 32
 
 #define BEISCSI_SGLIST_ELEMENTS 30
 
@@ -265,7 +266,9 @@ struct invalidate_command_table {
         unsigned short cid;
 } __packed;
 
-#define chip_skh_r(pdev)        (pdev->device == OC_SKH_ID1)
+#define chip_be2(phba)      (phba->generation == BE_GEN2)
+#define chip_be3_r(phba)    (phba->generation == BE_GEN3)
+#define is_chip_be2_be3r(phba) (chip_be3_r(phba) || (chip_be2(phba)))
 struct beiscsi_hba {
         struct hba_parameters params;
         struct hwi_controller *phwi_ctrlr;
@@ -304,10 +307,15 @@ struct beiscsi_hba {
         unsigned short avlbl_cids;
         unsigned short cid_alloc;
         unsigned short cid_free;
-        struct beiscsi_conn *conn_table[BE2_MAX_SESSIONS * 2];
         struct list_head hba_queue;
+#define BE_MAX_SESSION 2048
+#define BE_SET_CID_TO_CRI(cri_index, cid) \
+                          (phba->cid_to_cri_map[cid] = cri_index)
+#define BE_GET_CRI_FROM_CID(cid) (phba->cid_to_cri_map[cid])
+        unsigned short cid_to_cri_map[BE_MAX_SESSION];
         unsigned short *cid_array;
         struct iscsi_endpoint **ep_array;
+        struct beiscsi_conn **conn_table;
         struct iscsi_boot_kset *boot_kset;
         struct Scsi_Host *shost;
         struct iscsi_iface *ipv4_iface;
@@ -339,6 +347,7 @@ struct beiscsi_hba {
         struct delayed_work beiscsi_hw_check_task;
 
         u8 mac_address[ETH_ALEN];
+        char fw_ver_str[BEISCSI_VER_STRLEN];
         char wq_name[20];
         struct workqueue_struct *wq;    /* The actuak work queue */
         struct be_ctrl_info ctrl;
@@ -563,7 +572,7 @@ struct hwi_async_pdu_context {
          * This is a varying size list! Do not add anything
          * after this entry!!
          */
-        struct hwi_async_entry async_entry[BE2_MAX_SESSIONS * 2];
+        struct hwi_async_entry *async_entry;
 };
 
 #define PDUCQE_CODE_MASK        0x0000003F
@@ -749,6 +758,8 @@ void
 free_mgmt_sgl_handle(struct beiscsi_hba *phba, struct sgl_handle *psgl_handle);
 
 void beiscsi_process_all_cqs(struct work_struct *work);
+void beiscsi_free_mgmt_task_handles(struct beiscsi_conn *beiscsi_conn,
+                                     struct iscsi_task *task);
 
 static inline bool beiscsi_error(struct beiscsi_hba *phba)
 {
@@ -933,7 +944,7 @@ struct hwi_controller {
         struct sgl_handle *psgl_handle_base;
         unsigned int wrb_mem_index;
 
-        struct hwi_wrb_context wrb_context[BE2_MAX_SESSIONS * 2];
+        struct hwi_wrb_context *wrb_context;
         struct mcc_wrb *pmcc_wrb_base;
         struct be_ring default_pdu_hdr;
         struct be_ring default_pdu_data;
@@ -970,9 +981,7 @@ struct hwi_context_memory {
         struct be_queue_info be_def_hdrq;
         struct be_queue_info be_def_dataq;
 
-        struct be_queue_info be_wrbq[BE2_MAX_SESSIONS];
-        struct be_mcc_wrb_context *pbe_mcc_context;
-
+        struct be_queue_info *be_wrbq;
         struct hwi_async_pdu_context *pasync_ctx;
 };
 
diff --git a/drivers/scsi/be2iscsi/be_mgmt.c b/drivers/scsi/be2iscsi/be_mgmt.c
index 55cc9902263d..245a9595a93a 100644
--- a/drivers/scsi/be2iscsi/be_mgmt.c
+++ b/drivers/scsi/be2iscsi/be_mgmt.c
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2012 Emulex
+ * Copyright (C) 2005 - 2013 Emulex
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -368,6 +368,8 @@ int mgmt_check_supported_fw(struct be_ctrl_info *ctrl,
                 beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
                             "BM_%d : phba->fw_config.iscsi_features = %d\n",
                             phba->fw_config.iscsi_features);
+                memcpy(phba->fw_ver_str, resp->params.hba_attribs.
+                       firmware_version_string, BEISCSI_VER_STRLEN);
         } else
                 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
                             "BG_%d :  Failed in mgmt_check_supported_fw\n");
@@ -1260,6 +1262,45 @@ beiscsi_drvr_ver_disp(struct device *dev, struct device_attribute *attr,
 }
 
 /**
+ * beiscsi_fw_ver_disp()- Display Firmware Version
+ * @dev: ptr to device not used.
+ * @attr: device attribute, not used.
+ * @buf: contains formatted text Firmware version
+ *
+ * return
+ * size of the formatted string
+ **/
+ssize_t
+beiscsi_fw_ver_disp(struct device *dev, struct device_attribute *attr,
+                     char *buf)
+{
+        struct Scsi_Host *shost = class_to_shost(dev);
+        struct beiscsi_hba *phba = iscsi_host_priv(shost);
+
+        return snprintf(buf, PAGE_SIZE, "%s\n", phba->fw_ver_str);
+}
+
+/**
+ * beiscsi_active_cid_disp()- Display Sessions Active
+ * @dev: ptr to device not used.
+ * @attr: device attribute, not used.
+ * @buf: contains formatted text Session Count
+ *
+ * return
+ * size of the formatted string
+ **/
+ssize_t
+beiscsi_active_cid_disp(struct device *dev, struct device_attribute *attr,
+                         char *buf)
+{
+        struct Scsi_Host *shost = class_to_shost(dev);
+        struct beiscsi_hba *phba = iscsi_host_priv(shost);
+
+        return snprintf(buf, PAGE_SIZE, "%d\n",
+                       (phba->params.cxns_per_ctrl - phba->avlbl_cids));
+}
+
+/**
  * beiscsi_adap_family_disp()- Display adapter family.
  * @dev: ptr to device to get priv structure
  * @attr: device attribute, not used.
diff --git a/drivers/scsi/be2iscsi/be_mgmt.h b/drivers/scsi/be2iscsi/be_mgmt.h
index 2e4968add799..04af7e74fe48 100644
--- a/drivers/scsi/be2iscsi/be_mgmt.h
+++ b/drivers/scsi/be2iscsi/be_mgmt.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2012 Emulex
+ * Copyright (C) 2005 - 2013 Emulex
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -156,25 +156,25 @@ union invalidate_commands_params {
 } __packed;
 
 struct mgmt_hba_attributes {
-        u8 flashrom_version_string[32];
-        u8 manufacturer_name[32];
+        u8 flashrom_version_string[BEISCSI_VER_STRLEN];
+        u8 manufacturer_name[BEISCSI_VER_STRLEN];
         u32 supported_modes;
         u8 seeprom_version_lo;
         u8 seeprom_version_hi;
         u8 rsvd0[2];
         u32 fw_cmd_data_struct_version;
         u32 ep_fw_data_struct_version;
-        u32 future_reserved[12];
+        u8 ncsi_version_string[12];
         u32 default_extended_timeout;
-        u8 controller_model_number[32];
+        u8 controller_model_number[BEISCSI_VER_STRLEN];
         u8 controller_description[64];
-        u8 controller_serial_number[32];
-        u8 ip_version_string[32];
-        u8 firmware_version_string[32];
-        u8 bios_version_string[32];
-        u8 redboot_version_string[32];
-        u8 driver_version_string[32];
-        u8 fw_on_flash_version_string[32];
+        u8 controller_serial_number[BEISCSI_VER_STRLEN];
+        u8 ip_version_string[BEISCSI_VER_STRLEN];
+        u8 firmware_version_string[BEISCSI_VER_STRLEN];
+        u8 bios_version_string[BEISCSI_VER_STRLEN];
+        u8 redboot_version_string[BEISCSI_VER_STRLEN];
+        u8 driver_version_string[BEISCSI_VER_STRLEN];
+        u8 fw_on_flash_version_string[BEISCSI_VER_STRLEN];
         u32 functionalities_supported;
         u16 max_cdblength;
         u8 asic_revision;
@@ -190,7 +190,8 @@ struct mgmt_hba_attributes {
         u32 firmware_post_status;
         u32 hba_mtu[8];
         u8 iscsi_features;
-        u8 future_u8[3];
+        u8 asic_generation;
+        u8 future_u8[2];
         u32 future_u32[3];
 } __packed;
 
@@ -207,7 +208,7 @@ struct mgmt_controller_attributes {
         u64 unique_identifier;
         u8 netfilters;
         u8 rsvd0[3];
-        u8 future_u32[4];
+        u32 future_u32[4];
 } __packed;
 
 struct be_mgmt_controller_attributes {
@@ -311,6 +312,12 @@ int mgmt_set_vlan(struct beiscsi_hba *phba, uint16_t vlan_tag);
 ssize_t beiscsi_drvr_ver_disp(struct device *dev,
                                struct device_attribute *attr, char *buf);
 
+ssize_t beiscsi_fw_ver_disp(struct device *dev,
+                             struct device_attribute *attr, char *buf);
+
+ssize_t beiscsi_active_cid_disp(struct device *dev,
+                                 struct device_attribute *attr, char *buf);
+
 ssize_t beiscsi_adap_family_disp(struct device *dev,
                                   struct device_attribute *attr, char *buf);
 
diff --git a/drivers/scsi/bnx2fc/bnx2fc.h b/drivers/scsi/bnx2fc/bnx2fc.h
index 11596b2c4702..08b22a901c25 100644
--- a/drivers/scsi/bnx2fc/bnx2fc.h
+++ b/drivers/scsi/bnx2fc/bnx2fc.h
@@ -2,7 +2,7 @@
 #define _BNX2FC_H_
 /* bnx2fc.h: Broadcom NetXtreme II Linux FCoE offload driver.
  *
- * Copyright (c) 2008 - 2011 Broadcom Corporation
+ * Copyright (c) 2008 - 2013 Broadcom Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -64,10 +64,12 @@
 #include "bnx2fc_constants.h"
 
 #define BNX2FC_NAME             "bnx2fc"
-#define BNX2FC_VERSION          "1.0.13"
+#define BNX2FC_VERSION          "1.0.14"
 
 #define PFX                     "bnx2fc: "
 
+#define BCM_CHIP_LEN            16
+
 #define BNX2X_DOORBELL_PCI_BAR          2
 
 #define BNX2FC_MAX_BD_LEN               0xffff
@@ -241,6 +243,8 @@ struct bnx2fc_hba {
         int wait_for_link_down;
         int num_ofld_sess;
         struct list_head vports;
+
+        char chip_num[BCM_CHIP_LEN];
 };
 
 struct bnx2fc_interface {
diff --git a/drivers/scsi/bnx2fc/bnx2fc_els.c b/drivers/scsi/bnx2fc/bnx2fc_els.c
index bdbbb13b8534..b1c9a4f8caee 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_els.c
+++ b/drivers/scsi/bnx2fc/bnx2fc_els.c
@@ -3,7 +3,7 @@
  * This file contains helper routines that handle ELS requests
  * and responses.
  *
- * Copyright (c) 2008 - 2011 Broadcom Corporation
+ * Copyright (c) 2008 - 2013 Broadcom Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
diff --git a/drivers/scsi/bnx2fc/bnx2fc_fcoe.c b/drivers/scsi/bnx2fc/bnx2fc_fcoe.c
index 7dffec1e5715..69ac55495c1d 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_fcoe.c
+++ b/drivers/scsi/bnx2fc/bnx2fc_fcoe.c
@@ -3,7 +3,7 @@
  * cnic modules to create FCoE instances, send/receive non-offloaded
  * FIP/FCoE packets, listen to link events etc.
  *
- * Copyright (c) 2008 - 2011 Broadcom Corporation
+ * Copyright (c) 2008 - 2013 Broadcom Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -22,7 +22,7 @@ DEFINE_PER_CPU(struct bnx2fc_percpu_s, bnx2fc_percpu);
 
 #define DRV_MODULE_NAME         "bnx2fc"
 #define DRV_MODULE_VERSION      BNX2FC_VERSION
-#define DRV_MODULE_RELDATE      "Dec 21, 2012"
+#define DRV_MODULE_RELDATE      "Mar 08, 2013"
 
 
 static char version[] =
@@ -679,6 +679,7 @@ static int bnx2fc_shost_config(struct fc_lport *lport, struct device *dev)
 {
         struct fcoe_port *port = lport_priv(lport);
         struct bnx2fc_interface *interface = port->priv;
+        struct bnx2fc_hba *hba = interface->hba;
         struct Scsi_Host *shost = lport->host;
         int rc = 0;
 
@@ -699,8 +700,9 @@ static int bnx2fc_shost_config(struct fc_lport *lport, struct device *dev)
         }
         if (!lport->vport)
                 fc_host_max_npiv_vports(lport->host) = USHRT_MAX;
-        sprintf(fc_host_symbolic_name(lport->host), "%s v%s over %s",
-                BNX2FC_NAME, BNX2FC_VERSION,
+        snprintf(fc_host_symbolic_name(lport->host), 256,
+                 "%s (Broadcom %s) v%s over %s",
+                BNX2FC_NAME, hba->chip_num, BNX2FC_VERSION,
                 interface->netdev->name);
 
         return 0;
@@ -1656,23 +1658,60 @@ mem_err:
 static int bnx2fc_bind_pcidev(struct bnx2fc_hba *hba)
 {
         struct cnic_dev *cnic;
+        struct pci_dev *pdev;
 
         if (!hba->cnic) {
                 printk(KERN_ERR PFX "cnic is NULL\n");
                 return -ENODEV;
         }
         cnic = hba->cnic;
-        hba->pcidev = cnic->pcidev;
-        if (hba->pcidev)
-                pci_dev_get(hba->pcidev);
+        pdev = hba->pcidev = cnic->pcidev;
+        if (!hba->pcidev)
+                return -ENODEV;
 
+        switch (pdev->device) {
+        case PCI_DEVICE_ID_NX2_57710:
+                strncpy(hba->chip_num, "BCM57710", BCM_CHIP_LEN);
+                break;
+        case PCI_DEVICE_ID_NX2_57711:
+                strncpy(hba->chip_num, "BCM57711", BCM_CHIP_LEN);
+                break;
+        case PCI_DEVICE_ID_NX2_57712:
+        case PCI_DEVICE_ID_NX2_57712_MF:
+        case PCI_DEVICE_ID_NX2_57712_VF:
+                strncpy(hba->chip_num, "BCM57712", BCM_CHIP_LEN);
+                break;
+        case PCI_DEVICE_ID_NX2_57800:
+        case PCI_DEVICE_ID_NX2_57800_MF:
+        case PCI_DEVICE_ID_NX2_57800_VF:
+                strncpy(hba->chip_num, "BCM57800", BCM_CHIP_LEN);
+                break;
+        case PCI_DEVICE_ID_NX2_57810:
+        case PCI_DEVICE_ID_NX2_57810_MF:
+        case PCI_DEVICE_ID_NX2_57810_VF:
+                strncpy(hba->chip_num, "BCM57810", BCM_CHIP_LEN);
+                break;
+        case PCI_DEVICE_ID_NX2_57840:
+        case PCI_DEVICE_ID_NX2_57840_MF:
+        case PCI_DEVICE_ID_NX2_57840_VF:
+        case PCI_DEVICE_ID_NX2_57840_2_20:
+        case PCI_DEVICE_ID_NX2_57840_4_10:
+                strncpy(hba->chip_num, "BCM57840", BCM_CHIP_LEN);
+                break;
+        default:
+                pr_err(PFX "Unknown device id 0x%x\n", pdev->device);
+                break;
+        }
+        pci_dev_get(hba->pcidev);
         return 0;
 }
 
 static void bnx2fc_unbind_pcidev(struct bnx2fc_hba *hba)
 {
-        if (hba->pcidev)
+        if (hba->pcidev) {
+                hba->chip_num[0] = '\0';
                 pci_dev_put(hba->pcidev);
+        }
         hba->pcidev = NULL;
 }
 
diff --git a/drivers/scsi/bnx2fc/bnx2fc_hwi.c b/drivers/scsi/bnx2fc/bnx2fc_hwi.c
index 50510ffe1bf5..c0d035a8f8f9 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_hwi.c
+++ b/drivers/scsi/bnx2fc/bnx2fc_hwi.c
@@ -2,7 +2,7 @@
  * This file contains the code that low level functions that interact
  * with 57712 FCoE firmware.
  *
- * Copyright (c) 2008 - 2011 Broadcom Corporation
+ * Copyright (c) 2008 - 2013 Broadcom Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -126,7 +126,11 @@ int bnx2fc_send_fw_fcoe_init_msg(struct bnx2fc_hba *hba)
         fcoe_init3.error_bit_map_lo = 0xffffffff;
         fcoe_init3.error_bit_map_hi = 0xffffffff;
 
-        fcoe_init3.perf_config = 1;
+        /*
+         * enable both cached connection and cached tasks
+         * 0 = none, 1 = cached connection, 2 = cached tasks, 3 = both
+         */
+        fcoe_init3.perf_config = 3;
 
         kwqe_arr[0] = (struct kwqe *) &fcoe_init1;
         kwqe_arr[1] = (struct kwqe *) &fcoe_init2;
diff --git a/drivers/scsi/bnx2fc/bnx2fc_io.c b/drivers/scsi/bnx2fc/bnx2fc_io.c
index 723a9a8ba5ee..575142e92d9c 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_io.c
+++ b/drivers/scsi/bnx2fc/bnx2fc_io.c
@@ -1,7 +1,7 @@
 /* bnx2fc_io.c: Broadcom NetXtreme II Linux FCoE offload driver.
  * IO manager and SCSI IO processing.
  *
- * Copyright (c) 2008 - 2011 Broadcom Corporation
+ * Copyright (c) 2008 - 2013 Broadcom Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -1270,8 +1270,11 @@ int bnx2fc_eh_abort(struct scsi_cmnd *sc_cmd)
 
         spin_lock_bh(&tgt->tgt_lock);
         io_req->wait_for_comp = 0;
-        if (!(test_and_set_bit(BNX2FC_FLAG_ABTS_DONE,
-                                    &io_req->req_flags))) {
+        if (test_bit(BNX2FC_FLAG_IO_COMPL, &io_req->req_flags)) {
+                BNX2FC_IO_DBG(io_req, "IO completed in a different context\n");
+                rc = SUCCESS;
+        } else if (!(test_and_set_bit(BNX2FC_FLAG_ABTS_DONE,
+                                      &io_req->req_flags))) {
                 /* Let the scsi-ml try to recover this command */
                 printk(KERN_ERR PFX "abort failed, xid = 0x%x\n",
                        io_req->xid);
diff --git a/drivers/scsi/bnx2fc/bnx2fc_tgt.c b/drivers/scsi/bnx2fc/bnx2fc_tgt.c
index c57a3bb8a9fb..4d93177dfb53 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_tgt.c
+++ b/drivers/scsi/bnx2fc/bnx2fc_tgt.c
@@ -2,7 +2,7 @@
  * Handles operations such as session offload/upload etc, and manages
  * session resources such as connection id and qp resources.
  *
- * Copyright (c) 2008 - 2011 Broadcom Corporation
+ * Copyright (c) 2008 - 2013 Broadcom Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
diff --git a/drivers/scsi/csiostor/csio_lnode.h b/drivers/scsi/csiostor/csio_lnode.h
index 0f9c04175b11..372a67d122d3 100644
--- a/drivers/scsi/csiostor/csio_lnode.h
+++ b/drivers/scsi/csiostor/csio_lnode.h
@@ -114,7 +114,7 @@ struct csio_lnode_stats {
         uint32_t        n_rnode_match;  /* matched rnode */
         uint32_t        n_dev_loss_tmo; /* Device loss timeout */
         uint32_t        n_fdmi_err;     /* fdmi err */
-        uint32_t        n_evt_fw[PROTO_ERR_IMPL_LOGO];  /* fw events */
+        uint32_t        n_evt_fw[PROTO_ERR_IMPL_LOGO + 1];      /* fw events */
         enum csio_ln_ev n_evt_sm[CSIO_LNE_MAX_EVENT];   /* State m/c events */
         uint32_t        n_rnode_alloc;  /* rnode allocated */
         uint32_t        n_rnode_free;   /* rnode freed */
diff --git a/drivers/scsi/csiostor/csio_rnode.h b/drivers/scsi/csiostor/csio_rnode.h
index 65940096a80d..433434221222 100644
--- a/drivers/scsi/csiostor/csio_rnode.h
+++ b/drivers/scsi/csiostor/csio_rnode.h
@@ -63,7 +63,7 @@ struct csio_rnode_stats {
         uint32_t        n_err_nomem;    /* error nomem */
         uint32_t        n_evt_unexp;    /* unexpected event */
         uint32_t        n_evt_drop;     /* unexpected event */
-        uint32_t        n_evt_fw[PROTO_ERR_IMPL_LOGO];  /* fw events */
+        uint32_t        n_evt_fw[PROTO_ERR_IMPL_LOGO + 1];      /* fw events */
         enum csio_rn_ev n_evt_sm[CSIO_RNFE_MAX_EVENT];  /* State m/c events */
         uint32_t        n_lun_rst;      /* Number of resets of
                                          * of LUNs under this
diff --git a/drivers/scsi/fnic/fnic.h b/drivers/scsi/fnic/fnic.h
index 98436c363035..b6d1f92ed33c 100644
--- a/drivers/scsi/fnic/fnic.h
+++ b/drivers/scsi/fnic/fnic.h
@@ -38,7 +38,7 @@
 
 #define DRV_NAME                "fnic"
 #define DRV_DESCRIPTION         "Cisco FCoE HBA Driver"
-#define DRV_VERSION             "1.5.0.2"
+#define DRV_VERSION             "1.5.0.22"
 #define PFX                     DRV_NAME ": "
 #define DFX                     DRV_NAME "%d: "
 
@@ -192,6 +192,18 @@ enum fnic_state {
 
 struct mempool;
 
+enum fnic_evt {
+        FNIC_EVT_START_VLAN_DISC = 1,
+        FNIC_EVT_START_FCF_DISC = 2,
+        FNIC_EVT_MAX,
+};
+
+struct fnic_event {
+        struct list_head list;
+        struct fnic *fnic;
+        enum fnic_evt event;
+};
+
 /* Per-instance private data structure */
 struct fnic {
         struct fc_lport *lport;
@@ -254,6 +266,18 @@ struct fnic {
         struct sk_buff_head frame_queue;
         struct sk_buff_head tx_queue;
 
+        /*** FIP related data members  -- start ***/
+        void (*set_vlan)(struct fnic *, u16 vlan);
+        struct work_struct      fip_frame_work;
+        struct sk_buff_head     fip_frame_queue;
+        struct timer_list       fip_timer;
+        struct list_head        vlans;
+        spinlock_t              vlans_lock;
+
+        struct work_struct      event_work;
+        struct list_head        evlist;
+        /*** FIP related data members  -- end ***/
+
         /* copy work queue cache line section */
         ____cacheline_aligned struct vnic_wq_copy wq_copy[FNIC_WQ_COPY_MAX];
         /* completion queue cache line section */
@@ -278,6 +302,7 @@ static inline struct fnic *fnic_from_ctlr(struct fcoe_ctlr *fip)
 }
 
 extern struct workqueue_struct *fnic_event_queue;
+extern struct workqueue_struct *fnic_fip_queue;
 extern struct device_attribute *fnic_attrs[];
 
 void fnic_clear_intr_mode(struct fnic *fnic);
@@ -289,6 +314,7 @@ int fnic_send(struct fc_lport *, struct fc_frame *);
 void fnic_free_wq_buf(struct vnic_wq *wq, struct vnic_wq_buf *buf);
 void fnic_handle_frame(struct work_struct *work);
 void fnic_handle_link(struct work_struct *work);
+void fnic_handle_event(struct work_struct *work);
 int fnic_rq_cmpl_handler(struct fnic *fnic, int);
 int fnic_alloc_rq_frame(struct vnic_rq *rq);
 void fnic_free_rq_buf(struct vnic_rq *rq, struct vnic_rq_buf *buf);
@@ -321,6 +347,12 @@ void fnic_handle_link_event(struct fnic *fnic);
 
 int fnic_is_abts_pending(struct fnic *, struct scsi_cmnd *);
 
+void fnic_handle_fip_frame(struct work_struct *work);
+void fnic_handle_fip_event(struct fnic *fnic);
+void fnic_fcoe_reset_vlans(struct fnic *fnic);
+void fnic_fcoe_evlist_free(struct fnic *fnic);
+extern void fnic_handle_fip_timer(struct fnic *fnic);
+
 static inline int
 fnic_chk_state_flags_locked(struct fnic *fnic, unsigned long st_flags)
 {
diff --git a/drivers/scsi/fnic/fnic_fcs.c b/drivers/scsi/fnic/fnic_fcs.c
index 483eb9dbe663..006fa92a02df 100644
--- a/drivers/scsi/fnic/fnic_fcs.c
+++ b/drivers/scsi/fnic/fnic_fcs.c
@@ -31,12 +31,20 @@
 #include <scsi/libfc.h>
 #include "fnic_io.h"
 #include "fnic.h"
+#include "fnic_fip.h"
 #include "cq_enet_desc.h"
 #include "cq_exch_desc.h"
 
+static u8 fcoe_all_fcfs[ETH_ALEN];
+struct workqueue_struct *fnic_fip_queue;
 struct workqueue_struct *fnic_event_queue;
 
 static void fnic_set_eth_mode(struct fnic *);
+static void fnic_fcoe_send_vlan_req(struct fnic *fnic);
+static void fnic_fcoe_start_fcf_disc(struct fnic *fnic);
+static void fnic_fcoe_process_vlan_resp(struct fnic *fnic, struct sk_buff *);
+static int fnic_fcoe_vlan_check(struct fnic *fnic, u16 flag);
+static int fnic_fcoe_handle_fip_frame(struct fnic *fnic, struct sk_buff *skb);
 
 void fnic_handle_link(struct work_struct *work)
 {
@@ -69,6 +77,11 @@ void fnic_handle_link(struct work_struct *work)
                                 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host,
                                              "link down\n");
                                 fcoe_ctlr_link_down(&fnic->ctlr);
+                                if (fnic->config.flags & VFCF_FIP_CAPABLE) {
+                                        /* start FCoE VLAN discovery */
+                                        fnic_fcoe_send_vlan_req(fnic);
+                                        return;
+                                }
                                 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host,
                                              "link up\n");
                                 fcoe_ctlr_link_up(&fnic->ctlr);
@@ -79,6 +92,11 @@ void fnic_handle_link(struct work_struct *work)
         } else if (fnic->link_status) {
                 /* DOWN -> UP */
                 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
+                if (fnic->config.flags & VFCF_FIP_CAPABLE) {
+                        /* start FCoE VLAN discovery */
+                        fnic_fcoe_send_vlan_req(fnic);
+                        return;
+                }
                 FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host, "link up\n");
                 fcoe_ctlr_link_up(&fnic->ctlr);
         } else {
@@ -128,6 +146,441 @@ void fnic_handle_frame(struct work_struct *work)
         }
 }
 
+void fnic_fcoe_evlist_free(struct fnic *fnic)
+{
+        struct fnic_event *fevt = NULL;
+        struct fnic_event *next = NULL;
+        unsigned long flags;
+
+        spin_lock_irqsave(&fnic->fnic_lock, flags);
+        if (list_empty(&fnic->evlist)) {
+                spin_unlock_irqrestore(&fnic->fnic_lock, flags);
+                return;
+        }
+
+        list_for_each_entry_safe(fevt, next, &fnic->evlist, list) {
+                list_del(&fevt->list);
+                kfree(fevt);
+        }
+        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
+}
+
+void fnic_handle_event(struct work_struct *work)
+{
+        struct fnic *fnic = container_of(work, struct fnic, event_work);
+        struct fnic_event *fevt = NULL;
+        struct fnic_event *next = NULL;
+        unsigned long flags;
+
+        spin_lock_irqsave(&fnic->fnic_lock, flags);
+        if (list_empty(&fnic->evlist)) {
+                spin_unlock_irqrestore(&fnic->fnic_lock, flags);
+                return;
+        }
+
+        list_for_each_entry_safe(fevt, next, &fnic->evlist, list) {
+                if (fnic->stop_rx_link_events) {
+                        list_del(&fevt->list);
+                        kfree(fevt);
+                        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
+                        return;
+                }
+                /*
+                 * If we're in a transitional state, just re-queue and return.
+                 * The queue will be serviced when we get to a stable state.
+                 */
+                if (fnic->state != FNIC_IN_FC_MODE &&
+                    fnic->state != FNIC_IN_ETH_MODE) {
+                        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
+                        return;
+                }
+
+                list_del(&fevt->list);
+                switch (fevt->event) {
+                case FNIC_EVT_START_VLAN_DISC:
+                        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
+                        fnic_fcoe_send_vlan_req(fnic);
+                        spin_lock_irqsave(&fnic->fnic_lock, flags);
+                        break;
+                case FNIC_EVT_START_FCF_DISC:
+                        FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host,
+                                  "Start FCF Discovery\n");
+                        fnic_fcoe_start_fcf_disc(fnic);
+                        break;
+                default:
+                        FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host,
+                                  "Unknown event 0x%x\n", fevt->event);
+                        break;
+                }
+                kfree(fevt);
+        }
+        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
+}
+
+/**
+ * Check if the Received FIP FLOGI frame is rejected
+ * @fip: The FCoE controller that received the frame
+ * @skb: The received FIP frame
+ *
+ * Returns non-zero if the frame is rejected with unsupported cmd with
+ * insufficient resource els explanation.
+ */
+static inline int is_fnic_fip_flogi_reject(struct fcoe_ctlr *fip,
+                                         struct sk_buff *skb)
+{
+        struct fc_lport *lport = fip->lp;
+        struct fip_header *fiph;
+        struct fc_frame_header *fh = NULL;
+        struct fip_desc *desc;
+        struct fip_encaps *els;
+        enum fip_desc_type els_dtype = 0;
+        u16 op;
+        u8 els_op;
+        u8 sub;
+
+        size_t els_len = 0;
+        size_t rlen;
+        size_t dlen = 0;
+
+        if (skb_linearize(skb))
+                return 0;
+
+        if (skb->len < sizeof(*fiph))
+                return 0;
+
+        fiph = (struct fip_header *)skb->data;
+        op = ntohs(fiph->fip_op);
+        sub = fiph->fip_subcode;
+
+        if (op != FIP_OP_LS)
+                return 0;
+
+        if (sub != FIP_SC_REP)
+                return 0;
+
+        rlen = ntohs(fiph->fip_dl_len) * 4;
+        if (rlen + sizeof(*fiph) > skb->len)
+                return 0;
+
+        desc = (struct fip_desc *)(fiph + 1);
+        dlen = desc->fip_dlen * FIP_BPW;
+
+        if (desc->fip_dtype == FIP_DT_FLOGI) {
+
+                shost_printk(KERN_DEBUG, lport->host,
+                          " FIP TYPE FLOGI: fab name:%llx "
+                          "vfid:%d map:%x\n",
+                          fip->sel_fcf->fabric_name, fip->sel_fcf->vfid,
+                          fip->sel_fcf->fc_map);
+                if (dlen < sizeof(*els) + sizeof(*fh) + 1)
+                        return 0;
+
+                els_len = dlen - sizeof(*els);
+                els = (struct fip_encaps *)desc;
+                fh = (struct fc_frame_header *)(els + 1);
+                els_dtype = desc->fip_dtype;
+
+                if (!fh)
+                        return 0;
+
+                /*
+                 * ELS command code, reason and explanation should be = Reject,
+                 * unsupported command and insufficient resource
+                 */
+                els_op = *(u8 *)(fh + 1);
+                if (els_op == ELS_LS_RJT) {
+                        shost_printk(KERN_INFO, lport->host,
+                                  "Flogi Request Rejected by Switch\n");
+                        return 1;
+                }
+                shost_printk(KERN_INFO, lport->host,
+                                "Flogi Request Accepted by Switch\n");
+        }
+        return 0;
+}
+
+static void fnic_fcoe_send_vlan_req(struct fnic *fnic)
+{
+        struct fcoe_ctlr *fip = &fnic->ctlr;
+        struct sk_buff *skb;
+        char *eth_fr;
+        int fr_len;
+        struct fip_vlan *vlan;
+        u64 vlan_tov;
+
+        fnic_fcoe_reset_vlans(fnic);
+        fnic->set_vlan(fnic, 0);
+        FNIC_FCS_DBG(KERN_INFO, fnic->lport->host,
+                  "Sending VLAN request...\n");
+        skb = dev_alloc_skb(sizeof(struct fip_vlan));
+        if (!skb)
+                return;
+
+        fr_len = sizeof(*vlan);
+        eth_fr = (char *)skb->data;
+        vlan = (struct fip_vlan *)eth_fr;
+
+        memset(vlan, 0, sizeof(*vlan));
+        memcpy(vlan->eth.h_source, fip->ctl_src_addr, ETH_ALEN);
+        memcpy(vlan->eth.h_dest, fcoe_all_fcfs, ETH_ALEN);
+        vlan->eth.h_proto = htons(ETH_P_FIP);
+
+        vlan->fip.fip_ver = FIP_VER_ENCAPS(FIP_VER);
+        vlan->fip.fip_op = htons(FIP_OP_VLAN);
+        vlan->fip.fip_subcode = FIP_SC_VL_REQ;
+        vlan->fip.fip_dl_len = htons(sizeof(vlan->desc) / FIP_BPW);
+
+        vlan->desc.mac.fd_desc.fip_dtype = FIP_DT_MAC;
+        vlan->desc.mac.fd_desc.fip_dlen = sizeof(vlan->desc.mac) / FIP_BPW;
+        memcpy(&vlan->desc.mac.fd_mac, fip->ctl_src_addr, ETH_ALEN);
+
+        vlan->desc.wwnn.fd_desc.fip_dtype = FIP_DT_NAME;
+        vlan->desc.wwnn.fd_desc.fip_dlen = sizeof(vlan->desc.wwnn) / FIP_BPW;
+        put_unaligned_be64(fip->lp->wwnn, &vlan->desc.wwnn.fd_wwn);
+
+        skb_put(skb, sizeof(*vlan));
+        skb->protocol = htons(ETH_P_FIP);
+        skb_reset_mac_header(skb);
+        skb_reset_network_header(skb);
+        fip->send(fip, skb);
+
+        /* set a timer so that we can retry if there no response */
+        vlan_tov = jiffies + msecs_to_jiffies(FCOE_CTLR_FIPVLAN_TOV);
+        mod_timer(&fnic->fip_timer, round_jiffies(vlan_tov));
+}
+
+static void fnic_fcoe_process_vlan_resp(struct fnic *fnic, struct sk_buff *skb)
+{
+        struct fcoe_ctlr *fip = &fnic->ctlr;
+        struct fip_header *fiph;
+        struct fip_desc *desc;
+        u16 vid;
+        size_t rlen;
+        size_t dlen;
+        struct fcoe_vlan *vlan;
+        u64 sol_time;
+        unsigned long flags;
+
+        FNIC_FCS_DBG(KERN_INFO, fnic->lport->host,
+                  "Received VLAN response...\n");
+
+        fiph = (struct fip_header *) skb->data;
+
+        FNIC_FCS_DBG(KERN_INFO, fnic->lport->host,
+                  "Received VLAN response... OP 0x%x SUB_OP 0x%x\n",
+                  ntohs(fiph->fip_op), fiph->fip_subcode);
+
+        rlen = ntohs(fiph->fip_dl_len) * 4;
+        fnic_fcoe_reset_vlans(fnic);
+        spin_lock_irqsave(&fnic->vlans_lock, flags);
+        desc = (struct fip_desc *)(fiph + 1);
+        while (rlen > 0) {
+                dlen = desc->fip_dlen * FIP_BPW;
+                switch (desc->fip_dtype) {
+                case FIP_DT_VLAN:
+                        vid = ntohs(((struct fip_vlan_desc *)desc)->fd_vlan);
+                        shost_printk(KERN_INFO, fnic->lport->host,
+                                  "process_vlan_resp: FIP VLAN %d\n", vid);
+                        vlan = kmalloc(sizeof(*vlan),
+                                                        GFP_ATOMIC);
+                        if (!vlan) {
+                                /* retry from timer */
+                                spin_unlock_irqrestore(&fnic->vlans_lock,
+                                                        flags);
+                                goto out;
+                        }
+                        memset(vlan, 0, sizeof(struct fcoe_vlan));
+                        vlan->vid = vid & 0x0fff;
+                        vlan->state = FIP_VLAN_AVAIL;
+                        list_add_tail(&vlan->list, &fnic->vlans);
+                        break;
+                }
+                desc = (struct fip_desc *)((char *)desc + dlen);
+                rlen -= dlen;
+        }
+
+        /* any VLAN descriptors present ? */
+        if (list_empty(&fnic->vlans)) {
+                /* retry from timer */
+                FNIC_FCS_DBG(KERN_INFO, fnic->lport->host,
+                          "No VLAN descriptors in FIP VLAN response\n");
+                spin_unlock_irqrestore(&fnic->vlans_lock, flags);
+                goto out;
+        }
+
+        vlan = list_first_entry(&fnic->vlans, struct fcoe_vlan, list);
+        fnic->set_vlan(fnic, vlan->vid);
+        vlan->state = FIP_VLAN_SENT; /* sent now */
+        vlan->sol_count++;
+        spin_unlock_irqrestore(&fnic->vlans_lock, flags);
+
+        /* start the solicitation */
+        fcoe_ctlr_link_up(fip);
+
+        sol_time = jiffies + msecs_to_jiffies(FCOE_CTLR_START_DELAY);
+        mod_timer(&fnic->fip_timer, round_jiffies(sol_time));
+out:
+        return;
+}
+
+static void fnic_fcoe_start_fcf_disc(struct fnic *fnic)
+{
+        unsigned long flags;
+        struct fcoe_vlan *vlan;
+        u64 sol_time;
+
+        spin_lock_irqsave(&fnic->vlans_lock, flags);
+        vlan = list_first_entry(&fnic->vlans, struct fcoe_vlan, list);
+        fnic->set_vlan(fnic, vlan->vid);
+        vlan->state = FIP_VLAN_SENT; /* sent now */
+        vlan->sol_count = 1;
+        spin_unlock_irqrestore(&fnic->vlans_lock, flags);
+
+        /* start the solicitation */
+        fcoe_ctlr_link_up(&fnic->ctlr);
+
+        sol_time = jiffies + msecs_to_jiffies(FCOE_CTLR_START_DELAY);
+        mod_timer(&fnic->fip_timer, round_jiffies(sol_time));
+}
+
+static int fnic_fcoe_vlan_check(struct fnic *fnic, u16 flag)
+{
+        unsigned long flags;
+        struct fcoe_vlan *fvlan;
+
+        spin_lock_irqsave(&fnic->vlans_lock, flags);
+        if (list_empty(&fnic->vlans)) {
+                spin_unlock_irqrestore(&fnic->vlans_lock, flags);
+                return -EINVAL;
+        }
+
+        fvlan = list_first_entry(&fnic->vlans, struct fcoe_vlan, list);
+        if (fvlan->state == FIP_VLAN_USED) {
+                spin_unlock_irqrestore(&fnic->vlans_lock, flags);
+                return 0;
+        }
+
+        if (fvlan->state == FIP_VLAN_SENT) {
+                fvlan->state = FIP_VLAN_USED;
+                spin_unlock_irqrestore(&fnic->vlans_lock, flags);
+                return 0;
+        }
+        spin_unlock_irqrestore(&fnic->vlans_lock, flags);
+        return -EINVAL;
+}
+
+static void fnic_event_enq(struct fnic *fnic, enum fnic_evt ev)
+{
+        struct fnic_event *fevt;
+        unsigned long flags;
+
+        fevt = kmalloc(sizeof(*fevt), GFP_ATOMIC);
+        if (!fevt)
+                return;
+
+        fevt->fnic = fnic;
+        fevt->event = ev;
+
+        spin_lock_irqsave(&fnic->fnic_lock, flags);
+        list_add_tail(&fevt->list, &fnic->evlist);
+        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
+
+        schedule_work(&fnic->event_work);
+}
+
+static int fnic_fcoe_handle_fip_frame(struct fnic *fnic, struct sk_buff *skb)
+{
+        struct fip_header *fiph;
+        int ret = 1;
+        u16 op;
+        u8 sub;
+
+        if (!skb || !(skb->data))
+                return -1;
+
+        if (skb_linearize(skb))
+                goto drop;
+
+        fiph = (struct fip_header *)skb->data;
+        op = ntohs(fiph->fip_op);
+        sub = fiph->fip_subcode;
+
+        if (FIP_VER_DECAPS(fiph->fip_ver) != FIP_VER)
+                goto drop;
+
+        if (ntohs(fiph->fip_dl_len) * FIP_BPW + sizeof(*fiph) > skb->len)
+                goto drop;
+
+        if (op == FIP_OP_DISC && sub == FIP_SC_ADV) {
+                if (fnic_fcoe_vlan_check(fnic, ntohs(fiph->fip_flags)))
+                        goto drop;
+                /* pass it on to fcoe */
+                ret = 1;
+        } else if (op == FIP_OP_VLAN && sub == FIP_SC_VL_REP) {
+                /* set the vlan as used */
+                fnic_fcoe_process_vlan_resp(fnic, skb);
+                ret = 0;
+        } else if (op == FIP_OP_CTRL && sub == FIP_SC_CLR_VLINK) {
+                /* received CVL request, restart vlan disc */
+                fnic_event_enq(fnic, FNIC_EVT_START_VLAN_DISC);
+                /* pass it on to fcoe */
+                ret = 1;
+        }
+drop:
+        return ret;
+}
+
+void fnic_handle_fip_frame(struct work_struct *work)
+{
+        struct fnic *fnic = container_of(work, struct fnic, fip_frame_work);
+        unsigned long flags;
+        struct sk_buff *skb;
+        struct ethhdr *eh;
+
+        while ((skb = skb_dequeue(&fnic->fip_frame_queue))) {
+                spin_lock_irqsave(&fnic->fnic_lock, flags);
+                if (fnic->stop_rx_link_events) {
+                        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
+                        dev_kfree_skb(skb);
+                        return;
+                }
+                /*
+                 * If we're in a transitional state, just re-queue and return.
+                 * The queue will be serviced when we get to a stable state.
+                 */
+                if (fnic->state != FNIC_IN_FC_MODE &&
+                    fnic->state != FNIC_IN_ETH_MODE) {
+                        skb_queue_head(&fnic->fip_frame_queue, skb);
+                        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
+                        return;
+                }
+                spin_unlock_irqrestore(&fnic->fnic_lock, flags);
+                eh = (struct ethhdr *)skb->data;
+                if (eh->h_proto == htons(ETH_P_FIP)) {
+                        skb_pull(skb, sizeof(*eh));
+                        if (fnic_fcoe_handle_fip_frame(fnic, skb) <= 0) {
+                                dev_kfree_skb(skb);
+                                continue;
+                        }
+                        /*
+                         * If there's FLOGI rejects - clear all
+                         * fcf's & restart from scratch
+                         */
+                        if (is_fnic_fip_flogi_reject(&fnic->ctlr, skb)) {
+                                shost_printk(KERN_INFO, fnic->lport->host,
+                                          "Trigger a Link down - VLAN Disc\n");
+                                fcoe_ctlr_link_down(&fnic->ctlr);
+                                /* start FCoE VLAN discovery */
+                                fnic_fcoe_send_vlan_req(fnic);
+                                dev_kfree_skb(skb);
+                                continue;
+                        }
+                        fcoe_ctlr_recv(&fnic->ctlr, skb);
+                        continue;
+                }
+        }
+}
+
 /**
  * fnic_import_rq_eth_pkt() - handle received FCoE or FIP frame.
  * @fnic:       fnic instance.
@@ -150,8 +603,14 @@ static inline int fnic_import_rq_eth_pkt(struct fnic *fnic, struct sk_buff *skb)
                 skb_reset_mac_header(skb);
         }
         if (eh->h_proto == htons(ETH_P_FIP)) {
-                skb_pull(skb, sizeof(*eh));
-                fcoe_ctlr_recv(&fnic->ctlr, skb);
+                if (!(fnic->config.flags & VFCF_FIP_CAPABLE)) {
+                        printk(KERN_ERR "Dropped FIP frame, as firmware "
+                                        "uses non-FIP mode, Enable FIP "
+                                        "using UCSM\n");
+                        goto drop;
+                }
+                skb_queue_tail(&fnic->fip_frame_queue, skb);
+                queue_work(fnic_fip_queue, &fnic->fip_frame_work);
                 return 1;               /* let caller know packet was used */
         }
         if (eh->h_proto != htons(ETH_P_FCOE))
@@ -720,3 +1179,104 @@ void fnic_free_wq_buf(struct vnic_wq *wq, struct vnic_wq_buf *buf)
         dev_kfree_skb(fp_skb(fp));
         buf->os_buf = NULL;
 }
+
+void fnic_fcoe_reset_vlans(struct fnic *fnic)
+{
+        unsigned long flags;
+        struct fcoe_vlan *vlan;
+        struct fcoe_vlan *next;
+
+        /*
+         * indicate a link down to fcoe so that all fcf's are free'd
+         * might not be required since we did this before sending vlan
+         * discovery request
+         */
+        spin_lock_irqsave(&fnic->vlans_lock, flags);
+        if (!list_empty(&fnic->vlans)) {
+                list_for_each_entry_safe(vlan, next, &fnic->vlans, list) {
+                        list_del(&vlan->list);
+                        kfree(vlan);
+                }
+        }
+        spin_unlock_irqrestore(&fnic->vlans_lock, flags);
+}
+
+void fnic_handle_fip_timer(struct fnic *fnic)
+{
+        unsigned long flags;
+        struct fcoe_vlan *vlan;
+        u64 sol_time;
+
+        spin_lock_irqsave(&fnic->fnic_lock, flags);
+        if (fnic->stop_rx_link_events) {
+                spin_unlock_irqrestore(&fnic->fnic_lock, flags);
+                return;
+        }
+        spin_unlock_irqrestore(&fnic->fnic_lock, flags);
+
+        if (fnic->ctlr.mode == FIP_ST_NON_FIP)
+                return;
+
+        spin_lock_irqsave(&fnic->vlans_lock, flags);
+        if (list_empty(&fnic->vlans)) {
+                /* no vlans available, try again */
+                FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host,
+                          "Start VLAN Discovery\n");
+                spin_unlock_irqrestore(&fnic->vlans_lock, flags);
+                fnic_event_enq(fnic, FNIC_EVT_START_VLAN_DISC);
+                return;
+        }
+
+        vlan = list_first_entry(&fnic->vlans, struct fcoe_vlan, list);
+        shost_printk(KERN_DEBUG, fnic->lport->host,
+                  "fip_timer: vlan %d state %d sol_count %d\n",
+                  vlan->vid, vlan->state, vlan->sol_count);
+        switch (vlan->state) {
+        case FIP_VLAN_USED:
+                FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host,
+                          "FIP VLAN is selected for FC transaction\n");
+                spin_unlock_irqrestore(&fnic->vlans_lock, flags);
+                break;
+        case FIP_VLAN_FAILED:
+                /* if all vlans are in failed state, restart vlan disc */
+                FNIC_FCS_DBG(KERN_DEBUG, fnic->lport->host,
+                          "Start VLAN Discovery\n");
+                spin_unlock_irqrestore(&fnic->vlans_lock, flags);
+                fnic_event_enq(fnic, FNIC_EVT_START_VLAN_DISC);
+                break;
+        case FIP_VLAN_SENT:
+                if (vlan->sol_count >= FCOE_CTLR_MAX_SOL) {
+                        /*
+                         * no response on this vlan, remove  from the list.
+                         * Try the next vlan
+                         */
+                        shost_printk(KERN_INFO, fnic->lport->host,
+                                  "Dequeue this VLAN ID %d from list\n",
+                                  vlan->vid);
+                        list_del(&vlan->list);
+                        kfree(vlan);
+                        vlan = NULL;
+                        if (list_empty(&fnic->vlans)) {
+                                /* we exhausted all vlans, restart vlan disc */
+                                spin_unlock_irqrestore(&fnic->vlans_lock,
+                                                        flags);
+                                shost_printk(KERN_INFO, fnic->lport->host,
+                                          "fip_timer: vlan list empty, "
+                                          "trigger vlan disc\n");
+                                fnic_event_enq(fnic, FNIC_EVT_START_VLAN_DISC);
+                                return;
+                        }
+                        /* check the next vlan */
+                        vlan = list_first_entry(&fnic->vlans, struct fcoe_vlan,
+                                                        list);
+                        fnic->set_vlan(fnic, vlan->vid);
+                        vlan->state = FIP_VLAN_SENT; /* sent now */
+                }
+                spin_unlock_irqrestore(&fnic->vlans_lock, flags);
+                vlan->sol_count++;
+                sol_time = jiffies + msecs_to_jiffies
+                                        (FCOE_CTLR_START_DELAY);
+                mod_timer(&fnic->fip_timer, round_jiffies(sol_time));
+                break;
+        }
+}
diff --git a/drivers/scsi/fnic/fnic_fip.h b/drivers/scsi/fnic/fnic_fip.h
new file mode 100644
index 000000000000..87e74c2ab971
--- /dev/null
+++ b/drivers/scsi/fnic/fnic_fip.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2008 Cisco Systems, Inc.  All rights reserved.
+ * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
+ *
+ * This program is free software; you may redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef _FNIC_FIP_H_
+#define _FNIC_FIP_H_
+
+
+#define FCOE_CTLR_START_DELAY    2000    /* ms after first adv. to choose FCF */
+#define FCOE_CTLR_FIPVLAN_TOV    2000    /* ms after FIP VLAN disc */
+#define FCOE_CTLR_MAX_SOL        8
+
+#define FINC_MAX_FLOGI_REJECTS   8
+
+/*
+ * FIP_DT_VLAN descriptor.
+ */
+struct fip_vlan_desc {
+        struct fip_desc fd_desc;
+        __be16 fd_vlan;
+} __attribute__((packed));
+
+struct vlan {
+        __be16 vid;
+        __be16 type;
+};
+
+/*
+ * VLAN entry.
+ */
+struct fcoe_vlan {
+        struct list_head list;
+        u16 vid;                /* vlan ID */
+        u16 sol_count;          /* no. of sols sent */
+        u16 state;              /* state */
+};
+
+enum fip_vlan_state {
+        FIP_VLAN_AVAIL  = 0,    /* don't do anything */
+        FIP_VLAN_SENT   = 1,    /* sent */
+        FIP_VLAN_USED   = 2,    /* succeed */
+        FIP_VLAN_FAILED = 3,    /* failed to response */
+};
+
+struct fip_vlan {
+        struct ethhdr eth;
+        struct fip_header fip;
+        struct {
+                struct fip_mac_desc mac;
+                struct fip_wwn_desc wwnn;
+        } desc;
+};
+
+#endif  /* __FINC_FIP_H_ */
diff --git a/drivers/scsi/fnic/fnic_main.c b/drivers/scsi/fnic/fnic_main.c
index d601ac543c52..5f09d1814d26 100644
--- a/drivers/scsi/fnic/fnic_main.c
+++ b/drivers/scsi/fnic/fnic_main.c
@@ -39,6 +39,7 @@
 #include "vnic_intr.h"
 #include "vnic_stats.h"
 #include "fnic_io.h"
+#include "fnic_fip.h"
 #include "fnic.h"
 
 #define PCI_DEVICE_ID_CISCO_FNIC        0x0045
@@ -292,6 +293,13 @@ static void fnic_notify_timer(unsigned long data)
                   round_jiffies(jiffies + FNIC_NOTIFY_TIMER_PERIOD));
 }
 
+static void fnic_fip_notify_timer(unsigned long data)
+{
+        struct fnic *fnic = (struct fnic *)data;
+
+        fnic_handle_fip_timer(fnic);
+}
+
 static void fnic_notify_timer_start(struct fnic *fnic)
 {
         switch (vnic_dev_get_intr_mode(fnic->vdev)) {
@@ -403,6 +411,12 @@ static u8 *fnic_get_mac(struct fc_lport *lport)
         return fnic->data_src_addr;
 }
 
+static void fnic_set_vlan(struct fnic *fnic, u16 vlan_id)
+{
+        u16 old_vlan;
+        old_vlan = vnic_dev_set_default_vlan(fnic->vdev, vlan_id);
+}
+
 static int fnic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 {
         struct Scsi_Host *host;
@@ -620,7 +634,29 @@ static int fnic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                 vnic_dev_packet_filter(fnic->vdev, 1, 1, 0, 0, 0);
                 vnic_dev_add_addr(fnic->vdev, FIP_ALL_ENODE_MACS);
                 vnic_dev_add_addr(fnic->vdev, fnic->ctlr.ctl_src_addr);
+                fnic->set_vlan = fnic_set_vlan;
                 fcoe_ctlr_init(&fnic->ctlr, FIP_MODE_AUTO);
+                setup_timer(&fnic->fip_timer, fnic_fip_notify_timer,
+                                                        (unsigned long)fnic);
+                spin_lock_init(&fnic->vlans_lock);
+                INIT_WORK(&fnic->fip_frame_work, fnic_handle_fip_frame);
+                INIT_WORK(&fnic->event_work, fnic_handle_event);
+                skb_queue_head_init(&fnic->fip_frame_queue);
+                spin_lock_irqsave(&fnic_list_lock, flags);
+                if (!fnic_fip_queue) {
+                        fnic_fip_queue =
+                                create_singlethread_workqueue("fnic_fip_q");
+                        if (!fnic_fip_queue) {
+                                spin_unlock_irqrestore(&fnic_list_lock, flags);
+                                printk(KERN_ERR PFX "fnic FIP work queue "
+                                                 "create failed\n");
+                                err = -ENOMEM;
+                                goto err_out_free_max_pool;
+                        }
+                }
+                spin_unlock_irqrestore(&fnic_list_lock, flags);
+                INIT_LIST_HEAD(&fnic->evlist);
+                INIT_LIST_HEAD(&fnic->vlans);
         } else {
                 shost_printk(KERN_INFO, fnic->lport->host,
                              "firmware uses non-FIP mode\n");
@@ -807,6 +843,13 @@ static void fnic_remove(struct pci_dev *pdev)
         skb_queue_purge(&fnic->frame_queue);
         skb_queue_purge(&fnic->tx_queue);
 
+        if (fnic->config.flags & VFCF_FIP_CAPABLE) {
+                del_timer_sync(&fnic->fip_timer);
+                skb_queue_purge(&fnic->fip_frame_queue);
+                fnic_fcoe_reset_vlans(fnic);
+                fnic_fcoe_evlist_free(fnic);
+        }
+
         /*
          * Log off the fabric. This stops all remote ports, dns port,
          * logs off the fabric. This flushes all rport, disc, lport work
@@ -889,8 +932,8 @@ static int __init fnic_init_module(void)
         len = sizeof(struct fnic_sgl_list);
         fnic_sgl_cache[FNIC_SGL_CACHE_MAX] = kmem_cache_create
                 ("fnic_sgl_max", len + FNIC_SG_DESC_ALIGN, FNIC_SG_DESC_ALIGN,
-                 SLAB_HWCACHE_ALIGN,
-                 NULL);
+                  SLAB_HWCACHE_ALIGN,
+                  NULL);
         if (!fnic_sgl_cache[FNIC_SGL_CACHE_MAX]) {
                 printk(KERN_ERR PFX "failed to create fnic max sgl slab\n");
                 err = -ENOMEM;
@@ -951,6 +994,10 @@ static void __exit fnic_cleanup_module(void)
 {
         pci_unregister_driver(&fnic_driver);
         destroy_workqueue(fnic_event_queue);
+        if (fnic_fip_queue) {
+                flush_workqueue(fnic_fip_queue);
+                destroy_workqueue(fnic_fip_queue);
+        }
         kmem_cache_destroy(fnic_sgl_cache[FNIC_SGL_CACHE_MAX]);
         kmem_cache_destroy(fnic_sgl_cache[FNIC_SGL_CACHE_DFLT]);
         kmem_cache_destroy(fnic_io_req_cache);
diff --git a/drivers/scsi/fnic/vnic_dev.c b/drivers/scsi/fnic/vnic_dev.c
index b576be734e2e..9795d6f3e197 100644
--- a/drivers/scsi/fnic/vnic_dev.c
+++ b/drivers/scsi/fnic/vnic_dev.c
@@ -584,6 +584,16 @@ int vnic_dev_init(struct vnic_dev *vdev, int arg)
         return vnic_dev_cmd(vdev, CMD_INIT, &a0, &a1, wait);
 }
 
+u16 vnic_dev_set_default_vlan(struct vnic_dev *vdev, u16 new_default_vlan)
+{
+        u64 a0 = new_default_vlan, a1 = 0;
+        int wait = 1000;
+        int old_vlan = 0;
+
+        old_vlan = vnic_dev_cmd(vdev, CMD_SET_DEFAULT_VLAN, &a0, &a1, wait);
+        return (u16)old_vlan;
+}
+
 int vnic_dev_link_status(struct vnic_dev *vdev)
 {
         if (vdev->linkstatus)
diff --git a/drivers/scsi/fnic/vnic_dev.h b/drivers/scsi/fnic/vnic_dev.h
index f9935a8a5a09..40d4195f562b 100644
--- a/drivers/scsi/fnic/vnic_dev.h
+++ b/drivers/scsi/fnic/vnic_dev.h
@@ -148,6 +148,8 @@ int vnic_dev_disable(struct vnic_dev *vdev);
 int vnic_dev_open(struct vnic_dev *vdev, int arg);
 int vnic_dev_open_done(struct vnic_dev *vdev, int *done);
 int vnic_dev_init(struct vnic_dev *vdev, int arg);
+u16 vnic_dev_set_default_vlan(struct vnic_dev *vdev,
+                                u16 new_default_vlan);
 int vnic_dev_soft_reset(struct vnic_dev *vdev, int arg);
 int vnic_dev_soft_reset_done(struct vnic_dev *vdev, int *done);
 void vnic_dev_set_intr_mode(struct vnic_dev *vdev,
diff --git a/drivers/scsi/fnic/vnic_devcmd.h b/drivers/scsi/fnic/vnic_devcmd.h
index 7c9ccbd4134b..3e2fcbda6aed 100644
--- a/drivers/scsi/fnic/vnic_devcmd.h
+++ b/drivers/scsi/fnic/vnic_devcmd.h
@@ -196,6 +196,73 @@ enum vnic_devcmd_cmd {
 
         /* undo initialize of virtual link */
         CMD_DEINIT              = _CMDCNW(_CMD_DIR_NONE, _CMD_VTYPE_ALL, 34),
+
+        /* check fw capability of a cmd:
+         * in:  (u32)a0=cmd
+         * out: (u32)a0=errno, 0:valid cmd, a1=supported VNIC_STF_* bits */
+        CMD_CAPABILITY      = _CMDC(_CMD_DIR_RW, _CMD_VTYPE_ALL, 36),
+
+        /* persistent binding info
+         * in:  (u64)a0=paddr of arg
+         *      (u32)a1=CMD_PERBI_XXX */
+        CMD_PERBI       = _CMDC(_CMD_DIR_RW, _CMD_VTYPE_FC, 37),
+
+        /* Interrupt Assert Register functionality
+         * in: (u16)a0=interrupt number to assert
+         */
+        CMD_IAR         = _CMDCNW(_CMD_DIR_WRITE, _CMD_VTYPE_ALL, 38),
+
+        /* initiate hangreset, like softreset after hang detected */
+        CMD_HANG_RESET      = _CMDC(_CMD_DIR_NONE, _CMD_VTYPE_ALL, 39),
+
+        /* hangreset status:
+         *    out: a0=0 reset complete, a0=1 reset in progress */
+        CMD_HANG_RESET_STATUS   = _CMDC(_CMD_DIR_READ, _CMD_VTYPE_ALL, 40),
+
+        /*
+         * Set hw ingress packet vlan rewrite mode:
+         * in:  (u32)a0=new vlan rewrite mode
+         * out: (u32)a0=old vlan rewrite mode */
+        CMD_IG_VLAN_REWRITE_MODE = _CMDC(_CMD_DIR_RW, _CMD_VTYPE_ENET, 41),
+
+        /*
+         * in:  (u16)a0=bdf of target vnic
+         *      (u32)a1=cmd to proxy
+         *      a2-a15=args to cmd in a1
+         * out: (u32)a0=status of proxied cmd
+         *      a1-a15=out args of proxied cmd */
+        CMD_PROXY_BY_BDF =  _CMDC(_CMD_DIR_RW, _CMD_VTYPE_ALL, 42),
+
+        /*
+         * As for BY_BDF except a0 is index of hvnlink subordinate vnic
+         * or SR-IOV virtual vnic
+         */
+        CMD_PROXY_BY_INDEX =    _CMDC(_CMD_DIR_RW, _CMD_VTYPE_ALL, 43),
+
+        /*
+         * For HPP toggle:
+         * adapter-info-get
+         * in:  (u64)a0=phsical address of buffer passed in from caller.
+         *      (u16)a1=size of buffer specified in a0.
+         * out: (u64)a0=phsical address of buffer passed in from caller.
+         *      (u16)a1=actual bytes from VIF-CONFIG-INFO TLV, or
+         *              0 if no VIF-CONFIG-INFO TLV was ever received. */
+        CMD_CONFIG_INFO_GET = _CMDC(_CMD_DIR_RW, _CMD_VTYPE_ALL, 44),
+
+        /*
+         * INT13 API: (u64)a0=paddr to vnic_int13_params struct
+         *            (u32)a1=INT13_CMD_xxx
+         */
+        CMD_INT13_ALL = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ALL, 45),
+
+        /*
+         * Set default vlan:
+         * in: (u16)a0=new default vlan
+         *     (u16)a1=zero for overriding vlan with param a0,
+         *             non-zero for resetting vlan to the default
+         * out: (u16)a0=old default vlan
+         */
+        CMD_SET_DEFAULT_VLAN = _CMDC(_CMD_DIR_RW, _CMD_VTYPE_ALL, 46)
 };
 
 /* flags for CMD_OPEN */
diff --git a/drivers/scsi/ibmvscsi/ibmvfc.c b/drivers/scsi/ibmvscsi/ibmvfc.c
index cc82d0f322b6..4e31caa21ddf 100644
--- a/drivers/scsi/ibmvscsi/ibmvfc.c
+++ b/drivers/scsi/ibmvscsi/ibmvfc.c
@@ -2179,7 +2179,7 @@ static int ibmvfc_cancel_all(struct scsi_device *sdev, int type)
                 return 0;
         }
 
-        if (vhost->state == IBMVFC_ACTIVE) {
+        if (vhost->logged_in) {
                 evt = ibmvfc_get_event(vhost);
                 ibmvfc_init_event(evt, ibmvfc_sync_completion, IBMVFC_MAD_FORMAT);
 
@@ -2190,7 +2190,12 @@ static int ibmvfc_cancel_all(struct scsi_device *sdev, int type)
                 tmf->common.length = sizeof(*tmf);
                 tmf->scsi_id = rport->port_id;
                 int_to_scsilun(sdev->lun, &tmf->lun);
-                tmf->flags = (type | IBMVFC_TMF_LUA_VALID);
+                if (!(vhost->login_buf->resp.capabilities & IBMVFC_CAN_SUPPRESS_ABTS))
+                        type &= ~IBMVFC_TMF_SUPPRESS_ABTS;
+                if (vhost->state == IBMVFC_ACTIVE)
+                        tmf->flags = (type | IBMVFC_TMF_LUA_VALID);
+                else
+                        tmf->flags = ((type & IBMVFC_TMF_SUPPRESS_ABTS) | IBMVFC_TMF_LUA_VALID);
                 tmf->cancel_key = (unsigned long)sdev->hostdata;
                 tmf->my_cancel_key = (unsigned long)starget->hostdata;
 
@@ -2327,7 +2332,7 @@ static int ibmvfc_abort_task_set(struct scsi_device *sdev)
         timeout = wait_for_completion_timeout(&evt->comp, timeout);
 
         if (!timeout) {
-                rc = ibmvfc_cancel_all(sdev, IBMVFC_TMF_ABORT_TASK_SET);
+                rc = ibmvfc_cancel_all(sdev, 0);
                 if (!rc) {
                         rc = ibmvfc_wait_for_ops(vhost, sdev->hostdata, ibmvfc_match_key);
                         if (rc == SUCCESS)
@@ -2383,24 +2388,30 @@ out:
  * @cmd:        scsi command to abort
  *
  * Returns:
- *      SUCCESS / FAILED
+ *      SUCCESS / FAST_IO_FAIL / FAILED
  **/
 static int ibmvfc_eh_abort_handler(struct scsi_cmnd *cmd)
 {
         struct scsi_device *sdev = cmd->device;
         struct ibmvfc_host *vhost = shost_priv(sdev->host);
-        int cancel_rc, abort_rc;
+        int cancel_rc, block_rc;
         int rc = FAILED;
 
         ENTER;
-        fc_block_scsi_eh(cmd);
+        block_rc = fc_block_scsi_eh(cmd);
         ibmvfc_wait_while_resetting(vhost);
-        cancel_rc = ibmvfc_cancel_all(sdev, IBMVFC_TMF_ABORT_TASK_SET);
-        abort_rc = ibmvfc_abort_task_set(sdev);
+        if (block_rc != FAST_IO_FAIL) {
+                cancel_rc = ibmvfc_cancel_all(sdev, IBMVFC_TMF_ABORT_TASK_SET);
+                ibmvfc_abort_task_set(sdev);
+        } else
+                cancel_rc = ibmvfc_cancel_all(sdev, IBMVFC_TMF_SUPPRESS_ABTS);
 
-        if (!cancel_rc && !abort_rc)
+        if (!cancel_rc)
                 rc = ibmvfc_wait_for_ops(vhost, sdev, ibmvfc_match_lun);
 
+        if (block_rc == FAST_IO_FAIL && rc != FAILED)
+                rc = FAST_IO_FAIL;
+
         LEAVE;
         return rc;
 }
@@ -2410,29 +2421,47 @@ static int ibmvfc_eh_abort_handler(struct scsi_cmnd *cmd)
  * @cmd:        scsi command struct
  *
  * Returns:
- *      SUCCESS / FAILED
+ *      SUCCESS / FAST_IO_FAIL / FAILED
  **/
 static int ibmvfc_eh_device_reset_handler(struct scsi_cmnd *cmd)
 {
         struct scsi_device *sdev = cmd->device;
         struct ibmvfc_host *vhost = shost_priv(sdev->host);
-        int cancel_rc, reset_rc;
+        int cancel_rc, block_rc, reset_rc = 0;
         int rc = FAILED;
 
         ENTER;
-        fc_block_scsi_eh(cmd);
+        block_rc = fc_block_scsi_eh(cmd);
         ibmvfc_wait_while_resetting(vhost);
-        cancel_rc = ibmvfc_cancel_all(sdev, IBMVFC_TMF_LUN_RESET);
-        reset_rc = ibmvfc_reset_device(sdev, IBMVFC_LUN_RESET, "LUN");
+        if (block_rc != FAST_IO_FAIL) {
+                cancel_rc = ibmvfc_cancel_all(sdev, IBMVFC_TMF_LUN_RESET);
+                reset_rc = ibmvfc_reset_device(sdev, IBMVFC_LUN_RESET, "LUN");
+        } else
+                cancel_rc = ibmvfc_cancel_all(sdev, IBMVFC_TMF_SUPPRESS_ABTS);
 
         if (!cancel_rc && !reset_rc)
                 rc = ibmvfc_wait_for_ops(vhost, sdev, ibmvfc_match_lun);
 
+        if (block_rc == FAST_IO_FAIL && rc != FAILED)
+                rc = FAST_IO_FAIL;
+
         LEAVE;
         return rc;
 }
 
 /**
+ * ibmvfc_dev_cancel_all_noreset - Device iterated cancel all function
+ * @sdev:       scsi device struct
+ * @data:       return code
+ *
+ **/
+static void ibmvfc_dev_cancel_all_noreset(struct scsi_device *sdev, void *data)
+{
+        unsigned long *rc = data;
+        *rc |= ibmvfc_cancel_all(sdev, IBMVFC_TMF_SUPPRESS_ABTS);
+}
+
+/**
  * ibmvfc_dev_cancel_all_reset - Device iterated cancel all function
  * @sdev:       scsi device struct
  * @data:       return code
@@ -2449,26 +2478,33 @@ static void ibmvfc_dev_cancel_all_reset(struct scsi_device *sdev, void *data)
  * @cmd:        scsi command struct
  *
  * Returns:
- *      SUCCESS / FAILED
+ *      SUCCESS / FAST_IO_FAIL / FAILED
  **/
 static int ibmvfc_eh_target_reset_handler(struct scsi_cmnd *cmd)
 {
         struct scsi_device *sdev = cmd->device;
         struct ibmvfc_host *vhost = shost_priv(sdev->host);
         struct scsi_target *starget = scsi_target(sdev);
-        int reset_rc;
+        int block_rc;
+        int reset_rc = 0;
         int rc = FAILED;
         unsigned long cancel_rc = 0;
 
         ENTER;
-        fc_block_scsi_eh(cmd);
+        block_rc = fc_block_scsi_eh(cmd);
         ibmvfc_wait_while_resetting(vhost);
-        starget_for_each_device(starget, &cancel_rc, ibmvfc_dev_cancel_all_reset);
-        reset_rc = ibmvfc_reset_device(sdev, IBMVFC_TARGET_RESET, "target");
+        if (block_rc != FAST_IO_FAIL) {
+                starget_for_each_device(starget, &cancel_rc, ibmvfc_dev_cancel_all_reset);
+                reset_rc = ibmvfc_reset_device(sdev, IBMVFC_TARGET_RESET, "target");
+        } else
+                starget_for_each_device(starget, &cancel_rc, ibmvfc_dev_cancel_all_noreset);
 
         if (!cancel_rc && !reset_rc)
                 rc = ibmvfc_wait_for_ops(vhost, starget, ibmvfc_match_target);
 
+        if (block_rc == FAST_IO_FAIL && rc != FAILED)
+                rc = FAST_IO_FAIL;
+
         LEAVE;
         return rc;
 }
@@ -2480,12 +2516,16 @@ static int ibmvfc_eh_target_reset_handler(struct scsi_cmnd *cmd)
  **/
 static int ibmvfc_eh_host_reset_handler(struct scsi_cmnd *cmd)
 {
-        int rc;
+        int rc, block_rc;
         struct ibmvfc_host *vhost = shost_priv(cmd->device->host);
 
-        fc_block_scsi_eh(cmd);
+        block_rc = fc_block_scsi_eh(cmd);
         dev_err(vhost->dev, "Resetting connection due to error recovery\n");
         rc = ibmvfc_issue_fc_host_lip(vhost->host);
+
+        if (block_rc == FAST_IO_FAIL)
+                return FAST_IO_FAIL;
+
         return rc ? FAILED : SUCCESS;
 }
 
@@ -2509,8 +2549,7 @@ static void ibmvfc_terminate_rport_io(struct fc_rport *rport)
                 dev_rport = starget_to_rport(scsi_target(sdev));
                 if (dev_rport != rport)
                         continue;
-                ibmvfc_cancel_all(sdev, IBMVFC_TMF_ABORT_TASK_SET);
-                ibmvfc_abort_task_set(sdev);
+                ibmvfc_cancel_all(sdev, IBMVFC_TMF_SUPPRESS_ABTS);
         }
 
         rc = ibmvfc_wait_for_ops(vhost, rport, ibmvfc_match_rport);
diff --git a/drivers/scsi/ibmvscsi/ibmvfc.h b/drivers/scsi/ibmvscsi/ibmvfc.h
index 3be8af624e6f..017a5290e8c1 100644
--- a/drivers/scsi/ibmvscsi/ibmvfc.h
+++ b/drivers/scsi/ibmvscsi/ibmvfc.h
@@ -29,8 +29,8 @@
 #include "viosrp.h"
 
 #define IBMVFC_NAME     "ibmvfc"
-#define IBMVFC_DRIVER_VERSION           "1.0.10"
-#define IBMVFC_DRIVER_DATE              "(August 24, 2012)"
+#define IBMVFC_DRIVER_VERSION           "1.0.11"
+#define IBMVFC_DRIVER_DATE              "(April 12, 2013)"
 
 #define IBMVFC_DEFAULT_TIMEOUT  60
 #define IBMVFC_ADISC_CANCEL_TIMEOUT     45
@@ -208,10 +208,10 @@ struct ibmvfc_npiv_login_resp {
         u16 error;
         u32 flags;
 #define IBMVFC_NATIVE_FC                0x01
-#define IBMVFC_CAN_FLUSH_ON_HALT        0x08
         u32 reserved;
         u64 capabilities;
 #define IBMVFC_CAN_FLUSH_ON_HALT        0x08
+#define IBMVFC_CAN_SUPPRESS_ABTS        0x10
         u32 max_cmds;
         u32 scsi_id_sz;
         u64 max_dma_len;
@@ -351,6 +351,7 @@ struct ibmvfc_tmf {
 #define IBMVFC_TMF_LUN_RESET            0x10
 #define IBMVFC_TMF_TGT_RESET            0x20
 #define IBMVFC_TMF_LUA_VALID            0x40
+#define IBMVFC_TMF_SUPPRESS_ABTS        0x80
         u32 cancel_key;
         u32 my_cancel_key;
         u32 pad;
diff --git a/drivers/scsi/ipr.c b/drivers/scsi/ipr.c
index 2197b57fb225..82a3c1ec8706 100644
--- a/drivers/scsi/ipr.c
+++ b/drivers/scsi/ipr.c
@@ -4777,7 +4777,7 @@ static int ipr_eh_host_reset(struct scsi_cmnd *cmd)
         ioa_cfg = (struct ipr_ioa_cfg *) cmd->device->host->hostdata;
         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
 
-        if (!ioa_cfg->in_reset_reload) {
+        if (!ioa_cfg->in_reset_reload && !ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead) {
                 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_ABBREV);
                 dev_err(&ioa_cfg->pdev->dev,
                         "Adapter being reset as a result of error recovery.\n");
@@ -6421,7 +6421,7 @@ static void ipr_build_ata_ioadl64(struct ipr_cmnd *ipr_cmd,
 {
         u32 ioadl_flags = 0;
         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
-        struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ioadl64;
+        struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ata_ioadl.ioadl64;
         struct ipr_ioadl64_desc *last_ioadl64 = NULL;
         int len = qc->nbytes;
         struct scatterlist *sg;
@@ -6441,7 +6441,7 @@ static void ipr_build_ata_ioadl64(struct ipr_cmnd *ipr_cmd,
         ioarcb->ioadl_len =
                 cpu_to_be32(sizeof(struct ipr_ioadl64_desc) * ipr_cmd->dma_use_sg);
         ioarcb->u.sis64_addr_data.data_ioadl_addr =
-                cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ata_ioadl));
+                cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ata_ioadl.ioadl64));
 
         for_each_sg(qc->sg, sg, qc->n_elem, si) {
                 ioadl64->flags = cpu_to_be32(ioadl_flags);
@@ -6739,6 +6739,7 @@ static int ipr_invalid_adapter(struct ipr_ioa_cfg *ioa_cfg)
 static int ipr_ioa_bringdown_done(struct ipr_cmnd *ipr_cmd)
 {
         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
+        int i;
 
         ENTER;
         if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].removing_ioa) {
@@ -6750,6 +6751,13 @@ static int ipr_ioa_bringdown_done(struct ipr_cmnd *ipr_cmd)
 
         ioa_cfg->in_reset_reload = 0;
         ioa_cfg->reset_retries = 0;
+        for (i = 0; i < ioa_cfg->hrrq_num; i++) {
+                spin_lock(&ioa_cfg->hrrq[i]._lock);
+                ioa_cfg->hrrq[i].ioa_is_dead = 1;
+                spin_unlock(&ioa_cfg->hrrq[i]._lock);
+        }
+        wmb();
+
         list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
         wake_up_all(&ioa_cfg->reset_wait_q);
         LEAVE;
@@ -8651,7 +8659,7 @@ static void ipr_pci_perm_failure(struct pci_dev *pdev)
         spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
         if (ioa_cfg->sdt_state == WAIT_FOR_DUMP)
                 ioa_cfg->sdt_state = ABORT_DUMP;
-        ioa_cfg->reset_retries = IPR_NUM_RESET_RELOAD_RETRIES;
+        ioa_cfg->reset_retries = IPR_NUM_RESET_RELOAD_RETRIES - 1;
         ioa_cfg->in_ioa_bringdown = 1;
         for (i = 0; i < ioa_cfg->hrrq_num; i++) {
                 spin_lock(&ioa_cfg->hrrq[i]._lock);
diff --git a/drivers/scsi/ipr.h b/drivers/scsi/ipr.h
index 21a6ff1ed5c6..a1fb840596ef 100644
--- a/drivers/scsi/ipr.h
+++ b/drivers/scsi/ipr.h
@@ -552,7 +552,7 @@ struct ipr_ioarcb_ata_regs {	/* 22 bytes */
         u8 hob_lbam;
         u8 hob_lbah;
         u8 ctl;
-}__attribute__ ((packed, aligned(4)));
+}__attribute__ ((packed, aligned(2)));
 
 struct ipr_ioadl_desc {
         __be32 flags_and_data_len;
diff --git a/drivers/scsi/isci/remote_device.c b/drivers/scsi/isci/remote_device.c
index c3aa6c5457b9..96a26f454673 100644
--- a/drivers/scsi/isci/remote_device.c
+++ b/drivers/scsi/isci/remote_device.c
@@ -1085,7 +1085,7 @@ static void sci_remote_device_ready_state_enter(struct sci_base_state_machine *s
         struct isci_host *ihost = idev->owning_port->owning_controller;
         struct domain_device *dev = idev->domain_dev;
 
-        if (dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_SATA)) {
+        if (dev->dev_type == SAS_SATA_DEV || (dev->tproto & SAS_PROTOCOL_SATA)) {
                 sci_change_state(&idev->sm, SCI_STP_DEV_IDLE);
         } else if (dev_is_expander(dev)) {
                 sci_change_state(&idev->sm, SCI_SMP_DEV_IDLE);
@@ -1098,7 +1098,7 @@ static void sci_remote_device_ready_state_exit(struct sci_base_state_machine *sm
         struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
         struct domain_device *dev = idev->domain_dev;
 
-        if (dev->dev_type == SAS_END_DEV) {
+        if (dev->dev_type == SAS_END_DEVICE) {
                 struct isci_host *ihost = idev->owning_port->owning_controller;
 
                 isci_remote_device_not_ready(ihost, idev,
diff --git a/drivers/scsi/isci/remote_device.h b/drivers/scsi/isci/remote_device.h
index 7674caae1d88..47a013fffae7 100644
--- a/drivers/scsi/isci/remote_device.h
+++ b/drivers/scsi/isci/remote_device.h
@@ -297,7 +297,7 @@ static inline struct isci_remote_device *rnc_to_dev(struct sci_remote_node_conte
 
 static inline bool dev_is_expander(struct domain_device *dev)
 {
-        return dev->dev_type == EDGE_DEV || dev->dev_type == FANOUT_DEV;
+        return dev->dev_type == SAS_EDGE_EXPANDER_DEVICE || dev->dev_type == SAS_FANOUT_EXPANDER_DEVICE;
 }
 
 static inline void sci_remote_device_decrement_request_count(struct isci_remote_device *idev)
diff --git a/drivers/scsi/isci/request.c b/drivers/scsi/isci/request.c
index 9594ab62702b..e3e3bcbd5a9f 100644
--- a/drivers/scsi/isci/request.c
+++ b/drivers/scsi/isci/request.c
@@ -2978,7 +2978,7 @@ static void sci_request_started_state_enter(struct sci_base_state_machine *sm)
         /* all unaccelerated request types (non ssp or ncq) handled with
          * substates
          */
-        if (!task && dev->dev_type == SAS_END_DEV) {
+        if (!task && dev->dev_type == SAS_END_DEVICE) {
                 state = SCI_REQ_TASK_WAIT_TC_COMP;
         } else if (task && task->task_proto == SAS_PROTOCOL_SMP) {
                 state = SCI_REQ_SMP_WAIT_RESP;
@@ -3101,7 +3101,7 @@ sci_io_request_construct(struct isci_host *ihost,
         if (idev->rnc.remote_node_index == SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX)
                 return SCI_FAILURE_INVALID_REMOTE_DEVICE;
 
-        if (dev->dev_type == SAS_END_DEV)
+        if (dev->dev_type == SAS_END_DEVICE)
                 /* pass */;
         else if (dev_is_sata(dev))
                 memset(&ireq->stp.cmd, 0, sizeof(ireq->stp.cmd));
@@ -3125,7 +3125,7 @@ enum sci_status sci_task_request_construct(struct isci_host *ihost,
         /* Build the common part of the request */
         sci_general_request_construct(ihost, idev, ireq);
 
-        if (dev->dev_type == SAS_END_DEV || dev_is_sata(dev)) {
+        if (dev->dev_type == SAS_END_DEVICE || dev_is_sata(dev)) {
                 set_bit(IREQ_TMF, &ireq->flags);
                 memset(ireq->tc, 0, sizeof(struct scu_task_context));
 
diff --git a/drivers/scsi/isci/task.c b/drivers/scsi/isci/task.c
index b6f19a1db780..9bb020ac089c 100644
--- a/drivers/scsi/isci/task.c
+++ b/drivers/scsi/isci/task.c
@@ -250,7 +250,7 @@ static struct isci_request *isci_task_request_build(struct isci_host *ihost,
         }
 
         /* XXX convert to get this from task->tproto like other drivers */
-        if (dev->dev_type == SAS_END_DEV) {
+        if (dev->dev_type == SAS_END_DEVICE) {
                 isci_tmf->proto = SAS_PROTOCOL_SSP;
                 status = sci_task_request_construct_ssp(ireq);
                 if (status != SCI_SUCCESS)
diff --git a/drivers/scsi/libsas/sas_ata.c b/drivers/scsi/libsas/sas_ata.c
index bdb81cda8401..161c98efade9 100644
--- a/drivers/scsi/libsas/sas_ata.c
+++ b/drivers/scsi/libsas/sas_ata.c
@@ -285,14 +285,14 @@ int sas_get_ata_info(struct domain_device *dev, struct ex_phy *phy)
         if (phy->attached_tproto & SAS_PROTOCOL_STP)
                 dev->tproto = phy->attached_tproto;
         if (phy->attached_sata_dev)
-                dev->tproto |= SATA_DEV;
+                dev->tproto |= SAS_SATA_DEV;
 
-        if (phy->attached_dev_type == SATA_PENDING)
-                dev->dev_type = SATA_PENDING;
+        if (phy->attached_dev_type == SAS_SATA_PENDING)
+                dev->dev_type = SAS_SATA_PENDING;
         else {
                 int res;
 
-                dev->dev_type = SATA_DEV;
+                dev->dev_type = SAS_SATA_DEV;
                 res = sas_get_report_phy_sata(dev->parent, phy->phy_id,
                                               &dev->sata_dev.rps_resp);
                 if (res) {
@@ -314,7 +314,7 @@ static int sas_ata_clear_pending(struct domain_device *dev, struct ex_phy *phy)
         int res;
 
         /* we weren't pending, so successfully end the reset sequence now */
-        if (dev->dev_type != SATA_PENDING)
+        if (dev->dev_type != SAS_SATA_PENDING)
                 return 1;
 
         /* hmmm, if this succeeds do we need to repost the domain_device to the
@@ -348,9 +348,9 @@ static int smp_ata_check_ready(struct ata_link *link)
                 return 0;
 
         switch (ex_phy->attached_dev_type) {
-        case SATA_PENDING:
+        case SAS_SATA_PENDING:
                 return 0;
-        case SAS_END_DEV:
+        case SAS_END_DEVICE:
                 if (ex_phy->attached_sata_dev)
                         return sas_ata_clear_pending(dev, ex_phy);
         default:
@@ -631,7 +631,7 @@ static void sas_get_ata_command_set(struct domain_device *dev)
         struct dev_to_host_fis *fis =
                 (struct dev_to_host_fis *) dev->frame_rcvd;
 
-        if (dev->dev_type == SATA_PENDING)
+        if (dev->dev_type == SAS_SATA_PENDING)
                 return;
 
         if ((fis->sector_count == 1 && /* ATA */
@@ -797,7 +797,7 @@ int sas_discover_sata(struct domain_device *dev)
 {
         int res;
 
-        if (dev->dev_type == SATA_PM)
+        if (dev->dev_type == SAS_SATA_PM)
                 return -ENODEV;
 
         sas_get_ata_command_set(dev);
diff --git a/drivers/scsi/libsas/sas_discover.c b/drivers/scsi/libsas/sas_discover.c
index a0c3003e0c7d..62b58d38ce2e 100644
--- a/drivers/scsi/libsas/sas_discover.c
+++ b/drivers/scsi/libsas/sas_discover.c
@@ -39,11 +39,11 @@
 void sas_init_dev(struct domain_device *dev)
 {
         switch (dev->dev_type) {
-        case SAS_END_DEV:
+        case SAS_END_DEVICE:
                 INIT_LIST_HEAD(&dev->ssp_dev.eh_list_node);
                 break;
-        case EDGE_DEV:
-        case FANOUT_DEV:
+        case SAS_EDGE_EXPANDER_DEVICE:
+        case SAS_FANOUT_EXPANDER_DEVICE:
                 INIT_LIST_HEAD(&dev->ex_dev.children);
                 mutex_init(&dev->ex_dev.cmd_mutex);
                 break;
@@ -93,9 +93,9 @@ static int sas_get_port_device(struct asd_sas_port *port)
                 if (fis->interrupt_reason == 1 && fis->lbal == 1 &&
                     fis->byte_count_low==0x69 && fis->byte_count_high == 0x96
                     && (fis->device & ~0x10) == 0)
-                        dev->dev_type = SATA_PM;
+                        dev->dev_type = SAS_SATA_PM;
                 else
-                        dev->dev_type = SATA_DEV;
+                        dev->dev_type = SAS_SATA_DEV;
                 dev->tproto = SAS_PROTOCOL_SATA;
         } else {
                 struct sas_identify_frame *id =
@@ -109,21 +109,21 @@ static int sas_get_port_device(struct asd_sas_port *port)
 
         dev->port = port;
         switch (dev->dev_type) {
-        case SATA_DEV:
+        case SAS_SATA_DEV:
                 rc = sas_ata_init(dev);
                 if (rc) {
                         rphy = NULL;
                         break;
                 }
                 /* fall through */
-        case SAS_END_DEV:
+        case SAS_END_DEVICE:
                 rphy = sas_end_device_alloc(port->port);
                 break;
-        case EDGE_DEV:
+        case SAS_EDGE_EXPANDER_DEVICE:
                 rphy = sas_expander_alloc(port->port,
                                           SAS_EDGE_EXPANDER_DEVICE);
                 break;
-        case FANOUT_DEV:
+        case SAS_FANOUT_EXPANDER_DEVICE:
                 rphy = sas_expander_alloc(port->port,
                                           SAS_FANOUT_EXPANDER_DEVICE);
                 break;
@@ -156,7 +156,7 @@ static int sas_get_port_device(struct asd_sas_port *port)
         dev->rphy = rphy;
         get_device(&dev->rphy->dev);
 
-        if (dev_is_sata(dev) || dev->dev_type == SAS_END_DEV)
+        if (dev_is_sata(dev) || dev->dev_type == SAS_END_DEVICE)
                 list_add_tail(&dev->disco_list_node, &port->disco_list);
         else {
                 spin_lock_irq(&port->dev_list_lock);
@@ -315,7 +315,7 @@ void sas_free_device(struct kref *kref)
         dev->phy = NULL;
 
         /* remove the phys and ports, everything else should be gone */
-        if (dev->dev_type == EDGE_DEV || dev->dev_type == FANOUT_DEV)
+        if (dev->dev_type == SAS_EDGE_EXPANDER_DEVICE || dev->dev_type == SAS_FANOUT_EXPANDER_DEVICE)
                 kfree(dev->ex_dev.ex_phy);
 
         if (dev_is_sata(dev) && dev->sata_dev.ap) {
@@ -343,7 +343,7 @@ static void sas_unregister_common_dev(struct asd_sas_port *port, struct domain_d
         spin_unlock_irq(&port->dev_list_lock);
 
         spin_lock_irq(&ha->lock);
-        if (dev->dev_type == SAS_END_DEV &&
+        if (dev->dev_type == SAS_END_DEVICE &&
             !list_empty(&dev->ssp_dev.eh_list_node)) {
                 list_del_init(&dev->ssp_dev.eh_list_node);
                 ha->eh_active--;
@@ -457,15 +457,15 @@ static void sas_discover_domain(struct work_struct *work)
                     task_pid_nr(current));
 
         switch (dev->dev_type) {
-        case SAS_END_DEV:
+        case SAS_END_DEVICE:
                 error = sas_discover_end_dev(dev);
                 break;
-        case EDGE_DEV:
-        case FANOUT_DEV:
+        case SAS_EDGE_EXPANDER_DEVICE:
+        case SAS_FANOUT_EXPANDER_DEVICE:
                 error = sas_discover_root_expander(dev);
                 break;
-        case SATA_DEV:
-        case SATA_PM:
+        case SAS_SATA_DEV:
+        case SAS_SATA_PM:
 #ifdef CONFIG_SCSI_SAS_ATA
                 error = sas_discover_sata(dev);
                 break;
diff --git a/drivers/scsi/libsas/sas_expander.c b/drivers/scsi/libsas/sas_expander.c
index f42b0e15410f..446b85110a1f 100644
--- a/drivers/scsi/libsas/sas_expander.c
+++ b/drivers/scsi/libsas/sas_expander.c
@@ -183,21 +183,21 @@ static char sas_route_char(struct domain_device *dev, struct ex_phy *phy)
         }
 }
 
-static enum sas_dev_type to_dev_type(struct discover_resp *dr)
+static enum sas_device_type to_dev_type(struct discover_resp *dr)
 {
         /* This is detecting a failure to transmit initial dev to host
          * FIS as described in section J.5 of sas-2 r16
          */
-        if (dr->attached_dev_type == NO_DEVICE && dr->attached_sata_dev &&
+        if (dr->attached_dev_type == SAS_PHY_UNUSED && dr->attached_sata_dev &&
             dr->linkrate >= SAS_LINK_RATE_1_5_GBPS)
-                return SATA_PENDING;
+                return SAS_SATA_PENDING;
         else
                 return dr->attached_dev_type;
 }
 
 static void sas_set_ex_phy(struct domain_device *dev, int phy_id, void *rsp)
 {
-        enum sas_dev_type dev_type;
+        enum sas_device_type dev_type;
         enum sas_linkrate linkrate;
         u8 sas_addr[SAS_ADDR_SIZE];
         struct smp_resp *resp = rsp;
@@ -238,7 +238,7 @@ static void sas_set_ex_phy(struct domain_device *dev, int phy_id, void *rsp)
         /* Handle vacant phy - rest of dr data is not valid so skip it */
         if (phy->phy_state == PHY_VACANT) {
                 memset(phy->attached_sas_addr, 0, SAS_ADDR_SIZE);
-                phy->attached_dev_type = NO_DEVICE;
+                phy->attached_dev_type = SAS_PHY_UNUSED;
                 if (!test_bit(SAS_HA_ATA_EH_ACTIVE, &ha->state)) {
                         phy->phy_id = phy_id;
                         goto skip;
@@ -259,7 +259,7 @@ static void sas_set_ex_phy(struct domain_device *dev, int phy_id, void *rsp)
         /* help some expanders that fail to zero sas_address in the 'no
          * device' case
          */
-        if (phy->attached_dev_type == NO_DEVICE ||
+        if (phy->attached_dev_type == SAS_PHY_UNUSED ||
             phy->linkrate < SAS_LINK_RATE_1_5_GBPS)
                 memset(phy->attached_sas_addr, 0, SAS_ADDR_SIZE);
         else
@@ -292,13 +292,13 @@ static void sas_set_ex_phy(struct domain_device *dev, int phy_id, void *rsp)
 
  out:
         switch (phy->attached_dev_type) {
-        case SATA_PENDING:
+        case SAS_SATA_PENDING:
                 type = "stp pending";
                 break;
-        case NO_DEVICE:
+        case SAS_PHY_UNUSED:
                 type = "no device";
                 break;
-        case SAS_END_DEV:
+        case SAS_END_DEVICE:
                 if (phy->attached_iproto) {
                         if (phy->attached_tproto)
                                 type = "host+target";
@@ -311,8 +311,8 @@ static void sas_set_ex_phy(struct domain_device *dev, int phy_id, void *rsp)
                                 type = "ssp";
                 }
                 break;
-        case EDGE_DEV:
-        case FANOUT_DEV:
+        case SAS_EDGE_EXPANDER_DEVICE:
+        case SAS_FANOUT_EXPANDER_DEVICE:
                 type = "smp";
                 break;
         default:
@@ -833,7 +833,7 @@ static struct domain_device *sas_ex_discover_end_dev(
         } else
 #endif
           if (phy->attached_tproto & SAS_PROTOCOL_SSP) {
-                child->dev_type = SAS_END_DEV;
+                child->dev_type = SAS_END_DEVICE;
                 rphy = sas_end_device_alloc(phy->port);
                 /* FIXME: error handling */
                 if (unlikely(!rphy))
@@ -932,11 +932,11 @@ static struct domain_device *sas_ex_discover_expander(
 
 
         switch (phy->attached_dev_type) {
-        case EDGE_DEV:
+        case SAS_EDGE_EXPANDER_DEVICE:
                 rphy = sas_expander_alloc(phy->port,
                                           SAS_EDGE_EXPANDER_DEVICE);
                 break;
-        case FANOUT_DEV:
+        case SAS_FANOUT_EXPANDER_DEVICE:
                 rphy = sas_expander_alloc(phy->port,
                                           SAS_FANOUT_EXPANDER_DEVICE);
                 break;
@@ -1013,7 +1013,7 @@ static int sas_ex_discover_dev(struct domain_device *dev, int phy_id)
         if (sas_dev_present_in_domain(dev->port, ex_phy->attached_sas_addr))
                 sas_ex_disable_port(dev, ex_phy->attached_sas_addr);
 
-        if (ex_phy->attached_dev_type == NO_DEVICE) {
+        if (ex_phy->attached_dev_type == SAS_PHY_UNUSED) {
                 if (ex_phy->routing_attr == DIRECT_ROUTING) {
                         memset(ex_phy->attached_sas_addr, 0, SAS_ADDR_SIZE);
                         sas_configure_routing(dev, ex_phy->attached_sas_addr);
@@ -1022,10 +1022,10 @@ static int sas_ex_discover_dev(struct domain_device *dev, int phy_id)
         } else if (ex_phy->linkrate == SAS_LINK_RATE_UNKNOWN)
                 return 0;
 
-        if (ex_phy->attached_dev_type != SAS_END_DEV &&
-            ex_phy->attached_dev_type != FANOUT_DEV &&
-            ex_phy->attached_dev_type != EDGE_DEV &&
-            ex_phy->attached_dev_type != SATA_PENDING) {
+        if (ex_phy->attached_dev_type != SAS_END_DEVICE &&
+            ex_phy->attached_dev_type != SAS_FANOUT_EXPANDER_DEVICE &&
+            ex_phy->attached_dev_type != SAS_EDGE_EXPANDER_DEVICE &&
+            ex_phy->attached_dev_type != SAS_SATA_PENDING) {
                 SAS_DPRINTK("unknown device type(0x%x) attached to ex %016llx "
                             "phy 0x%x\n", ex_phy->attached_dev_type,
                             SAS_ADDR(dev->sas_addr),
@@ -1049,11 +1049,11 @@ static int sas_ex_discover_dev(struct domain_device *dev, int phy_id)
         }
 
         switch (ex_phy->attached_dev_type) {
-        case SAS_END_DEV:
-        case SATA_PENDING:
+        case SAS_END_DEVICE:
+        case SAS_SATA_PENDING:
                 child = sas_ex_discover_end_dev(dev, phy_id);
                 break;
-        case FANOUT_DEV:
+        case SAS_FANOUT_EXPANDER_DEVICE:
                 if (SAS_ADDR(dev->port->disc.fanout_sas_addr)) {
                         SAS_DPRINTK("second fanout expander %016llx phy 0x%x "
                                     "attached to ex %016llx phy 0x%x\n",
@@ -1067,7 +1067,7 @@ static int sas_ex_discover_dev(struct domain_device *dev, int phy_id)
                         memcpy(dev->port->disc.fanout_sas_addr,
                                ex_phy->attached_sas_addr, SAS_ADDR_SIZE);
                 /* fallthrough */
-        case EDGE_DEV:
+        case SAS_EDGE_EXPANDER_DEVICE:
                 child = sas_ex_discover_expander(dev, phy_id);
                 break;
         default:
@@ -1111,8 +1111,8 @@ static int sas_find_sub_addr(struct domain_device *dev, u8 *sub_addr)
                     phy->phy_state == PHY_NOT_PRESENT)
                         continue;
 
-                if ((phy->attached_dev_type == EDGE_DEV ||
-                     phy->attached_dev_type == FANOUT_DEV) &&
+                if ((phy->attached_dev_type == SAS_EDGE_EXPANDER_DEVICE ||
+                     phy->attached_dev_type == SAS_FANOUT_EXPANDER_DEVICE) &&
                     phy->routing_attr == SUBTRACTIVE_ROUTING) {
 
                         memcpy(sub_addr, phy->attached_sas_addr,SAS_ADDR_SIZE);
@@ -1130,8 +1130,8 @@ static int sas_check_level_subtractive_boundary(struct domain_device *dev)
         u8 sub_addr[8] = {0, };
 
         list_for_each_entry(child, &ex->children, siblings) {
-                if (child->dev_type != EDGE_DEV &&
-                    child->dev_type != FANOUT_DEV)
+                if (child->dev_type != SAS_EDGE_EXPANDER_DEVICE &&
+                    child->dev_type != SAS_FANOUT_EXPANDER_DEVICE)
                         continue;
                 if (sub_addr[0] == 0) {
                         sas_find_sub_addr(child, sub_addr);
@@ -1208,7 +1208,7 @@ static int sas_check_ex_subtractive_boundary(struct domain_device *dev)
         int i;
         u8  *sub_sas_addr = NULL;
 
-        if (dev->dev_type != EDGE_DEV)
+        if (dev->dev_type != SAS_EDGE_EXPANDER_DEVICE)
                 return 0;
 
         for (i = 0; i < ex->num_phys; i++) {
@@ -1218,8 +1218,8 @@ static int sas_check_ex_subtractive_boundary(struct domain_device *dev)
                     phy->phy_state == PHY_NOT_PRESENT)
                         continue;
 
-                if ((phy->attached_dev_type == FANOUT_DEV ||
-                     phy->attached_dev_type == EDGE_DEV) &&
+                if ((phy->attached_dev_type == SAS_FANOUT_EXPANDER_DEVICE ||
+                     phy->attached_dev_type == SAS_EDGE_EXPANDER_DEVICE) &&
                     phy->routing_attr == SUBTRACTIVE_ROUTING) {
 
                         if (!sub_sas_addr)
@@ -1245,8 +1245,8 @@ static void sas_print_parent_topology_bug(struct domain_device *child,
                                                  struct ex_phy *child_phy)
 {
         static const char *ex_type[] = {
-                [EDGE_DEV] = "edge",
-                [FANOUT_DEV] = "fanout",
+                [SAS_EDGE_EXPANDER_DEVICE] = "edge",
+                [SAS_FANOUT_EXPANDER_DEVICE] = "fanout",
         };
         struct domain_device *parent = child->parent;
 
@@ -1321,8 +1321,8 @@ static int sas_check_parent_topology(struct domain_device *child)
         if (!child->parent)
                 return 0;
 
-        if (child->parent->dev_type != EDGE_DEV &&
-            child->parent->dev_type != FANOUT_DEV)
+        if (child->parent->dev_type != SAS_EDGE_EXPANDER_DEVICE &&
+            child->parent->dev_type != SAS_FANOUT_EXPANDER_DEVICE)
                 return 0;
 
         parent_ex = &child->parent->ex_dev;
@@ -1341,8 +1341,8 @@ static int sas_check_parent_topology(struct domain_device *child)
                 child_phy = &child_ex->ex_phy[parent_phy->attached_phy_id];
 
                 switch (child->parent->dev_type) {
-                case EDGE_DEV:
-                        if (child->dev_type == FANOUT_DEV) {
+                case SAS_EDGE_EXPANDER_DEVICE:
+                        if (child->dev_type == SAS_FANOUT_EXPANDER_DEVICE) {
                                 if (parent_phy->routing_attr != SUBTRACTIVE_ROUTING ||
                                     child_phy->routing_attr != TABLE_ROUTING) {
                                         sas_print_parent_topology_bug(child, parent_phy, child_phy);
@@ -1366,7 +1366,7 @@ static int sas_check_parent_topology(struct domain_device *child)
                                 }
                         }
                         break;
-                case FANOUT_DEV:
+                case SAS_FANOUT_EXPANDER_DEVICE:
                         if (parent_phy->routing_attr != TABLE_ROUTING ||
                             child_phy->routing_attr != SUBTRACTIVE_ROUTING) {
                                 sas_print_parent_topology_bug(child, parent_phy, child_phy);
@@ -1619,8 +1619,8 @@ static int sas_ex_level_discovery(struct asd_sas_port *port, const int level)
         struct domain_device *dev;
 
         list_for_each_entry(dev, &port->dev_list, dev_list_node) {
-                if (dev->dev_type == EDGE_DEV ||
-                    dev->dev_type == FANOUT_DEV) {
+                if (dev->dev_type == SAS_EDGE_EXPANDER_DEVICE ||
+                    dev->dev_type == SAS_FANOUT_EXPANDER_DEVICE) {
                         struct sas_expander_device *ex =
                                 rphy_to_expander_device(dev->rphy);
 
@@ -1720,7 +1720,7 @@ static int sas_get_phy_change_count(struct domain_device *dev,
 }
 
 static int sas_get_phy_attached_dev(struct domain_device *dev, int phy_id,
-                                    u8 *sas_addr, enum sas_dev_type *type)
+                                    u8 *sas_addr, enum sas_device_type *type)
 {
         int res;
         struct smp_resp *disc_resp;
@@ -1849,7 +1849,7 @@ static int sas_find_bcast_dev(struct domain_device *dev,
                         SAS_DPRINTK("Expander phys DID NOT change\n");
         }
         list_for_each_entry(ch, &ex->children, siblings) {
-                if (ch->dev_type == EDGE_DEV || ch->dev_type == FANOUT_DEV) {
+                if (ch->dev_type == SAS_EDGE_EXPANDER_DEVICE || ch->dev_type == SAS_FANOUT_EXPANDER_DEVICE) {
                         res = sas_find_bcast_dev(ch, src_dev);
                         if (*src_dev)
                                 return res;
@@ -1866,8 +1866,8 @@ static void sas_unregister_ex_tree(struct asd_sas_port *port, struct domain_devi
 
         list_for_each_entry_safe(child, n, &ex->children, siblings) {
                 set_bit(SAS_DEV_GONE, &child->state);
-                if (child->dev_type == EDGE_DEV ||
-                    child->dev_type == FANOUT_DEV)
+                if (child->dev_type == SAS_EDGE_EXPANDER_DEVICE ||
+                    child->dev_type == SAS_FANOUT_EXPANDER_DEVICE)
                         sas_unregister_ex_tree(port, child);
                 else
                         sas_unregister_dev(port, child);
@@ -1887,8 +1887,8 @@ static void sas_unregister_devs_sas_addr(struct domain_device *parent,
                         if (SAS_ADDR(child->sas_addr) ==
                             SAS_ADDR(phy->attached_sas_addr)) {
                                 set_bit(SAS_DEV_GONE, &child->state);
-                                if (child->dev_type == EDGE_DEV ||
-                                    child->dev_type == FANOUT_DEV)
+                                if (child->dev_type == SAS_EDGE_EXPANDER_DEVICE ||
+                                    child->dev_type == SAS_FANOUT_EXPANDER_DEVICE)
                                         sas_unregister_ex_tree(parent->port, child);
                                 else
                                         sas_unregister_dev(parent->port, child);
@@ -1916,8 +1916,8 @@ static int sas_discover_bfs_by_root_level(struct domain_device *root,
         int res = 0;
 
         list_for_each_entry(child, &ex_root->children, siblings) {
-                if (child->dev_type == EDGE_DEV ||
-                    child->dev_type == FANOUT_DEV) {
+                if (child->dev_type == SAS_EDGE_EXPANDER_DEVICE ||
+                    child->dev_type == SAS_FANOUT_EXPANDER_DEVICE) {
                         struct sas_expander_device *ex =
                                 rphy_to_expander_device(child->rphy);
 
@@ -1970,8 +1970,8 @@ static int sas_discover_new(struct domain_device *dev, int phy_id)
         list_for_each_entry(child, &dev->ex_dev.children, siblings) {
                 if (SAS_ADDR(child->sas_addr) ==
                     SAS_ADDR(ex_phy->attached_sas_addr)) {
-                        if (child->dev_type == EDGE_DEV ||
-                            child->dev_type == FANOUT_DEV)
+                        if (child->dev_type == SAS_EDGE_EXPANDER_DEVICE ||
+                            child->dev_type == SAS_FANOUT_EXPANDER_DEVICE)
                                 res = sas_discover_bfs_by_root(child);
                         break;
                 }
@@ -1979,16 +1979,16 @@ static int sas_discover_new(struct domain_device *dev, int phy_id)
         return res;
 }
 
-static bool dev_type_flutter(enum sas_dev_type new, enum sas_dev_type old)
+static bool dev_type_flutter(enum sas_device_type new, enum sas_device_type old)
 {
         if (old == new)
                 return true;
 
         /* treat device directed resets as flutter, if we went
-         * SAS_END_DEV to SATA_PENDING the link needs recovery
+         * SAS_END_DEVICE to SAS_SATA_PENDING the link needs recovery
          */
-        if ((old == SATA_PENDING && new == SAS_END_DEV) ||
-            (old == SAS_END_DEV && new == SATA_PENDING))
+        if ((old == SAS_SATA_PENDING && new == SAS_END_DEVICE) ||
+            (old == SAS_END_DEVICE && new == SAS_SATA_PENDING))
                 return true;
 
         return false;
@@ -1998,7 +1998,7 @@ static int sas_rediscover_dev(struct domain_device *dev, int phy_id, bool last)
 {
         struct expander_device *ex = &dev->ex_dev;
         struct ex_phy *phy = &ex->ex_phy[phy_id];
-        enum sas_dev_type type = NO_DEVICE;
+        enum sas_device_type type = SAS_PHY_UNUSED;
         u8 sas_addr[8];
         int res;
 
@@ -2032,7 +2032,7 @@ static int sas_rediscover_dev(struct domain_device *dev, int phy_id, bool last)
 
                 sas_ex_phy_discover(dev, phy_id);
 
-                if (ata_dev && phy->attached_dev_type == SATA_PENDING)
+                if (ata_dev && phy->attached_dev_type == SAS_SATA_PENDING)
                         action = ", needs recovery";
                 SAS_DPRINTK("ex %016llx phy 0x%x broadcast flutter%s\n",
                             SAS_ADDR(dev->sas_addr), phy_id, action);
diff --git a/drivers/scsi/libsas/sas_internal.h b/drivers/scsi/libsas/sas_internal.h
index 1de67964e5a1..7e7ba83f0a21 100644
--- a/drivers/scsi/libsas/sas_internal.h
+++ b/drivers/scsi/libsas/sas_internal.h
@@ -131,16 +131,16 @@ static inline void sas_fill_in_rphy(struct domain_device *dev,
         rphy->identify.initiator_port_protocols = dev->iproto;
         rphy->identify.target_port_protocols = dev->tproto;
         switch (dev->dev_type) {
-        case SATA_DEV:
+        case SAS_SATA_DEV:
                 /* FIXME: need sata device type */
-        case SAS_END_DEV:
-        case SATA_PENDING:
+        case SAS_END_DEVICE:
+        case SAS_SATA_PENDING:
                 rphy->identify.device_type = SAS_END_DEVICE;
                 break;
-        case EDGE_DEV:
+        case SAS_EDGE_EXPANDER_DEVICE:
                 rphy->identify.device_type = SAS_EDGE_EXPANDER_DEVICE;
                 break;
-        case FANOUT_DEV:
+        case SAS_FANOUT_EXPANDER_DEVICE:
                 rphy->identify.device_type = SAS_FANOUT_EXPANDER_DEVICE;
                 break;
         default:
diff --git a/drivers/scsi/libsas/sas_port.c b/drivers/scsi/libsas/sas_port.c
index 1398b714c018..d3c5297c6c89 100644
--- a/drivers/scsi/libsas/sas_port.c
+++ b/drivers/scsi/libsas/sas_port.c
@@ -69,7 +69,7 @@ static void sas_resume_port(struct asd_sas_phy *phy)
                         continue;
                 }
 
-                if (dev->dev_type == EDGE_DEV || dev->dev_type == FANOUT_DEV) {
+                if (dev->dev_type == SAS_EDGE_EXPANDER_DEVICE || dev->dev_type == SAS_FANOUT_EXPANDER_DEVICE) {
                         dev->ex_dev.ex_change_count = -1;
                         for (i = 0; i < dev->ex_dev.num_phys; i++) {
                                 struct ex_phy *phy = &dev->ex_dev.ex_phy[i];
diff --git a/drivers/scsi/lpfc/lpfc.h b/drivers/scsi/lpfc/lpfc.h
index 7706c99ec8bb..bcc56cac4fd8 100644
--- a/drivers/scsi/lpfc/lpfc.h
+++ b/drivers/scsi/lpfc/lpfc.h
@@ -46,10 +46,15 @@ struct lpfc_sli2_slim;
 #define LPFC_DEFAULT_MENLO_SG_SEG_CNT 128       /* sg element count per scsi
                 cmnd for menlo needs nearly twice as for firmware
                 downloads using bsg */
-#define LPFC_DEFAULT_PROT_SG_SEG_CNT 4096 /* sg protection elements count */
+
+#define LPFC_MIN_SG_SLI4_BUF_SZ 0x800   /* based on LPFC_DEFAULT_SG_SEG_CNT */
+#define LPFC_MAX_SG_SLI4_SEG_CNT_DIF 128 /* sg element count per scsi cmnd */
+#define LPFC_MAX_SG_SEG_CNT_DIF 512     /* sg element count per scsi cmnd  */
 #define LPFC_MAX_SG_SEG_CNT     4096    /* sg element count per scsi cmnd */
+#define LPFC_MAX_SGL_SEG_CNT    512     /* SGL element count per scsi cmnd */
+#define LPFC_MAX_BPL_SEG_CNT    4096    /* BPL element count per scsi cmnd */
+
 #define LPFC_MAX_SGE_SIZE       0x80000000 /* Maximum data allowed in a SGE */
-#define LPFC_MAX_PROT_SG_SEG_CNT 4096   /* prot sg element count per scsi cmd*/
 #define LPFC_IOCB_LIST_CNT      2250    /* list of IOCBs for fast-path usage. */
 #define LPFC_Q_RAMP_UP_INTERVAL 120     /* lun q_depth ramp up interval */
 #define LPFC_VNAME_LEN          100     /* vport symbolic name length */
@@ -66,8 +71,10 @@ struct lpfc_sli2_slim;
  * queue depths when there are driver resource error or Firmware
  * resource error.
  */
-#define QUEUE_RAMP_DOWN_INTERVAL        (1 * HZ)   /* 1 Second */
-#define QUEUE_RAMP_UP_INTERVAL          (300 * HZ) /* 5 minutes */
+/* 1 Second */
+#define QUEUE_RAMP_DOWN_INTERVAL        (msecs_to_jiffies(1000 * 1))
+/* 5 minutes */
+#define QUEUE_RAMP_UP_INTERVAL          (msecs_to_jiffies(1000 * 300))
 
 /* Number of exchanges reserved for discovery to complete */
 #define LPFC_DISC_IOCB_BUFF_COUNT 20
@@ -671,6 +678,7 @@ struct lpfc_hba {
         uint32_t lmt;
 
         uint32_t fc_topology;   /* link topology, from LINK INIT */
+        uint32_t fc_topology_changed;   /* link topology, from LINK INIT */
 
         struct lpfc_stats fc_stat;
 
@@ -701,9 +709,11 @@ struct lpfc_hba {
         uint32_t cfg_poll_tmo;
         uint32_t cfg_use_msi;
         uint32_t cfg_fcp_imax;
+        uint32_t cfg_fcp_cpu_map;
         uint32_t cfg_fcp_wq_count;
         uint32_t cfg_fcp_eq_count;
         uint32_t cfg_fcp_io_channel;
+        uint32_t cfg_total_seg_cnt;
         uint32_t cfg_sg_seg_cnt;
         uint32_t cfg_prot_sg_seg_cnt;
         uint32_t cfg_sg_dma_buf_size;
@@ -804,8 +814,10 @@ struct lpfc_hba {
         uint64_t bg_reftag_err_cnt;
 
         /* fastpath list. */
-        spinlock_t scsi_buf_list_lock;
-        struct list_head lpfc_scsi_buf_list;
+        spinlock_t scsi_buf_list_get_lock;  /* SCSI buf alloc list lock */
+        spinlock_t scsi_buf_list_put_lock;  /* SCSI buf free list lock */
+        struct list_head lpfc_scsi_buf_list_get;
+        struct list_head lpfc_scsi_buf_list_put;
         uint32_t total_scsi_bufs;
         struct list_head lpfc_iocb_list;
         uint32_t total_iocbq_bufs;
diff --git a/drivers/scsi/lpfc/lpfc_attr.c b/drivers/scsi/lpfc/lpfc_attr.c
index 9290713af253..3c5625b8b1f4 100644
--- a/drivers/scsi/lpfc/lpfc_attr.c
+++ b/drivers/scsi/lpfc/lpfc_attr.c
@@ -674,6 +674,9 @@ lpfc_do_offline(struct lpfc_hba *phba, uint32_t type)
         int i;
         int rc;
 
+        if (phba->pport->fc_flag & FC_OFFLINE_MODE)
+                return 0;
+
         init_completion(&online_compl);
         rc = lpfc_workq_post_event(phba, &status, &online_compl,
                               LPFC_EVT_OFFLINE_PREP);
@@ -741,7 +744,8 @@ lpfc_selective_reset(struct lpfc_hba *phba)
         int status = 0;
         int rc;
 
-        if (!phba->cfg_enable_hba_reset)
+        if ((!phba->cfg_enable_hba_reset) ||
+            (phba->pport->fc_flag & FC_OFFLINE_MODE))
                 return -EACCES;
 
         status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
@@ -895,6 +899,7 @@ lpfc_sli4_pdev_reg_request(struct lpfc_hba *phba, uint32_t opcode)
                 pci_disable_sriov(pdev);
                 phba->cfg_sriov_nr_virtfn = 0;
         }
+
         status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
 
         if (status != 0)
@@ -2801,6 +2806,8 @@ lpfc_topology_store(struct device *dev, struct device_attribute *attr,
                 lpfc_printf_vlog(vport, KERN_ERR, LOG_INIT,
                         "3054 lpfc_topology changed from %d to %d\n",
                         prev_val, val);
+                if (prev_val != val && phba->sli_rev == LPFC_SLI_REV4)
+                        phba->fc_topology_changed = 1;
                 err = lpfc_issue_lip(lpfc_shost_from_vport(phba->pport));
                 if (err) {
                         phba->cfg_topology = prev_val;
@@ -3792,6 +3799,141 @@ lpfc_fcp_imax_init(struct lpfc_hba *phba, int val)
 static DEVICE_ATTR(lpfc_fcp_imax, S_IRUGO | S_IWUSR,
                    lpfc_fcp_imax_show, lpfc_fcp_imax_store);
 
+/**
+ * lpfc_state_show - Display current driver CPU affinity
+ * @dev: class converted to a Scsi_host structure.
+ * @attr: device attribute, not used.
+ * @buf: on return contains text describing the state of the link.
+ *
+ * Returns: size of formatted string.
+ **/
+static ssize_t
+lpfc_fcp_cpu_map_show(struct device *dev, struct device_attribute *attr,
+                      char *buf)
+{
+        struct Scsi_Host  *shost = class_to_shost(dev);
+        struct lpfc_vport *vport = (struct lpfc_vport *)shost->hostdata;
+        struct lpfc_hba   *phba = vport->phba;
+        struct lpfc_vector_map_info *cpup;
+        int  idx, len = 0;
+
+        if ((phba->sli_rev != LPFC_SLI_REV4) ||
+            (phba->intr_type != MSIX))
+                return len;
+
+        switch (phba->cfg_fcp_cpu_map) {
+        case 0:
+                len += snprintf(buf + len, PAGE_SIZE-len,
+                                "fcp_cpu_map: No mapping (%d)\n",
+                                phba->cfg_fcp_cpu_map);
+                return len;
+        case 1:
+                len += snprintf(buf + len, PAGE_SIZE-len,
+                                "fcp_cpu_map: HBA centric mapping (%d): "
+                                "%d online CPUs\n",
+                                phba->cfg_fcp_cpu_map,
+                                phba->sli4_hba.num_online_cpu);
+                break;
+        case 2:
+                len += snprintf(buf + len, PAGE_SIZE-len,
+                                "fcp_cpu_map: Driver centric mapping (%d): "
+                                "%d online CPUs\n",
+                                phba->cfg_fcp_cpu_map,
+                                phba->sli4_hba.num_online_cpu);
+                break;
+        }
+
+        cpup = phba->sli4_hba.cpu_map;
+        for (idx = 0; idx < phba->sli4_hba.num_present_cpu; idx++) {
+                if (cpup->irq == LPFC_VECTOR_MAP_EMPTY)
+                        len += snprintf(buf + len, PAGE_SIZE-len,
+                                        "CPU %02d io_chan %02d "
+                                        "physid %d coreid %d\n",
+                                        idx, cpup->channel_id, cpup->phys_id,
+                                        cpup->core_id);
+                else
+                        len += snprintf(buf + len, PAGE_SIZE-len,
+                                        "CPU %02d io_chan %02d "
+                                        "physid %d coreid %d IRQ %d\n",
+                                        idx, cpup->channel_id, cpup->phys_id,
+                                        cpup->core_id, cpup->irq);
+
+                cpup++;
+        }
+        return len;
+}
+
+/**
+ * lpfc_fcp_cpu_map_store - Change CPU affinity of driver vectors
+ * @dev: class device that is converted into a Scsi_host.
+ * @attr: device attribute, not used.
+ * @buf: one or more lpfc_polling_flags values.
+ * @count: not used.
+ *
+ * Returns:
+ * -EINVAL  - Not implemented yet.
+ **/
+static ssize_t
+lpfc_fcp_cpu_map_store(struct device *dev, struct device_attribute *attr,
+                       const char *buf, size_t count)
+{
+        int status = -EINVAL;
+        return status;
+}
+
+/*
+# lpfc_fcp_cpu_map: Defines how to map CPUs to IRQ vectors
+# for the HBA.
+#
+# Value range is [0 to 2]. Default value is LPFC_DRIVER_CPU_MAP (2).
+#       0 - Do not affinitze IRQ vectors
+#       1 - Affintize HBA vectors with respect to each HBA
+#           (start with CPU0 for each HBA)
+#       2 - Affintize HBA vectors with respect to the entire driver
+#           (round robin thru all CPUs across all HBAs)
+*/
+static int lpfc_fcp_cpu_map = LPFC_DRIVER_CPU_MAP;
+module_param(lpfc_fcp_cpu_map, int, S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(lpfc_fcp_cpu_map,
+                 "Defines how to map CPUs to IRQ vectors per HBA");
+
+/**
+ * lpfc_fcp_cpu_map_init - Set the initial sr-iov virtual function enable
+ * @phba: lpfc_hba pointer.
+ * @val: link speed value.
+ *
+ * Description:
+ * If val is in a valid range [0-2], then affinitze the adapter's
+ * MSIX vectors.
+ *
+ * Returns:
+ * zero if val saved.
+ * -EINVAL val out of range
+ **/
+static int
+lpfc_fcp_cpu_map_init(struct lpfc_hba *phba, int val)
+{
+        if (phba->sli_rev != LPFC_SLI_REV4) {
+                phba->cfg_fcp_cpu_map = 0;
+                return 0;
+        }
+
+        if (val >= LPFC_MIN_CPU_MAP && val <= LPFC_MAX_CPU_MAP) {
+                phba->cfg_fcp_cpu_map = val;
+                return 0;
+        }
+
+        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                        "3326 fcp_cpu_map: %d out of range, using default\n",
+                        val);
+        phba->cfg_fcp_cpu_map = LPFC_DRIVER_CPU_MAP;
+
+        return 0;
+}
+
+static DEVICE_ATTR(lpfc_fcp_cpu_map, S_IRUGO | S_IWUSR,
+                   lpfc_fcp_cpu_map_show, lpfc_fcp_cpu_map_store);
+
 /*
 # lpfc_fcp_class:  Determines FC class to use for the FCP protocol.
 # Value range is [2,3]. Default value is 3.
@@ -4009,12 +4151,11 @@ LPFC_ATTR_R(enable_bg, 0, 0, 1, "Enable BlockGuard Support");
 #       0  = disabled (default)
 #       1  = enabled
 # Value range is [0,1]. Default value is 0.
+#
+# This feature in under investigation and may be supported in the future.
 */
 unsigned int lpfc_fcp_look_ahead = LPFC_LOOK_AHEAD_OFF;
 
-module_param(lpfc_fcp_look_ahead, uint, S_IRUGO);
-MODULE_PARM_DESC(lpfc_fcp_look_ahead, "Look ahead for completions");
-
 /*
 # lpfc_prot_mask: i
 #       - Bit mask of host protection capabilities used to register with the
@@ -4071,16 +4212,23 @@ MODULE_PARM_DESC(lpfc_delay_discovery,
 
 /*
  * lpfc_sg_seg_cnt - Initial Maximum DMA Segment Count
- * This value can be set to values between 64 and 256. The default value is
+ * This value can be set to values between 64 and 4096. The default value is
  * 64, but may be increased to allow for larger Max I/O sizes. The scsi layer
  * will be allowed to request I/Os of sizes up to (MAX_SEG_COUNT * SEG_SIZE).
+ * Because of the additional overhead involved in setting up T10-DIF,
+ * this parameter will be limited to 128 if BlockGuard is enabled under SLI4
+ * and will be limited to 512 if BlockGuard is enabled under SLI3.
  */
 LPFC_ATTR_R(sg_seg_cnt, LPFC_DEFAULT_SG_SEG_CNT, LPFC_DEFAULT_SG_SEG_CNT,
             LPFC_MAX_SG_SEG_CNT, "Max Scatter Gather Segment Count");
 
-LPFC_ATTR_R(prot_sg_seg_cnt, LPFC_DEFAULT_PROT_SG_SEG_CNT,
-                LPFC_DEFAULT_PROT_SG_SEG_CNT, LPFC_MAX_PROT_SG_SEG_CNT,
-                "Max Protection Scatter Gather Segment Count");
+/*
+ * This parameter will be depricated, the driver cannot limit the
+ * protection data s/g list.
+ */
+LPFC_ATTR_R(prot_sg_seg_cnt, LPFC_DEFAULT_SG_SEG_CNT,
+            LPFC_DEFAULT_SG_SEG_CNT, LPFC_MAX_SG_SEG_CNT,
+            "Max Protection Scatter Gather Segment Count");
 
 struct device_attribute *lpfc_hba_attrs[] = {
         &dev_attr_bg_info,
@@ -4141,6 +4289,7 @@ struct device_attribute *lpfc_hba_attrs[] = {
         &dev_attr_lpfc_poll_tmo,
         &dev_attr_lpfc_use_msi,
         &dev_attr_lpfc_fcp_imax,
+        &dev_attr_lpfc_fcp_cpu_map,
         &dev_attr_lpfc_fcp_wq_count,
         &dev_attr_lpfc_fcp_eq_count,
         &dev_attr_lpfc_fcp_io_channel,
@@ -5123,6 +5272,7 @@ lpfc_get_cfgparam(struct lpfc_hba *phba)
         lpfc_enable_rrq_init(phba, lpfc_enable_rrq);
         lpfc_use_msi_init(phba, lpfc_use_msi);
         lpfc_fcp_imax_init(phba, lpfc_fcp_imax);
+        lpfc_fcp_cpu_map_init(phba, lpfc_fcp_cpu_map);
         lpfc_fcp_wq_count_init(phba, lpfc_fcp_wq_count);
         lpfc_fcp_eq_count_init(phba, lpfc_fcp_eq_count);
         lpfc_fcp_io_channel_init(phba, lpfc_fcp_io_channel);
diff --git a/drivers/scsi/lpfc/lpfc_bsg.c b/drivers/scsi/lpfc/lpfc_bsg.c
index 888666892004..094be2cad65b 100644
--- a/drivers/scsi/lpfc/lpfc_bsg.c
+++ b/drivers/scsi/lpfc/lpfc_bsg.c
@@ -219,26 +219,35 @@ lpfc_bsg_copy_data(struct lpfc_dmabuf *dma_buffers,
         unsigned int transfer_bytes, bytes_copied = 0;
         unsigned int sg_offset, dma_offset;
         unsigned char *dma_address, *sg_address;
-        struct scatterlist *sgel;
         LIST_HEAD(temp_list);
-
+        struct sg_mapping_iter miter;
+        unsigned long flags;
+        unsigned int sg_flags = SG_MITER_ATOMIC;
+        bool sg_valid;
 
         list_splice_init(&dma_buffers->list, &temp_list);
         list_add(&dma_buffers->list, &temp_list);
         sg_offset = 0;
-        sgel = bsg_buffers->sg_list;
+        if (to_buffers)
+                sg_flags |= SG_MITER_FROM_SG;
+        else
+                sg_flags |= SG_MITER_TO_SG;
+        sg_miter_start(&miter, bsg_buffers->sg_list, bsg_buffers->sg_cnt,
+                       sg_flags);
+        local_irq_save(flags);
+        sg_valid = sg_miter_next(&miter);
         list_for_each_entry(mp, &temp_list, list) {
                 dma_offset = 0;
-                while (bytes_to_transfer && sgel &&
+                while (bytes_to_transfer && sg_valid &&
                        (dma_offset < LPFC_BPL_SIZE)) {
                         dma_address = mp->virt + dma_offset;
                         if (sg_offset) {
                                 /* Continue previous partial transfer of sg */
-                                sg_address = sg_virt(sgel) + sg_offset;
-                                transfer_bytes = sgel->length - sg_offset;
+                                sg_address = miter.addr + sg_offset;
+                                transfer_bytes = miter.length - sg_offset;
                         } else {
-                                sg_address = sg_virt(sgel);
-                                transfer_bytes = sgel->length;
+                                sg_address = miter.addr;
+                                transfer_bytes = miter.length;
                         }
                         if (bytes_to_transfer < transfer_bytes)
                                 transfer_bytes = bytes_to_transfer;
@@ -252,12 +261,14 @@ lpfc_bsg_copy_data(struct lpfc_dmabuf *dma_buffers,
                         sg_offset += transfer_bytes;
                         bytes_to_transfer -= transfer_bytes;
                         bytes_copied += transfer_bytes;
-                        if (sg_offset >= sgel->length) {
+                        if (sg_offset >= miter.length) {
                                 sg_offset = 0;
-                                sgel = sg_next(sgel);
+                                sg_valid = sg_miter_next(&miter);
                         }
                 }
         }
+        sg_miter_stop(&miter);
+        local_irq_restore(flags);
         list_del_init(&dma_buffers->list);
         list_splice(&temp_list, &dma_buffers->list);
         return bytes_copied;
@@ -471,6 +482,7 @@ lpfc_bsg_send_mgmt_cmd(struct fc_bsg_job *job)
         cmdiocbq->context1 = dd_data;
         cmdiocbq->context2 = cmp;
         cmdiocbq->context3 = bmp;
+        cmdiocbq->context_un.ndlp = ndlp;
         dd_data->type = TYPE_IOCB;
         dd_data->set_job = job;
         dd_data->context_un.iocb.cmdiocbq = cmdiocbq;
@@ -1508,6 +1520,7 @@ lpfc_issue_ct_rsp(struct lpfc_hba *phba, struct fc_bsg_job *job, uint32_t tag,
         ctiocb->context1 = dd_data;
         ctiocb->context2 = cmp;
         ctiocb->context3 = bmp;
+        ctiocb->context_un.ndlp = ndlp;
         ctiocb->iocb_cmpl = lpfc_issue_ct_rsp_cmp;
 
         dd_data->type = TYPE_IOCB;
@@ -2576,7 +2589,8 @@ static int lpfcdiag_loop_get_xri(struct lpfc_hba *phba, uint16_t rpi,
         evt->wait_time_stamp = jiffies;
         time_left = wait_event_interruptible_timeout(
                 evt->wq, !list_empty(&evt->events_to_see),
-                ((phba->fc_ratov * 2) + LPFC_DRVR_TIMEOUT) * HZ);
+                msecs_to_jiffies(1000 *
+                        ((phba->fc_ratov * 2) + LPFC_DRVR_TIMEOUT)));
         if (list_empty(&evt->events_to_see))
                 ret_val = (time_left) ? -EINTR : -ETIMEDOUT;
         else {
@@ -3151,7 +3165,8 @@ lpfc_bsg_diag_loopback_run(struct fc_bsg_job *job)
         evt->waiting = 1;
         time_left = wait_event_interruptible_timeout(
                 evt->wq, !list_empty(&evt->events_to_see),
-                ((phba->fc_ratov * 2) + LPFC_DRVR_TIMEOUT) * HZ);
+                msecs_to_jiffies(1000 *
+                        ((phba->fc_ratov * 2) + LPFC_DRVR_TIMEOUT)));
         evt->waiting = 0;
         if (list_empty(&evt->events_to_see)) {
                 rc = (time_left) ? -EINTR : -ETIMEDOUT;
diff --git a/drivers/scsi/lpfc/lpfc_crtn.h b/drivers/scsi/lpfc/lpfc_crtn.h
index 7631893ae005..d41456e5f814 100644
--- a/drivers/scsi/lpfc/lpfc_crtn.h
+++ b/drivers/scsi/lpfc/lpfc_crtn.h
@@ -470,3 +470,4 @@ int lpfc_sli4_xri_sgl_update(struct lpfc_hba *);
 void lpfc_free_sgl_list(struct lpfc_hba *, struct list_head *);
 uint32_t lpfc_sli_port_speed_get(struct lpfc_hba *);
 int lpfc_sli4_request_firmware_update(struct lpfc_hba *, uint8_t);
+void lpfc_sli4_offline_eratt(struct lpfc_hba *);
diff --git a/drivers/scsi/lpfc/lpfc_ct.c b/drivers/scsi/lpfc/lpfc_ct.c
index 7bff3a19af56..ae1a07c57cae 100644
--- a/drivers/scsi/lpfc/lpfc_ct.c
+++ b/drivers/scsi/lpfc/lpfc_ct.c
@@ -1811,7 +1811,8 @@ lpfc_fdmi_timeout_handler(struct lpfc_vport *vport)
                 if (init_utsname()->nodename[0] != '\0')
                         lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DHBA);
                 else
-                        mod_timer(&vport->fc_fdmitmo, jiffies + HZ * 60);
+                        mod_timer(&vport->fc_fdmitmo, jiffies +
+                                  msecs_to_jiffies(1000 * 60));
         }
         return;
 }
diff --git a/drivers/scsi/lpfc/lpfc_els.c b/drivers/scsi/lpfc/lpfc_els.c
index bbed8471bf0b..3cae0a92e8bd 100644
--- a/drivers/scsi/lpfc/lpfc_els.c
+++ b/drivers/scsi/lpfc/lpfc_els.c
@@ -29,6 +29,7 @@
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_transport_fc.h>
 
+
 #include "lpfc_hw4.h"
 #include "lpfc_hw.h"
 #include "lpfc_sli.h"
@@ -238,7 +239,10 @@ lpfc_prep_els_iocb(struct lpfc_vport *vport, uint8_t expectRsp,
 
                 icmd->un.elsreq64.remoteID = did;               /* DID */
                 icmd->ulpCommand = CMD_ELS_REQUEST64_CR;
-                icmd->ulpTimeout = phba->fc_ratov * 2;
+                if (elscmd == ELS_CMD_FLOGI)
+                        icmd->ulpTimeout = FF_DEF_RATOV * 2;
+                else
+                        icmd->ulpTimeout = phba->fc_ratov * 2;
         } else {
                 icmd->un.xseq64.bdl.addrHigh = putPaddrHigh(pbuflist->phys);
                 icmd->un.xseq64.bdl.addrLow = putPaddrLow(pbuflist->phys);
@@ -308,16 +312,20 @@ lpfc_prep_els_iocb(struct lpfc_vport *vport, uint8_t expectRsp,
                 /* Xmit ELS command <elsCmd> to remote NPORT <did> */
                 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
                                  "0116 Xmit ELS command x%x to remote "
-                                 "NPORT x%x I/O tag: x%x, port state: x%x\n",
+                                 "NPORT x%x I/O tag: x%x, port state:x%x"
+                                 " fc_flag:x%x\n",
                                  elscmd, did, elsiocb->iotag,
-                                 vport->port_state);
+                                 vport->port_state,
+                                 vport->fc_flag);
         } else {
                 /* Xmit ELS response <elsCmd> to remote NPORT <did> */
                 lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
                                  "0117 Xmit ELS response x%x to remote "
-                                 "NPORT x%x I/O tag: x%x, size: x%x\n",
+                                 "NPORT x%x I/O tag: x%x, size: x%x "
+                                 "port_state x%x fc_flag x%x\n",
                                  elscmd, ndlp->nlp_DID, elsiocb->iotag,
-                                 cmdSize);
+                                 cmdSize, vport->port_state,
+                                 vport->fc_flag);
         }
         return elsiocb;
 
@@ -909,6 +917,23 @@ lpfc_cmpl_els_flogi_nport(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
         spin_lock_irq(shost->host_lock);
         vport->fc_flag |= FC_PT2PT;
         spin_unlock_irq(shost->host_lock);
+        /* If physical FC port changed, unreg VFI and ALL VPIs / RPIs */
+        if ((phba->sli_rev == LPFC_SLI_REV4) && phba->fc_topology_changed) {
+                lpfc_unregister_fcf_prep(phba);
+
+                /* The FC_VFI_REGISTERED flag will get clear in the cmpl
+                 * handler for unreg_vfi, but if we don't force the
+                 * FC_VFI_REGISTERED flag then the reg_vfi mailbox could be
+                 * built with the update bit set instead of just the vp bit to
+                 * change the Nport ID.  We need to have the vp set and the
+                 * Upd cleared on topology changes.
+                 */
+                spin_lock_irq(shost->host_lock);
+                vport->fc_flag &= ~FC_VFI_REGISTERED;
+                spin_unlock_irq(shost->host_lock);
+                phba->fc_topology_changed = 0;
+                lpfc_issue_reg_vfi(vport);
+        }
 
         /* Start discovery - this should just do CLEAR_LA */
         lpfc_disc_start(vport);
@@ -1030,9 +1055,19 @@ stop_rr_fcf_flogi:
                         vport->cfg_discovery_threads = LPFC_MAX_DISC_THREADS;
                 if ((phba->sli_rev == LPFC_SLI_REV4) &&
                     (!(vport->fc_flag & FC_VFI_REGISTERED) ||
-                     (vport->fc_prevDID != vport->fc_myDID))) {
-                        if (vport->fc_flag & FC_VFI_REGISTERED)
-                                lpfc_sli4_unreg_all_rpis(vport);
+                     (vport->fc_prevDID != vport->fc_myDID) ||
+                        phba->fc_topology_changed)) {
+                        if (vport->fc_flag & FC_VFI_REGISTERED) {
+                                if (phba->fc_topology_changed) {
+                                        lpfc_unregister_fcf_prep(phba);
+                                        spin_lock_irq(shost->host_lock);
+                                        vport->fc_flag &= ~FC_VFI_REGISTERED;
+                                        spin_unlock_irq(shost->host_lock);
+                                        phba->fc_topology_changed = 0;
+                                } else {
+                                        lpfc_sli4_unreg_all_rpis(vport);
+                                }
+                        }
                         lpfc_issue_reg_vfi(vport);
                         lpfc_nlp_put(ndlp);
                         goto out;
@@ -1054,10 +1089,11 @@ stop_rr_fcf_flogi:
 
         /* FLOGI completes successfully */
         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
-                         "0101 FLOGI completes successfully "
-                         "Data: x%x x%x x%x x%x\n",
+                         "0101 FLOGI completes successfully, I/O tag:x%x, "
+                         "Data: x%x x%x x%x x%x x%x x%x\n", cmdiocb->iotag,
                          irsp->un.ulpWord[4], sp->cmn.e_d_tov,
-                         sp->cmn.w2.r_a_tov, sp->cmn.edtovResolution);
+                         sp->cmn.w2.r_a_tov, sp->cmn.edtovResolution,
+                         vport->port_state, vport->fc_flag);
 
         if (vport->port_state == LPFC_FLOGI) {
                 /*
@@ -5047,6 +5083,8 @@ lpfc_els_rcv_flogi(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
         struct ls_rjt stat;
         uint32_t cmd, did;
         int rc;
+        uint32_t fc_flag = 0;
+        uint32_t port_state = 0;
 
         cmd = *lp++;
         sp = (struct serv_parm *) lp;
@@ -5113,16 +5151,25 @@ lpfc_els_rcv_flogi(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
                          * will be.
                          */
                         vport->fc_myDID = PT2PT_LocalID;
-                }
+                } else
+                        vport->fc_myDID = PT2PT_RemoteID;
 
                 /*
                  * The vport state should go to LPFC_FLOGI only
                  * AFTER we issue a FLOGI, not receive one.
                  */
                 spin_lock_irq(shost->host_lock);
+                fc_flag = vport->fc_flag;
+                port_state = vport->port_state;
                 vport->fc_flag |= FC_PT2PT;
                 vport->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
+                vport->port_state = LPFC_FLOGI;
                 spin_unlock_irq(shost->host_lock);
+                lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
+                                 "3311 Rcv Flogi PS x%x new PS x%x "
+                                 "fc_flag x%x new fc_flag x%x\n",
+                                 port_state, vport->port_state,
+                                 fc_flag, vport->fc_flag);
 
                 /*
                  * We temporarily set fc_myDID to make it look like we are
@@ -6241,7 +6288,8 @@ lpfc_els_timeout_handler(struct lpfc_vport *vport)
         }
 
         if (!list_empty(&phba->sli.ring[LPFC_ELS_RING].txcmplq))
-                mod_timer(&vport->els_tmofunc, jiffies + HZ * timeout);
+                mod_timer(&vport->els_tmofunc,
+                          jiffies + msecs_to_jiffies(1000 * timeout));
 }
 
 /**
@@ -6612,7 +6660,9 @@ lpfc_els_unsol_buffer(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
         /* ELS command <elsCmd> received from NPORT <did> */
         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
                          "0112 ELS command x%x received from NPORT x%x "
-                         "Data: x%x\n", cmd, did, vport->port_state);
+                         "Data: x%x x%x x%x x%x\n",
+                        cmd, did, vport->port_state, vport->fc_flag,
+                        vport->fc_myDID, vport->fc_prevDID);
         switch (cmd) {
         case ELS_CMD_PLOGI:
                 lpfc_debugfs_disc_trc(vport, LPFC_DISC_TRC_ELS_UNSOL,
@@ -6621,6 +6671,19 @@ lpfc_els_unsol_buffer(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
 
                 phba->fc_stat.elsRcvPLOGI++;
                 ndlp = lpfc_plogi_confirm_nport(phba, payload, ndlp);
+                if (phba->sli_rev == LPFC_SLI_REV4 &&
+                    (phba->pport->fc_flag & FC_PT2PT)) {
+                        vport->fc_prevDID = vport->fc_myDID;
+                        /* Our DID needs to be updated before registering
+                         * the vfi. This is done in lpfc_rcv_plogi but
+                         * that is called after the reg_vfi.
+                         */
+                        vport->fc_myDID = elsiocb->iocb.un.rcvels.parmRo;
+                        lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
+                                         "3312 Remote port assigned DID x%x "
+                                         "%x\n", vport->fc_myDID,
+                                         vport->fc_prevDID);
+                }
 
                 lpfc_send_els_event(vport, ndlp, payload);
 
@@ -6630,6 +6693,7 @@ lpfc_els_unsol_buffer(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
                         rjt_exp = LSEXP_NOTHING_MORE;
                         break;
                 }
+                shost = lpfc_shost_from_vport(vport);
                 if (vport->port_state < LPFC_DISC_AUTH) {
                         if (!(phba->pport->fc_flag & FC_PT2PT) ||
                                 (phba->pport->fc_flag & FC_PT2PT_PLOGI)) {
@@ -6641,9 +6705,18 @@ lpfc_els_unsol_buffer(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
                          * another NPort and the other side has initiated
                          * the PLOGI before responding to our FLOGI.
                          */
+                        if (phba->sli_rev == LPFC_SLI_REV4 &&
+                            (phba->fc_topology_changed ||
+                             vport->fc_myDID != vport->fc_prevDID)) {
+                                lpfc_unregister_fcf_prep(phba);
+                                spin_lock_irq(shost->host_lock);
+                                vport->fc_flag &= ~FC_VFI_REGISTERED;
+                                spin_unlock_irq(shost->host_lock);
+                                phba->fc_topology_changed = 0;
+                                lpfc_issue_reg_vfi(vport);
+                        }
                 }
 
-                shost = lpfc_shost_from_vport(vport);
                 spin_lock_irq(shost->host_lock);
                 ndlp->nlp_flag &= ~NLP_TARGET_REMOVE;
                 spin_unlock_irq(shost->host_lock);
@@ -7002,8 +7075,11 @@ lpfc_do_scr_ns_plogi(struct lpfc_hba *phba, struct lpfc_vport *vport)
         spin_lock_irq(shost->host_lock);
         if (vport->fc_flag & FC_DISC_DELAYED) {
                 spin_unlock_irq(shost->host_lock);
+                lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
+                                "3334 Delay fc port discovery for %d seconds\n",
+                                phba->fc_ratov);
                 mod_timer(&vport->delayed_disc_tmo,
-                        jiffies + HZ * phba->fc_ratov);
+                        jiffies + msecs_to_jiffies(1000 * phba->fc_ratov));
                 return;
         }
         spin_unlock_irq(shost->host_lock);
@@ -7287,7 +7363,7 @@ lpfc_retry_pport_discovery(struct lpfc_hba *phba)
                 return;
 
         shost = lpfc_shost_from_vport(phba->pport);
-        mod_timer(&ndlp->nlp_delayfunc, jiffies + HZ);
+        mod_timer(&ndlp->nlp_delayfunc, jiffies + msecs_to_jiffies(1000));
         spin_lock_irq(shost->host_lock);
         ndlp->nlp_flag |= NLP_DELAY_TMO;
         spin_unlock_irq(shost->host_lock);
@@ -7791,7 +7867,8 @@ lpfc_block_fabric_iocbs(struct lpfc_hba *phba)
         blocked = test_and_set_bit(FABRIC_COMANDS_BLOCKED, &phba->bit_flags);
         /* Start a timer to unblock fabric iocbs after 100ms */
         if (!blocked)
-                mod_timer(&phba->fabric_block_timer, jiffies + HZ/10 );
+                mod_timer(&phba->fabric_block_timer,
+                          jiffies + msecs_to_jiffies(100));
 
         return;
 }
diff --git a/drivers/scsi/lpfc/lpfc_hbadisc.c b/drivers/scsi/lpfc/lpfc_hbadisc.c
index 326e05a65a73..0f6e2548f35d 100644
--- a/drivers/scsi/lpfc/lpfc_hbadisc.c
+++ b/drivers/scsi/lpfc/lpfc_hbadisc.c
@@ -160,11 +160,12 @@ lpfc_dev_loss_tmo_callbk(struct fc_rport *rport)
         if (!list_empty(&evtp->evt_listp))
                 return;
 
+        evtp->evt_arg1  = lpfc_nlp_get(ndlp);
+
         spin_lock_irq(&phba->hbalock);
         /* We need to hold the node by incrementing the reference
          * count until this queued work is done
          */
-        evtp->evt_arg1  = lpfc_nlp_get(ndlp);
         if (evtp->evt_arg1) {
                 evtp->evt = LPFC_EVT_DEV_LOSS;
                 list_add_tail(&evtp->evt_listp, &phba->work_list);
@@ -1008,9 +1009,6 @@ lpfc_linkup(struct lpfc_hba *phba)
                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++)
                         lpfc_linkup_port(vports[i]);
         lpfc_destroy_vport_work_array(phba, vports);
-        if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
-            (phba->sli_rev < LPFC_SLI_REV4))
-                lpfc_issue_clear_la(phba, phba->pport);
 
         return 0;
 }
@@ -1436,7 +1434,8 @@ lpfc_register_fcf(struct lpfc_hba *phba)
         if (phba->fcf.fcf_flag & FCF_REGISTERED) {
                 phba->fcf.fcf_flag |= (FCF_SCAN_DONE | FCF_IN_USE);
                 phba->hba_flag &= ~FCF_TS_INPROG;
-                if (phba->pport->port_state != LPFC_FLOGI) {
+                if (phba->pport->port_state != LPFC_FLOGI &&
+                    phba->pport->fc_flag & FC_FABRIC) {
                         phba->hba_flag |= FCF_RR_INPROG;
                         spin_unlock_irq(&phba->hbalock);
                         lpfc_initial_flogi(phba->pport);
@@ -2270,8 +2269,11 @@ lpfc_mbx_cmpl_fcf_scan_read_fcf_rec(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
                                 spin_unlock_irq(&phba->hbalock);
                                 lpfc_printf_log(phba, KERN_INFO, LOG_FIP,
                                                 "2836 New FCF matches in-use "
-                                                "FCF (x%x)\n",
-                                                phba->fcf.current_rec.fcf_indx);
+                                                "FCF (x%x), port_state:x%x, "
+                                                "fc_flag:x%x\n",
+                                                phba->fcf.current_rec.fcf_indx,
+                                                phba->pport->port_state,
+                                                phba->pport->fc_flag);
                                 goto out;
                         } else
                                 lpfc_printf_log(phba, KERN_ERR, LOG_FIP,
@@ -2796,7 +2798,19 @@ void
 lpfc_issue_init_vpi(struct lpfc_vport *vport)
 {
         LPFC_MBOXQ_t *mboxq;
-        int rc;
+        int rc, vpi;
+
+        if ((vport->port_type != LPFC_PHYSICAL_PORT) && (!vport->vpi)) {
+                vpi = lpfc_alloc_vpi(vport->phba);
+                if (!vpi) {
+                        lpfc_printf_vlog(vport, KERN_ERR,
+                                         LOG_MBOX,
+                                         "3303 Failed to obtain vport vpi\n");
+                        lpfc_vport_set_state(vport, FC_VPORT_FAILED);
+                        return;
+                }
+                vport->vpi = vpi;
+        }
 
         mboxq = mempool_alloc(vport->phba->mbox_mem_pool, GFP_KERNEL);
         if (!mboxq) {
@@ -2894,9 +2908,14 @@ lpfc_mbx_cmpl_reg_vfi(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
                 goto out_free_mem;
         }
 
-        /* If the VFI is already registered, there is nothing else to do */
+        /* If the VFI is already registered, there is nothing else to do
+         * Unless this was a VFI update and we are in PT2PT mode, then
+         * we should drop through to set the port state to ready.
+         */
         if (vport->fc_flag & FC_VFI_REGISTERED)
-                goto out_free_mem;
+                if (!(phba->sli_rev == LPFC_SLI_REV4 &&
+                      vport->fc_flag & FC_PT2PT))
+                        goto out_free_mem;
 
         /* The VPI is implicitly registered when the VFI is registered */
         spin_lock_irq(shost->host_lock);
@@ -2913,6 +2932,13 @@ lpfc_mbx_cmpl_reg_vfi(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
                 goto out_free_mem;
         }
 
+        lpfc_printf_vlog(vport, KERN_INFO, LOG_SLI,
+                         "3313 cmpl reg vfi  port_state:%x fc_flag:%x myDid:%x "
+                         "alpacnt:%d LinkState:%x topology:%x\n",
+                         vport->port_state, vport->fc_flag, vport->fc_myDID,
+                         vport->phba->alpa_map[0],
+                         phba->link_state, phba->fc_topology);
+
         if (vport->port_state == LPFC_FABRIC_CFG_LINK) {
                 /*
                  * For private loop or for NPort pt2pt,
@@ -2925,7 +2951,10 @@ lpfc_mbx_cmpl_reg_vfi(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
                         /* Use loop map to make discovery list */
                         lpfc_disc_list_loopmap(vport);
                         /* Start discovery */
-                        lpfc_disc_start(vport);
+                        if (vport->fc_flag & FC_PT2PT)
+                                vport->port_state = LPFC_VPORT_READY;
+                        else
+                                lpfc_disc_start(vport);
                 } else {
                         lpfc_start_fdiscs(phba);
                         lpfc_do_scr_ns_plogi(phba, vport);
@@ -3007,6 +3036,15 @@ lpfc_mbx_process_link_up(struct lpfc_hba *phba, struct lpfc_mbx_read_top *la)
                 break;
         }
 
+        if (phba->fc_topology &&
+            phba->fc_topology != bf_get(lpfc_mbx_read_top_topology, la)) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
+                                "3314 Toplogy changed was 0x%x is 0x%x\n",
+                                phba->fc_topology,
+                                bf_get(lpfc_mbx_read_top_topology, la));
+                phba->fc_topology_changed = 1;
+        }
+
         phba->fc_topology = bf_get(lpfc_mbx_read_top_topology, la);
         phba->link_flag &= ~LS_NPIV_FAB_SUPPORTED;
 
@@ -4235,7 +4273,7 @@ lpfc_set_disctmo(struct lpfc_vport *vport)
                         tmo, vport->port_state, vport->fc_flag);
         }
 
-        mod_timer(&vport->fc_disctmo, jiffies + HZ * tmo);
+        mod_timer(&vport->fc_disctmo, jiffies + msecs_to_jiffies(1000 * tmo));
         spin_lock_irq(shost->host_lock);
         vport->fc_flag |= FC_DISC_TMO;
         spin_unlock_irq(shost->host_lock);
@@ -4949,8 +4987,12 @@ lpfc_disc_start(struct lpfc_vport *vport)
         uint32_t clear_la_pending;
         int did_changed;
 
-        if (!lpfc_is_link_up(phba))
+        if (!lpfc_is_link_up(phba)) {
+                lpfc_printf_vlog(vport, KERN_INFO, LOG_SLI,
+                                 "3315 Link is not up %x\n",
+                                 phba->link_state);
                 return;
+        }
 
         if (phba->link_state == LPFC_CLEAR_LA)
                 clear_la_pending = 1;
@@ -4983,11 +5025,13 @@ lpfc_disc_start(struct lpfc_vport *vport)
         if (num_sent)
                 return;
 
-        /* Register the VPI for SLI3, NON-NPIV only. */
+        /* Register the VPI for SLI3, NPIV only. */
         if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
             !(vport->fc_flag & FC_PT2PT) &&
             !(vport->fc_flag & FC_RSCN_MODE) &&
             (phba->sli_rev < LPFC_SLI_REV4)) {
+                if (vport->port_type == LPFC_PHYSICAL_PORT)
+                        lpfc_issue_clear_la(phba, vport);
                 lpfc_issue_reg_vpi(phba, vport);
                 return;
         }
@@ -5410,7 +5454,8 @@ lpfc_mbx_cmpl_fdmi_reg_login(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
         if (vport->cfg_fdmi_on == 1)
                 lpfc_fdmi_cmd(vport, ndlp, SLI_MGMT_DHBA);
         else
-                mod_timer(&vport->fc_fdmitmo, jiffies + HZ * 60);
+                mod_timer(&vport->fc_fdmitmo,
+                          jiffies + msecs_to_jiffies(1000 * 60));
 
         /* decrement the node reference count held for this callback
          * function.
@@ -5855,7 +5900,7 @@ lpfc_unregister_fcf_prep(struct lpfc_hba *phba)
         struct lpfc_vport **vports;
         struct lpfc_nodelist *ndlp;
         struct Scsi_Host *shost;
-        int i, rc;
+        int i = 0, rc;
 
         /* Unregister RPIs */
         if (lpfc_fcf_inuse(phba))
@@ -5883,6 +5928,20 @@ lpfc_unregister_fcf_prep(struct lpfc_hba *phba)
                         spin_unlock_irq(shost->host_lock);
                 }
         lpfc_destroy_vport_work_array(phba, vports);
+        if (i == 0 && (!(phba->sli3_options & LPFC_SLI3_NPIV_ENABLED))) {
+                ndlp = lpfc_findnode_did(phba->pport, Fabric_DID);
+                if (ndlp)
+                        lpfc_cancel_retry_delay_tmo(phba->pport, ndlp);
+                lpfc_cleanup_pending_mbox(phba->pport);
+                if (phba->sli_rev == LPFC_SLI_REV4)
+                        lpfc_sli4_unreg_all_rpis(phba->pport);
+                lpfc_mbx_unreg_vpi(phba->pport);
+                shost = lpfc_shost_from_vport(phba->pport);
+                spin_lock_irq(shost->host_lock);
+                phba->pport->fc_flag |= FC_VPORT_NEEDS_INIT_VPI;
+                phba->pport->vpi_state &= ~LPFC_VPI_REGISTERED;
+                spin_unlock_irq(shost->host_lock);
+        }
 
         /* Cleanup any outstanding ELS commands */
         lpfc_els_flush_all_cmd(phba);
diff --git a/drivers/scsi/lpfc/lpfc_hw.h b/drivers/scsi/lpfc/lpfc_hw.h
index e8c476031703..83700c18f468 100644
--- a/drivers/scsi/lpfc/lpfc_hw.h
+++ b/drivers/scsi/lpfc/lpfc_hw.h
@@ -1667,6 +1667,7 @@ enum lpfc_protgrp_type {
 #define BG_OP_IN_CSUM_OUT_CSUM          0x5
 #define BG_OP_IN_CRC_OUT_CSUM           0x6
 #define BG_OP_IN_CSUM_OUT_CRC           0x7
+#define BG_OP_RAW_MODE                  0x8
 
 struct lpfc_pde5 {
         uint32_t word0;
diff --git a/drivers/scsi/lpfc/lpfc_hw4.h b/drivers/scsi/lpfc/lpfc_hw4.h
index 1dd2f6f0a127..713a4613ec3a 100644
--- a/drivers/scsi/lpfc/lpfc_hw4.h
+++ b/drivers/scsi/lpfc/lpfc_hw4.h
@@ -200,6 +200,11 @@ struct lpfc_sli_intf {
 #define LPFC_MAX_IMAX          5000000
 #define LPFC_DEF_IMAX          50000
 
+#define LPFC_MIN_CPU_MAP       0
+#define LPFC_MAX_CPU_MAP       2
+#define LPFC_HBA_CPU_MAP       1
+#define LPFC_DRIVER_CPU_MAP    2  /* Default */
+
 /* PORT_CAPABILITIES constants. */
 #define LPFC_MAX_SUPPORTED_PAGES        8
 
@@ -621,7 +626,7 @@ struct lpfc_register {
 #define lpfc_sliport_status_rdy_SHIFT   23
 #define lpfc_sliport_status_rdy_MASK    0x1
 #define lpfc_sliport_status_rdy_WORD    word0
-#define MAX_IF_TYPE_2_RESETS    1000
+#define MAX_IF_TYPE_2_RESETS            6
 
 #define LPFC_CTL_PORT_CTL_OFFSET        0x408
 #define lpfc_sliport_ctrl_end_SHIFT     30
diff --git a/drivers/scsi/lpfc/lpfc_init.c b/drivers/scsi/lpfc/lpfc_init.c
index 90b8b0515e23..cb465b253910 100644
--- a/drivers/scsi/lpfc/lpfc_init.c
+++ b/drivers/scsi/lpfc/lpfc_init.c
@@ -33,6 +33,7 @@
 #include <linux/slab.h>
 #include <linux/firmware.h>
 #include <linux/miscdevice.h>
+#include <linux/percpu.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_device.h>
@@ -58,6 +59,9 @@ char *_dump_buf_dif;
 unsigned long _dump_buf_dif_order;
 spinlock_t _dump_buf_lock;
 
+/* Used when mapping IRQ vectors in a driver centric manner */
+uint16_t lpfc_used_cpu[LPFC_MAX_CPU];
+
 static void lpfc_get_hba_model_desc(struct lpfc_hba *, uint8_t *, uint8_t *);
 static int lpfc_post_rcv_buf(struct lpfc_hba *);
 static int lpfc_sli4_queue_verify(struct lpfc_hba *);
@@ -541,13 +545,16 @@ lpfc_config_port_post(struct lpfc_hba *phba)
 
         /* Set up ring-0 (ELS) timer */
         timeout = phba->fc_ratov * 2;
-        mod_timer(&vport->els_tmofunc, jiffies + HZ * timeout);
+        mod_timer(&vport->els_tmofunc,
+                  jiffies + msecs_to_jiffies(1000 * timeout));
         /* Set up heart beat (HB) timer */
-        mod_timer(&phba->hb_tmofunc, jiffies + HZ * LPFC_HB_MBOX_INTERVAL);
+        mod_timer(&phba->hb_tmofunc,
+                  jiffies + msecs_to_jiffies(1000 * LPFC_HB_MBOX_INTERVAL));
         phba->hb_outstanding = 0;
         phba->last_completion_time = jiffies;
         /* Set up error attention (ERATT) polling timer */
-        mod_timer(&phba->eratt_poll, jiffies + HZ * LPFC_ERATT_POLL_INTERVAL);
+        mod_timer(&phba->eratt_poll,
+                  jiffies + msecs_to_jiffies(1000 * LPFC_ERATT_POLL_INTERVAL));
 
         if (phba->hba_flag & LINK_DISABLED) {
                 lpfc_printf_log(phba,
@@ -908,9 +915,9 @@ lpfc_hba_down_post_s4(struct lpfc_hba *phba)
                 psb->pCmd = NULL;
                 psb->status = IOSTAT_SUCCESS;
         }
-        spin_lock_irqsave(&phba->scsi_buf_list_lock, iflag);
-        list_splice(&aborts, &phba->lpfc_scsi_buf_list);
-        spin_unlock_irqrestore(&phba->scsi_buf_list_lock, iflag);
+        spin_lock_irqsave(&phba->scsi_buf_list_put_lock, iflag);
+        list_splice(&aborts, &phba->lpfc_scsi_buf_list_put);
+        spin_unlock_irqrestore(&phba->scsi_buf_list_put_lock, iflag);
         return 0;
 }
 
@@ -1021,7 +1028,8 @@ lpfc_hb_mbox_cmpl(struct lpfc_hba * phba, LPFC_MBOXQ_t * pmboxq)
                 !(phba->link_state == LPFC_HBA_ERROR) &&
                 !(phba->pport->load_flag & FC_UNLOADING))
                 mod_timer(&phba->hb_tmofunc,
-                        jiffies + HZ * LPFC_HB_MBOX_INTERVAL);
+                          jiffies +
+                          msecs_to_jiffies(1000 * LPFC_HB_MBOX_INTERVAL));
         return;
 }
 
@@ -1064,15 +1072,18 @@ lpfc_hb_timeout_handler(struct lpfc_hba *phba)
 
         spin_lock_irq(&phba->pport->work_port_lock);
 
-        if (time_after(phba->last_completion_time + LPFC_HB_MBOX_INTERVAL * HZ,
-                jiffies)) {
+        if (time_after(phba->last_completion_time +
+                        msecs_to_jiffies(1000 * LPFC_HB_MBOX_INTERVAL),
+                        jiffies)) {
                 spin_unlock_irq(&phba->pport->work_port_lock);
                 if (!phba->hb_outstanding)
                         mod_timer(&phba->hb_tmofunc,
-                                jiffies + HZ * LPFC_HB_MBOX_INTERVAL);
+                                jiffies +
+                                msecs_to_jiffies(1000 * LPFC_HB_MBOX_INTERVAL));
                 else
                         mod_timer(&phba->hb_tmofunc,
-                                jiffies + HZ * LPFC_HB_MBOX_TIMEOUT);
+                                jiffies +
+                                msecs_to_jiffies(1000 * LPFC_HB_MBOX_TIMEOUT));
                 return;
         }
         spin_unlock_irq(&phba->pport->work_port_lock);
@@ -1104,7 +1115,8 @@ lpfc_hb_timeout_handler(struct lpfc_hba *phba)
                                 if (!pmboxq) {
                                         mod_timer(&phba->hb_tmofunc,
                                                  jiffies +
-                                                 HZ * LPFC_HB_MBOX_INTERVAL);
+                                                 msecs_to_jiffies(1000 *
+                                                 LPFC_HB_MBOX_INTERVAL));
                                         return;
                                 }
 
@@ -1120,7 +1132,8 @@ lpfc_hb_timeout_handler(struct lpfc_hba *phba)
                                                         phba->mbox_mem_pool);
                                         mod_timer(&phba->hb_tmofunc,
                                                 jiffies +
-                                                HZ * LPFC_HB_MBOX_INTERVAL);
+                                                msecs_to_jiffies(1000 *
+                                                LPFC_HB_MBOX_INTERVAL));
                                         return;
                                 }
                                 phba->skipped_hb = 0;
@@ -1136,7 +1149,8 @@ lpfc_hb_timeout_handler(struct lpfc_hba *phba)
                                 phba->skipped_hb = jiffies;
 
                         mod_timer(&phba->hb_tmofunc,
-                                  jiffies + HZ * LPFC_HB_MBOX_TIMEOUT);
+                                 jiffies +
+                                 msecs_to_jiffies(1000 * LPFC_HB_MBOX_TIMEOUT));
                         return;
                 } else {
                         /*
@@ -1150,7 +1164,8 @@ lpfc_hb_timeout_handler(struct lpfc_hba *phba)
                                         jiffies_to_msecs(jiffies
                                                  - phba->last_completion_time));
                         mod_timer(&phba->hb_tmofunc,
-                                  jiffies + HZ * LPFC_HB_MBOX_TIMEOUT);
+                                jiffies +
+                                msecs_to_jiffies(1000 * LPFC_HB_MBOX_TIMEOUT));
                 }
         }
 }
@@ -1191,7 +1206,7 @@ lpfc_offline_eratt(struct lpfc_hba *phba)
  * This routine is called to bring a SLI4 HBA offline when HBA hardware error
  * other than Port Error 6 has been detected.
  **/
-static void
+void
 lpfc_sli4_offline_eratt(struct lpfc_hba *phba)
 {
         lpfc_offline_prep(phba, LPFC_MBX_NO_WAIT);
@@ -2633,6 +2648,7 @@ lpfc_online(struct lpfc_hba *phba)
         struct lpfc_vport *vport;
         struct lpfc_vport **vports;
         int i;
+        bool vpis_cleared = false;
 
         if (!phba)
                 return 0;
@@ -2656,6 +2672,10 @@ lpfc_online(struct lpfc_hba *phba)
                         lpfc_unblock_mgmt_io(phba);
                         return 1;
                 }
+                spin_lock_irq(&phba->hbalock);
+                if (!phba->sli4_hba.max_cfg_param.vpi_used)
+                        vpis_cleared = true;
+                spin_unlock_irq(&phba->hbalock);
         } else {
                 if (lpfc_sli_hba_setup(phba)) { /* Initialize SLI2/SLI3 HBA */
                         lpfc_unblock_mgmt_io(phba);
@@ -2672,8 +2692,13 @@ lpfc_online(struct lpfc_hba *phba)
                         vports[i]->fc_flag &= ~FC_OFFLINE_MODE;
                         if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED)
                                 vports[i]->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
-                        if (phba->sli_rev == LPFC_SLI_REV4)
+                        if (phba->sli_rev == LPFC_SLI_REV4) {
                                 vports[i]->fc_flag |= FC_VPORT_NEEDS_INIT_VPI;
+                                if ((vpis_cleared) &&
+                                    (vports[i]->port_type !=
+                                        LPFC_PHYSICAL_PORT))
+                                        vports[i]->vpi = 0;
+                        }
                         spin_unlock_irq(shost->host_lock);
                 }
                 lpfc_destroy_vport_work_array(phba, vports);
@@ -2833,16 +2858,30 @@ lpfc_scsi_free(struct lpfc_hba *phba)
         struct lpfc_iocbq *io, *io_next;
 
         spin_lock_irq(&phba->hbalock);
+
         /* Release all the lpfc_scsi_bufs maintained by this host. */
-        spin_lock(&phba->scsi_buf_list_lock);
-        list_for_each_entry_safe(sb, sb_next, &phba->lpfc_scsi_buf_list, list) {
+
+        spin_lock(&phba->scsi_buf_list_put_lock);
+        list_for_each_entry_safe(sb, sb_next, &phba->lpfc_scsi_buf_list_put,
+                                 list) {
                 list_del(&sb->list);
                 pci_pool_free(phba->lpfc_scsi_dma_buf_pool, sb->data,
                               sb->dma_handle);
                 kfree(sb);
                 phba->total_scsi_bufs--;
         }
-        spin_unlock(&phba->scsi_buf_list_lock);
+        spin_unlock(&phba->scsi_buf_list_put_lock);
+
+        spin_lock(&phba->scsi_buf_list_get_lock);
+        list_for_each_entry_safe(sb, sb_next, &phba->lpfc_scsi_buf_list_get,
+                                 list) {
+                list_del(&sb->list);
+                pci_pool_free(phba->lpfc_scsi_dma_buf_pool, sb->data,
+                              sb->dma_handle);
+                kfree(sb);
+                phba->total_scsi_bufs--;
+        }
+        spin_unlock(&phba->scsi_buf_list_get_lock);
 
         /* Release all the lpfc_iocbq entries maintained by this host. */
         list_for_each_entry_safe(io, io_next, &phba->lpfc_iocb_list, list) {
@@ -2978,9 +3017,12 @@ lpfc_sli4_xri_sgl_update(struct lpfc_hba *phba)
                         phba->sli4_hba.scsi_xri_cnt,
                         phba->sli4_hba.scsi_xri_max);
 
-        spin_lock_irq(&phba->scsi_buf_list_lock);
-        list_splice_init(&phba->lpfc_scsi_buf_list, &scsi_sgl_list);
-        spin_unlock_irq(&phba->scsi_buf_list_lock);
+        spin_lock_irq(&phba->scsi_buf_list_get_lock);
+        spin_lock_irq(&phba->scsi_buf_list_put_lock);
+        list_splice_init(&phba->lpfc_scsi_buf_list_get, &scsi_sgl_list);
+        list_splice(&phba->lpfc_scsi_buf_list_put, &scsi_sgl_list);
+        spin_unlock_irq(&phba->scsi_buf_list_put_lock);
+        spin_unlock_irq(&phba->scsi_buf_list_get_lock);
 
         if (phba->sli4_hba.scsi_xri_cnt > phba->sli4_hba.scsi_xri_max) {
                 /* max scsi xri shrinked below the allocated scsi buffers */
@@ -2994,9 +3036,9 @@ lpfc_sli4_xri_sgl_update(struct lpfc_hba *phba)
                                       psb->dma_handle);
                         kfree(psb);
                 }
-                spin_lock_irq(&phba->scsi_buf_list_lock);
+                spin_lock_irq(&phba->scsi_buf_list_get_lock);
                 phba->sli4_hba.scsi_xri_cnt -= scsi_xri_cnt;
-                spin_unlock_irq(&phba->scsi_buf_list_lock);
+                spin_unlock_irq(&phba->scsi_buf_list_get_lock);
         }
 
         /* update xris associated to remaining allocated scsi buffers */
@@ -3014,9 +3056,12 @@ lpfc_sli4_xri_sgl_update(struct lpfc_hba *phba)
                 psb->cur_iocbq.sli4_lxritag = lxri;
                 psb->cur_iocbq.sli4_xritag = phba->sli4_hba.xri_ids[lxri];
         }
-        spin_lock_irq(&phba->scsi_buf_list_lock);
-        list_splice_init(&scsi_sgl_list, &phba->lpfc_scsi_buf_list);
-        spin_unlock_irq(&phba->scsi_buf_list_lock);
+        spin_lock_irq(&phba->scsi_buf_list_get_lock);
+        spin_lock_irq(&phba->scsi_buf_list_put_lock);
+        list_splice_init(&scsi_sgl_list, &phba->lpfc_scsi_buf_list_get);
+        INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list_put);
+        spin_unlock_irq(&phba->scsi_buf_list_put_lock);
+        spin_unlock_irq(&phba->scsi_buf_list_get_lock);
 
         return 0;
 
@@ -3197,14 +3242,15 @@ int lpfc_scan_finished(struct Scsi_Host *shost, unsigned long time)
                 stat = 1;
                 goto finished;
         }
-        if (time >= 30 * HZ) {
+        if (time >= msecs_to_jiffies(30 * 1000)) {
                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
                                 "0461 Scanning longer than 30 "
                                 "seconds.  Continuing initialization\n");
                 stat = 1;
                 goto finished;
         }
-        if (time >= 15 * HZ && phba->link_state <= LPFC_LINK_DOWN) {
+        if (time >= msecs_to_jiffies(15 * 1000) &&
+            phba->link_state <= LPFC_LINK_DOWN) {
                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
                                 "0465 Link down longer than 15 "
                                 "seconds.  Continuing initialization\n");
@@ -3216,7 +3262,7 @@ int lpfc_scan_finished(struct Scsi_Host *shost, unsigned long time)
                 goto finished;
         if (vport->num_disc_nodes || vport->fc_prli_sent)
                 goto finished;
-        if (vport->fc_map_cnt == 0 && time < 2 * HZ)
+        if (vport->fc_map_cnt == 0 && time < msecs_to_jiffies(2 * 1000))
                 goto finished;
         if ((phba->sli.sli_flag & LPFC_SLI_MBOX_ACTIVE) != 0)
                 goto finished;
@@ -4215,7 +4261,8 @@ lpfc_sli4_async_fip_evt(struct lpfc_hba *phba,
                          * If there are other active VLinks present,
                          * re-instantiate the Vlink using FDISC.
                          */
-                        mod_timer(&ndlp->nlp_delayfunc, jiffies + HZ);
+                        mod_timer(&ndlp->nlp_delayfunc,
+                                  jiffies + msecs_to_jiffies(1000));
                         shost = lpfc_shost_from_vport(vport);
                         spin_lock_irq(shost->host_lock);
                         ndlp->nlp_flag |= NLP_DELAY_TMO;
@@ -4707,23 +4754,52 @@ lpfc_sli_driver_resource_setup(struct lpfc_hba *phba)
                 return -ENOMEM;
 
         /*
-         * Since the sg_tablesize is module parameter, the sg_dma_buf_size
+         * Since lpfc_sg_seg_cnt is module parameter, the sg_dma_buf_size
          * used to create the sg_dma_buf_pool must be dynamically calculated.
-         * 2 segments are added since the IOCB needs a command and response bde.
          */
-        phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd) +
-                sizeof(struct fcp_rsp) +
-                        ((phba->cfg_sg_seg_cnt + 2) * sizeof(struct ulp_bde64));
 
+        /* Initialize the host templates the configured values. */
+        lpfc_vport_template.sg_tablesize = phba->cfg_sg_seg_cnt;
+        lpfc_template.sg_tablesize = phba->cfg_sg_seg_cnt;
+
+        /* There are going to be 2 reserved BDEs: 1 FCP cmnd + 1 FCP rsp */
         if (phba->cfg_enable_bg) {
-                phba->cfg_sg_seg_cnt = LPFC_MAX_SG_SEG_CNT;
-                phba->cfg_sg_dma_buf_size +=
-                        phba->cfg_prot_sg_seg_cnt * sizeof(struct ulp_bde64);
+                /*
+                 * The scsi_buf for a T10-DIF I/O will hold the FCP cmnd,
+                 * the FCP rsp, and a BDE for each. Sice we have no control
+                 * over how many protection data segments the SCSI Layer
+                 * will hand us (ie: there could be one for every block
+                 * in the IO), we just allocate enough BDEs to accomidate
+                 * our max amount and we need to limit lpfc_sg_seg_cnt to
+                 * minimize the risk of running out.
+                 */
+                phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd) +
+                        sizeof(struct fcp_rsp) +
+                        (LPFC_MAX_SG_SEG_CNT * sizeof(struct ulp_bde64));
+
+                if (phba->cfg_sg_seg_cnt > LPFC_MAX_SG_SEG_CNT_DIF)
+                        phba->cfg_sg_seg_cnt = LPFC_MAX_SG_SEG_CNT_DIF;
+
+                /* Total BDEs in BPL for scsi_sg_list and scsi_sg_prot_list */
+                phba->cfg_total_seg_cnt = LPFC_MAX_SG_SEG_CNT;
+        } else {
+                /*
+                 * The scsi_buf for a regular I/O will hold the FCP cmnd,
+                 * the FCP rsp, a BDE for each, and a BDE for up to
+                 * cfg_sg_seg_cnt data segments.
+                 */
+                phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd) +
+                        sizeof(struct fcp_rsp) +
+                        ((phba->cfg_sg_seg_cnt + 2) * sizeof(struct ulp_bde64));
+
+                /* Total BDEs in BPL for scsi_sg_list */
+                phba->cfg_total_seg_cnt = phba->cfg_sg_seg_cnt + 2;
         }
 
-        /* Also reinitialize the host templates with new values. */
-        lpfc_vport_template.sg_tablesize = phba->cfg_sg_seg_cnt;
-        lpfc_template.sg_tablesize = phba->cfg_sg_seg_cnt;
+        lpfc_printf_log(phba, KERN_INFO, LOG_INIT | LOG_FCP,
+                        "9088 sg_tablesize:%d dmabuf_size:%d total_bde:%d\n",
+                        phba->cfg_sg_seg_cnt, phba->cfg_sg_dma_buf_size,
+                        phba->cfg_total_seg_cnt);
 
         phba->max_vpi = LPFC_MAX_VPI;
         /* This will be set to correct value after config_port mbox */
@@ -4789,13 +4865,13 @@ lpfc_sli_driver_resource_unset(struct lpfc_hba *phba)
 static int
 lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
 {
+        struct lpfc_vector_map_info *cpup;
         struct lpfc_sli *psli;
         LPFC_MBOXQ_t *mboxq;
-        int rc, i, hbq_count, buf_size, dma_buf_size, max_buf_size;
+        int rc, i, hbq_count, max_buf_size;
         uint8_t pn_page[LPFC_MAX_SUPPORTED_PAGES] = {0};
         struct lpfc_mqe *mqe;
-        int longs, sli_family;
-        int sges_per_segment;
+        int longs;
 
         /* Before proceed, wait for POST done and device ready */
         rc = lpfc_sli4_post_status_check(phba);
@@ -4863,11 +4939,6 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
         phba->fc_map[1] = LPFC_FCOE_FCF_MAP1;
         phba->fc_map[2] = LPFC_FCOE_FCF_MAP2;
 
-        /* With BlockGuard we can have multiple SGEs per Data Segemnt */
-        sges_per_segment = 1;
-        if (phba->cfg_enable_bg)
-                sges_per_segment = 2;
-
         /*
          * For SLI4, instead of using ring 0 (LPFC_FCP_RING) for FCP commands
          * we will associate a new ring, for each FCP fastpath EQ/CQ/WQ tuple.
@@ -4878,43 +4949,71 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
                         sizeof(struct lpfc_sli_ring), GFP_KERNEL);
         if (!phba->sli.ring)
                 return -ENOMEM;
+
         /*
-         * Since the sg_tablesize is module parameter, the sg_dma_buf_size
+         * It doesn't matter what family our adapter is in, we are
+         * limited to 2 Pages, 512 SGEs, for our SGL.
+         * There are going to be 2 reserved SGEs: 1 FCP cmnd + 1 FCP rsp
+         */
+        max_buf_size = (2 * SLI4_PAGE_SIZE);
+        if (phba->cfg_sg_seg_cnt > LPFC_MAX_SGL_SEG_CNT - 2)
+                phba->cfg_sg_seg_cnt = LPFC_MAX_SGL_SEG_CNT - 2;
+
+        /*
+         * Since lpfc_sg_seg_cnt is module parameter, the sg_dma_buf_size
          * used to create the sg_dma_buf_pool must be dynamically calculated.
-         * 2 segments are added since the IOCB needs a command and response bde.
-         * To insure that the scsi sgl does not cross a 4k page boundary only
-         * sgl sizes of must be a power of 2.
          */
-        buf_size = (sizeof(struct fcp_cmnd) + sizeof(struct fcp_rsp) +
-                    (((phba->cfg_sg_seg_cnt * sges_per_segment) + 2) *
-                    sizeof(struct sli4_sge)));
-
-        sli_family = bf_get(lpfc_sli_intf_sli_family, &phba->sli4_hba.sli_intf);
-        max_buf_size = LPFC_SLI4_MAX_BUF_SIZE;
-        switch (sli_family) {
-        case LPFC_SLI_INTF_FAMILY_BE2:
-        case LPFC_SLI_INTF_FAMILY_BE3:
-                /* There is a single hint for BE - 2 pages per BPL. */
-                if (bf_get(lpfc_sli_intf_sli_hint1, &phba->sli4_hba.sli_intf) ==
-                    LPFC_SLI_INTF_SLI_HINT1_1)
-                        max_buf_size = LPFC_SLI4_FL1_MAX_BUF_SIZE;
-                break;
-        case LPFC_SLI_INTF_FAMILY_LNCR_A0:
-        case LPFC_SLI_INTF_FAMILY_LNCR_B0:
-        default:
-                break;
+
+        if (phba->cfg_enable_bg) {
+                /*
+                 * The scsi_buf for a T10-DIF I/O will hold the FCP cmnd,
+                 * the FCP rsp, and a SGE for each. Sice we have no control
+                 * over how many protection data segments the SCSI Layer
+                 * will hand us (ie: there could be one for every block
+                 * in the IO), we just allocate enough SGEs to accomidate
+                 * our max amount and we need to limit lpfc_sg_seg_cnt to
+                 * minimize the risk of running out.
+                 */
+                phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd) +
+                        sizeof(struct fcp_rsp) + max_buf_size;
+
+                /* Total SGEs for scsi_sg_list and scsi_sg_prot_list */
+                phba->cfg_total_seg_cnt = LPFC_MAX_SGL_SEG_CNT;
+
+                if (phba->cfg_sg_seg_cnt > LPFC_MAX_SG_SLI4_SEG_CNT_DIF)
+                        phba->cfg_sg_seg_cnt = LPFC_MAX_SG_SLI4_SEG_CNT_DIF;
+        } else {
+                /*
+                 * The scsi_buf for a regular I/O will hold the FCP cmnd,
+                 * the FCP rsp, a SGE for each, and a SGE for up to
+                 * cfg_sg_seg_cnt data segments.
+                 */
+                phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd) +
+                        sizeof(struct fcp_rsp) +
+                        ((phba->cfg_sg_seg_cnt + 2) * sizeof(struct sli4_sge));
+
+                /* Total SGEs for scsi_sg_list */
+                phba->cfg_total_seg_cnt = phba->cfg_sg_seg_cnt + 2;
+                /*
+                 * NOTE: if (phba->cfg_sg_seg_cnt + 2) <= 256 we only need
+                 * to post 1 page for the SGL.
+                 */
         }
 
-        for (dma_buf_size = LPFC_SLI4_MIN_BUF_SIZE;
-             dma_buf_size < max_buf_size && buf_size > dma_buf_size;
-             dma_buf_size = dma_buf_size << 1)
-                ;
-        if (dma_buf_size == max_buf_size)
-                phba->cfg_sg_seg_cnt = (dma_buf_size -
-                        sizeof(struct fcp_cmnd) - sizeof(struct fcp_rsp) -
-                        (2 * sizeof(struct sli4_sge))) /
-                                sizeof(struct sli4_sge);
-        phba->cfg_sg_dma_buf_size = dma_buf_size;
+        /* Initialize the host templates with the updated values. */
+        lpfc_vport_template.sg_tablesize = phba->cfg_sg_seg_cnt;
+        lpfc_template.sg_tablesize = phba->cfg_sg_seg_cnt;
+
+        if (phba->cfg_sg_dma_buf_size  <= LPFC_MIN_SG_SLI4_BUF_SZ)
+                phba->cfg_sg_dma_buf_size = LPFC_MIN_SG_SLI4_BUF_SZ;
+        else
+                phba->cfg_sg_dma_buf_size =
+                        SLI4_PAGE_ALIGN(phba->cfg_sg_dma_buf_size);
+
+        lpfc_printf_log(phba, KERN_INFO, LOG_INIT | LOG_FCP,
+                        "9087 sg_tablesize:%d dmabuf_size:%d total_sge:%d\n",
+                        phba->cfg_sg_seg_cnt, phba->cfg_sg_dma_buf_size,
+                        phba->cfg_total_seg_cnt);
 
         /* Initialize buffer queue management fields */
         hbq_count = lpfc_sli_hbq_count();
@@ -5104,6 +5203,26 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
                 goto out_free_fcp_eq_hdl;
         }
 
+        phba->sli4_hba.cpu_map = kzalloc((sizeof(struct lpfc_vector_map_info) *
+                                         phba->sli4_hba.num_present_cpu),
+                                         GFP_KERNEL);
+        if (!phba->sli4_hba.cpu_map) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                "3327 Failed allocate memory for msi-x "
+                                "interrupt vector mapping\n");
+                rc = -ENOMEM;
+                goto out_free_msix;
+        }
+        /* Initialize io channels for round robin */
+        cpup = phba->sli4_hba.cpu_map;
+        rc = 0;
+        for (i = 0; i < phba->sli4_hba.num_present_cpu; i++) {
+                cpup->channel_id = rc;
+                rc++;
+                if (rc >= phba->cfg_fcp_io_channel)
+                        rc = 0;
+        }
+
         /*
          * Enable sr-iov virtual functions if supported and configured
          * through the module parameter.
@@ -5123,6 +5242,8 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
 
         return 0;
 
+out_free_msix:
+        kfree(phba->sli4_hba.msix_entries);
 out_free_fcp_eq_hdl:
         kfree(phba->sli4_hba.fcp_eq_hdl);
 out_free_fcf_rr_bmask:
@@ -5152,6 +5273,11 @@ lpfc_sli4_driver_resource_unset(struct lpfc_hba *phba)
 {
         struct lpfc_fcf_conn_entry *conn_entry, *next_conn_entry;
 
+        /* Free memory allocated for msi-x interrupt vector to CPU mapping */
+        kfree(phba->sli4_hba.cpu_map);
+        phba->sli4_hba.num_present_cpu = 0;
+        phba->sli4_hba.num_online_cpu = 0;
+
         /* Free memory allocated for msi-x interrupt vector entries */
         kfree(phba->sli4_hba.msix_entries);
 
@@ -5260,8 +5386,10 @@ lpfc_setup_driver_resource_phase1(struct lpfc_hba *phba)
         init_waitqueue_head(&phba->work_waitq);
 
         /* Initialize the scsi buffer list used by driver for scsi IO */
-        spin_lock_init(&phba->scsi_buf_list_lock);
-        INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list);
+        spin_lock_init(&phba->scsi_buf_list_get_lock);
+        INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list_get);
+        spin_lock_init(&phba->scsi_buf_list_put_lock);
+        INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list_put);
 
         /* Initialize the fabric iocb list */
         INIT_LIST_HEAD(&phba->fabric_iocb_list);
@@ -6696,6 +6824,7 @@ lpfc_sli4_queue_verify(struct lpfc_hba *phba)
         int cfg_fcp_io_channel;
         uint32_t cpu;
         uint32_t i = 0;
+        uint32_t j = 0;
 
 
         /*
@@ -6706,15 +6835,21 @@ lpfc_sli4_queue_verify(struct lpfc_hba *phba)
         /* Sanity check on HBA EQ parameters */
         cfg_fcp_io_channel = phba->cfg_fcp_io_channel;
 
-        /* It doesn't make sense to have more io channels then CPUs */
-        for_each_online_cpu(cpu) {
-                i++;
+        /* It doesn't make sense to have more io channels then online CPUs */
+        for_each_present_cpu(cpu) {
+                if (cpu_online(cpu))
+                        i++;
+                j++;
         }
+        phba->sli4_hba.num_online_cpu = i;
+        phba->sli4_hba.num_present_cpu = j;
+
         if (i < cfg_fcp_io_channel) {
                 lpfc_printf_log(phba,
                                 KERN_ERR, LOG_INIT,
                                 "3188 Reducing IO channels to match number of "
-                                "CPUs: from %d to %d\n", cfg_fcp_io_channel, i);
+                                "online CPUs: from %d to %d\n",
+                                cfg_fcp_io_channel, i);
                 cfg_fcp_io_channel = i;
         }
 
@@ -7743,8 +7878,13 @@ lpfc_pci_function_reset(struct lpfc_hba *phba)
 
 out:
         /* Catch the not-ready port failure after a port reset. */
-        if (num_resets >= MAX_IF_TYPE_2_RESETS)
+        if (num_resets >= MAX_IF_TYPE_2_RESETS) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                "3317 HBA not functional: IP Reset Failed "
+                                "after (%d) retries, try: "
+                                "echo fw_reset > board_mode\n", num_resets);
                 rc = -ENODEV;
+        }
 
         return rc;
 }
@@ -8209,6 +8349,269 @@ lpfc_sli_disable_intr(struct lpfc_hba *phba)
 }
 
 /**
+ * lpfc_find_next_cpu - Find next available CPU that matches the phys_id
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * Find next available CPU to use for IRQ to CPU affinity.
+ */
+static int
+lpfc_find_next_cpu(struct lpfc_hba *phba, uint32_t phys_id)
+{
+        struct lpfc_vector_map_info *cpup;
+        int cpu;
+
+        cpup = phba->sli4_hba.cpu_map;
+        for (cpu = 0; cpu < phba->sli4_hba.num_present_cpu; cpu++) {
+                /* CPU must be online */
+                if (cpu_online(cpu)) {
+                        if ((cpup->irq == LPFC_VECTOR_MAP_EMPTY) &&
+                            (lpfc_used_cpu[cpu] == LPFC_VECTOR_MAP_EMPTY) &&
+                            (cpup->phys_id == phys_id)) {
+                                return cpu;
+                        }
+                }
+                cpup++;
+        }
+
+        /*
+         * If we get here, we have used ALL CPUs for the specific
+         * phys_id. Now we need to clear out lpfc_used_cpu and start
+         * reusing CPUs.
+         */
+
+        for (cpu = 0; cpu < phba->sli4_hba.num_present_cpu; cpu++) {
+                if (lpfc_used_cpu[cpu] == phys_id)
+                        lpfc_used_cpu[cpu] = LPFC_VECTOR_MAP_EMPTY;
+        }
+
+        cpup = phba->sli4_hba.cpu_map;
+        for (cpu = 0; cpu < phba->sli4_hba.num_present_cpu; cpu++) {
+                /* CPU must be online */
+                if (cpu_online(cpu)) {
+                        if ((cpup->irq == LPFC_VECTOR_MAP_EMPTY) &&
+                            (cpup->phys_id == phys_id)) {
+                                return cpu;
+                        }
+                }
+                cpup++;
+        }
+        return LPFC_VECTOR_MAP_EMPTY;
+}
+
+/**
+ * lpfc_sli4_set_affinity - Set affinity for HBA IRQ vectors
+ * @phba:       pointer to lpfc hba data structure.
+ * @vectors:    number of HBA vectors
+ *
+ * Affinitize MSIX IRQ vectors to CPUs. Try to equally spread vector
+ * affinization across multple physical CPUs (numa nodes).
+ * In addition, this routine will assign an IO channel for each CPU
+ * to use when issuing I/Os.
+ */
+static int
+lpfc_sli4_set_affinity(struct lpfc_hba *phba, int vectors)
+{
+        int i, idx, saved_chann, used_chann, cpu, phys_id;
+        int max_phys_id, num_io_channel, first_cpu;
+        struct lpfc_vector_map_info *cpup;
+#ifdef CONFIG_X86
+        struct cpuinfo_x86 *cpuinfo;
+#endif
+        struct cpumask *mask;
+        uint8_t chann[LPFC_FCP_IO_CHAN_MAX+1];
+
+        /* If there is no mapping, just return */
+        if (!phba->cfg_fcp_cpu_map)
+                return 1;
+
+        /* Init cpu_map array */
+        memset(phba->sli4_hba.cpu_map, 0xff,
+               (sizeof(struct lpfc_vector_map_info) *
+                phba->sli4_hba.num_present_cpu));
+
+        max_phys_id = 0;
+        phys_id = 0;
+        num_io_channel = 0;
+        first_cpu = LPFC_VECTOR_MAP_EMPTY;
+
+        /* Update CPU map with physical id and core id of each CPU */
+        cpup = phba->sli4_hba.cpu_map;
+        for (cpu = 0; cpu < phba->sli4_hba.num_present_cpu; cpu++) {
+#ifdef CONFIG_X86
+                cpuinfo = &cpu_data(cpu);
+                cpup->phys_id = cpuinfo->phys_proc_id;
+                cpup->core_id = cpuinfo->cpu_core_id;
+#else
+                /* No distinction between CPUs for other platforms */
+                cpup->phys_id = 0;
+                cpup->core_id = 0;
+#endif
+
+                lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
+                                "3328 CPU physid %d coreid %d\n",
+                                cpup->phys_id, cpup->core_id);
+
+                if (cpup->phys_id > max_phys_id)
+                        max_phys_id = cpup->phys_id;
+                cpup++;
+        }
+
+        /* Now associate the HBA vectors with specific CPUs */
+        for (idx = 0; idx < vectors; idx++) {
+                cpup = phba->sli4_hba.cpu_map;
+                cpu = lpfc_find_next_cpu(phba, phys_id);
+                if (cpu == LPFC_VECTOR_MAP_EMPTY) {
+
+                        /* Try for all phys_id's */
+                        for (i = 1; i < max_phys_id; i++) {
+                                phys_id++;
+                                if (phys_id > max_phys_id)
+                                        phys_id = 0;
+                                cpu = lpfc_find_next_cpu(phba, phys_id);
+                                if (cpu == LPFC_VECTOR_MAP_EMPTY)
+                                        continue;
+                                goto found;
+                        }
+
+                        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                        "3329 Cannot set affinity:"
+                                        "Error mapping vector %d (%d)\n",
+                                        idx, vectors);
+                        return 0;
+                }
+found:
+                cpup += cpu;
+                if (phba->cfg_fcp_cpu_map == LPFC_DRIVER_CPU_MAP)
+                        lpfc_used_cpu[cpu] = phys_id;
+
+                /* Associate vector with selected CPU */
+                cpup->irq = phba->sli4_hba.msix_entries[idx].vector;
+
+                /* Associate IO channel with selected CPU */
+                cpup->channel_id = idx;
+                num_io_channel++;
+
+                if (first_cpu == LPFC_VECTOR_MAP_EMPTY)
+                        first_cpu = cpu;
+
+                /* Now affinitize to the selected CPU */
+                mask = &cpup->maskbits;
+                cpumask_clear(mask);
+                cpumask_set_cpu(cpu, mask);
+                i = irq_set_affinity_hint(phba->sli4_hba.msix_entries[idx].
+                                          vector, mask);
+
+                lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
+                                "3330 Set Affinity: CPU %d channel %d "
+                                "irq %d (%x)\n",
+                                cpu, cpup->channel_id,
+                                phba->sli4_hba.msix_entries[idx].vector, i);
+
+                /* Spread vector mapping across multple physical CPU nodes */
+                phys_id++;
+                if (phys_id > max_phys_id)
+                        phys_id = 0;
+        }
+
+        /*
+         * Finally fill in the IO channel for any remaining CPUs.
+         * At this point, all IO channels have been assigned to a specific
+         * MSIx vector, mapped to a specific CPU.
+         * Base the remaining IO channel assigned, to IO channels already
+         * assigned to other CPUs on the same phys_id.
+         */
+        for (i = 0; i <= max_phys_id; i++) {
+                /*
+                 * If there are no io channels already mapped to
+                 * this phys_id, just round robin thru the io_channels.
+                 * Setup chann[] for round robin.
+                 */
+                for (idx = 0; idx < phba->cfg_fcp_io_channel; idx++)
+                        chann[idx] = idx;
+
+                saved_chann = 0;
+                used_chann = 0;
+
+                /*
+                 * First build a list of IO channels already assigned
+                 * to this phys_id before reassigning the same IO
+                 * channels to the remaining CPUs.
+                 */
+                cpup = phba->sli4_hba.cpu_map;
+                cpu = first_cpu;
+                cpup += cpu;
+                for (idx = 0; idx < phba->sli4_hba.num_present_cpu;
+                     idx++) {
+                        if (cpup->phys_id == i) {
+                                /*
+                                 * Save any IO channels that are
+                                 * already mapped to this phys_id.
+                                 */
+                                if (cpup->irq != LPFC_VECTOR_MAP_EMPTY) {
+                                        chann[saved_chann] =
+                                                cpup->channel_id;
+                                        saved_chann++;
+                                        goto out;
+                                }
+
+                                /* See if we are using round-robin */
+                                if (saved_chann == 0)
+                                        saved_chann =
+                                                phba->cfg_fcp_io_channel;
+
+                                /* Associate next IO channel with CPU */
+                                cpup->channel_id = chann[used_chann];
+                                num_io_channel++;
+                                used_chann++;
+                                if (used_chann == saved_chann)
+                                        used_chann = 0;
+
+                                lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
+                                                "3331 Set IO_CHANN "
+                                                "CPU %d channel %d\n",
+                                                idx, cpup->channel_id);
+                        }
+out:
+                        cpu++;
+                        if (cpu >= phba->sli4_hba.num_present_cpu) {
+                                cpup = phba->sli4_hba.cpu_map;
+                                cpu = 0;
+                        } else {
+                                cpup++;
+                        }
+                }
+        }
+
+        if (phba->sli4_hba.num_online_cpu != phba->sli4_hba.num_present_cpu) {
+                cpup = phba->sli4_hba.cpu_map;
+                for (idx = 0; idx < phba->sli4_hba.num_present_cpu; idx++) {
+                        if (cpup->channel_id == LPFC_VECTOR_MAP_EMPTY) {
+                                cpup->channel_id = 0;
+                                num_io_channel++;
+
+                                lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
+                                                "3332 Assign IO_CHANN "
+                                                "CPU %d channel %d\n",
+                                                idx, cpup->channel_id);
+                        }
+                        cpup++;
+                }
+        }
+
+        /* Sanity check */
+        if (num_io_channel != phba->sli4_hba.num_present_cpu)
+                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                "3333 Set affinity mismatch:"
+                                "%d chann != %d cpus: %d vactors\n",
+                                num_io_channel, phba->sli4_hba.num_present_cpu,
+                                vectors);
+
+        phba->cfg_fcp_io_sched = LPFC_FCP_SCHED_BY_CPU;
+        return 1;
+}
+
+
+/**
  * lpfc_sli4_enable_msix - Enable MSI-X interrupt mode to SLI-4 device
  * @phba: pointer to lpfc hba data structure.
  *
@@ -8259,9 +8662,7 @@ enable_msix_vectors:
                                 phba->sli4_hba.msix_entries[index].vector,
                                 phba->sli4_hba.msix_entries[index].entry);
 
-        /*
-         * Assign MSI-X vectors to interrupt handlers
-         */
+        /* Assign MSI-X vectors to interrupt handlers */
         for (index = 0; index < vectors; index++) {
                 memset(&phba->sli4_hba.handler_name[index], 0, 16);
                 sprintf((char *)&phba->sli4_hba.handler_name[index],
@@ -8289,6 +8690,8 @@ enable_msix_vectors:
                                 phba->cfg_fcp_io_channel, vectors);
                 phba->cfg_fcp_io_channel = vectors;
         }
+
+        lpfc_sli4_set_affinity(phba, vectors);
         return rc;
 
 cfg_fail_out:
@@ -9213,15 +9616,15 @@ lpfc_sli_prep_dev_for_reset(struct lpfc_hba *phba)
         /* Block all SCSI devices' I/Os on the host */
         lpfc_scsi_dev_block(phba);
 
+        /* Flush all driver's outstanding SCSI I/Os as we are to reset */
+        lpfc_sli_flush_fcp_rings(phba);
+
         /* stop all timers */
         lpfc_stop_hba_timers(phba);
 
         /* Disable interrupt and pci device */
         lpfc_sli_disable_intr(phba);
         pci_disable_device(phba->pcidev);
-
-        /* Flush all driver's outstanding SCSI I/Os as we are to reset */
-        lpfc_sli_flush_fcp_rings(phba);
 }
 
 /**
@@ -9966,6 +10369,9 @@ lpfc_sli4_prep_dev_for_reset(struct lpfc_hba *phba)
         /* Block all SCSI devices' I/Os on the host */
         lpfc_scsi_dev_block(phba);
 
+        /* Flush all driver's outstanding SCSI I/Os as we are to reset */
+        lpfc_sli_flush_fcp_rings(phba);
+
         /* stop all timers */
         lpfc_stop_hba_timers(phba);
 
@@ -9973,9 +10379,6 @@ lpfc_sli4_prep_dev_for_reset(struct lpfc_hba *phba)
         lpfc_sli4_disable_intr(phba);
         lpfc_sli4_queue_destroy(phba);
         pci_disable_device(phba->pcidev);
-
-        /* Flush all driver's outstanding SCSI I/Os as we are to reset */
-        lpfc_sli_flush_fcp_rings(phba);
 }
 
 /**
@@ -10535,6 +10938,7 @@ static struct miscdevice lpfc_mgmt_dev = {
 static int __init
 lpfc_init(void)
 {
+        int cpu;
         int error = 0;
 
         printk(LPFC_MODULE_DESC "\n");
@@ -10561,6 +10965,11 @@ lpfc_init(void)
                         return -ENOMEM;
                 }
         }
+
+        /* Initialize in case vector mapping is needed */
+        for (cpu = 0; cpu < LPFC_MAX_CPU; cpu++)
+                lpfc_used_cpu[cpu] = LPFC_VECTOR_MAP_EMPTY;
+
         error = pci_register_driver(&lpfc_driver);
         if (error) {
                 fc_release_transport(lpfc_transport_template);
diff --git a/drivers/scsi/lpfc/lpfc_logmsg.h b/drivers/scsi/lpfc/lpfc_logmsg.h
index baf53e6c2bd1..2a4e5d21eab2 100644
--- a/drivers/scsi/lpfc/lpfc_logmsg.h
+++ b/drivers/scsi/lpfc/lpfc_logmsg.h
@@ -37,6 +37,7 @@
 #define LOG_EVENT       0x00010000      /* CT,TEMP,DUMP, logging */
 #define LOG_FIP         0x00020000      /* FIP events */
 #define LOG_FCP_UNDER   0x00040000      /* FCP underruns errors */
+#define LOG_SCSI_CMD    0x00080000      /* ALL SCSI commands */
 #define LOG_ALL_MSG     0xffffffff      /* LOG all messages */
 
 #define lpfc_printf_vlog(vport, level, mask, fmt, arg...) \
diff --git a/drivers/scsi/lpfc/lpfc_mbox.c b/drivers/scsi/lpfc/lpfc_mbox.c
index a7a9fa468308..41363db7d426 100644
--- a/drivers/scsi/lpfc/lpfc_mbox.c
+++ b/drivers/scsi/lpfc/lpfc_mbox.c
@@ -2149,18 +2149,21 @@ lpfc_reg_vfi(struct lpfcMboxq *mbox, struct lpfc_vport *vport, dma_addr_t phys)
 
         /* Only FC supports upd bit */
         if ((phba->sli4_hba.lnk_info.lnk_tp == LPFC_LNK_TYPE_FC) &&
-            (vport->fc_flag & FC_VFI_REGISTERED)) {
+            (vport->fc_flag & FC_VFI_REGISTERED) &&
+            (!phba->fc_topology_changed)) {
                 bf_set(lpfc_reg_vfi_vp, reg_vfi, 0);
                 bf_set(lpfc_reg_vfi_upd, reg_vfi, 1);
         }
         lpfc_printf_vlog(vport, KERN_INFO, LOG_MBOX,
                         "3134 Register VFI, mydid:x%x, fcfi:%d, "
-                        " vfi:%d, vpi:%d, fc_pname:%x%x\n",
+                        " vfi:%d, vpi:%d, fc_pname:%x%x fc_flag:x%x"
+                        " port_state:x%x topology chg:%d\n",
                         vport->fc_myDID,
                         phba->fcf.fcfi,
                         phba->sli4_hba.vfi_ids[vport->vfi],
                         phba->vpi_ids[vport->vpi],
-                        reg_vfi->wwn[0], reg_vfi->wwn[1]);
+                        reg_vfi->wwn[0], reg_vfi->wwn[1], vport->fc_flag,
+                        vport->port_state, phba->fc_topology_changed);
 }
 
 /**
diff --git a/drivers/scsi/lpfc/lpfc_mem.c b/drivers/scsi/lpfc/lpfc_mem.c
index cd86069a0ba8..812d0cd7c86d 100644
--- a/drivers/scsi/lpfc/lpfc_mem.c
+++ b/drivers/scsi/lpfc/lpfc_mem.c
@@ -64,18 +64,26 @@ lpfc_mem_alloc(struct lpfc_hba *phba, int align)
         struct lpfc_dma_pool *pool = &phba->lpfc_mbuf_safety_pool;
         int i;
 
-        if (phba->sli_rev == LPFC_SLI_REV4)
+        if (phba->sli_rev == LPFC_SLI_REV4) {
+                /* Calculate alignment */
+                if (phba->cfg_sg_dma_buf_size < SLI4_PAGE_SIZE)
+                        i = phba->cfg_sg_dma_buf_size;
+                else
+                        i = SLI4_PAGE_SIZE;
+
                 phba->lpfc_scsi_dma_buf_pool =
                         pci_pool_create("lpfc_scsi_dma_buf_pool",
                                 phba->pcidev,
                                 phba->cfg_sg_dma_buf_size,
-                                phba->cfg_sg_dma_buf_size,
+                                i,
                                 0);
-        else
+        } else {
                 phba->lpfc_scsi_dma_buf_pool =
                         pci_pool_create("lpfc_scsi_dma_buf_pool",
                                 phba->pcidev, phba->cfg_sg_dma_buf_size,
                                 align, 0);
+        }
+
         if (!phba->lpfc_scsi_dma_buf_pool)
                 goto fail;
 
diff --git a/drivers/scsi/lpfc/lpfc_nportdisc.c b/drivers/scsi/lpfc/lpfc_nportdisc.c
index 82f4d3542289..31e9b92f5a9b 100644
--- a/drivers/scsi/lpfc/lpfc_nportdisc.c
+++ b/drivers/scsi/lpfc/lpfc_nportdisc.c
@@ -332,9 +332,11 @@ lpfc_rcv_plogi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
 
         /* PLOGI chkparm OK */
         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
-                         "0114 PLOGI chkparm OK Data: x%x x%x x%x x%x\n",
+                         "0114 PLOGI chkparm OK Data: x%x x%x x%x "
+                         "x%x x%x x%x\n",
                          ndlp->nlp_DID, ndlp->nlp_state, ndlp->nlp_flag,
-                         ndlp->nlp_rpi);
+                         ndlp->nlp_rpi, vport->port_state,
+                         vport->fc_flag);
 
         if (vport->cfg_fcp_class == 2 && sp->cls2.classValid)
                 ndlp->nlp_fcp_info |= CLASS2;
@@ -574,7 +576,7 @@ out:
         lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp, NULL);
 
         /* 1 sec timeout */
-        mod_timer(&ndlp->nlp_delayfunc, jiffies + HZ);
+        mod_timer(&ndlp->nlp_delayfunc, jiffies + msecs_to_jiffies(1000));
 
         spin_lock_irq(shost->host_lock);
         ndlp->nlp_flag |= NLP_DELAY_TMO;
@@ -631,7 +633,8 @@ lpfc_rcv_logo(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
                          * If there are other active VLinks present,
                          * re-instantiate the Vlink using FDISC.
                          */
-                        mod_timer(&ndlp->nlp_delayfunc, jiffies + HZ);
+                        mod_timer(&ndlp->nlp_delayfunc,
+                                  jiffies + msecs_to_jiffies(1000));
                         spin_lock_irq(shost->host_lock);
                         ndlp->nlp_flag |= NLP_DELAY_TMO;
                         spin_unlock_irq(shost->host_lock);
@@ -648,7 +651,8 @@ lpfc_rcv_logo(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
                 !(ndlp->nlp_type & NLP_FCP_INITIATOR))) ||
                 (ndlp->nlp_state == NLP_STE_ADISC_ISSUE)) {
                 /* Only try to re-login if this is NOT a Fabric Node */
-                mod_timer(&ndlp->nlp_delayfunc, jiffies + HZ * 1);
+                mod_timer(&ndlp->nlp_delayfunc,
+                          jiffies + msecs_to_jiffies(1000 * 1));
                 spin_lock_irq(shost->host_lock);
                 ndlp->nlp_flag |= NLP_DELAY_TMO;
                 spin_unlock_irq(shost->host_lock);
@@ -969,7 +973,7 @@ lpfc_rcv_els_plogi_issue(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
         }
 
         /* Put ndlp in npr state set plogi timer for 1 sec */
-        mod_timer(&ndlp->nlp_delayfunc, jiffies + HZ * 1);
+        mod_timer(&ndlp->nlp_delayfunc, jiffies + msecs_to_jiffies(1000 * 1));
         spin_lock_irq(shost->host_lock);
         ndlp->nlp_flag |= NLP_DELAY_TMO;
         spin_unlock_irq(shost->host_lock);
@@ -1303,7 +1307,8 @@ lpfc_cmpl_adisc_adisc_issue(struct lpfc_vport *vport,
         if ((irsp->ulpStatus) ||
             (!lpfc_check_adisc(vport, ndlp, &ap->nodeName, &ap->portName))) {
                 /* 1 sec timeout */
-                mod_timer(&ndlp->nlp_delayfunc, jiffies + HZ);
+                mod_timer(&ndlp->nlp_delayfunc,
+                          jiffies + msecs_to_jiffies(1000));
                 spin_lock_irq(shost->host_lock);
                 ndlp->nlp_flag |= NLP_DELAY_TMO;
                 spin_unlock_irq(shost->host_lock);
@@ -1509,7 +1514,8 @@ lpfc_cmpl_reglogin_reglogin_issue(struct lpfc_vport *vport,
                 }
 
                 /* Put ndlp in npr state set plogi timer for 1 sec */
-                mod_timer(&ndlp->nlp_delayfunc, jiffies + HZ * 1);
+                mod_timer(&ndlp->nlp_delayfunc,
+                          jiffies + msecs_to_jiffies(1000 * 1));
                 spin_lock_irq(shost->host_lock);
                 ndlp->nlp_flag |= NLP_DELAY_TMO;
                 spin_unlock_irq(shost->host_lock);
@@ -2145,7 +2151,8 @@ lpfc_rcv_prlo_npr_node(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
         lpfc_els_rsp_acc(vport, ELS_CMD_ACC, cmdiocb, ndlp, NULL);
 
         if ((ndlp->nlp_flag & NLP_DELAY_TMO) == 0) {
-                mod_timer(&ndlp->nlp_delayfunc, jiffies + HZ * 1);
+                mod_timer(&ndlp->nlp_delayfunc,
+                          jiffies + msecs_to_jiffies(1000 * 1));
                 spin_lock_irq(shost->host_lock);
                 ndlp->nlp_flag |= NLP_DELAY_TMO;
                 ndlp->nlp_flag &= ~NLP_NPR_ADISC;
diff --git a/drivers/scsi/lpfc/lpfc_scsi.c b/drivers/scsi/lpfc/lpfc_scsi.c
index 74b8710e1e90..8523b278ec9d 100644
--- a/drivers/scsi/lpfc/lpfc_scsi.c
+++ b/drivers/scsi/lpfc/lpfc_scsi.c
@@ -24,6 +24,8 @@
 #include <linux/export.h>
 #include <linux/delay.h>
 #include <asm/unaligned.h>
+#include <linux/crc-t10dif.h>
+#include <net/checksum.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_device.h>
@@ -48,7 +50,7 @@
 #define LPFC_RESET_WAIT  2
 #define LPFC_ABORT_WAIT  2
 
-int _dump_buf_done;
+int _dump_buf_done = 1;
 
 static char *dif_op_str[] = {
         "PROT_NORMAL",
@@ -66,6 +68,10 @@ struct scsi_dif_tuple {
         __be32 ref_tag;         /* Target LBA or indirect LBA */
 };
 
+#if !defined(SCSI_PROT_GUARD_CHECK) || !defined(SCSI_PROT_REF_CHECK)
+#define scsi_prot_flagged(sc, flg)      sc
+#endif
+
 static void
 lpfc_release_scsi_buf_s4(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb);
 static void
@@ -534,7 +540,16 @@ lpfc_new_scsi_buf_s3(struct lpfc_vport *vport, int num_to_alloc)
         dma_addr_t pdma_phys_fcp_rsp;
         dma_addr_t pdma_phys_bpl;
         uint16_t iotag;
-        int bcnt;
+        int bcnt, bpl_size;
+
+        bpl_size = phba->cfg_sg_dma_buf_size -
+                (sizeof(struct fcp_cmnd) + sizeof(struct fcp_rsp));
+
+        lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
+                         "9067 ALLOC %d scsi_bufs: %d (%d + %d + %d)\n",
+                         num_to_alloc, phba->cfg_sg_dma_buf_size,
+                         (int)sizeof(struct fcp_cmnd),
+                         (int)sizeof(struct fcp_rsp), bpl_size);
 
         for (bcnt = 0; bcnt < num_to_alloc; bcnt++) {
                 psb = kzalloc(sizeof(struct lpfc_scsi_buf), GFP_KERNEL);
@@ -759,7 +774,7 @@ lpfc_sli4_post_scsi_sgl_list(struct lpfc_hba *phba,
                              struct list_head *post_sblist, int sb_count)
 {
         struct lpfc_scsi_buf *psb, *psb_next;
-        int status;
+        int status, sgl_size;
         int post_cnt = 0, block_cnt = 0, num_posting = 0, num_posted = 0;
         dma_addr_t pdma_phys_bpl1;
         int last_xritag = NO_XRI;
@@ -771,6 +786,9 @@ lpfc_sli4_post_scsi_sgl_list(struct lpfc_hba *phba,
         if (sb_count <= 0)
                 return -EINVAL;
 
+        sgl_size = phba->cfg_sg_dma_buf_size -
+                (sizeof(struct fcp_cmnd) + sizeof(struct fcp_rsp));
+
         list_for_each_entry_safe(psb, psb_next, post_sblist, list) {
                 list_del_init(&psb->list);
                 block_cnt++;
@@ -803,7 +821,7 @@ lpfc_sli4_post_scsi_sgl_list(struct lpfc_hba *phba,
                                 post_cnt = block_cnt;
                         } else if (block_cnt == 1) {
                                 /* last single sgl with non-contiguous xri */
-                                if (phba->cfg_sg_dma_buf_size > SGL_PAGE_SIZE)
+                                if (sgl_size > SGL_PAGE_SIZE)
                                         pdma_phys_bpl1 = psb->dma_phys_bpl +
                                                                 SGL_PAGE_SIZE;
                                 else
@@ -885,9 +903,12 @@ lpfc_sli4_repost_scsi_sgl_list(struct lpfc_hba *phba)
         int num_posted, rc = 0;
 
         /* get all SCSI buffers need to repost to a local list */
-        spin_lock_irq(&phba->scsi_buf_list_lock);
-        list_splice_init(&phba->lpfc_scsi_buf_list, &post_sblist);
-        spin_unlock_irq(&phba->scsi_buf_list_lock);
+        spin_lock_irq(&phba->scsi_buf_list_get_lock);
+        spin_lock_irq(&phba->scsi_buf_list_put_lock);
+        list_splice_init(&phba->lpfc_scsi_buf_list_get, &post_sblist);
+        list_splice(&phba->lpfc_scsi_buf_list_put, &post_sblist);
+        spin_unlock_irq(&phba->scsi_buf_list_put_lock);
+        spin_unlock_irq(&phba->scsi_buf_list_get_lock);
 
         /* post the list of scsi buffer sgls to port if available */
         if (!list_empty(&post_sblist)) {
@@ -923,13 +944,22 @@ lpfc_new_scsi_buf_s4(struct lpfc_vport *vport, int num_to_alloc)
         IOCB_t *iocb;
         dma_addr_t pdma_phys_fcp_cmd;
         dma_addr_t pdma_phys_fcp_rsp;
-        dma_addr_t pdma_phys_bpl, pdma_phys_bpl1;
+        dma_addr_t pdma_phys_bpl;
         uint16_t iotag, lxri = 0;
-        int bcnt, num_posted;
+        int bcnt, num_posted, sgl_size;
         LIST_HEAD(prep_sblist);
         LIST_HEAD(post_sblist);
         LIST_HEAD(scsi_sblist);
 
+        sgl_size = phba->cfg_sg_dma_buf_size -
+                (sizeof(struct fcp_cmnd) + sizeof(struct fcp_rsp));
+
+        lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
+                         "9068 ALLOC %d scsi_bufs: %d (%d + %d + %d)\n",
+                         num_to_alloc, phba->cfg_sg_dma_buf_size, sgl_size,
+                         (int)sizeof(struct fcp_cmnd),
+                         (int)sizeof(struct fcp_rsp));
+
         for (bcnt = 0; bcnt < num_to_alloc; bcnt++) {
                 psb = kzalloc(sizeof(struct lpfc_scsi_buf), GFP_KERNEL);
                 if (!psb)
@@ -948,6 +978,15 @@ lpfc_new_scsi_buf_s4(struct lpfc_vport *vport, int num_to_alloc)
                 }
                 memset(psb->data, 0, phba->cfg_sg_dma_buf_size);
 
+                /* Page alignment is CRITICAL, double check to be sure */
+                if (((unsigned long)(psb->data) &
+                    (unsigned long)(SLI4_PAGE_SIZE - 1)) != 0) {
+                        pci_pool_free(phba->lpfc_scsi_dma_buf_pool,
+                                      psb->data, psb->dma_handle);
+                        kfree(psb);
+                        break;
+                }
+
                 /* Allocate iotag for psb->cur_iocbq. */
                 iotag = lpfc_sli_next_iotag(phba, &psb->cur_iocbq);
                 if (iotag == 0) {
@@ -968,17 +1007,14 @@ lpfc_new_scsi_buf_s4(struct lpfc_vport *vport, int num_to_alloc)
                 psb->cur_iocbq.sli4_xritag = phba->sli4_hba.xri_ids[lxri];
                 psb->cur_iocbq.iocb_flag |= LPFC_IO_FCP;
                 psb->fcp_bpl = psb->data;
-                psb->fcp_cmnd = (psb->data + phba->cfg_sg_dma_buf_size)
-                        - (sizeof(struct fcp_cmnd) + sizeof(struct fcp_rsp));
+                psb->fcp_cmnd = (psb->data + sgl_size);
                 psb->fcp_rsp = (struct fcp_rsp *)((uint8_t *)psb->fcp_cmnd +
                                         sizeof(struct fcp_cmnd));
 
                 /* Initialize local short-hand pointers. */
                 sgl = (struct sli4_sge *)psb->fcp_bpl;
                 pdma_phys_bpl = psb->dma_handle;
-                pdma_phys_fcp_cmd =
-                        (psb->dma_handle + phba->cfg_sg_dma_buf_size)
-                         - (sizeof(struct fcp_cmnd) + sizeof(struct fcp_rsp));
+                pdma_phys_fcp_cmd = (psb->dma_handle + sgl_size);
                 pdma_phys_fcp_rsp = pdma_phys_fcp_cmd + sizeof(struct fcp_cmnd);
 
                 /*
@@ -1020,17 +1056,13 @@ lpfc_new_scsi_buf_s4(struct lpfc_vport *vport, int num_to_alloc)
                 iocb->ulpLe = 1;
                 iocb->ulpClass = CLASS3;
                 psb->cur_iocbq.context1 = psb;
-                if (phba->cfg_sg_dma_buf_size > SGL_PAGE_SIZE)
-                        pdma_phys_bpl1 = pdma_phys_bpl + SGL_PAGE_SIZE;
-                else
-                        pdma_phys_bpl1 = 0;
                 psb->dma_phys_bpl = pdma_phys_bpl;
 
                 /* add the scsi buffer to a post list */
                 list_add_tail(&psb->list, &post_sblist);
-                spin_lock_irq(&phba->scsi_buf_list_lock);
+                spin_lock_irq(&phba->scsi_buf_list_get_lock);
                 phba->sli4_hba.scsi_xri_cnt++;
-                spin_unlock_irq(&phba->scsi_buf_list_lock);
+                spin_unlock_irq(&phba->scsi_buf_list_get_lock);
         }
         lpfc_printf_log(phba, KERN_INFO, LOG_BG,
                         "3021 Allocate %d out of %d requested new SCSI "
@@ -1079,17 +1111,23 @@ static struct lpfc_scsi_buf*
 lpfc_get_scsi_buf_s3(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp)
 {
         struct  lpfc_scsi_buf * lpfc_cmd = NULL;
-        struct list_head *scsi_buf_list = &phba->lpfc_scsi_buf_list;
-        unsigned long iflag = 0;
-
-        spin_lock_irqsave(&phba->scsi_buf_list_lock, iflag);
-        list_remove_head(scsi_buf_list, lpfc_cmd, struct lpfc_scsi_buf, list);
-        if (lpfc_cmd) {
-                lpfc_cmd->seg_cnt = 0;
-                lpfc_cmd->nonsg_phys = 0;
-                lpfc_cmd->prot_seg_cnt = 0;
+        struct list_head *scsi_buf_list_get = &phba->lpfc_scsi_buf_list_get;
+        unsigned long gflag = 0;
+        unsigned long pflag = 0;
+
+        spin_lock_irqsave(&phba->scsi_buf_list_get_lock, gflag);
+        list_remove_head(scsi_buf_list_get, lpfc_cmd, struct lpfc_scsi_buf,
+                         list);
+        if (!lpfc_cmd) {
+                spin_lock_irqsave(&phba->scsi_buf_list_put_lock, pflag);
+                list_splice(&phba->lpfc_scsi_buf_list_put,
+                            &phba->lpfc_scsi_buf_list_get);
+                INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list_put);
+                list_remove_head(scsi_buf_list_get, lpfc_cmd,
+                                 struct lpfc_scsi_buf, list);
+                spin_unlock_irqrestore(&phba->scsi_buf_list_put_lock, pflag);
         }
-        spin_unlock_irqrestore(&phba->scsi_buf_list_lock, iflag);
+        spin_unlock_irqrestore(&phba->scsi_buf_list_get_lock, gflag);
         return  lpfc_cmd;
 }
 /**
@@ -1107,28 +1145,39 @@ static struct lpfc_scsi_buf*
 lpfc_get_scsi_buf_s4(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp)
 {
         struct lpfc_scsi_buf *lpfc_cmd ;
-        unsigned long iflag = 0;
+        unsigned long gflag = 0;
+        unsigned long pflag = 0;
         int found = 0;
 
-        spin_lock_irqsave(&phba->scsi_buf_list_lock, iflag);
-        list_for_each_entry(lpfc_cmd, &phba->lpfc_scsi_buf_list,
-                                                        list) {
+        spin_lock_irqsave(&phba->scsi_buf_list_get_lock, gflag);
+        list_for_each_entry(lpfc_cmd, &phba->lpfc_scsi_buf_list_get, list) {
                 if (lpfc_test_rrq_active(phba, ndlp,
                                          lpfc_cmd->cur_iocbq.sli4_lxritag))
                         continue;
                 list_del(&lpfc_cmd->list);
                 found = 1;
-                lpfc_cmd->seg_cnt = 0;
-                lpfc_cmd->nonsg_phys = 0;
-                lpfc_cmd->prot_seg_cnt = 0;
                 break;
         }
-        spin_unlock_irqrestore(&phba->scsi_buf_list_lock,
-                                                 iflag);
+        if (!found) {
+                spin_lock_irqsave(&phba->scsi_buf_list_put_lock, pflag);
+                list_splice(&phba->lpfc_scsi_buf_list_put,
+                            &phba->lpfc_scsi_buf_list_get);
+                INIT_LIST_HEAD(&phba->lpfc_scsi_buf_list_put);
+                spin_unlock_irqrestore(&phba->scsi_buf_list_put_lock, pflag);
+                list_for_each_entry(lpfc_cmd, &phba->lpfc_scsi_buf_list_get,
+                                    list) {
+                        if (lpfc_test_rrq_active(
+                                phba, ndlp, lpfc_cmd->cur_iocbq.sli4_lxritag))
+                                continue;
+                        list_del(&lpfc_cmd->list);
+                        found = 1;
+                        break;
+                }
+        }
+        spin_unlock_irqrestore(&phba->scsi_buf_list_get_lock, gflag);
         if (!found)
                 return NULL;
-        else
-                return  lpfc_cmd;
+        return  lpfc_cmd;
 }
 /**
  * lpfc_get_scsi_buf - Get a scsi buffer from lpfc_scsi_buf_list of the HBA
@@ -1160,10 +1209,15 @@ lpfc_release_scsi_buf_s3(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb)
 {
         unsigned long iflag = 0;
 
-        spin_lock_irqsave(&phba->scsi_buf_list_lock, iflag);
+        psb->seg_cnt = 0;
+        psb->nonsg_phys = 0;
+        psb->prot_seg_cnt = 0;
+
+        spin_lock_irqsave(&phba->scsi_buf_list_put_lock, iflag);
         psb->pCmd = NULL;
-        list_add_tail(&psb->list, &phba->lpfc_scsi_buf_list);
-        spin_unlock_irqrestore(&phba->scsi_buf_list_lock, iflag);
+        psb->cur_iocbq.iocb_flag = LPFC_IO_FCP;
+        list_add_tail(&psb->list, &phba->lpfc_scsi_buf_list_put);
+        spin_unlock_irqrestore(&phba->scsi_buf_list_put_lock, iflag);
 }
 
 /**
@@ -1181,6 +1235,10 @@ lpfc_release_scsi_buf_s4(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb)
 {
         unsigned long iflag = 0;
 
+        psb->seg_cnt = 0;
+        psb->nonsg_phys = 0;
+        psb->prot_seg_cnt = 0;
+
         if (psb->exch_busy) {
                 spin_lock_irqsave(&phba->sli4_hba.abts_scsi_buf_list_lock,
                                         iflag);
@@ -1190,11 +1248,11 @@ lpfc_release_scsi_buf_s4(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb)
                 spin_unlock_irqrestore(&phba->sli4_hba.abts_scsi_buf_list_lock,
                                         iflag);
         } else {
-
-                spin_lock_irqsave(&phba->scsi_buf_list_lock, iflag);
                 psb->pCmd = NULL;
-                list_add_tail(&psb->list, &phba->lpfc_scsi_buf_list);
-                spin_unlock_irqrestore(&phba->scsi_buf_list_lock, iflag);
+                psb->cur_iocbq.iocb_flag = LPFC_IO_FCP;
+                spin_lock_irqsave(&phba->scsi_buf_list_put_lock, iflag);
+                list_add_tail(&psb->list, &phba->lpfc_scsi_buf_list_put);
+                spin_unlock_irqrestore(&phba->scsi_buf_list_put_lock, iflag);
         }
 }
 
@@ -1268,6 +1326,7 @@ lpfc_scsi_prep_dma_buf_s3(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
                                "dma_map_sg.  Config %d, seg_cnt %d\n",
                                __func__, phba->cfg_sg_seg_cnt,
                                lpfc_cmd->seg_cnt);
+                        lpfc_cmd->seg_cnt = 0;
                         scsi_dma_unmap(scsi_cmnd);
                         return 1;
                 }
@@ -2013,9 +2072,21 @@ lpfc_bg_setup_bpl(struct lpfc_hba *phba, struct scsi_cmnd *sc,
         bf_set(pde6_type, pde6, LPFC_PDE6_DESCRIPTOR);
         bf_set(pde6_optx, pde6, txop);
         bf_set(pde6_oprx, pde6, rxop);
+
+        /*
+         * We only need to check the data on READs, for WRITEs
+         * protection data is automatically generated, not checked.
+         */
         if (datadir == DMA_FROM_DEVICE) {
-                bf_set(pde6_ce, pde6, checking);
-                bf_set(pde6_re, pde6, checking);
+                if (scsi_prot_flagged(sc, SCSI_PROT_GUARD_CHECK))
+                        bf_set(pde6_ce, pde6, checking);
+                else
+                        bf_set(pde6_ce, pde6, 0);
+
+                if (scsi_prot_flagged(sc, SCSI_PROT_REF_CHECK))
+                        bf_set(pde6_re, pde6, checking);
+                else
+                        bf_set(pde6_re, pde6, 0);
         }
         bf_set(pde6_ai, pde6, 1);
         bf_set(pde6_ae, pde6, 0);
@@ -2145,6 +2216,10 @@ lpfc_bg_setup_bpl_prot(struct lpfc_hba *phba, struct scsi_cmnd *sc,
 
         split_offset = 0;
         do {
+                /* Check to see if we ran out of space */
+                if (num_bde >= (phba->cfg_total_seg_cnt - 2))
+                        return num_bde + 3;
+
                 /* setup PDE5 with what we have */
                 pde5 = (struct lpfc_pde5 *) bpl;
                 memset(pde5, 0, sizeof(struct lpfc_pde5));
@@ -2164,8 +2239,17 @@ lpfc_bg_setup_bpl_prot(struct lpfc_hba *phba, struct scsi_cmnd *sc,
                 bf_set(pde6_type, pde6, LPFC_PDE6_DESCRIPTOR);
                 bf_set(pde6_optx, pde6, txop);
                 bf_set(pde6_oprx, pde6, rxop);
-                bf_set(pde6_ce, pde6, checking);
-                bf_set(pde6_re, pde6, checking);
+
+                if (scsi_prot_flagged(sc, SCSI_PROT_GUARD_CHECK))
+                        bf_set(pde6_ce, pde6, checking);
+                else
+                        bf_set(pde6_ce, pde6, 0);
+
+                if (scsi_prot_flagged(sc, SCSI_PROT_REF_CHECK))
+                        bf_set(pde6_re, pde6, checking);
+                else
+                        bf_set(pde6_re, pde6, 0);
+
                 bf_set(pde6_ai, pde6, 1);
                 bf_set(pde6_ae, pde6, 0);
                 bf_set(pde6_apptagval, pde6, 0);
@@ -2213,6 +2297,10 @@ lpfc_bg_setup_bpl_prot(struct lpfc_hba *phba, struct scsi_cmnd *sc,
                 pgdone = 0;
                 subtotal = 0; /* total bytes processed for current prot grp */
                 while (!pgdone) {
+                        /* Check to see if we ran out of space */
+                        if (num_bde >= phba->cfg_total_seg_cnt)
+                                return num_bde + 1;
+
                         if (!sgde) {
                                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
                                         "9065 BLKGRD:%s Invalid data segment\n",
@@ -2324,7 +2412,6 @@ lpfc_bg_setup_sgl(struct lpfc_hba *phba, struct scsi_cmnd *sc,
         struct sli4_sge_diseed *diseed = NULL;
         dma_addr_t physaddr;
         int i = 0, num_sge = 0, status;
-        int datadir = sc->sc_data_direction;
         uint32_t reftag;
         unsigned blksize;
         uint8_t txop, rxop;
@@ -2362,13 +2449,26 @@ lpfc_bg_setup_sgl(struct lpfc_hba *phba, struct scsi_cmnd *sc,
         diseed->ref_tag = cpu_to_le32(reftag);
         diseed->ref_tag_tran = diseed->ref_tag;
 
+        /*
+         * We only need to check the data on READs, for WRITEs
+         * protection data is automatically generated, not checked.
+         */
+        if (sc->sc_data_direction == DMA_FROM_DEVICE) {
+                if (scsi_prot_flagged(sc, SCSI_PROT_GUARD_CHECK))
+                        bf_set(lpfc_sli4_sge_dif_ce, diseed, checking);
+                else
+                        bf_set(lpfc_sli4_sge_dif_ce, diseed, 0);
+
+                if (scsi_prot_flagged(sc, SCSI_PROT_REF_CHECK))
+                        bf_set(lpfc_sli4_sge_dif_re, diseed, checking);
+                else
+                        bf_set(lpfc_sli4_sge_dif_re, diseed, 0);
+        }
+
         /* setup DISEED with the rest of the info */
         bf_set(lpfc_sli4_sge_dif_optx, diseed, txop);
         bf_set(lpfc_sli4_sge_dif_oprx, diseed, rxop);
-        if (datadir == DMA_FROM_DEVICE) {
-                bf_set(lpfc_sli4_sge_dif_ce, diseed, checking);
-                bf_set(lpfc_sli4_sge_dif_re, diseed, checking);
-        }
+
         bf_set(lpfc_sli4_sge_dif_ai, diseed, 1);
         bf_set(lpfc_sli4_sge_dif_me, diseed, 0);
 
@@ -2497,6 +2597,10 @@ lpfc_bg_setup_sgl_prot(struct lpfc_hba *phba, struct scsi_cmnd *sc,
 
         split_offset = 0;
         do {
+                /* Check to see if we ran out of space */
+                if (num_sge >= (phba->cfg_total_seg_cnt - 2))
+                        return num_sge + 3;
+
                 /* setup DISEED with what we have */
                 diseed = (struct sli4_sge_diseed *) sgl;
                 memset(diseed, 0, sizeof(struct sli4_sge_diseed));
@@ -2506,11 +2610,34 @@ lpfc_bg_setup_sgl_prot(struct lpfc_hba *phba, struct scsi_cmnd *sc,
                 diseed->ref_tag = cpu_to_le32(reftag);
                 diseed->ref_tag_tran = diseed->ref_tag;
 
+                if (scsi_prot_flagged(sc, SCSI_PROT_GUARD_CHECK)) {
+                        bf_set(lpfc_sli4_sge_dif_ce, diseed, checking);
+
+                } else {
+                        bf_set(lpfc_sli4_sge_dif_ce, diseed, 0);
+                        /*
+                         * When in this mode, the hardware will replace
+                         * the guard tag from the host with a
+                         * newly generated good CRC for the wire.
+                         * Switch to raw mode here to avoid this
+                         * behavior. What the host sends gets put on the wire.
+                         */
+                        if (txop == BG_OP_IN_CRC_OUT_CRC) {
+                                txop = BG_OP_RAW_MODE;
+                                rxop = BG_OP_RAW_MODE;
+                        }
+                }
+
+
+                if (scsi_prot_flagged(sc, SCSI_PROT_REF_CHECK))
+                        bf_set(lpfc_sli4_sge_dif_re, diseed, checking);
+                else
+                        bf_set(lpfc_sli4_sge_dif_re, diseed, 0);
+
                 /* setup DISEED with the rest of the info */
                 bf_set(lpfc_sli4_sge_dif_optx, diseed, txop);
                 bf_set(lpfc_sli4_sge_dif_oprx, diseed, rxop);
-                bf_set(lpfc_sli4_sge_dif_ce, diseed, checking);
-                bf_set(lpfc_sli4_sge_dif_re, diseed, checking);
+
                 bf_set(lpfc_sli4_sge_dif_ai, diseed, 1);
                 bf_set(lpfc_sli4_sge_dif_me, diseed, 0);
 
@@ -2556,6 +2683,10 @@ lpfc_bg_setup_sgl_prot(struct lpfc_hba *phba, struct scsi_cmnd *sc,
                 pgdone = 0;
                 subtotal = 0; /* total bytes processed for current prot grp */
                 while (!pgdone) {
+                        /* Check to see if we ran out of space */
+                        if (num_sge >= phba->cfg_total_seg_cnt)
+                                return num_sge + 1;
+
                         if (!sgde) {
                                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,
                                         "9086 BLKGRD:%s Invalid data segment\n",
@@ -2670,6 +2801,47 @@ lpfc_prot_group_type(struct lpfc_hba *phba, struct scsi_cmnd *sc)
 }
 
 /**
+ * lpfc_bg_scsi_adjust_dl - Adjust SCSI data length for BlockGuard
+ * @phba: The Hba for which this call is being executed.
+ * @lpfc_cmd: The scsi buffer which is going to be adjusted.
+ *
+ * Adjust the data length to account for how much data
+ * is actually on the wire.
+ *
+ * returns the adjusted data length
+ **/
+static int
+lpfc_bg_scsi_adjust_dl(struct lpfc_hba *phba,
+                       struct lpfc_scsi_buf *lpfc_cmd)
+{
+        struct scsi_cmnd *sc = lpfc_cmd->pCmd;
+        int fcpdl;
+
+        fcpdl = scsi_bufflen(sc);
+
+        /* Check if there is protection data on the wire */
+        if (sc->sc_data_direction == DMA_FROM_DEVICE) {
+                /* Read */
+                if (scsi_get_prot_op(sc) ==  SCSI_PROT_READ_INSERT)
+                        return fcpdl;
+
+        } else {
+                /* Write */
+                if (scsi_get_prot_op(sc) ==  SCSI_PROT_WRITE_STRIP)
+                        return fcpdl;
+        }
+
+        /*
+         * If we are in DIF Type 1 mode every data block has a 8 byte
+         * DIF (trailer) attached to it. Must ajust FCP data length.
+         */
+        if (scsi_prot_flagged(sc, SCSI_PROT_TRANSFER_PI))
+                fcpdl += (fcpdl / lpfc_cmd_blksize(sc)) * 8;
+
+        return fcpdl;
+}
+
+/**
  * lpfc_bg_scsi_prep_dma_buf_s3 - DMA mapping for scsi buffer to SLI3 IF spec
  * @phba: The Hba for which this call is being executed.
  * @lpfc_cmd: The scsi buffer which is going to be prep'ed.
@@ -2689,8 +2861,7 @@ lpfc_bg_scsi_prep_dma_buf_s3(struct lpfc_hba *phba,
         uint32_t num_bde = 0;
         int datasegcnt, protsegcnt, datadir = scsi_cmnd->sc_data_direction;
         int prot_group_type = 0;
-        int diflen, fcpdl;
-        unsigned blksize;
+        int fcpdl;
 
         /*
          * Start the lpfc command prep by bumping the bpl beyond fcp_cmnd
@@ -2711,28 +2882,28 @@ lpfc_bg_scsi_prep_dma_buf_s3(struct lpfc_hba *phba,
                         return 1;
 
                 lpfc_cmd->seg_cnt = datasegcnt;
-                if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt) {
-                        lpfc_printf_log(phba, KERN_ERR, LOG_BG,
-                                        "9067 BLKGRD: %s: Too many sg segments"
-                                        " from dma_map_sg.  Config %d, seg_cnt"
-                                        " %d\n",
-                                        __func__, phba->cfg_sg_seg_cnt,
-                                        lpfc_cmd->seg_cnt);
-                        scsi_dma_unmap(scsi_cmnd);
-                        return 1;
-                }
+
+                /* First check if data segment count from SCSI Layer is good */
+                if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt)
+                        goto err;
 
                 prot_group_type = lpfc_prot_group_type(phba, scsi_cmnd);
 
                 switch (prot_group_type) {
                 case LPFC_PG_TYPE_NO_DIF:
+
+                        /* Here we need to add a PDE5 and PDE6 to the count */
+                        if ((lpfc_cmd->seg_cnt + 2) > phba->cfg_total_seg_cnt)
+                                goto err;
+
                         num_bde = lpfc_bg_setup_bpl(phba, scsi_cmnd, bpl,
                                         datasegcnt);
                         /* we should have 2 or more entries in buffer list */
                         if (num_bde < 2)
                                 goto err;
                         break;
-                case LPFC_PG_TYPE_DIF_BUF:{
+
+                case LPFC_PG_TYPE_DIF_BUF:
                         /*
                          * This type indicates that protection buffers are
                          * passed to the driver, so that needs to be prepared
@@ -2747,31 +2918,28 @@ lpfc_bg_scsi_prep_dma_buf_s3(struct lpfc_hba *phba,
                         }
 
                         lpfc_cmd->prot_seg_cnt = protsegcnt;
-                        if (lpfc_cmd->prot_seg_cnt
-                            > phba->cfg_prot_sg_seg_cnt) {
-                                lpfc_printf_log(phba, KERN_ERR, LOG_BG,
-                                        "9068 BLKGRD: %s: Too many prot sg "
-                                        "segments from dma_map_sg.  Config %d,"
-                                                "prot_seg_cnt %d\n", __func__,
-                                                phba->cfg_prot_sg_seg_cnt,
-                                                lpfc_cmd->prot_seg_cnt);
-                                dma_unmap_sg(&phba->pcidev->dev,
-                                             scsi_prot_sglist(scsi_cmnd),
-                                             scsi_prot_sg_count(scsi_cmnd),
-                                             datadir);
-                                scsi_dma_unmap(scsi_cmnd);
-                                return 1;
-                        }
+
+                        /*
+                         * There is a minimun of 4 BPLs used for every
+                         * protection data segment.
+                         */
+                        if ((lpfc_cmd->prot_seg_cnt * 4) >
+                            (phba->cfg_total_seg_cnt - 2))
+                                goto err;
 
                         num_bde = lpfc_bg_setup_bpl_prot(phba, scsi_cmnd, bpl,
                                         datasegcnt, protsegcnt);
                         /* we should have 3 or more entries in buffer list */
-                        if (num_bde < 3)
+                        if ((num_bde < 3) ||
+                            (num_bde > phba->cfg_total_seg_cnt))
                                 goto err;
                         break;
-                }
+
                 case LPFC_PG_TYPE_INVALID:
                 default:
+                        scsi_dma_unmap(scsi_cmnd);
+                        lpfc_cmd->seg_cnt = 0;
+
                         lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
                                         "9022 Unexpected protection group %i\n",
                                         prot_group_type);
@@ -2790,18 +2958,7 @@ lpfc_bg_scsi_prep_dma_buf_s3(struct lpfc_hba *phba,
         iocb_cmd->ulpBdeCount = 1;
         iocb_cmd->ulpLe = 1;
 
-        fcpdl = scsi_bufflen(scsi_cmnd);
-
-        if (scsi_get_prot_type(scsi_cmnd) == SCSI_PROT_DIF_TYPE1) {
-                /*
-                 * We are in DIF Type 1 mode
-                 * Every data block has a 8 byte DIF (trailer)
-                 * attached to it.  Must ajust FCP data length
-                 */
-                blksize = lpfc_cmd_blksize(scsi_cmnd);
-                diflen = (fcpdl / blksize) * 8;
-                fcpdl += diflen;
-        }
+        fcpdl = lpfc_bg_scsi_adjust_dl(phba, lpfc_cmd);
         fcp_cmnd->fcpDl = be32_to_cpu(fcpdl);
 
         /*
@@ -2812,14 +2969,234 @@ lpfc_bg_scsi_prep_dma_buf_s3(struct lpfc_hba *phba,
 
         return 0;
 err:
+        if (lpfc_cmd->seg_cnt)
+                scsi_dma_unmap(scsi_cmnd);
+        if (lpfc_cmd->prot_seg_cnt)
+                dma_unmap_sg(&phba->pcidev->dev, scsi_prot_sglist(scsi_cmnd),
+                             scsi_prot_sg_count(scsi_cmnd),
+                             scsi_cmnd->sc_data_direction);
+
         lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
-                        "9023 Could not setup all needed BDE's"
-                        "prot_group_type=%d, num_bde=%d\n",
+                        "9023 Cannot setup S/G List for HBA"
+                        "IO segs %d/%d BPL %d SCSI %d: %d %d\n",
+                        lpfc_cmd->seg_cnt, lpfc_cmd->prot_seg_cnt,
+                        phba->cfg_total_seg_cnt, phba->cfg_sg_seg_cnt,
                         prot_group_type, num_bde);
+
+        lpfc_cmd->seg_cnt = 0;
+        lpfc_cmd->prot_seg_cnt = 0;
         return 1;
 }
 
 /*
+ * This function calcuates the T10 DIF guard tag
+ * on the specified data using a CRC algorithmn
+ * using crc_t10dif.
+ */
+uint16_t
+lpfc_bg_crc(uint8_t *data, int count)
+{
+        uint16_t crc = 0;
+        uint16_t x;
+
+        crc = crc_t10dif(data, count);
+        x = cpu_to_be16(crc);
+        return x;
+}
+
+/*
+ * This function calcuates the T10 DIF guard tag
+ * on the specified data using a CSUM algorithmn
+ * using ip_compute_csum.
+ */
+uint16_t
+lpfc_bg_csum(uint8_t *data, int count)
+{
+        uint16_t ret;
+
+        ret = ip_compute_csum(data, count);
+        return ret;
+}
+
+/*
+ * This function examines the protection data to try to determine
+ * what type of T10-DIF error occurred.
+ */
+void
+lpfc_calc_bg_err(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
+{
+        struct scatterlist *sgpe; /* s/g prot entry */
+        struct scatterlist *sgde; /* s/g data entry */
+        struct scsi_cmnd *cmd = lpfc_cmd->pCmd;
+        struct scsi_dif_tuple *src = NULL;
+        uint8_t *data_src = NULL;
+        uint16_t guard_tag, guard_type;
+        uint16_t start_app_tag, app_tag;
+        uint32_t start_ref_tag, ref_tag;
+        int prot, protsegcnt;
+        int err_type, len, data_len;
+        int chk_ref, chk_app, chk_guard;
+        uint16_t sum;
+        unsigned blksize;
+
+        err_type = BGS_GUARD_ERR_MASK;
+        sum = 0;
+        guard_tag = 0;
+
+        /* First check to see if there is protection data to examine */
+        prot = scsi_get_prot_op(cmd);
+        if ((prot == SCSI_PROT_READ_STRIP) ||
+            (prot == SCSI_PROT_WRITE_INSERT) ||
+            (prot == SCSI_PROT_NORMAL))
+                goto out;
+
+        /* Currently the driver just supports ref_tag and guard_tag checking */
+        chk_ref = 1;
+        chk_app = 0;
+        chk_guard = 0;
+
+        /* Setup a ptr to the protection data provided by the SCSI host */
+        sgpe = scsi_prot_sglist(cmd);
+        protsegcnt = lpfc_cmd->prot_seg_cnt;
+
+        if (sgpe && protsegcnt) {
+
+                /*
+                 * We will only try to verify guard tag if the segment
+                 * data length is a multiple of the blksize.
+                 */
+                sgde = scsi_sglist(cmd);
+                blksize = lpfc_cmd_blksize(cmd);
+                data_src = (uint8_t *)sg_virt(sgde);
+                data_len = sgde->length;
+                if ((data_len & (blksize - 1)) == 0)
+                        chk_guard = 1;
+                guard_type = scsi_host_get_guard(cmd->device->host);
+
+                start_ref_tag = (uint32_t)scsi_get_lba(cmd); /* Truncate LBA */
+                start_app_tag = src->app_tag;
+                src = (struct scsi_dif_tuple *)sg_virt(sgpe);
+                len = sgpe->length;
+                while (src && protsegcnt) {
+                        while (len) {
+
+                                /*
+                                 * First check to see if a protection data
+                                 * check is valid
+                                 */
+                                if ((src->ref_tag == 0xffffffff) ||
+                                    (src->app_tag == 0xffff)) {
+                                        start_ref_tag++;
+                                        goto skipit;
+                                }
+
+                                /* App Tag checking */
+                                app_tag = src->app_tag;
+                                if (chk_app && (app_tag != start_app_tag)) {
+                                        err_type = BGS_APPTAG_ERR_MASK;
+                                        goto out;
+                                }
+
+                                /* Reference Tag checking */
+                                ref_tag = be32_to_cpu(src->ref_tag);
+                                if (chk_ref && (ref_tag != start_ref_tag)) {
+                                        err_type = BGS_REFTAG_ERR_MASK;
+                                        goto out;
+                                }
+                                start_ref_tag++;
+
+                                /* Guard Tag checking */
+                                if (chk_guard) {
+                                        guard_tag = src->guard_tag;
+                                        if (guard_type == SHOST_DIX_GUARD_IP)
+                                                sum = lpfc_bg_csum(data_src,
+                                                                   blksize);
+                                        else
+                                                sum = lpfc_bg_crc(data_src,
+                                                                  blksize);
+                                        if ((guard_tag != sum)) {
+                                                err_type = BGS_GUARD_ERR_MASK;
+                                                goto out;
+                                        }
+                                }
+skipit:
+                                len -= sizeof(struct scsi_dif_tuple);
+                                if (len < 0)
+                                        len = 0;
+                                src++;
+
+                                data_src += blksize;
+                                data_len -= blksize;
+
+                                /*
+                                 * Are we at the end of the Data segment?
+                                 * The data segment is only used for Guard
+                                 * tag checking.
+                                 */
+                                if (chk_guard && (data_len == 0)) {
+                                        chk_guard = 0;
+                                        sgde = sg_next(sgde);
+                                        if (!sgde)
+                                                goto out;
+
+                                        data_src = (uint8_t *)sg_virt(sgde);
+                                        data_len = sgde->length;
+                                        if ((data_len & (blksize - 1)) == 0)
+                                                chk_guard = 1;
+                                }
+                        }
+
+                        /* Goto the next Protection data segment */
+                        sgpe = sg_next(sgpe);
+                        if (sgpe) {
+                                src = (struct scsi_dif_tuple *)sg_virt(sgpe);
+                                len = sgpe->length;
+                        } else {
+                                src = NULL;
+                        }
+                        protsegcnt--;
+                }
+        }
+out:
+        if (err_type == BGS_GUARD_ERR_MASK) {
+                scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
+                                        0x10, 0x1);
+                cmd->result = DRIVER_SENSE << 24
+                        | ScsiResult(DID_ABORT, SAM_STAT_CHECK_CONDITION);
+                phba->bg_guard_err_cnt++;
+                lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
+                                "9069 BLKGRD: LBA %lx grd_tag error %x != %x\n",
+                                (unsigned long)scsi_get_lba(cmd),
+                                sum, guard_tag);
+
+        } else if (err_type == BGS_REFTAG_ERR_MASK) {
+                scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
+                                        0x10, 0x3);
+                cmd->result = DRIVER_SENSE << 24
+                        | ScsiResult(DID_ABORT, SAM_STAT_CHECK_CONDITION);
+
+                phba->bg_reftag_err_cnt++;
+                lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
+                                "9066 BLKGRD: LBA %lx ref_tag error %x != %x\n",
+                                (unsigned long)scsi_get_lba(cmd),
+                                ref_tag, start_ref_tag);
+
+        } else if (err_type == BGS_APPTAG_ERR_MASK) {
+                scsi_build_sense_buffer(1, cmd->sense_buffer, ILLEGAL_REQUEST,
+                                        0x10, 0x2);
+                cmd->result = DRIVER_SENSE << 24
+                        | ScsiResult(DID_ABORT, SAM_STAT_CHECK_CONDITION);
+
+                phba->bg_apptag_err_cnt++;
+                lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
+                                "9041 BLKGRD: LBA %lx app_tag error %x != %x\n",
+                                (unsigned long)scsi_get_lba(cmd),
+                                app_tag, start_app_tag);
+        }
+}
+
+
+/*
  * This function checks for BlockGuard errors detected by
  * the HBA.  In case of errors, the ASC/ASCQ fields in the
  * sense buffer will be set accordingly, paired with
@@ -2842,12 +3219,6 @@ lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd,
         uint32_t bgstat = bgf->bgstat;
         uint64_t failing_sector = 0;
 
-        lpfc_printf_log(phba, KERN_ERR, LOG_BG, "9069 BLKGRD: BG ERROR in cmd"
-                        " 0x%x lba 0x%llx blk cnt 0x%x "
-                        "bgstat=0x%x bghm=0x%x\n",
-                        cmd->cmnd[0], (unsigned long long)scsi_get_lba(cmd),
-                        blk_rq_sectors(cmd->request), bgstat, bghm);
-
         spin_lock(&_dump_buf_lock);
         if (!_dump_buf_done) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_BG,  "9070 BLKGRD: Saving"
@@ -2870,18 +3241,24 @@ lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd,
 
         if (lpfc_bgs_get_invalid_prof(bgstat)) {
                 cmd->result = ScsiResult(DID_ERROR, 0);
-                lpfc_printf_log(phba, KERN_ERR, LOG_BG, "9072 BLKGRD: Invalid"
-                        " BlockGuard profile. bgstat:0x%x\n",
-                        bgstat);
+                lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
+                                "9072 BLKGRD: Invalid BG Profile in cmd"
+                                " 0x%x lba 0x%llx blk cnt 0x%x "
+                                "bgstat=x%x bghm=x%x\n", cmd->cmnd[0],
+                                (unsigned long long)scsi_get_lba(cmd),
+                                blk_rq_sectors(cmd->request), bgstat, bghm);
                 ret = (-1);
                 goto out;
         }
 
         if (lpfc_bgs_get_uninit_dif_block(bgstat)) {
                 cmd->result = ScsiResult(DID_ERROR, 0);
-                lpfc_printf_log(phba, KERN_ERR, LOG_BG, "9073 BLKGRD: "
-                                "Invalid BlockGuard DIF Block. bgstat:0x%x\n",
-                                bgstat);
+                lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
+                                "9073 BLKGRD: Invalid BG PDIF Block in cmd"
+                                " 0x%x lba 0x%llx blk cnt 0x%x "
+                                "bgstat=x%x bghm=x%x\n", cmd->cmnd[0],
+                                (unsigned long long)scsi_get_lba(cmd),
+                                blk_rq_sectors(cmd->request), bgstat, bghm);
                 ret = (-1);
                 goto out;
         }
@@ -2894,8 +3271,12 @@ lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd,
                 cmd->result = DRIVER_SENSE << 24
                         | ScsiResult(DID_ABORT, SAM_STAT_CHECK_CONDITION);
                 phba->bg_guard_err_cnt++;
-                lpfc_printf_log(phba, KERN_ERR, LOG_BG,
-                        "9055 BLKGRD: guard_tag error\n");
+                lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
+                                "9055 BLKGRD: Guard Tag error in cmd"
+                                " 0x%x lba 0x%llx blk cnt 0x%x "
+                                "bgstat=x%x bghm=x%x\n", cmd->cmnd[0],
+                                (unsigned long long)scsi_get_lba(cmd),
+                                blk_rq_sectors(cmd->request), bgstat, bghm);
         }
 
         if (lpfc_bgs_get_reftag_err(bgstat)) {
@@ -2907,8 +3288,12 @@ lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd,
                         | ScsiResult(DID_ABORT, SAM_STAT_CHECK_CONDITION);
 
                 phba->bg_reftag_err_cnt++;
-                lpfc_printf_log(phba, KERN_ERR, LOG_BG,
-                        "9056 BLKGRD: ref_tag error\n");
+                lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
+                                "9056 BLKGRD: Ref Tag error in cmd"
+                                " 0x%x lba 0x%llx blk cnt 0x%x "
+                                "bgstat=x%x bghm=x%x\n", cmd->cmnd[0],
+                                (unsigned long long)scsi_get_lba(cmd),
+                                blk_rq_sectors(cmd->request), bgstat, bghm);
         }
 
         if (lpfc_bgs_get_apptag_err(bgstat)) {
@@ -2920,8 +3305,12 @@ lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd,
                         | ScsiResult(DID_ABORT, SAM_STAT_CHECK_CONDITION);
 
                 phba->bg_apptag_err_cnt++;
-                lpfc_printf_log(phba, KERN_ERR, LOG_BG,
-                        "9061 BLKGRD: app_tag error\n");
+                lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
+                                "9061 BLKGRD: App Tag error in cmd"
+                                " 0x%x lba 0x%llx blk cnt 0x%x "
+                                "bgstat=x%x bghm=x%x\n", cmd->cmnd[0],
+                                (unsigned long long)scsi_get_lba(cmd),
+                                blk_rq_sectors(cmd->request), bgstat, bghm);
         }
 
         if (lpfc_bgs_get_hi_water_mark_present(bgstat)) {
@@ -2960,11 +3349,16 @@ lpfc_parse_bg_err(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd,
 
         if (!ret) {
                 /* No error was reported - problem in FW? */
-                cmd->result = ScsiResult(DID_ERROR, 0);
-                lpfc_printf_log(phba, KERN_ERR, LOG_BG,
-                        "9057 BLKGRD: Unknown error reported!\n");
+                lpfc_printf_log(phba, KERN_WARNING, LOG_FCP | LOG_BG,
+                                "9057 BLKGRD: Unknown error in cmd"
+                                " 0x%x lba 0x%llx blk cnt 0x%x "
+                                "bgstat=x%x bghm=x%x\n", cmd->cmnd[0],
+                                (unsigned long long)scsi_get_lba(cmd),
+                                blk_rq_sectors(cmd->request), bgstat, bghm);
+
+                /* Calcuate what type of error it was */
+                lpfc_calc_bg_err(phba, lpfc_cmd);
         }
-
 out:
         return ret;
 }
@@ -3028,6 +3422,7 @@ lpfc_scsi_prep_dma_buf_s4(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
                                 "dma_map_sg.  Config %d, seg_cnt %d\n",
                                 __func__, phba->cfg_sg_seg_cnt,
                                lpfc_cmd->seg_cnt);
+                        lpfc_cmd->seg_cnt = 0;
                         scsi_dma_unmap(scsi_cmnd);
                         return 1;
                 }
@@ -3094,45 +3489,6 @@ lpfc_scsi_prep_dma_buf_s4(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
 }
 
 /**
- * lpfc_bg_scsi_adjust_dl - Adjust SCSI data length for BlockGuard
- * @phba: The Hba for which this call is being executed.
- * @lpfc_cmd: The scsi buffer which is going to be adjusted.
- *
- * Adjust the data length to account for how much data
- * is actually on the wire.
- *
- * returns the adjusted data length
- **/
-static int
-lpfc_bg_scsi_adjust_dl(struct lpfc_hba *phba,
-                struct lpfc_scsi_buf *lpfc_cmd)
-{
-        struct scsi_cmnd *sc = lpfc_cmd->pCmd;
-        int diflen, fcpdl;
-        unsigned blksize;
-
-        fcpdl = scsi_bufflen(sc);
-
-        /* Check if there is protection data on the wire */
-        if (sc->sc_data_direction == DMA_FROM_DEVICE) {
-                /* Read */
-                if (scsi_get_prot_op(sc) ==  SCSI_PROT_READ_INSERT)
-                        return fcpdl;
-
-        } else {
-                /* Write */
-                if (scsi_get_prot_op(sc) ==  SCSI_PROT_WRITE_STRIP)
-                        return fcpdl;
-        }
-
-        /* If protection data on the wire, adjust the count accordingly */
-        blksize = lpfc_cmd_blksize(sc);
-        diflen = (fcpdl / blksize) * 8;
-        fcpdl += diflen;
-        return fcpdl;
-}
-
-/**
  * lpfc_bg_scsi_prep_dma_buf_s4 - DMA mapping for scsi buffer to SLI4 IF spec
  * @phba: The Hba for which this call is being executed.
  * @lpfc_cmd: The scsi buffer which is going to be mapped.
@@ -3149,14 +3505,14 @@ lpfc_bg_scsi_prep_dma_buf_s4(struct lpfc_hba *phba,
         struct fcp_cmnd *fcp_cmnd = lpfc_cmd->fcp_cmnd;
         struct sli4_sge *sgl = (struct sli4_sge *)(lpfc_cmd->fcp_bpl);
         IOCB_t *iocb_cmd = &lpfc_cmd->cur_iocbq.iocb;
-        uint32_t num_bde = 0;
+        uint32_t num_sge = 0;
         int datasegcnt, protsegcnt, datadir = scsi_cmnd->sc_data_direction;
         int prot_group_type = 0;
         int fcpdl;
 
         /*
          * Start the lpfc command prep by bumping the sgl beyond fcp_cmnd
-         *  fcp_rsp regions to the first data bde entry
+         *  fcp_rsp regions to the first data sge entry
          */
         if (scsi_sg_count(scsi_cmnd)) {
                 /*
@@ -3179,28 +3535,28 @@ lpfc_bg_scsi_prep_dma_buf_s4(struct lpfc_hba *phba,
 
                 sgl += 1;
                 lpfc_cmd->seg_cnt = datasegcnt;
-                if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt) {
-                        lpfc_printf_log(phba, KERN_ERR, LOG_BG,
-                                        "9087 BLKGRD: %s: Too many sg segments"
-                                        " from dma_map_sg.  Config %d, seg_cnt"
-                                        " %d\n",
-                                        __func__, phba->cfg_sg_seg_cnt,
-                                        lpfc_cmd->seg_cnt);
-                        scsi_dma_unmap(scsi_cmnd);
-                        return 1;
-                }
+
+                /* First check if data segment count from SCSI Layer is good */
+                if (lpfc_cmd->seg_cnt > phba->cfg_sg_seg_cnt)
+                        goto err;
 
                 prot_group_type = lpfc_prot_group_type(phba, scsi_cmnd);
 
                 switch (prot_group_type) {
                 case LPFC_PG_TYPE_NO_DIF:
-                        num_bde = lpfc_bg_setup_sgl(phba, scsi_cmnd, sgl,
+                        /* Here we need to add a DISEED to the count */
+                        if ((lpfc_cmd->seg_cnt + 1) > phba->cfg_total_seg_cnt)
+                                goto err;
+
+                        num_sge = lpfc_bg_setup_sgl(phba, scsi_cmnd, sgl,
                                         datasegcnt);
+
                         /* we should have 2 or more entries in buffer list */
-                        if (num_bde < 2)
+                        if (num_sge < 2)
                                 goto err;
                         break;
-                case LPFC_PG_TYPE_DIF_BUF:{
+
+                case LPFC_PG_TYPE_DIF_BUF:
                         /*
                          * This type indicates that protection buffers are
                          * passed to the driver, so that needs to be prepared
@@ -3215,31 +3571,28 @@ lpfc_bg_scsi_prep_dma_buf_s4(struct lpfc_hba *phba,
                         }
 
                         lpfc_cmd->prot_seg_cnt = protsegcnt;
-                        if (lpfc_cmd->prot_seg_cnt
-                            > phba->cfg_prot_sg_seg_cnt) {
-                                lpfc_printf_log(phba, KERN_ERR, LOG_BG,
-                                        "9088 BLKGRD: %s: Too many prot sg "
-                                        "segments from dma_map_sg.  Config %d,"
-                                                "prot_seg_cnt %d\n", __func__,
-                                                phba->cfg_prot_sg_seg_cnt,
-                                                lpfc_cmd->prot_seg_cnt);
-                                dma_unmap_sg(&phba->pcidev->dev,
-                                             scsi_prot_sglist(scsi_cmnd),
-                                             scsi_prot_sg_count(scsi_cmnd),
-                                             datadir);
-                                scsi_dma_unmap(scsi_cmnd);
-                                return 1;
-                        }
+                        /*
+                         * There is a minimun of 3 SGEs used for every
+                         * protection data segment.
+                         */
+                        if ((lpfc_cmd->prot_seg_cnt * 3) >
+                            (phba->cfg_total_seg_cnt - 2))
+                                goto err;
 
-                        num_bde = lpfc_bg_setup_sgl_prot(phba, scsi_cmnd, sgl,
+                        num_sge = lpfc_bg_setup_sgl_prot(phba, scsi_cmnd, sgl,
                                         datasegcnt, protsegcnt);
+
                         /* we should have 3 or more entries in buffer list */
-                        if (num_bde < 3)
+                        if ((num_sge < 3) ||
+                            (num_sge > phba->cfg_total_seg_cnt))
                                 goto err;
                         break;
-                }
+
                 case LPFC_PG_TYPE_INVALID:
                 default:
+                        scsi_dma_unmap(scsi_cmnd);
+                        lpfc_cmd->seg_cnt = 0;
+
                         lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
                                         "9083 Unexpected protection group %i\n",
                                         prot_group_type);
@@ -3263,7 +3616,6 @@ lpfc_bg_scsi_prep_dma_buf_s4(struct lpfc_hba *phba,
         }
 
         fcpdl = lpfc_bg_scsi_adjust_dl(phba, lpfc_cmd);
-
         fcp_cmnd->fcpDl = be32_to_cpu(fcpdl);
 
         /*
@@ -3274,10 +3626,22 @@ lpfc_bg_scsi_prep_dma_buf_s4(struct lpfc_hba *phba,
 
         return 0;
 err:
+        if (lpfc_cmd->seg_cnt)
+                scsi_dma_unmap(scsi_cmnd);
+        if (lpfc_cmd->prot_seg_cnt)
+                dma_unmap_sg(&phba->pcidev->dev, scsi_prot_sglist(scsi_cmnd),
+                             scsi_prot_sg_count(scsi_cmnd),
+                             scsi_cmnd->sc_data_direction);
+
         lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
-                        "9084 Could not setup all needed BDE's"
-                        "prot_group_type=%d, num_bde=%d\n",
-                        prot_group_type, num_bde);
+                        "9084 Cannot setup S/G List for HBA"
+                        "IO segs %d/%d SGL %d SCSI %d: %d %d\n",
+                        lpfc_cmd->seg_cnt, lpfc_cmd->prot_seg_cnt,
+                        phba->cfg_total_seg_cnt, phba->cfg_sg_seg_cnt,
+                        prot_group_type, num_sge);
+
+        lpfc_cmd->seg_cnt = 0;
+        lpfc_cmd->prot_seg_cnt = 0;
         return 1;
 }
 
@@ -4357,7 +4721,8 @@ lpfc_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *cmnd)
 
         if (scsi_get_prot_op(cmnd) != SCSI_PROT_NORMAL) {
                 if (vport->phba->cfg_enable_bg) {
-                        lpfc_printf_vlog(vport, KERN_INFO, LOG_BG,
+                        lpfc_printf_vlog(vport,
+                                         KERN_INFO, LOG_SCSI_CMD,
                                          "9033 BLKGRD: rcvd %s cmd:x%x "
                                          "sector x%llx cnt %u pt %x\n",
                                          dif_op_str[scsi_get_prot_op(cmnd)],
@@ -4369,7 +4734,8 @@ lpfc_queuecommand(struct Scsi_Host *shost, struct scsi_cmnd *cmnd)
                 err = lpfc_bg_scsi_prep_dma_buf(phba, lpfc_cmd);
         } else {
                 if (vport->phba->cfg_enable_bg) {
-                        lpfc_printf_vlog(vport, KERN_INFO, LOG_BG,
+                        lpfc_printf_vlog(vport,
+                                         KERN_INFO, LOG_SCSI_CMD,
                                          "9038 BLKGRD: rcvd PROT_NORMAL cmd: "
                                          "x%x sector x%llx cnt %u pt %x\n",
                                          cmnd->cmnd[0],
@@ -4542,7 +4908,7 @@ lpfc_abort_handler(struct scsi_cmnd *cmnd)
         /* Wait for abort to complete */
         wait_event_timeout(waitq,
                           (lpfc_cmd->pCmd != cmnd),
-                           (2*vport->cfg_devloss_tmo*HZ));
+                           msecs_to_jiffies(2*vport->cfg_devloss_tmo*1000));
         lpfc_cmd->waitq = NULL;
 
         if (lpfc_cmd->pCmd == cmnd) {
@@ -5012,16 +5378,24 @@ lpfc_host_reset_handler(struct scsi_cmnd *cmnd)
         struct lpfc_hba *phba = vport->phba;
         int rc, ret = SUCCESS;
 
+        lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
+                         "3172 SCSI layer issued Host Reset Data:\n");
+
         lpfc_offline_prep(phba, LPFC_MBX_WAIT);
         lpfc_offline(phba);
         rc = lpfc_sli_brdrestart(phba);
         if (rc)
                 ret = FAILED;
-        lpfc_online(phba);
+        rc = lpfc_online(phba);
+        if (rc)
+                ret = FAILED;
         lpfc_unblock_mgmt_io(phba);
 
-        lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
-                        "3172 SCSI layer issued Host Reset Data: x%x\n", ret);
+        if (ret == FAILED) {
+                lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
+                                 "3323 Failed host reset, bring it offline\n");
+                lpfc_sli4_offline_eratt(phba);
+        }
         return ret;
 }
 
@@ -5088,11 +5462,11 @@ lpfc_slave_alloc(struct scsi_device *sdev)
         }
         num_allocated = lpfc_new_scsi_buf(vport, num_to_alloc);
         if (num_to_alloc != num_allocated) {
-                        lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
-                                 "0708 Allocation request of %d "
-                                 "command buffers did not succeed.  "
-                                 "Allocated %d buffers.\n",
-                                 num_to_alloc, num_allocated);
+                        lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
+                                         "0708 Allocation request of %d "
+                                         "command buffers did not succeed.  "
+                                         "Allocated %d buffers.\n",
+                                         num_to_alloc, num_allocated);
         }
         if (num_allocated > 0)
                 phba->total_scsi_bufs += num_allocated;
diff --git a/drivers/scsi/lpfc/lpfc_sli.c b/drivers/scsi/lpfc/lpfc_sli.c
index 35dd17eb0f27..572579f87de4 100644
--- a/drivers/scsi/lpfc/lpfc_sli.c
+++ b/drivers/scsi/lpfc/lpfc_sli.c
@@ -667,7 +667,7 @@ lpfc_handle_rrq_active(struct lpfc_hba *phba)
 
         spin_lock_irqsave(&phba->hbalock, iflags);
         phba->hba_flag &= ~HBA_RRQ_ACTIVE;
-        next_time = jiffies + HZ * (phba->fc_ratov + 1);
+        next_time = jiffies + msecs_to_jiffies(1000 * (phba->fc_ratov + 1));
         list_for_each_entry_safe(rrq, nextrrq,
                                  &phba->active_rrq_list, list) {
                 if (time_after(jiffies, rrq->rrq_stop_time))
@@ -782,7 +782,7 @@ lpfc_cleanup_wt_rrqs(struct lpfc_hba *phba)
                 return;
         spin_lock_irqsave(&phba->hbalock, iflags);
         phba->hba_flag &= ~HBA_RRQ_ACTIVE;
-        next_time = jiffies + HZ * (phba->fc_ratov * 2);
+        next_time = jiffies + msecs_to_jiffies(1000 * (phba->fc_ratov * 2));
         list_splice_init(&phba->active_rrq_list, &rrq_list);
         spin_unlock_irqrestore(&phba->hbalock, iflags);
 
@@ -878,7 +878,8 @@ lpfc_set_rrq_active(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
         else
                 rrq->send_rrq = 0;
         rrq->xritag = xritag;
-        rrq->rrq_stop_time = jiffies + HZ * (phba->fc_ratov + 1);
+        rrq->rrq_stop_time = jiffies +
+                                msecs_to_jiffies(1000 * (phba->fc_ratov + 1));
         rrq->ndlp = ndlp;
         rrq->nlp_DID = ndlp->nlp_DID;
         rrq->vport = ndlp->vport;
@@ -926,8 +927,7 @@ __lpfc_sli_get_sglq(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq)
         } else  if ((piocbq->iocb.ulpCommand == CMD_GEN_REQUEST64_CR) &&
                         !(piocbq->iocb_flag & LPFC_IO_LIBDFC))
                 ndlp = piocbq->context_un.ndlp;
-        else  if ((piocbq->iocb.ulpCommand == CMD_ELS_REQUEST64_CR) &&
-                        (piocbq->iocb_flag & LPFC_IO_LIBDFC))
+        else  if (piocbq->iocb_flag & LPFC_IO_LIBDFC)
                 ndlp = piocbq->context_un.ndlp;
         else
                 ndlp = piocbq->context1;
@@ -1339,7 +1339,8 @@ lpfc_sli_ringtxcmpl_put(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
                         BUG();
                 else
                         mod_timer(&piocb->vport->els_tmofunc,
-                                  jiffies + HZ * (phba->fc_ratov << 1));
+                                jiffies +
+                                msecs_to_jiffies(1000 * (phba->fc_ratov << 1)));
         }
 
 
@@ -2340,7 +2341,8 @@ lpfc_sli_handle_mb_event(struct lpfc_hba *phba)
                 /* Mailbox cmd <cmd> Cmpl <cmpl> */
                 lpfc_printf_log(phba, KERN_INFO, LOG_MBOX | LOG_SLI,
                                 "(%d):0307 Mailbox cmd x%x (x%x/x%x) Cmpl x%p "
-                                "Data: x%x x%x x%x x%x x%x x%x x%x x%x x%x\n",
+                                "Data: x%x x%x x%x x%x x%x x%x x%x x%x x%x "
+                                "x%x x%x x%x\n",
                                 pmb->vport ? pmb->vport->vpi : 0,
                                 pmbox->mbxCommand,
                                 lpfc_sli_config_mbox_subsys_get(phba, pmb),
@@ -2354,7 +2356,10 @@ lpfc_sli_handle_mb_event(struct lpfc_hba *phba)
                                 pmbox->un.varWords[4],
                                 pmbox->un.varWords[5],
                                 pmbox->un.varWords[6],
-                                pmbox->un.varWords[7]);
+                                pmbox->un.varWords[7],
+                                pmbox->un.varWords[8],
+                                pmbox->un.varWords[9],
+                                pmbox->un.varWords[10]);
 
                 if (pmb->mbox_cmpl)
                         pmb->mbox_cmpl(phba,pmb);
@@ -2908,8 +2913,9 @@ void lpfc_poll_eratt(unsigned long ptr)
                 lpfc_worker_wake_up(phba);
         else
                 /* Restart the timer for next eratt poll */
-                mod_timer(&phba->eratt_poll, jiffies +
-                                        HZ * LPFC_ERATT_POLL_INTERVAL);
+                mod_timer(&phba->eratt_poll,
+                          jiffies +
+                          msecs_to_jiffies(1000 * LPFC_ERATT_POLL_INTERVAL));
         return;
 }
 
@@ -5511,6 +5517,7 @@ lpfc_sli4_dealloc_extent(struct lpfc_hba *phba, uint16_t type)
                         list_del_init(&rsrc_blk->list);
                         kfree(rsrc_blk);
                 }
+                phba->sli4_hba.max_cfg_param.vpi_used = 0;
                 break;
         case LPFC_RSC_TYPE_FCOE_XRI:
                 kfree(phba->sli4_hba.xri_bmask);
@@ -5811,6 +5818,7 @@ lpfc_sli4_dealloc_resource_identifiers(struct lpfc_hba *phba)
                 lpfc_sli4_dealloc_extent(phba, LPFC_RSC_TYPE_FCOE_VFI);
         } else {
                 kfree(phba->vpi_bmask);
+                phba->sli4_hba.max_cfg_param.vpi_used = 0;
                 kfree(phba->vpi_ids);
                 bf_set(lpfc_vpi_rsrc_rdy, &phba->sli4_hba.sli4_flags, 0);
                 kfree(phba->sli4_hba.xri_bmask);
@@ -5992,7 +6000,7 @@ lpfc_sli4_repost_els_sgl_list(struct lpfc_hba *phba)
         struct lpfc_sglq *sglq_entry = NULL;
         struct lpfc_sglq *sglq_entry_next = NULL;
         struct lpfc_sglq *sglq_entry_first = NULL;
-        int status, post_cnt = 0, num_posted = 0, block_cnt = 0;
+        int status, total_cnt, post_cnt = 0, num_posted = 0, block_cnt = 0;
         int last_xritag = NO_XRI;
         LIST_HEAD(prep_sgl_list);
         LIST_HEAD(blck_sgl_list);
@@ -6004,6 +6012,7 @@ lpfc_sli4_repost_els_sgl_list(struct lpfc_hba *phba)
         list_splice_init(&phba->sli4_hba.lpfc_sgl_list, &allc_sgl_list);
         spin_unlock_irq(&phba->hbalock);
 
+        total_cnt = phba->sli4_hba.els_xri_cnt;
         list_for_each_entry_safe(sglq_entry, sglq_entry_next,
                                  &allc_sgl_list, list) {
                 list_del_init(&sglq_entry->list);
@@ -6055,9 +6064,7 @@ lpfc_sli4_repost_els_sgl_list(struct lpfc_hba *phba)
                                                 sglq_entry->sli4_xritag);
                                         list_add_tail(&sglq_entry->list,
                                                       &free_sgl_list);
-                                        spin_lock_irq(&phba->hbalock);
-                                        phba->sli4_hba.els_xri_cnt--;
-                                        spin_unlock_irq(&phba->hbalock);
+                                        total_cnt--;
                                 }
                         }
                 }
@@ -6085,9 +6092,7 @@ lpfc_sli4_repost_els_sgl_list(struct lpfc_hba *phba)
                                         (sglq_entry_first->sli4_xritag +
                                          post_cnt - 1));
                         list_splice_init(&blck_sgl_list, &free_sgl_list);
-                        spin_lock_irq(&phba->hbalock);
-                        phba->sli4_hba.els_xri_cnt -= post_cnt;
-                        spin_unlock_irq(&phba->hbalock);
+                        total_cnt -= post_cnt;
                 }
 
                 /* don't reset xirtag due to hole in xri block */
@@ -6097,6 +6102,8 @@ lpfc_sli4_repost_els_sgl_list(struct lpfc_hba *phba)
                 /* reset els sgl post count for next round of posting */
                 post_cnt = 0;
         }
+        /* update the number of XRIs posted for ELS */
+        phba->sli4_hba.els_xri_cnt = total_cnt;
 
         /* free the els sgls failed to post */
         lpfc_free_sgl_list(phba, &free_sgl_list);
@@ -6446,16 +6453,17 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
 
         /* Start the ELS watchdog timer */
         mod_timer(&vport->els_tmofunc,
-                  jiffies + HZ * (phba->fc_ratov * 2));
+                  jiffies + msecs_to_jiffies(1000 * (phba->fc_ratov * 2)));
 
         /* Start heart beat timer */
         mod_timer(&phba->hb_tmofunc,
-                  jiffies + HZ * LPFC_HB_MBOX_INTERVAL);
+                  jiffies + msecs_to_jiffies(1000 * LPFC_HB_MBOX_INTERVAL));
         phba->hb_outstanding = 0;
         phba->last_completion_time = jiffies;
 
         /* Start error attention (ERATT) polling timer */
-        mod_timer(&phba->eratt_poll, jiffies + HZ * LPFC_ERATT_POLL_INTERVAL);
+        mod_timer(&phba->eratt_poll,
+                  jiffies + msecs_to_jiffies(1000 * LPFC_ERATT_POLL_INTERVAL));
 
         /* Enable PCIe device Advanced Error Reporting (AER) if configured */
         if (phba->cfg_aer_support == 1 && !(phba->hba_flag & HBA_AER_ENABLED)) {
@@ -6822,8 +6830,9 @@ lpfc_sli_issue_mbox_s3(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmbox,
                         goto out_not_finished;
                 }
                 /* timeout active mbox command */
-                mod_timer(&psli->mbox_tmo, (jiffies +
-                               (HZ * lpfc_mbox_tmo_val(phba, pmbox))));
+                timeout = msecs_to_jiffies(lpfc_mbox_tmo_val(phba, pmbox) *
+                                           1000);
+                mod_timer(&psli->mbox_tmo, jiffies + timeout);
         }
 
         /* Mailbox cmd <cmd> issue */
@@ -7496,7 +7505,7 @@ lpfc_sli4_post_async_mbox(struct lpfc_hba *phba)
 
         /* Start timer for the mbox_tmo and log some mailbox post messages */
         mod_timer(&psli->mbox_tmo, (jiffies +
-                  (HZ * lpfc_mbox_tmo_val(phba, mboxq))));
+                  msecs_to_jiffies(1000 * lpfc_mbox_tmo_val(phba, mboxq))));
 
         lpfc_printf_log(phba, KERN_INFO, LOG_MBOX | LOG_SLI,
                         "(%d):0355 Mailbox cmd x%x (x%x/x%x) issue Data: "
@@ -7914,15 +7923,21 @@ lpfc_sli4_bpl2sgl(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq,
 static inline uint32_t
 lpfc_sli4_scmd_to_wqidx_distr(struct lpfc_hba *phba)
 {
-        int i;
-
-        if (phba->cfg_fcp_io_sched == LPFC_FCP_SCHED_BY_CPU)
-                i = smp_processor_id();
-        else
-                i = atomic_add_return(1, &phba->fcp_qidx);
+        struct lpfc_vector_map_info *cpup;
+        int chann, cpu;
 
-        i = (i % phba->cfg_fcp_io_channel);
-        return i;
+        if (phba->cfg_fcp_io_sched == LPFC_FCP_SCHED_BY_CPU) {
+                cpu = smp_processor_id();
+                if (cpu < phba->sli4_hba.num_present_cpu) {
+                        cpup = phba->sli4_hba.cpu_map;
+                        cpup += cpu;
+                        return cpup->channel_id;
+                }
+                chann = cpu;
+        }
+        chann = atomic_add_return(1, &phba->fcp_qidx);
+        chann = (chann % phba->cfg_fcp_io_channel);
+        return chann;
 }
 
 /**
@@ -8444,10 +8459,14 @@ __lpfc_sli_issue_iocb_s4(struct lpfc_hba *phba, uint32_t ring_number,
 
         if ((piocb->iocb_flag & LPFC_IO_FCP) ||
                 (piocb->iocb_flag & LPFC_USE_FCPWQIDX)) {
+                if (unlikely(!phba->sli4_hba.fcp_wq))
+                        return IOCB_ERROR;
                 if (lpfc_sli4_wq_put(phba->sli4_hba.fcp_wq[piocb->fcp_wqidx],
                                      &wqe))
                         return IOCB_ERROR;
         } else {
+                if (unlikely(!phba->sli4_hba.els_wq))
+                        return IOCB_ERROR;
                 if (lpfc_sli4_wq_put(phba->sli4_hba.els_wq, &wqe))
                         return IOCB_ERROR;
         }
@@ -10003,7 +10022,7 @@ lpfc_sli_issue_iocb_wait(struct lpfc_hba *phba,
         retval = lpfc_sli_issue_iocb(phba, ring_number, piocb,
                                      SLI_IOCB_RET_IOCB);
         if (retval == IOCB_SUCCESS) {
-                timeout_req = timeout * HZ;
+                timeout_req = msecs_to_jiffies(timeout * 1000);
                 timeleft = wait_event_timeout(done_q,
                                 lpfc_chk_iocb_flg(phba, piocb, LPFC_IO_WAKE),
                                 timeout_req);
@@ -10108,7 +10127,7 @@ lpfc_sli_issue_mbox_wait(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq,
         if (retval == MBX_BUSY || retval == MBX_SUCCESS) {
                 wait_event_interruptible_timeout(done_q,
                                 pmboxq->mbox_flag & LPFC_MBX_WAKE,
-                                timeout * HZ);
+                                msecs_to_jiffies(timeout * 1000));
 
                 spin_lock_irqsave(&phba->hbalock, flag);
                 pmboxq->context1 = NULL;
@@ -12899,8 +12918,9 @@ lpfc_wq_create(struct lpfc_hba *phba, struct lpfc_queue *wq,
                 }
                 wq->db_regaddr = bar_memmap_p + db_offset;
                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
-                                "3264 WQ[%d]: barset:x%x, offset:x%x\n",
-                                wq->queue_id, pci_barset, db_offset);
+                                "3264 WQ[%d]: barset:x%x, offset:x%x, "
+                                "format:x%x\n", wq->queue_id, pci_barset,
+                                db_offset, wq->db_format);
         } else {
                 wq->db_format = LPFC_DB_LIST_FORMAT;
                 wq->db_regaddr = phba->sli4_hba.WQDBregaddr;
@@ -13120,8 +13140,9 @@ lpfc_rq_create(struct lpfc_hba *phba, struct lpfc_queue *hrq,
                 }
                 hrq->db_regaddr = bar_memmap_p + db_offset;
                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
-                                "3266 RQ[qid:%d]: barset:x%x, offset:x%x\n",
-                                hrq->queue_id, pci_barset, db_offset);
+                                "3266 RQ[qid:%d]: barset:x%x, offset:x%x, "
+                                "format:x%x\n", hrq->queue_id, pci_barset,
+                                db_offset, hrq->db_format);
         } else {
                 hrq->db_format = LPFC_DB_RING_FORMAT;
                 hrq->db_regaddr = phba->sli4_hba.RQDBregaddr;
@@ -13971,13 +13992,14 @@ lpfc_fc_frame_check(struct lpfc_hba *phba, struct fc_frame_header *fc_hdr)
         }
 
         lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
-                        "2538 Received frame rctl:%s type:%s "
-                        "Frame Data:%08x %08x %08x %08x %08x %08x\n",
-                        rctl_names[fc_hdr->fh_r_ctl],
-                        type_names[fc_hdr->fh_type],
+                        "2538 Received frame rctl:%s (x%x), type:%s (x%x), "
+                        "frame Data:%08x %08x %08x %08x %08x %08x %08x\n",
+                        rctl_names[fc_hdr->fh_r_ctl], fc_hdr->fh_r_ctl,
+                        type_names[fc_hdr->fh_type], fc_hdr->fh_type,
                         be32_to_cpu(header[0]), be32_to_cpu(header[1]),
                         be32_to_cpu(header[2]), be32_to_cpu(header[3]),
-                        be32_to_cpu(header[4]), be32_to_cpu(header[5]));
+                        be32_to_cpu(header[4]), be32_to_cpu(header[5]),
+                        be32_to_cpu(header[6]));
         return 0;
 drop:
         lpfc_printf_log(phba, KERN_WARNING, LOG_ELS,
diff --git a/drivers/scsi/lpfc/lpfc_sli4.h b/drivers/scsi/lpfc/lpfc_sli4.h
index be02b59ea279..67af460184ba 100644
--- a/drivers/scsi/lpfc/lpfc_sli4.h
+++ b/drivers/scsi/lpfc/lpfc_sli4.h
@@ -346,11 +346,6 @@ struct lpfc_bmbx {
 #define SLI4_CT_VFI 2
 #define SLI4_CT_FCFI 3
 
-#define LPFC_SLI4_FL1_MAX_SEGMENT_SIZE  0x10000
-#define LPFC_SLI4_FL1_MAX_BUF_SIZE      0X2000
-#define LPFC_SLI4_MIN_BUF_SIZE          0x400
-#define LPFC_SLI4_MAX_BUF_SIZE          0x20000
-
 /*
  * SLI4 specific data structures
  */
@@ -440,6 +435,17 @@ struct lpfc_sli4_lnk_info {
 
 #define LPFC_SLI4_HANDLER_NAME_SZ       16
 
+/* Used for IRQ vector to CPU mapping */
+struct lpfc_vector_map_info {
+        uint16_t        phys_id;
+        uint16_t        core_id;
+        uint16_t        irq;
+        uint16_t        channel_id;
+        struct cpumask  maskbits;
+};
+#define LPFC_VECTOR_MAP_EMPTY   0xffff
+#define LPFC_MAX_CPU            256
+
 /* SLI4 HBA data structure entries */
 struct lpfc_sli4_hba {
         void __iomem *conf_regs_memmap_p; /* Kernel memory mapped address for
@@ -573,6 +579,11 @@ struct lpfc_sli4_hba {
         struct lpfc_iov iov;
         spinlock_t abts_scsi_buf_list_lock; /* list of aborted SCSI IOs */
         spinlock_t abts_sgl_list_lock; /* list of aborted els IOs */
+
+        /* CPU to vector mapping information */
+        struct lpfc_vector_map_info *cpu_map;
+        uint16_t num_online_cpu;
+        uint16_t num_present_cpu;
 };
 
 enum lpfc_sge_type {
diff --git a/drivers/scsi/lpfc/lpfc_version.h b/drivers/scsi/lpfc/lpfc_version.h
index 664cd04f7cd8..a38dc3b16969 100644
--- a/drivers/scsi/lpfc/lpfc_version.h
+++ b/drivers/scsi/lpfc/lpfc_version.h
@@ -18,7 +18,7 @@
  * included with this package.                                     *
  *******************************************************************/
 
-#define LPFC_DRIVER_VERSION "8.3.38"
+#define LPFC_DRIVER_VERSION "8.3.39"
 #define LPFC_DRIVER_NAME                "lpfc"
 
 /* Used for SLI 2/3 */
diff --git a/drivers/scsi/lpfc/lpfc_vport.c b/drivers/scsi/lpfc/lpfc_vport.c
index 0fe188e66000..e28e431564b0 100644
--- a/drivers/scsi/lpfc/lpfc_vport.c
+++ b/drivers/scsi/lpfc/lpfc_vport.c
@@ -80,7 +80,7 @@ inline void lpfc_vport_set_state(struct lpfc_vport *vport,
         }
 }
 
-static int
+int
 lpfc_alloc_vpi(struct lpfc_hba *phba)
 {
         unsigned long vpi;
@@ -568,6 +568,7 @@ lpfc_vport_delete(struct fc_vport *fc_vport)
         struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
         struct lpfc_hba   *phba = vport->phba;
         long timeout;
+        bool ns_ndlp_referenced = false;
 
         if (vport->port_type == LPFC_PHYSICAL_PORT) {
                 lpfc_printf_vlog(vport, KERN_ERR, LOG_VPORT,
@@ -628,6 +629,18 @@ lpfc_vport_delete(struct fc_vport *fc_vport)
 
         lpfc_debugfs_terminate(vport);
 
+        /*
+         * The call to fc_remove_host might release the NameServer ndlp. Since
+         * we might need to use the ndlp to send the DA_ID CT command,
+         * increment the reference for the NameServer ndlp to prevent it from
+         * being released.
+         */
+        ndlp = lpfc_findnode_did(vport, NameServer_DID);
+        if (ndlp && NLP_CHK_NODE_ACT(ndlp)) {
+                lpfc_nlp_get(ndlp);
+                ns_ndlp_referenced = true;
+        }
+
         /* Remove FC host and then SCSI host with the vport */
         fc_remove_host(lpfc_shost_from_vport(vport));
         scsi_remove_host(lpfc_shost_from_vport(vport));
@@ -734,6 +747,16 @@ lpfc_vport_delete(struct fc_vport *fc_vport)
                 lpfc_discovery_wait(vport);
 
 skip_logo:
+
+        /*
+         * If the NameServer ndlp has been incremented to allow the DA_ID CT
+         * command to be sent, decrement the ndlp now.
+         */
+        if (ns_ndlp_referenced) {
+                ndlp = lpfc_findnode_did(vport, NameServer_DID);
+                lpfc_nlp_put(ndlp);
+        }
+
         lpfc_cleanup(vport);
         lpfc_sli_host_down(vport);
 
diff --git a/drivers/scsi/lpfc/lpfc_vport.h b/drivers/scsi/lpfc/lpfc_vport.h
index 90828340acea..6b2c94eb8134 100644
--- a/drivers/scsi/lpfc/lpfc_vport.h
+++ b/drivers/scsi/lpfc/lpfc_vport.h
@@ -90,6 +90,7 @@ int lpfc_vport_getinfo(struct Scsi_Host *, struct vport_info *);
 int lpfc_vport_tgt_remove(struct Scsi_Host *, uint, uint);
 struct lpfc_vport **lpfc_create_vport_work_array(struct lpfc_hba *);
 void lpfc_destroy_vport_work_array(struct lpfc_hba *, struct lpfc_vport **);
+int lpfc_alloc_vpi(struct lpfc_hba *phba);
 
 /*
  *  queuecommand  VPORT-specific return codes. Specified in  the host byte code.
diff --git a/drivers/scsi/megaraid/megaraid_sas_base.c b/drivers/scsi/megaraid/megaraid_sas_base.c
index 7c90d57b867e..3a9ddae86f1f 100644
--- a/drivers/scsi/megaraid/megaraid_sas_base.c
+++ b/drivers/scsi/megaraid/megaraid_sas_base.c
@@ -4931,11 +4931,12 @@ static int megasas_mgmt_ioctl_fw(struct file *file, unsigned long arg)
                 printk(KERN_ERR "megaraid_sas: timed out while"
                         "waiting for HBA to recover\n");
                 error = -ENODEV;
-                goto out_kfree_ioc;
+                goto out_up;
         }
         spin_unlock_irqrestore(&instance->hba_lock, flags);
 
         error = megasas_mgmt_fw_ioctl(instance, user_ioc, ioc);
+      out_up:
         up(&instance->ioctl_sem);
 
       out_kfree_ioc:
diff --git a/drivers/scsi/mvsas/mv_init.c b/drivers/scsi/mvsas/mv_init.c
index 74550922ad55..7b7381d7671f 100644
--- a/drivers/scsi/mvsas/mv_init.c
+++ b/drivers/scsi/mvsas/mv_init.c
@@ -254,7 +254,7 @@ static int mvs_alloc(struct mvs_info *mvi, struct Scsi_Host *shost)
         }
         for (i = 0; i < MVS_MAX_DEVICES; i++) {
                 mvi->devices[i].taskfileset = MVS_ID_NOT_MAPPED;
-                mvi->devices[i].dev_type = NO_DEVICE;
+                mvi->devices[i].dev_type = SAS_PHY_UNUSED;
                 mvi->devices[i].device_id = i;
                 mvi->devices[i].dev_status = MVS_DEV_NORMAL;
                 init_timer(&mvi->devices[i].timer);
diff --git a/drivers/scsi/mvsas/mv_sas.c b/drivers/scsi/mvsas/mv_sas.c
index 532110f4562a..c9e244984e30 100644
--- a/drivers/scsi/mvsas/mv_sas.c
+++ b/drivers/scsi/mvsas/mv_sas.c
@@ -706,7 +706,7 @@ static int mvs_task_prep_ssp(struct mvs_info *mvi,
         return 0;
 }
 
-#define DEV_IS_GONE(mvi_dev)    ((!mvi_dev || (mvi_dev->dev_type == NO_DEVICE)))
+#define DEV_IS_GONE(mvi_dev)    ((!mvi_dev || (mvi_dev->dev_type == SAS_PHY_UNUSED)))
 static int mvs_task_prep(struct sas_task *task, struct mvs_info *mvi, int is_tmf,
                                 struct mvs_tmf_task *tmf, int *pass)
 {
@@ -726,7 +726,7 @@ static int mvs_task_prep(struct sas_task *task, struct mvs_info *mvi, int is_tmf
                  * libsas will use dev->port, should
                  * not call task_done for sata
                  */
-                if (dev->dev_type != SATA_DEV)
+                if (dev->dev_type != SAS_SATA_DEV)
                         task->task_done(task);
                 return rc;
         }
@@ -1159,10 +1159,10 @@ void mvs_update_phyinfo(struct mvs_info *mvi, int i, int get_st)
                         phy->identify.device_type =
                                 phy->att_dev_info & PORT_DEV_TYPE_MASK;
 
-                        if (phy->identify.device_type == SAS_END_DEV)
+                        if (phy->identify.device_type == SAS_END_DEVICE)
                                 phy->identify.target_port_protocols =
                                                         SAS_PROTOCOL_SSP;
-                        else if (phy->identify.device_type != NO_DEVICE)
+                        else if (phy->identify.device_type != SAS_PHY_UNUSED)
                                 phy->identify.target_port_protocols =
                                                         SAS_PROTOCOL_SMP;
                         if (oob_done)
@@ -1260,7 +1260,7 @@ struct mvs_device *mvs_alloc_dev(struct mvs_info *mvi)
 {
         u32 dev;
         for (dev = 0; dev < MVS_MAX_DEVICES; dev++) {
-                if (mvi->devices[dev].dev_type == NO_DEVICE) {
+                if (mvi->devices[dev].dev_type == SAS_PHY_UNUSED) {
                         mvi->devices[dev].device_id = dev;
                         return &mvi->devices[dev];
                 }
@@ -1278,7 +1278,7 @@ void mvs_free_dev(struct mvs_device *mvi_dev)
         u32 id = mvi_dev->device_id;
         memset(mvi_dev, 0, sizeof(*mvi_dev));
         mvi_dev->device_id = id;
-        mvi_dev->dev_type = NO_DEVICE;
+        mvi_dev->dev_type = SAS_PHY_UNUSED;
         mvi_dev->dev_status = MVS_DEV_NORMAL;
         mvi_dev->taskfileset = MVS_ID_NOT_MAPPED;
 }
@@ -1480,7 +1480,7 @@ static int mvs_debug_I_T_nexus_reset(struct domain_device *dev)
 {
         int rc;
         struct sas_phy *phy = sas_get_local_phy(dev);
-        int reset_type = (dev->dev_type == SATA_DEV ||
+        int reset_type = (dev->dev_type == SAS_SATA_DEV ||
                         (dev->tproto & SAS_PROTOCOL_STP)) ? 0 : 1;
         rc = sas_phy_reset(phy, reset_type);
         sas_put_local_phy(phy);
@@ -1629,7 +1629,7 @@ int mvs_abort_task(struct sas_task *task)
 
         } else if (task->task_proto & SAS_PROTOCOL_SATA ||
                 task->task_proto & SAS_PROTOCOL_STP) {
-                if (SATA_DEV == dev->dev_type) {
+                if (SAS_SATA_DEV == dev->dev_type) {
                         struct mvs_slot_info *slot = task->lldd_task;
                         u32 slot_idx = (u32)(slot - mvi->slot_info);
                         mv_dprintk("mvs_abort_task() mvi=%p task=%p "
diff --git a/drivers/scsi/mvsas/mv_sas.h b/drivers/scsi/mvsas/mv_sas.h
index 9f3cc13a5ce7..60e2fb7f2dca 100644
--- a/drivers/scsi/mvsas/mv_sas.h
+++ b/drivers/scsi/mvsas/mv_sas.h
@@ -67,7 +67,7 @@ extern const struct mvs_dispatch mvs_94xx_dispatch;
 extern struct kmem_cache *mvs_task_list_cache;
 
 #define DEV_IS_EXPANDER(type)   \
-        ((type == EDGE_DEV) || (type == FANOUT_DEV))
+        ((type == SAS_EDGE_EXPANDER_DEVICE) || (type == SAS_FANOUT_EXPANDER_DEVICE))
 
 #define bit(n) ((u64)1 << n)
 
@@ -241,7 +241,7 @@ struct mvs_phy {
 
 struct mvs_device {
         struct list_head                dev_entry;
-        enum sas_dev_type dev_type;
+        enum sas_device_type dev_type;
         struct mvs_info *mvi_info;
         struct domain_device *sas_device;
         struct timer_list timer;
diff --git a/drivers/scsi/pm8001/Makefile b/drivers/scsi/pm8001/Makefile
index 52f04296171c..ce4cd87c7c66 100644
--- a/drivers/scsi/pm8001/Makefile
+++ b/drivers/scsi/pm8001/Makefile
@@ -4,9 +4,10 @@
 # Copyright (C) 2008-2009  USI Co., Ltd.
 
 
-obj-$(CONFIG_SCSI_PM8001) += pm8001.o
-pm8001-y += pm8001_init.o \
+obj-$(CONFIG_SCSI_PM8001) += pm80xx.o
+pm80xx-y += pm8001_init.o \
                 pm8001_sas.o  \
                 pm8001_ctl.o  \
-                pm8001_hwi.o
+                pm8001_hwi.o  \
+                pm80xx_hwi.o
 
diff --git a/drivers/scsi/pm8001/pm8001_ctl.c b/drivers/scsi/pm8001/pm8001_ctl.c
index 45bc197bc22f..d99f41c2ca13 100644
--- a/drivers/scsi/pm8001/pm8001_ctl.c
+++ b/drivers/scsi/pm8001/pm8001_ctl.c
@@ -1,5 +1,5 @@
 /*
- * PMC-Sierra SPC 8001 SAS/SATA based host adapters driver
+ * PMC-Sierra 8001/8081/8088/8089 SAS/SATA based host adapters driver
  *
  * Copyright (c) 2008-2009 USI Co., Ltd.
  * All rights reserved.
@@ -58,8 +58,13 @@ static ssize_t pm8001_ctl_mpi_interface_rev_show(struct device *cdev,
         struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
         struct pm8001_hba_info *pm8001_ha = sha->lldd_ha;
 
-        return snprintf(buf, PAGE_SIZE, "%d\n",
-                pm8001_ha->main_cfg_tbl.interface_rev);
+        if (pm8001_ha->chip_id == chip_8001) {
+                return snprintf(buf, PAGE_SIZE, "%d\n",
+                        pm8001_ha->main_cfg_tbl.pm8001_tbl.interface_rev);
+        } else {
+                return snprintf(buf, PAGE_SIZE, "%d\n",
+                        pm8001_ha->main_cfg_tbl.pm80xx_tbl.interface_rev);
+        }
 }
 static
 DEVICE_ATTR(interface_rev, S_IRUGO, pm8001_ctl_mpi_interface_rev_show, NULL);
@@ -78,11 +83,19 @@ static ssize_t pm8001_ctl_fw_version_show(struct device *cdev,
         struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
         struct pm8001_hba_info *pm8001_ha = sha->lldd_ha;
 
-        return snprintf(buf, PAGE_SIZE, "%02x.%02x.%02x.%02x\n",
-                       (u8)(pm8001_ha->main_cfg_tbl.firmware_rev >> 24),
-                       (u8)(pm8001_ha->main_cfg_tbl.firmware_rev >> 16),
-                       (u8)(pm8001_ha->main_cfg_tbl.firmware_rev >> 8),
-                       (u8)(pm8001_ha->main_cfg_tbl.firmware_rev));
+        if (pm8001_ha->chip_id == chip_8001) {
+                return snprintf(buf, PAGE_SIZE, "%02x.%02x.%02x.%02x\n",
+                (u8)(pm8001_ha->main_cfg_tbl.pm8001_tbl.firmware_rev >> 24),
+                (u8)(pm8001_ha->main_cfg_tbl.pm8001_tbl.firmware_rev >> 16),
+                (u8)(pm8001_ha->main_cfg_tbl.pm8001_tbl.firmware_rev >> 8),
+                (u8)(pm8001_ha->main_cfg_tbl.pm8001_tbl.firmware_rev));
+        } else {
+                return snprintf(buf, PAGE_SIZE, "%02x.%02x.%02x.%02x\n",
+                (u8)(pm8001_ha->main_cfg_tbl.pm80xx_tbl.firmware_rev >> 24),
+                (u8)(pm8001_ha->main_cfg_tbl.pm80xx_tbl.firmware_rev >> 16),
+                (u8)(pm8001_ha->main_cfg_tbl.pm80xx_tbl.firmware_rev >> 8),
+                (u8)(pm8001_ha->main_cfg_tbl.pm80xx_tbl.firmware_rev));
+        }
 }
 static DEVICE_ATTR(fw_version, S_IRUGO, pm8001_ctl_fw_version_show, NULL);
 /**
@@ -99,8 +112,13 @@ static ssize_t pm8001_ctl_max_out_io_show(struct device *cdev,
         struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
         struct pm8001_hba_info *pm8001_ha = sha->lldd_ha;
 
-        return snprintf(buf, PAGE_SIZE, "%d\n",
-                        pm8001_ha->main_cfg_tbl.max_out_io);
+        if (pm8001_ha->chip_id == chip_8001) {
+                return snprintf(buf, PAGE_SIZE, "%d\n",
+                        pm8001_ha->main_cfg_tbl.pm8001_tbl.max_out_io);
+        } else {
+                return snprintf(buf, PAGE_SIZE, "%d\n",
+                        pm8001_ha->main_cfg_tbl.pm80xx_tbl.max_out_io);
+        }
 }
 static DEVICE_ATTR(max_out_io, S_IRUGO, pm8001_ctl_max_out_io_show, NULL);
 /**
@@ -117,8 +135,15 @@ static ssize_t pm8001_ctl_max_devices_show(struct device *cdev,
         struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
         struct pm8001_hba_info *pm8001_ha = sha->lldd_ha;
 
-        return snprintf(buf, PAGE_SIZE, "%04d\n",
-                        (u16)(pm8001_ha->main_cfg_tbl.max_sgl >> 16));
+        if (pm8001_ha->chip_id == chip_8001) {
+                return snprintf(buf, PAGE_SIZE, "%04d\n",
+                        (u16)(pm8001_ha->main_cfg_tbl.pm8001_tbl.max_sgl >> 16)
+                        );
+        } else {
+                return snprintf(buf, PAGE_SIZE, "%04d\n",
+                        (u16)(pm8001_ha->main_cfg_tbl.pm80xx_tbl.max_sgl >> 16)
+                        );
+        }
 }
 static DEVICE_ATTR(max_devices, S_IRUGO, pm8001_ctl_max_devices_show, NULL);
 /**
@@ -136,8 +161,15 @@ static ssize_t pm8001_ctl_max_sg_list_show(struct device *cdev,
         struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
         struct pm8001_hba_info *pm8001_ha = sha->lldd_ha;
 
-        return snprintf(buf, PAGE_SIZE, "%04d\n",
-                        pm8001_ha->main_cfg_tbl.max_sgl & 0x0000FFFF);
+        if (pm8001_ha->chip_id == chip_8001) {
+                return snprintf(buf, PAGE_SIZE, "%04d\n",
+                        pm8001_ha->main_cfg_tbl.pm8001_tbl.max_sgl & 0x0000FFFF
+                        );
+        } else {
+                return snprintf(buf, PAGE_SIZE, "%04d\n",
+                        pm8001_ha->main_cfg_tbl.pm80xx_tbl.max_sgl & 0x0000FFFF
+                        );
+        }
 }
 static DEVICE_ATTR(max_sg_list, S_IRUGO, pm8001_ctl_max_sg_list_show, NULL);
 
@@ -173,7 +205,14 @@ static ssize_t pm8001_ctl_sas_spec_support_show(struct device *cdev,
         struct Scsi_Host *shost = class_to_shost(cdev);
         struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
         struct pm8001_hba_info *pm8001_ha = sha->lldd_ha;
-        mode = (pm8001_ha->main_cfg_tbl.ctrl_cap_flag & 0xfe000000)>>25;
+        /* fe000000 means supports SAS2.1 */
+        if (pm8001_ha->chip_id == chip_8001)
+                mode = (pm8001_ha->main_cfg_tbl.pm8001_tbl.ctrl_cap_flag &
+                                                        0xfe000000)>>25;
+        else
+                /* fe000000 means supports SAS2.1 */
+                mode = (pm8001_ha->main_cfg_tbl.pm80xx_tbl.ctrl_cap_flag &
+                                                        0xfe000000)>>25;
         return show_sas_spec_support_status(mode, buf);
 }
 static DEVICE_ATTR(sas_spec_support, S_IRUGO,
@@ -361,10 +400,11 @@ static int pm8001_set_nvmd(struct pm8001_hba_info *pm8001_ha)
                 goto out;
         }
         payload = (struct pm8001_ioctl_payload *)ioctlbuffer;
-        memcpy((u8 *)payload->func_specific, (u8 *)pm8001_ha->fw_image->data,
+        memcpy((u8 *)&payload->func_specific, (u8 *)pm8001_ha->fw_image->data,
                                 pm8001_ha->fw_image->size);
         payload->length = pm8001_ha->fw_image->size;
         payload->id = 0;
+        payload->minor_function = 0x1;
         pm8001_ha->nvmd_completion = &completion;
         ret = PM8001_CHIP_DISP->set_nvmd_req(pm8001_ha, payload);
         wait_for_completion(&completion);
@@ -411,7 +451,7 @@ static int pm8001_update_flash(struct pm8001_hba_info *pm8001_ha)
                         payload->length = 1024*16;
                         payload->id = 0;
                         fwControl =
-                              (struct fw_control_info *)payload->func_specific;
+                              (struct fw_control_info *)&payload->func_specific;
                         fwControl->len = IOCTL_BUF_SIZE;   /* IN */
                         fwControl->size = partitionSize + HEADER_LEN;/* IN */
                         fwControl->retcode = 0;/* OUT */
diff --git a/drivers/scsi/pm8001/pm8001_defs.h b/drivers/scsi/pm8001/pm8001_defs.h
index c3d20c8d4abe..479c5a7a863a 100644
--- a/drivers/scsi/pm8001/pm8001_defs.h
+++ b/drivers/scsi/pm8001/pm8001_defs.h
@@ -1,5 +1,5 @@
 /*
- * PMC-Sierra SPC 8001 SAS/SATA based host adapters driver
+ * PMC-Sierra 8001/8081/8088/8089 SAS/SATA based host adapters driver
  *
  * Copyright (c) 2008-2009 USI Co., Ltd.
  * All rights reserved.
@@ -43,9 +43,12 @@
 
 enum chip_flavors {
         chip_8001,
+        chip_8008,
+        chip_8009,
+        chip_8018,
+        chip_8019
 };
-#define USI_MAX_MEMCNT                  9
-#define PM8001_MAX_DMA_SG               SG_ALL
+
 enum phy_speed {
         PHY_SPEED_15 = 0x01,
         PHY_SPEED_30 = 0x02,
@@ -69,23 +72,34 @@ enum port_type {
 #define PM8001_MPI_QUEUE         1024   /* maximum mpi queue entries */
 #define PM8001_MAX_INB_NUM       1
 #define PM8001_MAX_OUTB_NUM      1
+#define PM8001_MAX_SPCV_INB_NUM         1
+#define PM8001_MAX_SPCV_OUTB_NUM        4
 #define PM8001_CAN_QUEUE         508    /* SCSI Queue depth */
 
+/* Inbound/Outbound queue size */
+#define IOMB_SIZE_SPC           64
+#define IOMB_SIZE_SPCV          128
+
 /* unchangeable hardware details */
-#define PM8001_MAX_PHYS          8      /* max. possible phys */
-#define PM8001_MAX_PORTS         8      /* max. possible ports */
-#define PM8001_MAX_DEVICES       1024   /* max supported device */
+#define PM8001_MAX_PHYS          16     /* max. possible phys */
+#define PM8001_MAX_PORTS         16     /* max. possible ports */
+#define PM8001_MAX_DEVICES       2048   /* max supported device */
+#define PM8001_MAX_MSIX_VEC      64     /* max msi-x int for spcv/ve */
 
+#define USI_MAX_MEMCNT_BASE     5
+#define IB                      (USI_MAX_MEMCNT_BASE + 1)
+#define CI                      (IB + PM8001_MAX_SPCV_INB_NUM)
+#define OB                      (CI + PM8001_MAX_SPCV_INB_NUM)
+#define PI                      (OB + PM8001_MAX_SPCV_OUTB_NUM)
+#define USI_MAX_MEMCNT          (PI + PM8001_MAX_SPCV_OUTB_NUM)
+#define PM8001_MAX_DMA_SG       SG_ALL
 enum memory_region_num {
         AAP1 = 0x0, /* application acceleration processor */
         IOP,        /* IO processor */
-        CI,         /* consumer index */
-        PI,         /* producer index */
-        IB,         /* inbound queue */
-        OB,         /* outbound queue */
         NVMD,       /* NVM device */
         DEV_MEM,    /* memory for devices */
         CCB_MEM,    /* memory for command control block */
+        FW_FLASH    /* memory for fw flash update */
 };
 #define PM8001_EVENT_LOG_SIZE    (128 * 1024)
 
diff --git a/drivers/scsi/pm8001/pm8001_hwi.c b/drivers/scsi/pm8001/pm8001_hwi.c
index b8dd05074abb..69dd49c05f1e 100644
--- a/drivers/scsi/pm8001/pm8001_hwi.c
+++ b/drivers/scsi/pm8001/pm8001_hwi.c
@@ -50,32 +50,39 @@
 static void read_main_config_table(struct pm8001_hba_info *pm8001_ha)
 {
         void __iomem *address = pm8001_ha->main_cfg_tbl_addr;
-        pm8001_ha->main_cfg_tbl.signature       = pm8001_mr32(address, 0x00);
-        pm8001_ha->main_cfg_tbl.interface_rev   = pm8001_mr32(address, 0x04);
-        pm8001_ha->main_cfg_tbl.firmware_rev    = pm8001_mr32(address, 0x08);
-        pm8001_ha->main_cfg_tbl.max_out_io      = pm8001_mr32(address, 0x0C);
-        pm8001_ha->main_cfg_tbl.max_sgl         = pm8001_mr32(address, 0x10);
-        pm8001_ha->main_cfg_tbl.ctrl_cap_flag   = pm8001_mr32(address, 0x14);
-        pm8001_ha->main_cfg_tbl.gst_offset      = pm8001_mr32(address, 0x18);
-        pm8001_ha->main_cfg_tbl.inbound_queue_offset =
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.signature    =
+                                pm8001_mr32(address, 0x00);
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.interface_rev =
+                                pm8001_mr32(address, 0x04);
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.firmware_rev =
+                                pm8001_mr32(address, 0x08);
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.max_out_io   =
+                                pm8001_mr32(address, 0x0C);
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.max_sgl      =
+                                pm8001_mr32(address, 0x10);
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.ctrl_cap_flag =
+                                pm8001_mr32(address, 0x14);
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.gst_offset   =
+                                pm8001_mr32(address, 0x18);
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.inbound_queue_offset =
                 pm8001_mr32(address, MAIN_IBQ_OFFSET);
-        pm8001_ha->main_cfg_tbl.outbound_queue_offset =
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_queue_offset =
                 pm8001_mr32(address, MAIN_OBQ_OFFSET);
-        pm8001_ha->main_cfg_tbl.hda_mode_flag   =
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.hda_mode_flag        =
                 pm8001_mr32(address, MAIN_HDA_FLAGS_OFFSET);
 
         /* read analog Setting offset from the configuration table */
-        pm8001_ha->main_cfg_tbl.anolog_setup_table_offset =
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.anolog_setup_table_offset =
                 pm8001_mr32(address, MAIN_ANALOG_SETUP_OFFSET);
 
         /* read Error Dump Offset and Length */
-        pm8001_ha->main_cfg_tbl.fatal_err_dump_offset0 =
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.fatal_err_dump_offset0 =
                 pm8001_mr32(address, MAIN_FATAL_ERROR_RDUMP0_OFFSET);
-        pm8001_ha->main_cfg_tbl.fatal_err_dump_length0 =
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.fatal_err_dump_length0 =
                 pm8001_mr32(address, MAIN_FATAL_ERROR_RDUMP0_LENGTH);
-        pm8001_ha->main_cfg_tbl.fatal_err_dump_offset1 =
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.fatal_err_dump_offset1 =
                 pm8001_mr32(address, MAIN_FATAL_ERROR_RDUMP1_OFFSET);
-        pm8001_ha->main_cfg_tbl.fatal_err_dump_length1 =
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.fatal_err_dump_length1 =
                 pm8001_mr32(address, MAIN_FATAL_ERROR_RDUMP1_LENGTH);
 }
 
@@ -86,31 +93,56 @@ static void read_main_config_table(struct pm8001_hba_info *pm8001_ha)
 static void read_general_status_table(struct pm8001_hba_info *pm8001_ha)
 {
         void __iomem *address = pm8001_ha->general_stat_tbl_addr;
-        pm8001_ha->gs_tbl.gst_len_mpistate      = pm8001_mr32(address, 0x00);
-        pm8001_ha->gs_tbl.iq_freeze_state0      = pm8001_mr32(address, 0x04);
-        pm8001_ha->gs_tbl.iq_freeze_state1      = pm8001_mr32(address, 0x08);
-        pm8001_ha->gs_tbl.msgu_tcnt             = pm8001_mr32(address, 0x0C);
-        pm8001_ha->gs_tbl.iop_tcnt              = pm8001_mr32(address, 0x10);
-        pm8001_ha->gs_tbl.reserved              = pm8001_mr32(address, 0x14);
-        pm8001_ha->gs_tbl.phy_state[0]  = pm8001_mr32(address, 0x18);
-        pm8001_ha->gs_tbl.phy_state[1]  = pm8001_mr32(address, 0x1C);
-        pm8001_ha->gs_tbl.phy_state[2]  = pm8001_mr32(address, 0x20);
-        pm8001_ha->gs_tbl.phy_state[3]  = pm8001_mr32(address, 0x24);
-        pm8001_ha->gs_tbl.phy_state[4]  = pm8001_mr32(address, 0x28);
-        pm8001_ha->gs_tbl.phy_state[5]  = pm8001_mr32(address, 0x2C);
-        pm8001_ha->gs_tbl.phy_state[6]  = pm8001_mr32(address, 0x30);
-        pm8001_ha->gs_tbl.phy_state[7]  = pm8001_mr32(address, 0x34);
-        pm8001_ha->gs_tbl.reserved1             = pm8001_mr32(address, 0x38);
-        pm8001_ha->gs_tbl.reserved2             = pm8001_mr32(address, 0x3C);
-        pm8001_ha->gs_tbl.reserved3             = pm8001_mr32(address, 0x40);
-        pm8001_ha->gs_tbl.recover_err_info[0]   = pm8001_mr32(address, 0x44);
-        pm8001_ha->gs_tbl.recover_err_info[1]   = pm8001_mr32(address, 0x48);
-        pm8001_ha->gs_tbl.recover_err_info[2]   = pm8001_mr32(address, 0x4C);
-        pm8001_ha->gs_tbl.recover_err_info[3]   = pm8001_mr32(address, 0x50);
-        pm8001_ha->gs_tbl.recover_err_info[4]   = pm8001_mr32(address, 0x54);
-        pm8001_ha->gs_tbl.recover_err_info[5]   = pm8001_mr32(address, 0x58);
-        pm8001_ha->gs_tbl.recover_err_info[6]   = pm8001_mr32(address, 0x5C);
-        pm8001_ha->gs_tbl.recover_err_info[7]   = pm8001_mr32(address, 0x60);
+        pm8001_ha->gs_tbl.pm8001_tbl.gst_len_mpistate   =
+                                pm8001_mr32(address, 0x00);
+        pm8001_ha->gs_tbl.pm8001_tbl.iq_freeze_state0   =
+                                pm8001_mr32(address, 0x04);
+        pm8001_ha->gs_tbl.pm8001_tbl.iq_freeze_state1   =
+                                pm8001_mr32(address, 0x08);
+        pm8001_ha->gs_tbl.pm8001_tbl.msgu_tcnt          =
+                                pm8001_mr32(address, 0x0C);
+        pm8001_ha->gs_tbl.pm8001_tbl.iop_tcnt           =
+                                pm8001_mr32(address, 0x10);
+        pm8001_ha->gs_tbl.pm8001_tbl.rsvd               =
+                                pm8001_mr32(address, 0x14);
+        pm8001_ha->gs_tbl.pm8001_tbl.phy_state[0]       =
+                                pm8001_mr32(address, 0x18);
+        pm8001_ha->gs_tbl.pm8001_tbl.phy_state[1]       =
+                                pm8001_mr32(address, 0x1C);
+        pm8001_ha->gs_tbl.pm8001_tbl.phy_state[2]       =
+                                pm8001_mr32(address, 0x20);
+        pm8001_ha->gs_tbl.pm8001_tbl.phy_state[3]       =
+                                pm8001_mr32(address, 0x24);
+        pm8001_ha->gs_tbl.pm8001_tbl.phy_state[4]       =
+                                pm8001_mr32(address, 0x28);
+        pm8001_ha->gs_tbl.pm8001_tbl.phy_state[5]       =
+                                pm8001_mr32(address, 0x2C);
+        pm8001_ha->gs_tbl.pm8001_tbl.phy_state[6]       =
+                                pm8001_mr32(address, 0x30);
+        pm8001_ha->gs_tbl.pm8001_tbl.phy_state[7]       =
+                                pm8001_mr32(address, 0x34);
+        pm8001_ha->gs_tbl.pm8001_tbl.gpio_input_val     =
+                                pm8001_mr32(address, 0x38);
+        pm8001_ha->gs_tbl.pm8001_tbl.rsvd1[0]           =
+                                pm8001_mr32(address, 0x3C);
+        pm8001_ha->gs_tbl.pm8001_tbl.rsvd1[1]           =
+                                pm8001_mr32(address, 0x40);
+        pm8001_ha->gs_tbl.pm8001_tbl.recover_err_info[0]        =
+                                pm8001_mr32(address, 0x44);
+        pm8001_ha->gs_tbl.pm8001_tbl.recover_err_info[1]        =
+                                pm8001_mr32(address, 0x48);
+        pm8001_ha->gs_tbl.pm8001_tbl.recover_err_info[2]        =
+                                pm8001_mr32(address, 0x4C);
+        pm8001_ha->gs_tbl.pm8001_tbl.recover_err_info[3]        =
+                                pm8001_mr32(address, 0x50);
+        pm8001_ha->gs_tbl.pm8001_tbl.recover_err_info[4]        =
+                                pm8001_mr32(address, 0x54);
+        pm8001_ha->gs_tbl.pm8001_tbl.recover_err_info[5]        =
+                                pm8001_mr32(address, 0x58);
+        pm8001_ha->gs_tbl.pm8001_tbl.recover_err_info[6]        =
+                                pm8001_mr32(address, 0x5C);
+        pm8001_ha->gs_tbl.pm8001_tbl.recover_err_info[7]        =
+                                pm8001_mr32(address, 0x60);
 }
 
 /**
@@ -119,10 +151,9 @@ static void read_general_status_table(struct pm8001_hba_info *pm8001_ha)
  */
 static void read_inbnd_queue_table(struct pm8001_hba_info *pm8001_ha)
 {
-        int inbQ_num = 1;
         int i;
         void __iomem *address = pm8001_ha->inbnd_q_tbl_addr;
-        for (i = 0; i < inbQ_num; i++) {
+        for (i = 0; i < PM8001_MAX_INB_NUM; i++) {
                 u32 offset = i * 0x20;
                 pm8001_ha->inbnd_q_tbl[i].pi_pci_bar =
                       get_pci_bar_index(pm8001_mr32(address, (offset + 0x14)));
@@ -137,10 +168,9 @@ static void read_inbnd_queue_table(struct pm8001_hba_info *pm8001_ha)
  */
 static void read_outbnd_queue_table(struct pm8001_hba_info *pm8001_ha)
 {
-        int outbQ_num = 1;
         int i;
         void __iomem *address = pm8001_ha->outbnd_q_tbl_addr;
-        for (i = 0; i < outbQ_num; i++) {
+        for (i = 0; i < PM8001_MAX_OUTB_NUM; i++) {
                 u32 offset = i * 0x24;
                 pm8001_ha->outbnd_q_tbl[i].ci_pci_bar =
                       get_pci_bar_index(pm8001_mr32(address, (offset + 0x14)));
@@ -155,54 +185,57 @@ static void read_outbnd_queue_table(struct pm8001_hba_info *pm8001_ha)
  */
 static void init_default_table_values(struct pm8001_hba_info *pm8001_ha)
 {
-        int qn = 1;
         int i;
         u32 offsetib, offsetob;
         void __iomem *addressib = pm8001_ha->inbnd_q_tbl_addr;
         void __iomem *addressob = pm8001_ha->outbnd_q_tbl_addr;
 
-        pm8001_ha->main_cfg_tbl.inbound_q_nppd_hppd                     = 0;
-        pm8001_ha->main_cfg_tbl.outbound_hw_event_pid0_3                = 0;
-        pm8001_ha->main_cfg_tbl.outbound_hw_event_pid4_7                = 0;
-        pm8001_ha->main_cfg_tbl.outbound_ncq_event_pid0_3               = 0;
-        pm8001_ha->main_cfg_tbl.outbound_ncq_event_pid4_7               = 0;
-        pm8001_ha->main_cfg_tbl.outbound_tgt_ITNexus_event_pid0_3       = 0;
-        pm8001_ha->main_cfg_tbl.outbound_tgt_ITNexus_event_pid4_7       = 0;
-        pm8001_ha->main_cfg_tbl.outbound_tgt_ssp_event_pid0_3   = 0;
-        pm8001_ha->main_cfg_tbl.outbound_tgt_ssp_event_pid4_7   = 0;
-        pm8001_ha->main_cfg_tbl.outbound_tgt_smp_event_pid0_3   = 0;
-        pm8001_ha->main_cfg_tbl.outbound_tgt_smp_event_pid4_7   = 0;
-
-        pm8001_ha->main_cfg_tbl.upper_event_log_addr            =
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.inbound_q_nppd_hppd          = 0;
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_hw_event_pid0_3     = 0;
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_hw_event_pid4_7     = 0;
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_ncq_event_pid0_3    = 0;
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_ncq_event_pid4_7    = 0;
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_tgt_ITNexus_event_pid0_3 =
+                                                                         0;
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_tgt_ITNexus_event_pid4_7 =
+                                                                         0;
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_tgt_ssp_event_pid0_3 = 0;
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_tgt_ssp_event_pid4_7 = 0;
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_tgt_smp_event_pid0_3 = 0;
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_tgt_smp_event_pid4_7 = 0;
+
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.upper_event_log_addr         =
                 pm8001_ha->memoryMap.region[AAP1].phys_addr_hi;
-        pm8001_ha->main_cfg_tbl.lower_event_log_addr            =
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.lower_event_log_addr         =
                 pm8001_ha->memoryMap.region[AAP1].phys_addr_lo;
-        pm8001_ha->main_cfg_tbl.event_log_size  = PM8001_EVENT_LOG_SIZE;
-        pm8001_ha->main_cfg_tbl.event_log_option                = 0x01;
-        pm8001_ha->main_cfg_tbl.upper_iop_event_log_addr        =
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.event_log_size               =
+                PM8001_EVENT_LOG_SIZE;
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.event_log_option             = 0x01;
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.upper_iop_event_log_addr     =
                 pm8001_ha->memoryMap.region[IOP].phys_addr_hi;
-        pm8001_ha->main_cfg_tbl.lower_iop_event_log_addr        =
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.lower_iop_event_log_addr     =
                 pm8001_ha->memoryMap.region[IOP].phys_addr_lo;
-        pm8001_ha->main_cfg_tbl.iop_event_log_size      = PM8001_EVENT_LOG_SIZE;
-        pm8001_ha->main_cfg_tbl.iop_event_log_option            = 0x01;
-        pm8001_ha->main_cfg_tbl.fatal_err_interrupt             = 0x01;
-        for (i = 0; i < qn; i++) {
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.iop_event_log_size           =
+                PM8001_EVENT_LOG_SIZE;
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.iop_event_log_option         = 0x01;
+        pm8001_ha->main_cfg_tbl.pm8001_tbl.fatal_err_interrupt          = 0x01;
+        for (i = 0; i < PM8001_MAX_INB_NUM; i++) {
                 pm8001_ha->inbnd_q_tbl[i].element_pri_size_cnt  =
                         PM8001_MPI_QUEUE | (64 << 16) | (0x00<<30);
                 pm8001_ha->inbnd_q_tbl[i].upper_base_addr       =
-                        pm8001_ha->memoryMap.region[IB].phys_addr_hi;
+                        pm8001_ha->memoryMap.region[IB + i].phys_addr_hi;
                 pm8001_ha->inbnd_q_tbl[i].lower_base_addr       =
-                pm8001_ha->memoryMap.region[IB].phys_addr_lo;
+                pm8001_ha->memoryMap.region[IB + i].phys_addr_lo;
                 pm8001_ha->inbnd_q_tbl[i].base_virt             =
-                        (u8 *)pm8001_ha->memoryMap.region[IB].virt_ptr;
+                        (u8 *)pm8001_ha->memoryMap.region[IB + i].virt_ptr;
                 pm8001_ha->inbnd_q_tbl[i].total_length          =
-                        pm8001_ha->memoryMap.region[IB].total_len;
+                        pm8001_ha->memoryMap.region[IB + i].total_len;
                 pm8001_ha->inbnd_q_tbl[i].ci_upper_base_addr    =
-                        pm8001_ha->memoryMap.region[CI].phys_addr_hi;
+                        pm8001_ha->memoryMap.region[CI + i].phys_addr_hi;
                 pm8001_ha->inbnd_q_tbl[i].ci_lower_base_addr    =
-                        pm8001_ha->memoryMap.region[CI].phys_addr_lo;
+                        pm8001_ha->memoryMap.region[CI + i].phys_addr_lo;
                 pm8001_ha->inbnd_q_tbl[i].ci_virt               =
-                        pm8001_ha->memoryMap.region[CI].virt_ptr;
+                        pm8001_ha->memoryMap.region[CI + i].virt_ptr;
                 offsetib = i * 0x20;
                 pm8001_ha->inbnd_q_tbl[i].pi_pci_bar            =
                         get_pci_bar_index(pm8001_mr32(addressib,
@@ -212,25 +245,25 @@ static void init_default_table_values(struct pm8001_hba_info *pm8001_ha)
                 pm8001_ha->inbnd_q_tbl[i].producer_idx          = 0;
                 pm8001_ha->inbnd_q_tbl[i].consumer_index        = 0;
         }
-        for (i = 0; i < qn; i++) {
+        for (i = 0; i < PM8001_MAX_OUTB_NUM; i++) {
                 pm8001_ha->outbnd_q_tbl[i].element_size_cnt     =
                         PM8001_MPI_QUEUE | (64 << 16) | (0x01<<30);
                 pm8001_ha->outbnd_q_tbl[i].upper_base_addr      =
-                        pm8001_ha->memoryMap.region[OB].phys_addr_hi;
+                        pm8001_ha->memoryMap.region[OB + i].phys_addr_hi;
                 pm8001_ha->outbnd_q_tbl[i].lower_base_addr      =
-                        pm8001_ha->memoryMap.region[OB].phys_addr_lo;
+                        pm8001_ha->memoryMap.region[OB + i].phys_addr_lo;
                 pm8001_ha->outbnd_q_tbl[i].base_virt            =
-                        (u8 *)pm8001_ha->memoryMap.region[OB].virt_ptr;
+                        (u8 *)pm8001_ha->memoryMap.region[OB + i].virt_ptr;
                 pm8001_ha->outbnd_q_tbl[i].total_length         =
-                        pm8001_ha->memoryMap.region[OB].total_len;
+                        pm8001_ha->memoryMap.region[OB + i].total_len;
                 pm8001_ha->outbnd_q_tbl[i].pi_upper_base_addr   =
-                        pm8001_ha->memoryMap.region[PI].phys_addr_hi;
+                        pm8001_ha->memoryMap.region[PI + i].phys_addr_hi;
                 pm8001_ha->outbnd_q_tbl[i].pi_lower_base_addr   =
-                        pm8001_ha->memoryMap.region[PI].phys_addr_lo;
+                        pm8001_ha->memoryMap.region[PI + i].phys_addr_lo;
                 pm8001_ha->outbnd_q_tbl[i].interrup_vec_cnt_delay       =
-                        0 | (10 << 16) | (0 << 24);
+                        0 | (10 << 16) | (i << 24);
                 pm8001_ha->outbnd_q_tbl[i].pi_virt              =
-                        pm8001_ha->memoryMap.region[PI].virt_ptr;
+                        pm8001_ha->memoryMap.region[PI + i].virt_ptr;
                 offsetob = i * 0x24;
                 pm8001_ha->outbnd_q_tbl[i].ci_pci_bar           =
                         get_pci_bar_index(pm8001_mr32(addressob,
@@ -250,42 +283,51 @@ static void update_main_config_table(struct pm8001_hba_info *pm8001_ha)
 {
         void __iomem *address = pm8001_ha->main_cfg_tbl_addr;
         pm8001_mw32(address, 0x24,
-                pm8001_ha->main_cfg_tbl.inbound_q_nppd_hppd);
+                pm8001_ha->main_cfg_tbl.pm8001_tbl.inbound_q_nppd_hppd);
         pm8001_mw32(address, 0x28,
-                pm8001_ha->main_cfg_tbl.outbound_hw_event_pid0_3);
+                pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_hw_event_pid0_3);
         pm8001_mw32(address, 0x2C,
-                pm8001_ha->main_cfg_tbl.outbound_hw_event_pid4_7);
+                pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_hw_event_pid4_7);
         pm8001_mw32(address, 0x30,
-                pm8001_ha->main_cfg_tbl.outbound_ncq_event_pid0_3);
+                pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_ncq_event_pid0_3);
         pm8001_mw32(address, 0x34,
-                pm8001_ha->main_cfg_tbl.outbound_ncq_event_pid4_7);
+                pm8001_ha->main_cfg_tbl.pm8001_tbl.outbound_ncq_event_pid4_7);
         pm8001_mw32(address, 0x38,
-                pm8001_ha->main_cfg_tbl.outbound_tgt_ITNexus_event_pid0_3);
+                pm8001_ha->main_cfg_tbl.pm8001_tbl.
+                                        outbound_tgt_ITNexus_event_pid0_3);
         pm8001_mw32(address, 0x3C,
-                pm8001_ha->main_cfg_tbl.outbound_tgt_ITNexus_event_pid4_7);
+                pm8001_ha->main_cfg_tbl.pm8001_tbl.
+                                        outbound_tgt_ITNexus_event_pid4_7);
         pm8001_mw32(address, 0x40,
-                pm8001_ha->main_cfg_tbl.outbound_tgt_ssp_event_pid0_3);
+                pm8001_ha->main_cfg_tbl.pm8001_tbl.
+                                        outbound_tgt_ssp_event_pid0_3);
         pm8001_mw32(address, 0x44,
-                pm8001_ha->main_cfg_tbl.outbound_tgt_ssp_event_pid4_7);
+                pm8001_ha->main_cfg_tbl.pm8001_tbl.
+                                        outbound_tgt_ssp_event_pid4_7);
         pm8001_mw32(address, 0x48,
-                pm8001_ha->main_cfg_tbl.outbound_tgt_smp_event_pid0_3);
+                pm8001_ha->main_cfg_tbl.pm8001_tbl.
+                                        outbound_tgt_smp_event_pid0_3);
         pm8001_mw32(address, 0x4C,
-                pm8001_ha->main_cfg_tbl.outbound_tgt_smp_event_pid4_7);
+                pm8001_ha->main_cfg_tbl.pm8001_tbl.
+                                        outbound_tgt_smp_event_pid4_7);
         pm8001_mw32(address, 0x50,
-                pm8001_ha->main_cfg_tbl.upper_event_log_addr);
+                pm8001_ha->main_cfg_tbl.pm8001_tbl.upper_event_log_addr);
         pm8001_mw32(address, 0x54,
-                pm8001_ha->main_cfg_tbl.lower_event_log_addr);
-        pm8001_mw32(address, 0x58, pm8001_ha->main_cfg_tbl.event_log_size);
-        pm8001_mw32(address, 0x5C, pm8001_ha->main_cfg_tbl.event_log_option);
+                pm8001_ha->main_cfg_tbl.pm8001_tbl.lower_event_log_addr);
+        pm8001_mw32(address, 0x58,
+                pm8001_ha->main_cfg_tbl.pm8001_tbl.event_log_size);
+        pm8001_mw32(address, 0x5C,
+                pm8001_ha->main_cfg_tbl.pm8001_tbl.event_log_option);
         pm8001_mw32(address, 0x60,
-                pm8001_ha->main_cfg_tbl.upper_iop_event_log_addr);
+                pm8001_ha->main_cfg_tbl.pm8001_tbl.upper_iop_event_log_addr);
         pm8001_mw32(address, 0x64,
-                pm8001_ha->main_cfg_tbl.lower_iop_event_log_addr);
-        pm8001_mw32(address, 0x68, pm8001_ha->main_cfg_tbl.iop_event_log_size);
+                pm8001_ha->main_cfg_tbl.pm8001_tbl.lower_iop_event_log_addr);
+        pm8001_mw32(address, 0x68,
+                pm8001_ha->main_cfg_tbl.pm8001_tbl.iop_event_log_size);
         pm8001_mw32(address, 0x6C,
-                pm8001_ha->main_cfg_tbl.iop_event_log_option);
+                pm8001_ha->main_cfg_tbl.pm8001_tbl.iop_event_log_option);
         pm8001_mw32(address, 0x70,
-                pm8001_ha->main_cfg_tbl.fatal_err_interrupt);
+                pm8001_ha->main_cfg_tbl.pm8001_tbl.fatal_err_interrupt);
 }
 
 /**
@@ -597,6 +639,19 @@ static void init_pci_device_addresses(struct pm8001_hba_info *pm8001_ha)
  */
 static int pm8001_chip_init(struct pm8001_hba_info *pm8001_ha)
 {
+        u8 i = 0;
+        u16 deviceid;
+        pci_read_config_word(pm8001_ha->pdev, PCI_DEVICE_ID, &deviceid);
+        /* 8081 controllers need BAR shift to access MPI space
+        * as this is shared with BIOS data */
+        if (deviceid == 0x8081) {
+                if (-1 == pm8001_bar4_shift(pm8001_ha, GSM_SM_BASE)) {
+                        PM8001_FAIL_DBG(pm8001_ha,
+                                pm8001_printk("Shift Bar4 to 0x%x failed\n",
+                                        GSM_SM_BASE));
+                        return -1;
+                }
+        }
         /* check the firmware status */
         if (-1 == check_fw_ready(pm8001_ha)) {
                 PM8001_FAIL_DBG(pm8001_ha,
@@ -613,11 +668,16 @@ static int pm8001_chip_init(struct pm8001_hba_info *pm8001_ha)
         read_outbnd_queue_table(pm8001_ha);
         /* update main config table ,inbound table and outbound table */
         update_main_config_table(pm8001_ha);
-        update_inbnd_queue_table(pm8001_ha, 0);
-        update_outbnd_queue_table(pm8001_ha, 0);
-        mpi_set_phys_g3_with_ssc(pm8001_ha, 0);
-        /* 7->130ms, 34->500ms, 119->1.5s */
-        mpi_set_open_retry_interval_reg(pm8001_ha, 119);
+        for (i = 0; i < PM8001_MAX_INB_NUM; i++)
+                update_inbnd_queue_table(pm8001_ha, i);
+        for (i = 0; i < PM8001_MAX_OUTB_NUM; i++)
+                update_outbnd_queue_table(pm8001_ha, i);
+        /* 8081 controller donot require these operations */
+        if (deviceid != 0x8081) {
+                mpi_set_phys_g3_with_ssc(pm8001_ha, 0);
+                /* 7->130ms, 34->500ms, 119->1.5s */
+                mpi_set_open_retry_interval_reg(pm8001_ha, 119);
+        }
         /* notify firmware update finished and check initialization status */
         if (0 == mpi_init_check(pm8001_ha)) {
                 PM8001_INIT_DBG(pm8001_ha,
@@ -639,6 +699,16 @@ static int mpi_uninit_check(struct pm8001_hba_info *pm8001_ha)
         u32 max_wait_count;
         u32 value;
         u32 gst_len_mpistate;
+        u16 deviceid;
+        pci_read_config_word(pm8001_ha->pdev, PCI_DEVICE_ID, &deviceid);
+        if (deviceid == 0x8081) {
+                if (-1 == pm8001_bar4_shift(pm8001_ha, GSM_SM_BASE)) {
+                        PM8001_FAIL_DBG(pm8001_ha,
+                                pm8001_printk("Shift Bar4 to 0x%x failed\n",
+                                        GSM_SM_BASE));
+                        return -1;
+                }
+        }
         init_pci_device_addresses(pm8001_ha);
         /* Write bit1=1 to Inbound DoorBell Register to tell the SPC FW the
         table is stop */
@@ -740,14 +810,14 @@ static u32 soft_reset_ready_check(struct pm8001_hba_info *pm8001_ha)
  * pm8001_chip_soft_rst - soft reset the PM8001 chip, so that the clear all
  * the FW register status to the originated status.
  * @pm8001_ha: our hba card information
- * @signature: signature in host scratch pad0 register.
  */
 static int
-pm8001_chip_soft_rst(struct pm8001_hba_info *pm8001_ha, u32 signature)
+pm8001_chip_soft_rst(struct pm8001_hba_info *pm8001_ha)
 {
         u32     regVal, toggleVal;
         u32     max_wait_count;
         u32     regVal1, regVal2, regVal3;
+        u32     signature = 0x252acbcd; /* for host scratch pad0 */
         unsigned long flags;
 
         /* step1: Check FW is ready for soft reset */
@@ -1113,7 +1183,7 @@ static void pm8001_hw_chip_rst(struct pm8001_hba_info *pm8001_ha)
  * pm8001_chip_iounmap - which maped when initialized.
  * @pm8001_ha: our hba card information
  */
-static void pm8001_chip_iounmap(struct pm8001_hba_info *pm8001_ha)
+void pm8001_chip_iounmap(struct pm8001_hba_info *pm8001_ha)
 {
         s8 bar, logical = 0;
         for (bar = 0; bar < 6; bar++) {
@@ -1192,7 +1262,7 @@ pm8001_chip_msix_interrupt_disable(struct pm8001_hba_info *pm8001_ha,
  * @pm8001_ha: our hba card information
  */
 static void
-pm8001_chip_interrupt_enable(struct pm8001_hba_info *pm8001_ha)
+pm8001_chip_interrupt_enable(struct pm8001_hba_info *pm8001_ha, u8 vec)
 {
 #ifdef PM8001_USE_MSIX
         pm8001_chip_msix_interrupt_enable(pm8001_ha, 0);
@@ -1207,7 +1277,7 @@ pm8001_chip_interrupt_enable(struct pm8001_hba_info *pm8001_ha)
  * @pm8001_ha: our hba card information
  */
 static void
-pm8001_chip_interrupt_disable(struct pm8001_hba_info *pm8001_ha)
+pm8001_chip_interrupt_disable(struct pm8001_hba_info *pm8001_ha, u8 vec)
 {
 #ifdef PM8001_USE_MSIX
         pm8001_chip_msix_interrupt_disable(pm8001_ha, 0);
@@ -1218,12 +1288,13 @@ pm8001_chip_interrupt_disable(struct pm8001_hba_info *pm8001_ha)
 }
 
 /**
- * mpi_msg_free_get- get the free message buffer for transfer inbound queue.
+ * pm8001_mpi_msg_free_get - get the free message buffer for transfer
+ * inbound queue.
  * @circularQ: the inbound queue  we want to transfer to HBA.
  * @messageSize: the message size of this transfer, normally it is 64 bytes
  * @messagePtr: the pointer to message.
  */
-static int mpi_msg_free_get(struct inbound_queue_table *circularQ,
+int pm8001_mpi_msg_free_get(struct inbound_queue_table *circularQ,
                             u16 messageSize, void **messagePtr)
 {
         u32 offset, consumer_index;
@@ -1231,7 +1302,7 @@ static int mpi_msg_free_get(struct inbound_queue_table *circularQ,
         u8 bcCount = 1; /* only support single buffer */
 
         /* Checks is the requested message size can be allocated in this queue*/
-        if (messageSize > 64) {
+        if (messageSize > IOMB_SIZE_SPCV) {
                 *messagePtr = NULL;
                 return -1;
         }
@@ -1245,7 +1316,7 @@ static int mpi_msg_free_get(struct inbound_queue_table *circularQ,
                 return -1;
         }
         /* get memory IOMB buffer address */
-        offset = circularQ->producer_idx * 64;
+        offset = circularQ->producer_idx * messageSize;
         /* increment to next bcCount element */
         circularQ->producer_idx = (circularQ->producer_idx + bcCount)
                                 % PM8001_MPI_QUEUE;
@@ -1257,29 +1328,30 @@ static int mpi_msg_free_get(struct inbound_queue_table *circularQ,
 }
 
 /**
- * mpi_build_cmd- build the message queue for transfer, update the PI to FW
- * to tell the fw to get this message from IOMB.
+ * pm8001_mpi_build_cmd- build the message queue for transfer, update the PI to
+ * FW to tell the fw to get this message from IOMB.
  * @pm8001_ha: our hba card information
  * @circularQ: the inbound queue we want to transfer to HBA.
  * @opCode: the operation code represents commands which LLDD and fw recognized.
  * @payload: the command payload of each operation command.
  */
-static int mpi_build_cmd(struct pm8001_hba_info *pm8001_ha,
+int pm8001_mpi_build_cmd(struct pm8001_hba_info *pm8001_ha,
                          struct inbound_queue_table *circularQ,
-                         u32 opCode, void *payload)
+                         u32 opCode, void *payload, u32 responseQueue)
 {
         u32 Header = 0, hpriority = 0, bc = 1, category = 0x02;
-        u32 responseQueue = 0;
         void *pMessage;
 
-        if (mpi_msg_free_get(circularQ, 64, &pMessage) < 0) {
+        if (pm8001_mpi_msg_free_get(circularQ, pm8001_ha->iomb_size,
+                &pMessage) < 0) {
                 PM8001_IO_DBG(pm8001_ha,
                         pm8001_printk("No free mpi buffer\n"));
                 return -1;
         }
         BUG_ON(!payload);
         /*Copy to the payload*/
-        memcpy(pMessage, payload, (64 - sizeof(struct mpi_msg_hdr)));
+        memcpy(pMessage, payload, (pm8001_ha->iomb_size -
+                                sizeof(struct mpi_msg_hdr)));
 
         /*Build the header*/
         Header = ((1 << 31) | (hpriority << 30) | ((bc & 0x1f) << 24)
@@ -1291,12 +1363,13 @@ static int mpi_build_cmd(struct pm8001_hba_info *pm8001_ha,
         pm8001_cw32(pm8001_ha, circularQ->pi_pci_bar,
                 circularQ->pi_offset, circularQ->producer_idx);
         PM8001_IO_DBG(pm8001_ha,
-                pm8001_printk("after PI= %d CI= %d\n", circularQ->producer_idx,
-                circularQ->consumer_index));
+                pm8001_printk("INB Q %x OPCODE:%x , UPDATED PI=%d CI=%d\n",
+                        responseQueue, opCode, circularQ->producer_idx,
+                        circularQ->consumer_index));
         return 0;
 }
 
-static u32 mpi_msg_free_set(struct pm8001_hba_info *pm8001_ha, void *pMsg,
+u32 pm8001_mpi_msg_free_set(struct pm8001_hba_info *pm8001_ha, void *pMsg,
                             struct outbound_queue_table *circularQ, u8 bc)
 {
         u32 producer_index;
@@ -1305,7 +1378,7 @@ static u32 mpi_msg_free_set(struct pm8001_hba_info *pm8001_ha, void *pMsg,
 
         msgHeader = (struct mpi_msg_hdr *)(pMsg - sizeof(struct mpi_msg_hdr));
         pOutBoundMsgHeader = (struct mpi_msg_hdr *)(circularQ->base_virt +
-                                circularQ->consumer_idx * 64);
+                                circularQ->consumer_idx * pm8001_ha->iomb_size);
         if (pOutBoundMsgHeader != msgHeader) {
                 PM8001_FAIL_DBG(pm8001_ha,
                         pm8001_printk("consumer_idx = %d msgHeader = %p\n",
@@ -1336,13 +1409,14 @@ static u32 mpi_msg_free_set(struct pm8001_hba_info *pm8001_ha, void *pMsg,
 }
 
 /**
- * mpi_msg_consume- get the MPI message from  outbound queue message table.
+ * pm8001_mpi_msg_consume- get the MPI message from outbound queue
+ * message table.
  * @pm8001_ha: our hba card information
  * @circularQ: the outbound queue  table.
  * @messagePtr1: the message contents of this outbound message.
  * @pBC: the message size.
  */
-static u32 mpi_msg_consume(struct pm8001_hba_info *pm8001_ha,
+u32 pm8001_mpi_msg_consume(struct pm8001_hba_info *pm8001_ha,
                            struct outbound_queue_table *circularQ,
                            void **messagePtr1, u8 *pBC)
 {
@@ -1356,7 +1430,7 @@ static u32 mpi_msg_consume(struct pm8001_hba_info *pm8001_ha,
                         /*Get the pointer to the circular queue buffer element*/
                         msgHeader = (struct mpi_msg_hdr *)
                                 (circularQ->base_virt +
-                                circularQ->consumer_idx * 64);
+                                circularQ->consumer_idx * pm8001_ha->iomb_size);
                         /* read header */
                         header_tmp = pm8001_read_32(msgHeader);
                         msgHeader_tmp = cpu_to_le32(header_tmp);
@@ -1416,7 +1490,7 @@ static u32 mpi_msg_consume(struct pm8001_hba_info *pm8001_ha,
         return MPI_IO_STATUS_BUSY;
 }
 
-static void pm8001_work_fn(struct work_struct *work)
+void pm8001_work_fn(struct work_struct *work)
 {
         struct pm8001_work *pw = container_of(work, struct pm8001_work, work);
         struct pm8001_device *pm8001_dev;
@@ -1431,7 +1505,7 @@ static void pm8001_work_fn(struct work_struct *work)
         pm8001_dev = pw->data; /* Most stash device structure */
         if ((pm8001_dev == NULL)
          || ((pw->handler != IO_XFER_ERROR_BREAK)
-          && (pm8001_dev->dev_type == NO_DEVICE))) {
+          && (pm8001_dev->dev_type == SAS_PHY_UNUSED))) {
                 kfree(pw);
                 return;
         }
@@ -1596,7 +1670,7 @@ static void pm8001_work_fn(struct work_struct *work)
         }       break;
         case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS:
                 dev = pm8001_dev->sas_device;
-                pm8001_I_T_nexus_reset(dev);
+                pm8001_I_T_nexus_event_handler(dev);
                 break;
         case IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY:
                 dev = pm8001_dev->sas_device;
@@ -1614,7 +1688,7 @@ static void pm8001_work_fn(struct work_struct *work)
         kfree(pw);
 }
 
-static int pm8001_handle_event(struct pm8001_hba_info *pm8001_ha, void *data,
+int pm8001_handle_event(struct pm8001_hba_info *pm8001_ha, void *data,
                                int handler)
 {
         struct pm8001_work *pw;
@@ -1633,6 +1707,123 @@ static int pm8001_handle_event(struct pm8001_hba_info *pm8001_ha, void *data,
         return ret;
 }
 
+static void pm8001_send_abort_all(struct pm8001_hba_info *pm8001_ha,
+                struct pm8001_device *pm8001_ha_dev)
+{
+        int res;
+        u32 ccb_tag;
+        struct pm8001_ccb_info *ccb;
+        struct sas_task *task = NULL;
+        struct task_abort_req task_abort;
+        struct inbound_queue_table *circularQ;
+        u32 opc = OPC_INB_SATA_ABORT;
+        int ret;
+
+        if (!pm8001_ha_dev) {
+                PM8001_FAIL_DBG(pm8001_ha, pm8001_printk("dev is null\n"));
+                return;
+        }
+
+        task = sas_alloc_slow_task(GFP_ATOMIC);
+
+        if (!task) {
+                PM8001_FAIL_DBG(pm8001_ha, pm8001_printk("cannot "
+                                                "allocate task\n"));
+                return;
+        }
+
+        task->task_done = pm8001_task_done;
+
+        res = pm8001_tag_alloc(pm8001_ha, &ccb_tag);
+        if (res)
+                return;
+
+        ccb = &pm8001_ha->ccb_info[ccb_tag];
+        ccb->device = pm8001_ha_dev;
+        ccb->ccb_tag = ccb_tag;
+        ccb->task = task;
+
+        circularQ = &pm8001_ha->inbnd_q_tbl[0];
+
+        memset(&task_abort, 0, sizeof(task_abort));
+        task_abort.abort_all = cpu_to_le32(1);
+        task_abort.device_id = cpu_to_le32(pm8001_ha_dev->device_id);
+        task_abort.tag = cpu_to_le32(ccb_tag);
+
+        ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &task_abort, 0);
+
+}
+
+static void pm8001_send_read_log(struct pm8001_hba_info *pm8001_ha,
+                struct pm8001_device *pm8001_ha_dev)
+{
+        struct sata_start_req sata_cmd;
+        int res;
+        u32 ccb_tag;
+        struct pm8001_ccb_info *ccb;
+        struct sas_task *task = NULL;
+        struct host_to_dev_fis fis;
+        struct domain_device *dev;
+        struct inbound_queue_table *circularQ;
+        u32 opc = OPC_INB_SATA_HOST_OPSTART;
+
+        task = sas_alloc_slow_task(GFP_ATOMIC);
+
+        if (!task) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("cannot allocate task !!!\n"));
+                return;
+        }
+        task->task_done = pm8001_task_done;
+
+        res = pm8001_tag_alloc(pm8001_ha, &ccb_tag);
+        if (res) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("cannot allocate tag !!!\n"));
+                return;
+        }
+
+        /* allocate domain device by ourselves as libsas
+         * is not going to provide any
+        */
+        dev = kzalloc(sizeof(struct domain_device), GFP_ATOMIC);
+        if (!dev) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("Domain device cannot be allocated\n"));
+                sas_free_task(task);
+                return;
+        } else {
+                task->dev = dev;
+                task->dev->lldd_dev = pm8001_ha_dev;
+        }
+
+        ccb = &pm8001_ha->ccb_info[ccb_tag];
+        ccb->device = pm8001_ha_dev;
+        ccb->ccb_tag = ccb_tag;
+        ccb->task = task;
+        pm8001_ha_dev->id |= NCQ_READ_LOG_FLAG;
+        pm8001_ha_dev->id |= NCQ_2ND_RLE_FLAG;
+
+        memset(&sata_cmd, 0, sizeof(sata_cmd));
+        circularQ = &pm8001_ha->inbnd_q_tbl[0];
+
+        /* construct read log FIS */
+        memset(&fis, 0, sizeof(struct host_to_dev_fis));
+        fis.fis_type = 0x27;
+        fis.flags = 0x80;
+        fis.command = ATA_CMD_READ_LOG_EXT;
+        fis.lbal = 0x10;
+        fis.sector_count = 0x1;
+
+        sata_cmd.tag = cpu_to_le32(ccb_tag);
+        sata_cmd.device_id = cpu_to_le32(pm8001_ha_dev->device_id);
+        sata_cmd.ncqtag_atap_dir_m |= ((0x1 << 7) | (0x5 << 9));
+        memcpy(&sata_cmd.sata_fis, &fis, sizeof(struct host_to_dev_fis));
+
+        res = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &sata_cmd, 0);
+
+}
+
 /**
  * mpi_ssp_completion- process the event that FW response to the SSP request.
  * @pm8001_ha: our hba card information
@@ -1867,7 +2058,7 @@ mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
                 break;
         }
         PM8001_IO_DBG(pm8001_ha,
-                pm8001_printk("scsi_status = %x \n ",
+                pm8001_printk("scsi_status = %x\n ",
                 psspPayload->ssp_resp_iu.status));
         spin_lock_irqsave(&t->task_state_lock, flags);
         t->task_state_flags &= ~SAS_TASK_STATE_PENDING;
@@ -2096,16 +2287,44 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
         status = le32_to_cpu(psataPayload->status);
         tag = le32_to_cpu(psataPayload->tag);
 
+        if (!tag) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("tag null\n"));
+                return;
+        }
         ccb = &pm8001_ha->ccb_info[tag];
         param = le32_to_cpu(psataPayload->param);
-        t = ccb->task;
+        if (ccb) {
+                t = ccb->task;
+                pm8001_dev = ccb->device;
+        } else {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("ccb null\n"));
+                return;
+        }
+
+        if (t) {
+                if (t->dev && (t->dev->lldd_dev))
+                        pm8001_dev = t->dev->lldd_dev;
+        } else {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("task null\n"));
+                return;
+        }
+
+        if ((pm8001_dev && !(pm8001_dev->id & NCQ_READ_LOG_FLAG))
+                && unlikely(!t || !t->lldd_task || !t->dev)) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("task or dev null\n"));
+                return;
+        }
+
         ts = &t->task_status;
-        pm8001_dev = ccb->device;
-        if (status)
+        if (!ts) {
                 PM8001_FAIL_DBG(pm8001_ha,
-                        pm8001_printk("sata IO status 0x%x\n", status));
-        if (unlikely(!t || !t->lldd_task || !t->dev))
+                        pm8001_printk("ts null\n"));
                 return;
+        }
 
         switch (status) {
         case IO_SUCCESS:
@@ -2113,6 +2332,19 @@ mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
                 if (param == 0) {
                         ts->resp = SAS_TASK_COMPLETE;
                         ts->stat = SAM_STAT_GOOD;
+                        /* check if response is for SEND READ LOG */
+                        if (pm8001_dev &&
+                                (pm8001_dev->id & NCQ_READ_LOG_FLAG)) {
+                                /* set new bit for abort_all */
+                                pm8001_dev->id |= NCQ_ABORT_ALL_FLAG;
+                                /* clear bit for read log */
+                                pm8001_dev->id = pm8001_dev->id & 0x7FFFFFFF;
+                                pm8001_send_abort_all(pm8001_ha, pm8001_dev);
+                                /* Free the tag */
+                                pm8001_tag_free(pm8001_ha, tag);
+                                sas_free_task(t);
+                                return;
+                        }
                 } else {
                         u8 len;
                         ts->resp = SAS_TASK_COMPLETE;
@@ -2424,6 +2656,29 @@ static void mpi_sata_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
         unsigned long flags;
 
         ccb = &pm8001_ha->ccb_info[tag];
+
+        if (ccb) {
+                t = ccb->task;
+                pm8001_dev = ccb->device;
+        } else {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("No CCB !!!. returning\n"));
+        }
+        if (event)
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("SATA EVENT 0x%x\n", event));
+
+        /* Check if this is NCQ error */
+        if (event == IO_XFER_ERROR_ABORTED_NCQ_MODE) {
+                /* find device using device id */
+                pm8001_dev = pm8001_find_dev(pm8001_ha, dev_id);
+                /* send read log extension */
+                if (pm8001_dev)
+                        pm8001_send_read_log(pm8001_ha, pm8001_dev);
+                return;
+        }
+
+        ccb = &pm8001_ha->ccb_info[tag];
         t = ccb->task;
         pm8001_dev = ccb->device;
         if (event)
@@ -2432,9 +2687,9 @@ static void mpi_sata_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
         if (unlikely(!t || !t->lldd_task || !t->dev))
                 return;
         ts = &t->task_status;
-        PM8001_IO_DBG(pm8001_ha,
-                pm8001_printk("port_id = %x,device_id = %x\n",
-                port_id, dev_id));
+        PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+                "port_id:0x%x, device_id:0x%x, tag:0x%x, event:0x%x\n",
+                port_id, dev_id, tag, event));
         switch (event) {
         case IO_OVERFLOW:
                 PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_UNDERFLOW\n"));
@@ -2822,8 +3077,8 @@ mpi_smp_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
         }
 }
 
-static void
-mpi_set_dev_state_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+void pm8001_mpi_set_dev_state_resp(struct pm8001_hba_info *pm8001_ha,
+                void *piomb)
 {
         struct set_dev_state_resp *pPayload =
                 (struct set_dev_state_resp *)(piomb + 4);
@@ -2843,8 +3098,7 @@ mpi_set_dev_state_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
         pm8001_ccb_free(pm8001_ha, tag);
 }
 
-static void
-mpi_set_nvmd_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+void pm8001_mpi_set_nvmd_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
 {
         struct get_nvm_data_resp *pPayload =
                 (struct get_nvm_data_resp *)(piomb + 4);
@@ -2863,8 +3117,8 @@ mpi_set_nvmd_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
         pm8001_ccb_free(pm8001_ha, tag);
 }
 
-static void
-mpi_get_nvmd_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+void
+pm8001_mpi_get_nvmd_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
 {
         struct fw_control_ex    *fw_control_context;
         struct get_nvm_data_resp *pPayload =
@@ -2925,7 +3179,7 @@ mpi_get_nvmd_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
         pm8001_ccb_free(pm8001_ha, tag);
 }
 
-static int mpi_local_phy_ctl(struct pm8001_hba_info *pm8001_ha, void *piomb)
+int pm8001_mpi_local_phy_ctl(struct pm8001_hba_info *pm8001_ha, void *piomb)
 {
         struct local_phy_ctl_resp *pPayload =
                 (struct local_phy_ctl_resp *)(piomb + 4);
@@ -2954,7 +3208,7 @@ static int mpi_local_phy_ctl(struct pm8001_hba_info *pm8001_ha, void *piomb)
  * while receive a broadcast(change) primitive just tell the sas
  * layer to discover the changed domain rather than the whole domain.
  */
-static void pm8001_bytes_dmaed(struct pm8001_hba_info *pm8001_ha, int i)
+void pm8001_bytes_dmaed(struct pm8001_hba_info *pm8001_ha, int i)
 {
         struct pm8001_phy *phy = &pm8001_ha->phy[i];
         struct asd_sas_phy *sas_phy = &phy->sas_phy;
@@ -2988,7 +3242,7 @@ static void pm8001_bytes_dmaed(struct pm8001_hba_info *pm8001_ha, int i)
 }
 
 /* Get the link rate speed  */
-static void get_lrate_mode(struct pm8001_phy *phy, u8 link_rate)
+void pm8001_get_lrate_mode(struct pm8001_phy *phy, u8 link_rate)
 {
         struct sas_phy *sas_phy = phy->sas_phy.phy;
 
@@ -3025,7 +3279,7 @@ static void get_lrate_mode(struct pm8001_phy *phy, u8 link_rate)
  * LOCKING: the frame_rcvd_lock needs to be held since this parses the frame
  * buffer.
  */
-static void pm8001_get_attached_sas_addr(struct pm8001_phy *phy,
+void pm8001_get_attached_sas_addr(struct pm8001_phy *phy,
         u8 *sas_addr)
 {
         if (phy->sas_phy.frame_rcvd[0] == 0x34
@@ -3067,7 +3321,7 @@ static void pm8001_hw_event_ack_req(struct pm8001_hba_info *pm8001_ha,
                 ((phyId & 0x0F) << 4) | (port_id & 0x0F));
         payload.param0 = cpu_to_le32(param0);
         payload.param1 = cpu_to_le32(param1);
-        mpi_build_cmd(pm8001_ha, circularQ, opc, &payload);
+        pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &payload, 0);
 }
 
 static int pm8001_chip_phy_ctl_req(struct pm8001_hba_info *pm8001_ha,
@@ -3112,19 +3366,19 @@ hw_event_sas_phy_up(struct pm8001_hba_info *pm8001_ha, void *piomb)
                 pm8001_chip_phy_ctl_req(pm8001_ha, phy_id,
                         PHY_NOTIFY_ENABLE_SPINUP);
                 port->port_attached = 1;
-                get_lrate_mode(phy, link_rate);
+                pm8001_get_lrate_mode(phy, link_rate);
                 break;
         case SAS_EDGE_EXPANDER_DEVICE:
                 PM8001_MSG_DBG(pm8001_ha,
                         pm8001_printk("expander device.\n"));
                 port->port_attached = 1;
-                get_lrate_mode(phy, link_rate);
+                pm8001_get_lrate_mode(phy, link_rate);
                 break;
         case SAS_FANOUT_EXPANDER_DEVICE:
                 PM8001_MSG_DBG(pm8001_ha,
                         pm8001_printk("fanout expander device.\n"));
                 port->port_attached = 1;
-                get_lrate_mode(phy, link_rate);
+                pm8001_get_lrate_mode(phy, link_rate);
                 break;
         default:
                 PM8001_MSG_DBG(pm8001_ha,
@@ -3179,7 +3433,7 @@ hw_event_sata_phy_up(struct pm8001_hba_info *pm8001_ha, void *piomb)
                 " phy id = %d\n", port_id, phy_id));
         port->port_state =  portstate;
         port->port_attached = 1;
-        get_lrate_mode(phy, link_rate);
+        pm8001_get_lrate_mode(phy, link_rate);
         phy->phy_type |= PORT_TYPE_SATA;
         phy->phy_attached = 1;
         phy->sas_phy.oob_mode = SATA_OOB_MODE;
@@ -3189,7 +3443,7 @@ hw_event_sata_phy_up(struct pm8001_hba_info *pm8001_ha, void *piomb)
                 sizeof(struct dev_to_host_fis));
         phy->frame_rcvd_size = sizeof(struct dev_to_host_fis);
         phy->identify.target_port_protocols = SAS_PROTOCOL_SATA;
-        phy->identify.device_type = SATA_DEV;
+        phy->identify.device_type = SAS_SATA_DEV;
         pm8001_get_attached_sas_addr(phy, phy->sas_phy.attached_sas_addr);
         spin_unlock_irqrestore(&phy->sas_phy.frame_rcvd_lock, flags);
         pm8001_bytes_dmaed(pm8001_ha, phy_id);
@@ -3260,7 +3514,7 @@ hw_event_phy_down(struct pm8001_hba_info *pm8001_ha, void *piomb)
 }
 
 /**
- * mpi_reg_resp -process register device ID response.
+ * pm8001_mpi_reg_resp -process register device ID response.
  * @pm8001_ha: our hba card information
  * @piomb: IO message buffer
  *
@@ -3269,7 +3523,7 @@ hw_event_phy_down(struct pm8001_hba_info *pm8001_ha, void *piomb)
  * has assigned, from now,inter-communication with FW is no longer using the
  * SAS address, use device ID which FW assigned.
  */
-static int mpi_reg_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+int pm8001_mpi_reg_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
 {
         u32 status;
         u32 device_id;
@@ -3331,7 +3585,7 @@ static int mpi_reg_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
         return 0;
 }
 
-static int mpi_dereg_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+int pm8001_mpi_dereg_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
 {
         u32 status;
         u32 device_id;
@@ -3347,8 +3601,13 @@ static int mpi_dereg_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
         return 0;
 }
 
-static int
-mpi_fw_flash_update_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+/**
+ * fw_flash_update_resp - Response from FW for flash update command.
+ * @pm8001_ha: our hba card information
+ * @piomb: IO message buffer
+ */
+int pm8001_mpi_fw_flash_update_resp(struct pm8001_hba_info *pm8001_ha,
+                void *piomb)
 {
         u32 status;
         struct fw_control_ex    fw_control_context;
@@ -3403,10 +3662,6 @@ mpi_fw_flash_update_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
                 break;
         }
         ccb->fw_control_context->fw_control->retcode = status;
-        pci_free_consistent(pm8001_ha->pdev,
-                        fw_control_context.len,
-                        fw_control_context.virtAddr,
-                        fw_control_context.phys_addr);
         complete(pm8001_ha->nvmd_completion);
         ccb->task = NULL;
         ccb->ccb_tag = 0xFFFFFFFF;
@@ -3414,8 +3669,7 @@ mpi_fw_flash_update_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
         return 0;
 }
 
-static int
-mpi_general_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+int pm8001_mpi_general_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
 {
         u32 status;
         int i;
@@ -3431,8 +3685,7 @@ mpi_general_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
         return 0;
 }
 
-static int
-mpi_task_abort_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+int pm8001_mpi_task_abort_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
 {
         struct sas_task *t;
         struct pm8001_ccb_info *ccb;
@@ -3440,19 +3693,29 @@ mpi_task_abort_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
         u32 status ;
         u32 tag, scp;
         struct task_status_struct *ts;
+        struct pm8001_device *pm8001_dev;
 
         struct task_abort_resp *pPayload =
                 (struct task_abort_resp *)(piomb + 4);
 
         status = le32_to_cpu(pPayload->status);
         tag = le32_to_cpu(pPayload->tag);
+        if (!tag) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk(" TAG NULL. RETURNING !!!"));
+                return -1;
+        }
+
         scp = le32_to_cpu(pPayload->scp);
         ccb = &pm8001_ha->ccb_info[tag];
         t = ccb->task;
-        PM8001_IO_DBG(pm8001_ha,
-                pm8001_printk(" status = 0x%x\n", status));
-        if (t == NULL)
+        pm8001_dev = ccb->device; /* retrieve device */
+
+        if (!t) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk(" TASK NULL. RETURNING !!!"));
                 return -1;
+        }
         ts = &t->task_status;
         if (status != 0)
                 PM8001_FAIL_DBG(pm8001_ha,
@@ -3476,7 +3739,15 @@ mpi_task_abort_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
         spin_unlock_irqrestore(&t->task_state_lock, flags);
         pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
         mb();
-        t->task_done(t);
+
+        if ((pm8001_dev->id & NCQ_ABORT_ALL_FLAG) && t) {
+                pm8001_tag_free(pm8001_ha, tag);
+                sas_free_task(t);
+                /* clear the flag */
+                pm8001_dev->id &= 0xBFFFFFFF;
+        } else
+                t->task_done(t);
+
         return 0;
 }
 
@@ -3727,17 +3998,17 @@ static void process_one_iomb(struct pm8001_hba_info *pm8001_ha, void *piomb)
         case OPC_OUB_LOCAL_PHY_CNTRL:
                 PM8001_MSG_DBG(pm8001_ha,
                         pm8001_printk("OPC_OUB_LOCAL_PHY_CNTRL\n"));
-                mpi_local_phy_ctl(pm8001_ha, piomb);
+                pm8001_mpi_local_phy_ctl(pm8001_ha, piomb);
                 break;
         case OPC_OUB_DEV_REGIST:
                 PM8001_MSG_DBG(pm8001_ha,
                         pm8001_printk("OPC_OUB_DEV_REGIST\n"));
-                mpi_reg_resp(pm8001_ha, piomb);
+                pm8001_mpi_reg_resp(pm8001_ha, piomb);
                 break;
         case OPC_OUB_DEREG_DEV:
                 PM8001_MSG_DBG(pm8001_ha,
                         pm8001_printk("unregister the device\n"));
-                mpi_dereg_resp(pm8001_ha, piomb);
+                pm8001_mpi_dereg_resp(pm8001_ha, piomb);
                 break;
         case OPC_OUB_GET_DEV_HANDLE:
                 PM8001_MSG_DBG(pm8001_ha,
@@ -3775,7 +4046,7 @@ static void process_one_iomb(struct pm8001_hba_info *pm8001_ha, void *piomb)
         case OPC_OUB_FW_FLASH_UPDATE:
                 PM8001_MSG_DBG(pm8001_ha,
                         pm8001_printk("OPC_OUB_FW_FLASH_UPDATE\n"));
-                mpi_fw_flash_update_resp(pm8001_ha, piomb);
+                pm8001_mpi_fw_flash_update_resp(pm8001_ha, piomb);
                 break;
         case OPC_OUB_GPIO_RESPONSE:
                 PM8001_MSG_DBG(pm8001_ha,
@@ -3788,17 +4059,17 @@ static void process_one_iomb(struct pm8001_hba_info *pm8001_ha, void *piomb)
         case OPC_OUB_GENERAL_EVENT:
                 PM8001_MSG_DBG(pm8001_ha,
                         pm8001_printk("OPC_OUB_GENERAL_EVENT\n"));
-                mpi_general_event(pm8001_ha, piomb);
+                pm8001_mpi_general_event(pm8001_ha, piomb);
                 break;
         case OPC_OUB_SSP_ABORT_RSP:
                 PM8001_MSG_DBG(pm8001_ha,
                         pm8001_printk("OPC_OUB_SSP_ABORT_RSP\n"));
-                mpi_task_abort_resp(pm8001_ha, piomb);
+                pm8001_mpi_task_abort_resp(pm8001_ha, piomb);
                 break;
         case OPC_OUB_SATA_ABORT_RSP:
                 PM8001_MSG_DBG(pm8001_ha,
                         pm8001_printk("OPC_OUB_SATA_ABORT_RSP\n"));
-                mpi_task_abort_resp(pm8001_ha, piomb);
+                pm8001_mpi_task_abort_resp(pm8001_ha, piomb);
                 break;
         case OPC_OUB_SAS_DIAG_MODE_START_END:
                 PM8001_MSG_DBG(pm8001_ha,
@@ -3823,17 +4094,17 @@ static void process_one_iomb(struct pm8001_hba_info *pm8001_ha, void *piomb)
         case OPC_OUB_SMP_ABORT_RSP:
                 PM8001_MSG_DBG(pm8001_ha,
                         pm8001_printk("OPC_OUB_SMP_ABORT_RSP\n"));
-                mpi_task_abort_resp(pm8001_ha, piomb);
+                pm8001_mpi_task_abort_resp(pm8001_ha, piomb);
                 break;
         case OPC_OUB_GET_NVMD_DATA:
                 PM8001_MSG_DBG(pm8001_ha,
                         pm8001_printk("OPC_OUB_GET_NVMD_DATA\n"));
-                mpi_get_nvmd_resp(pm8001_ha, piomb);
+                pm8001_mpi_get_nvmd_resp(pm8001_ha, piomb);
                 break;
         case OPC_OUB_SET_NVMD_DATA:
                 PM8001_MSG_DBG(pm8001_ha,
                         pm8001_printk("OPC_OUB_SET_NVMD_DATA\n"));
-                mpi_set_nvmd_resp(pm8001_ha, piomb);
+                pm8001_mpi_set_nvmd_resp(pm8001_ha, piomb);
                 break;
         case OPC_OUB_DEVICE_HANDLE_REMOVAL:
                 PM8001_MSG_DBG(pm8001_ha,
@@ -3842,7 +4113,7 @@ static void process_one_iomb(struct pm8001_hba_info *pm8001_ha, void *piomb)
         case OPC_OUB_SET_DEVICE_STATE:
                 PM8001_MSG_DBG(pm8001_ha,
                         pm8001_printk("OPC_OUB_SET_DEVICE_STATE\n"));
-                mpi_set_dev_state_resp(pm8001_ha, piomb);
+                pm8001_mpi_set_dev_state_resp(pm8001_ha, piomb);
                 break;
         case OPC_OUB_GET_DEVICE_STATE:
                 PM8001_MSG_DBG(pm8001_ha,
@@ -3864,7 +4135,7 @@ static void process_one_iomb(struct pm8001_hba_info *pm8001_ha, void *piomb)
         }
 }
 
-static int process_oq(struct pm8001_hba_info *pm8001_ha)
+static int process_oq(struct pm8001_hba_info *pm8001_ha, u8 vec)
 {
         struct outbound_queue_table *circularQ;
         void *pMsg1 = NULL;
@@ -3873,14 +4144,15 @@ static int process_oq(struct pm8001_hba_info *pm8001_ha)
         unsigned long flags;
 
         spin_lock_irqsave(&pm8001_ha->lock, flags);
-        circularQ = &pm8001_ha->outbnd_q_tbl[0];
+        circularQ = &pm8001_ha->outbnd_q_tbl[vec];
         do {
-                ret = mpi_msg_consume(pm8001_ha, circularQ, &pMsg1, &bc);
+                ret = pm8001_mpi_msg_consume(pm8001_ha, circularQ, &pMsg1, &bc);
                 if (MPI_IO_STATUS_SUCCESS == ret) {
                         /* process the outbound message */
                         process_one_iomb(pm8001_ha, (void *)(pMsg1 - 4));
                         /* free the message from the outbound circular buffer */
-                        mpi_msg_free_set(pm8001_ha, pMsg1, circularQ, bc);
+                        pm8001_mpi_msg_free_set(pm8001_ha, pMsg1,
+                                                        circularQ, bc);
                 }
                 if (MPI_IO_STATUS_BUSY == ret) {
                         /* Update the producer index from SPC */
@@ -3903,7 +4175,7 @@ static const u8 data_dir_flags[] = {
         [PCI_DMA_FROMDEVICE]    = DATA_DIR_IN,/* INBOUND */
         [PCI_DMA_NONE]          = DATA_DIR_NONE,/* NO TRANSFER */
 };
-static void
+void
 pm8001_chip_make_sg(struct scatterlist *scatter, int nr, void *prd)
 {
         int i;
@@ -3978,7 +4250,7 @@ static int pm8001_chip_smp_req(struct pm8001_hba_info *pm8001_ha,
         smp_cmd.long_smp_req.long_resp_size =
                 cpu_to_le32((u32)sg_dma_len(&task->smp_task.smp_resp)-4);
         build_smp_cmd(pm8001_dev->device_id, smp_cmd.tag, &smp_cmd);
-        mpi_build_cmd(pm8001_ha, circularQ, opc, (u32 *)&smp_cmd);
+        pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (u32 *)&smp_cmd, 0);
         return 0;
 
 err_out_2:
@@ -4042,7 +4314,7 @@ static int pm8001_chip_ssp_io_req(struct pm8001_hba_info *pm8001_ha,
                 ssp_cmd.len = cpu_to_le32(task->total_xfer_len);
                 ssp_cmd.esgl = 0;
         }
-        ret = mpi_build_cmd(pm8001_ha, circularQ, opc, &ssp_cmd);
+        ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &ssp_cmd, 0);
         return ret;
 }
 
@@ -4060,6 +4332,7 @@ static int pm8001_chip_sata_req(struct pm8001_hba_info *pm8001_ha,
         u32 ATAP = 0x0;
         u32 dir;
         struct inbound_queue_table *circularQ;
+        unsigned long flags;
         u32  opc = OPC_INB_SATA_HOST_OPSTART;
         memset(&sata_cmd, 0, sizeof(sata_cmd));
         circularQ = &pm8001_ha->inbnd_q_tbl[0];
@@ -4080,8 +4353,10 @@ static int pm8001_chip_sata_req(struct pm8001_hba_info *pm8001_ha,
                         PM8001_IO_DBG(pm8001_ha, pm8001_printk("FPDMA\n"));
                 }
         }
-        if (task->ata_task.use_ncq && pm8001_get_ncq_tag(task, &hdr_tag))
+        if (task->ata_task.use_ncq && pm8001_get_ncq_tag(task, &hdr_tag)) {
+                task->ata_task.fis.sector_count |= (u8) (hdr_tag << 3);
                 ncg_tag = hdr_tag;
+        }
         dir = data_dir_flags[task->data_dir] << 8;
         sata_cmd.tag = cpu_to_le32(tag);
         sata_cmd.device_id = cpu_to_le32(pm8001_ha_dev->device_id);
@@ -4112,7 +4387,55 @@ static int pm8001_chip_sata_req(struct pm8001_hba_info *pm8001_ha,
                 sata_cmd.len = cpu_to_le32(task->total_xfer_len);
                 sata_cmd.esgl = 0;
         }
-        ret = mpi_build_cmd(pm8001_ha, circularQ, opc, &sata_cmd);
+
+        /* Check for read log for failed drive and return */
+        if (sata_cmd.sata_fis.command == 0x2f) {
+                if (pm8001_ha_dev && ((pm8001_ha_dev->id & NCQ_READ_LOG_FLAG) ||
+                        (pm8001_ha_dev->id & NCQ_ABORT_ALL_FLAG) ||
+                        (pm8001_ha_dev->id & NCQ_2ND_RLE_FLAG))) {
+                        struct task_status_struct *ts;
+
+                        pm8001_ha_dev->id &= 0xDFFFFFFF;
+                        ts = &task->task_status;
+
+                        spin_lock_irqsave(&task->task_state_lock, flags);
+                        ts->resp = SAS_TASK_COMPLETE;
+                        ts->stat = SAM_STAT_GOOD;
+                        task->task_state_flags &= ~SAS_TASK_STATE_PENDING;
+                        task->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
+                        task->task_state_flags |= SAS_TASK_STATE_DONE;
+                        if (unlikely((task->task_state_flags &
+                                        SAS_TASK_STATE_ABORTED))) {
+                                spin_unlock_irqrestore(&task->task_state_lock,
+                                                        flags);
+                                PM8001_FAIL_DBG(pm8001_ha,
+                                        pm8001_printk("task 0x%p resp 0x%x "
+                                        " stat 0x%x but aborted by upper layer "
+                                        "\n", task, ts->resp, ts->stat));
+                                pm8001_ccb_task_free(pm8001_ha, task, ccb, tag);
+                        } else if (task->uldd_task) {
+                                spin_unlock_irqrestore(&task->task_state_lock,
+                                                        flags);
+                                pm8001_ccb_task_free(pm8001_ha, task, ccb, tag);
+                                mb();/* ditto */
+                                spin_unlock_irq(&pm8001_ha->lock);
+                                task->task_done(task);
+                                spin_lock_irq(&pm8001_ha->lock);
+                                return 0;
+                        } else if (!task->uldd_task) {
+                                spin_unlock_irqrestore(&task->task_state_lock,
+                                                        flags);
+                                pm8001_ccb_task_free(pm8001_ha, task, ccb, tag);
+                                mb();/*ditto*/
+                                spin_unlock_irq(&pm8001_ha->lock);
+                                task->task_done(task);
+                                spin_lock_irq(&pm8001_ha->lock);
+                                return 0;
+                        }
+                }
+        }
+
+        ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &sata_cmd, 0);
         return ret;
 }
 
@@ -4142,12 +4465,12 @@ pm8001_chip_phy_start_req(struct pm8001_hba_info *pm8001_ha, u8 phy_id)
         payload.ase_sh_lm_slr_phyid = cpu_to_le32(SPINHOLD_DISABLE |
                 LINKMODE_AUTO | LINKRATE_15 |
                 LINKRATE_30 | LINKRATE_60 | phy_id);
-        payload.sas_identify.dev_type = SAS_END_DEV;
+        payload.sas_identify.dev_type = SAS_END_DEVICE;
         payload.sas_identify.initiator_bits = SAS_PROTOCOL_ALL;
         memcpy(payload.sas_identify.sas_addr,
                 pm8001_ha->sas_addr, SAS_ADDR_SIZE);
         payload.sas_identify.phy_id = phy_id;
-        ret = mpi_build_cmd(pm8001_ha, circularQ, opcode, &payload);
+        ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opcode, &payload, 0);
         return ret;
 }
 
@@ -4157,7 +4480,7 @@ pm8001_chip_phy_start_req(struct pm8001_hba_info *pm8001_ha, u8 phy_id)
  * @num: the inbound queue number
  * @phy_id: the phy id which we wanted to start up.
  */
-static int pm8001_chip_phy_stop_req(struct pm8001_hba_info *pm8001_ha,
+int pm8001_chip_phy_stop_req(struct pm8001_hba_info *pm8001_ha,
         u8 phy_id)
 {
         struct phy_stop_req payload;
@@ -4169,12 +4492,12 @@ static int pm8001_chip_phy_stop_req(struct pm8001_hba_info *pm8001_ha,
         memset(&payload, 0, sizeof(payload));
         payload.tag = cpu_to_le32(tag);
         payload.phy_id = cpu_to_le32(phy_id);
-        ret = mpi_build_cmd(pm8001_ha, circularQ, opcode, &payload);
+        ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opcode, &payload, 0);
         return ret;
 }
 
 /**
- * see comments on mpi_reg_resp.
+ * see comments on pm8001_mpi_reg_resp.
  */
 static int pm8001_chip_reg_dev_req(struct pm8001_hba_info *pm8001_ha,
         struct pm8001_device *pm8001_dev, u32 flag)
@@ -4204,11 +4527,11 @@ static int pm8001_chip_reg_dev_req(struct pm8001_hba_info *pm8001_ha,
         if (flag == 1)
                 stp_sspsmp_sata = 0x02; /*direct attached sata */
         else {
-                if (pm8001_dev->dev_type == SATA_DEV)
+                if (pm8001_dev->dev_type == SAS_SATA_DEV)
                         stp_sspsmp_sata = 0x00; /* stp*/
-                else if (pm8001_dev->dev_type == SAS_END_DEV ||
-                        pm8001_dev->dev_type == EDGE_DEV ||
-                        pm8001_dev->dev_type == FANOUT_DEV)
+                else if (pm8001_dev->dev_type == SAS_END_DEVICE ||
+                        pm8001_dev->dev_type == SAS_EDGE_EXPANDER_DEVICE ||
+                        pm8001_dev->dev_type == SAS_FANOUT_EXPANDER_DEVICE)
                         stp_sspsmp_sata = 0x01; /*ssp or smp*/
         }
         if (parent_dev && DEV_IS_EXPANDER(parent_dev->dev_type))
@@ -4228,14 +4551,14 @@ static int pm8001_chip_reg_dev_req(struct pm8001_hba_info *pm8001_ha,
                 cpu_to_le32(ITNT | (firstBurstSize * 0x10000));
         memcpy(payload.sas_addr, pm8001_dev->sas_device->sas_addr,
                 SAS_ADDR_SIZE);
-        rc = mpi_build_cmd(pm8001_ha, circularQ, opc, &payload);
+        rc = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &payload, 0);
         return rc;
 }
 
 /**
- * see comments on mpi_reg_resp.
+ * see comments on pm8001_mpi_reg_resp.
  */
-static int pm8001_chip_dereg_dev_req(struct pm8001_hba_info *pm8001_ha,
+int pm8001_chip_dereg_dev_req(struct pm8001_hba_info *pm8001_ha,
         u32 device_id)
 {
         struct dereg_dev_req payload;
@@ -4249,7 +4572,7 @@ static int pm8001_chip_dereg_dev_req(struct pm8001_hba_info *pm8001_ha,
         payload.device_id = cpu_to_le32(device_id);
         PM8001_MSG_DBG(pm8001_ha,
                 pm8001_printk("unregister device device_id = %d\n", device_id));
-        ret = mpi_build_cmd(pm8001_ha, circularQ, opc, &payload);
+        ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &payload, 0);
         return ret;
 }
 
@@ -4272,7 +4595,7 @@ static int pm8001_chip_phy_ctl_req(struct pm8001_hba_info *pm8001_ha,
         payload.tag = cpu_to_le32(1);
         payload.phyop_phyid =
                 cpu_to_le32(((phy_op & 0xff) << 8) | (phyId & 0x0F));
-        ret = mpi_build_cmd(pm8001_ha, circularQ, opc, &payload);
+        ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &payload, 0);
         return ret;
 }
 
@@ -4296,11 +4619,11 @@ static u32 pm8001_chip_is_our_interupt(struct pm8001_hba_info *pm8001_ha)
  * @stat: stat.
  */
 static irqreturn_t
-pm8001_chip_isr(struct pm8001_hba_info *pm8001_ha)
+pm8001_chip_isr(struct pm8001_hba_info *pm8001_ha, u8 vec)
 {
-        pm8001_chip_interrupt_disable(pm8001_ha);
-        process_oq(pm8001_ha);
-        pm8001_chip_interrupt_enable(pm8001_ha);
+        pm8001_chip_interrupt_disable(pm8001_ha, vec);
+        process_oq(pm8001_ha, vec);
+        pm8001_chip_interrupt_enable(pm8001_ha, vec);
         return IRQ_HANDLED;
 }
 
@@ -4322,7 +4645,7 @@ static int send_task_abort(struct pm8001_hba_info *pm8001_ha, u32 opc,
                 task_abort.device_id = cpu_to_le32(dev_id);
                 task_abort.tag = cpu_to_le32(cmd_tag);
         }
-        ret = mpi_build_cmd(pm8001_ha, circularQ, opc, &task_abort);
+        ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &task_abort, 0);
         return ret;
 }
 
@@ -4331,16 +4654,17 @@ static int send_task_abort(struct pm8001_hba_info *pm8001_ha, u32 opc,
  * @task: the task we wanted to aborted.
  * @flag: the abort flag.
  */
-static int pm8001_chip_abort_task(struct pm8001_hba_info *pm8001_ha,
+int pm8001_chip_abort_task(struct pm8001_hba_info *pm8001_ha,
         struct pm8001_device *pm8001_dev, u8 flag, u32 task_tag, u32 cmd_tag)
 {
         u32 opc, device_id;
         int rc = TMF_RESP_FUNC_FAILED;
-        PM8001_EH_DBG(pm8001_ha, pm8001_printk("cmd_tag = %x, abort task tag"
-                " = %x", cmd_tag, task_tag));
-        if (pm8001_dev->dev_type == SAS_END_DEV)
+        PM8001_EH_DBG(pm8001_ha,
+                pm8001_printk("cmd_tag = %x, abort task tag = 0x%x",
+                        cmd_tag, task_tag));
+        if (pm8001_dev->dev_type == SAS_END_DEVICE)
                 opc = OPC_INB_SSP_ABORT;
-        else if (pm8001_dev->dev_type == SATA_DEV)
+        else if (pm8001_dev->dev_type == SAS_SATA_DEV)
                 opc = OPC_INB_SATA_ABORT;
         else
                 opc = OPC_INB_SMP_ABORT;/* SMP */
@@ -4358,7 +4682,7 @@ static int pm8001_chip_abort_task(struct pm8001_hba_info *pm8001_ha,
  * @ccb: the ccb information.
  * @tmf: task management function.
  */
-static int pm8001_chip_ssp_tm_req(struct pm8001_hba_info *pm8001_ha,
+int pm8001_chip_ssp_tm_req(struct pm8001_hba_info *pm8001_ha,
         struct pm8001_ccb_info *ccb, struct pm8001_tmf_task *tmf)
 {
         struct sas_task *task = ccb->task;
@@ -4376,11 +4700,11 @@ static int pm8001_chip_ssp_tm_req(struct pm8001_hba_info *pm8001_ha,
         memcpy(sspTMCmd.lun, task->ssp_task.LUN, 8);
         sspTMCmd.tag = cpu_to_le32(ccb->ccb_tag);
         circularQ = &pm8001_ha->inbnd_q_tbl[0];
-        ret = mpi_build_cmd(pm8001_ha, circularQ, opc, &sspTMCmd);
+        ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &sspTMCmd, 0);
         return ret;
 }
 
-static int pm8001_chip_get_nvmd_req(struct pm8001_hba_info *pm8001_ha,
+int pm8001_chip_get_nvmd_req(struct pm8001_hba_info *pm8001_ha,
         void *payload)
 {
         u32 opc = OPC_INB_GET_NVMD_DATA;
@@ -4397,7 +4721,7 @@ static int pm8001_chip_get_nvmd_req(struct pm8001_hba_info *pm8001_ha,
         fw_control_context = kzalloc(sizeof(struct fw_control_ex), GFP_KERNEL);
         if (!fw_control_context)
                 return -ENOMEM;
-        fw_control_context->usrAddr = (u8 *)&ioctl_payload->func_specific[0];
+        fw_control_context->usrAddr = (u8 *)ioctl_payload->func_specific;
         fw_control_context->len = ioctl_payload->length;
         circularQ = &pm8001_ha->inbnd_q_tbl[0];
         memset(&nvmd_req, 0, sizeof(nvmd_req));
@@ -4456,11 +4780,11 @@ static int pm8001_chip_get_nvmd_req(struct pm8001_hba_info *pm8001_ha,
         default:
                 break;
         }
-        rc = mpi_build_cmd(pm8001_ha, circularQ, opc, &nvmd_req);
+        rc = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &nvmd_req, 0);
         return rc;
 }
 
-static int pm8001_chip_set_nvmd_req(struct pm8001_hba_info *pm8001_ha,
+int pm8001_chip_set_nvmd_req(struct pm8001_hba_info *pm8001_ha,
         void *payload)
 {
         u32 opc = OPC_INB_SET_NVMD_DATA;
@@ -4479,7 +4803,7 @@ static int pm8001_chip_set_nvmd_req(struct pm8001_hba_info *pm8001_ha,
                 return -ENOMEM;
         circularQ = &pm8001_ha->inbnd_q_tbl[0];
         memcpy(pm8001_ha->memoryMap.region[NVMD].virt_ptr,
-                ioctl_payload->func_specific,
+                &ioctl_payload->func_specific,
                 ioctl_payload->length);
         memset(&nvmd_req, 0, sizeof(nvmd_req));
         rc = pm8001_tag_alloc(pm8001_ha, &tag);
@@ -4536,7 +4860,7 @@ static int pm8001_chip_set_nvmd_req(struct pm8001_hba_info *pm8001_ha,
         default:
                 break;
         }
-        rc = mpi_build_cmd(pm8001_ha, circularQ, opc, &nvmd_req);
+        rc = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &nvmd_req, 0);
         return rc;
 }
 
@@ -4545,7 +4869,7 @@ static int pm8001_chip_set_nvmd_req(struct pm8001_hba_info *pm8001_ha,
  * @pm8001_ha: our hba card information.
  * @fw_flash_updata_info: firmware flash update param
  */
-static int
+int
 pm8001_chip_fw_flash_update_build(struct pm8001_hba_info *pm8001_ha,
         void *fw_flash_updata_info, u32 tag)
 {
@@ -4567,11 +4891,11 @@ pm8001_chip_fw_flash_update_build(struct pm8001_hba_info *pm8001_ha,
                 cpu_to_le32(lower_32_bits(le64_to_cpu(info->sgl.addr)));
         payload.sgl_addr_hi =
                 cpu_to_le32(upper_32_bits(le64_to_cpu(info->sgl.addr)));
-        ret = mpi_build_cmd(pm8001_ha, circularQ, opc, &payload);
+        ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &payload, 0);
         return ret;
 }
 
-static int
+int
 pm8001_chip_fw_flash_update_req(struct pm8001_hba_info *pm8001_ha,
         void *payload)
 {
@@ -4581,29 +4905,14 @@ pm8001_chip_fw_flash_update_req(struct pm8001_hba_info *pm8001_ha,
         int rc;
         u32 tag;
         struct pm8001_ccb_info *ccb;
-        void *buffer = NULL;
-        dma_addr_t phys_addr;
-        u32 phys_addr_hi;
-        u32 phys_addr_lo;
+        void *buffer = pm8001_ha->memoryMap.region[FW_FLASH].virt_ptr;
+        dma_addr_t phys_addr = pm8001_ha->memoryMap.region[FW_FLASH].phys_addr;
         struct pm8001_ioctl_payload *ioctl_payload = payload;
 
         fw_control_context = kzalloc(sizeof(struct fw_control_ex), GFP_KERNEL);
         if (!fw_control_context)
                 return -ENOMEM;
-        fw_control = (struct fw_control_info *)&ioctl_payload->func_specific[0];
-        if (fw_control->len != 0) {
-                if (pm8001_mem_alloc(pm8001_ha->pdev,
-                        (void **)&buffer,
-                        &phys_addr,
-                        &phys_addr_hi,
-                        &phys_addr_lo,
-                        fw_control->len, 0) != 0) {
-                                PM8001_FAIL_DBG(pm8001_ha,
-                                        pm8001_printk("Mem alloc failure\n"));
-                                kfree(fw_control_context);
-                                return -ENOMEM;
-                }
-        }
+        fw_control = (struct fw_control_info *)&ioctl_payload->func_specific;
         memcpy(buffer, fw_control->buffer, fw_control->len);
         flash_update_info.sgl.addr = cpu_to_le64(phys_addr);
         flash_update_info.sgl.im_len.len = cpu_to_le32(fw_control->len);
@@ -4613,6 +4922,7 @@ pm8001_chip_fw_flash_update_req(struct pm8001_hba_info *pm8001_ha,
         flash_update_info.total_image_len = fw_control->size;
         fw_control_context->fw_control = fw_control;
         fw_control_context->virtAddr = buffer;
+        fw_control_context->phys_addr = phys_addr;
         fw_control_context->len = fw_control->len;
         rc = pm8001_tag_alloc(pm8001_ha, &tag);
         if (rc) {
@@ -4627,7 +4937,7 @@ pm8001_chip_fw_flash_update_req(struct pm8001_hba_info *pm8001_ha,
         return rc;
 }
 
-static int
+int
 pm8001_chip_set_dev_state_req(struct pm8001_hba_info *pm8001_ha,
         struct pm8001_device *pm8001_dev, u32 state)
 {
@@ -4648,7 +4958,7 @@ pm8001_chip_set_dev_state_req(struct pm8001_hba_info *pm8001_ha,
         payload.tag = cpu_to_le32(tag);
         payload.device_id = cpu_to_le32(pm8001_dev->device_id);
         payload.nds = cpu_to_le32(state);
-        rc = mpi_build_cmd(pm8001_ha, circularQ, opc, &payload);
+        rc = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &payload, 0);
         return rc;
 
 }
@@ -4673,7 +4983,7 @@ pm8001_chip_sas_re_initialization(struct pm8001_hba_info *pm8001_ha)
         payload.SSAHOLT = cpu_to_le32(0xd << 25);
         payload.sata_hol_tmo = cpu_to_le32(80);
         payload.open_reject_cmdretries_data_retries = cpu_to_le32(0xff00ff);
-        rc = mpi_build_cmd(pm8001_ha, circularQ, opc, &payload);
+        rc = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &payload, 0);
         return rc;
 
 }
@@ -4706,4 +5016,3 @@ const struct pm8001_dispatch pm8001_8001_dispatch = {
         .set_dev_state_req      = pm8001_chip_set_dev_state_req,
         .sas_re_init_req        = pm8001_chip_sas_re_initialization,
 };
-
diff --git a/drivers/scsi/pm8001/pm8001_hwi.h b/drivers/scsi/pm8001/pm8001_hwi.h
index d437309cb1e1..d7c1e2034226 100644
--- a/drivers/scsi/pm8001/pm8001_hwi.h
+++ b/drivers/scsi/pm8001/pm8001_hwi.h
@@ -131,6 +131,8 @@
 #define LINKRATE_30                     (0x02 << 8)
 #define LINKRATE_60                     (0x04 << 8)
 
+/* for new SPC controllers MEMBASE III is shared between BIOS and DATA */
+#define GSM_SM_BASE                     0x4F0000
 struct mpi_msg_hdr{
         __le32  header; /* Bits [11:0]  - Message operation code */
         /* Bits [15:12] - Message Category */
@@ -298,7 +300,7 @@ struct local_phy_ctl_resp {
 
 
 #define OP_BITS 0x0000FF00
-#define ID_BITS 0x0000000F
+#define ID_BITS 0x000000FF
 
 /*
  * brief the data structure of PORT Control Command
diff --git a/drivers/scsi/pm8001/pm8001_init.c b/drivers/scsi/pm8001/pm8001_init.c
index 3d5e522e00fc..e4b9bc7f5410 100644
--- a/drivers/scsi/pm8001/pm8001_init.c
+++ b/drivers/scsi/pm8001/pm8001_init.c
@@ -1,5 +1,5 @@
 /*
- * PMC-Sierra SPC 8001 SAS/SATA based host adapters driver
+ * PMC-Sierra PM8001/8081/8088/8089 SAS/SATA based host adapters driver
  *
  * Copyright (c) 2008-2009 USI Co., Ltd.
  * All rights reserved.
@@ -44,8 +44,16 @@
 
 static struct scsi_transport_template *pm8001_stt;
 
+/**
+ * chip info structure to identify chip key functionality as
+ * encryption available/not, no of ports, hw specific function ref
+ */
 static const struct pm8001_chip_info pm8001_chips[] = {
-        [chip_8001] = {  8, &pm8001_8001_dispatch,},
+        [chip_8001] = {0,  8, &pm8001_8001_dispatch,},
+        [chip_8008] = {0,  8, &pm8001_80xx_dispatch,},
+        [chip_8009] = {1,  8, &pm8001_80xx_dispatch,},
+        [chip_8018] = {0,  16, &pm8001_80xx_dispatch,},
+        [chip_8019] = {1,  16, &pm8001_80xx_dispatch,},
 };
 static int pm8001_id;
 
@@ -155,37 +163,75 @@ static void pm8001_free(struct pm8001_hba_info *pm8001_ha)
 }
 
 #ifdef PM8001_USE_TASKLET
+
+/**
+ * tasklet for 64 msi-x interrupt handler
+ * @opaque: the passed general host adapter struct
+ * Note: pm8001_tasklet is common for pm8001 & pm80xx
+ */
 static void pm8001_tasklet(unsigned long opaque)
 {
         struct pm8001_hba_info *pm8001_ha;
+        u32 vec;
         pm8001_ha = (struct pm8001_hba_info *)opaque;
         if (unlikely(!pm8001_ha))
                 BUG_ON(1);
-        PM8001_CHIP_DISP->isr(pm8001_ha);
+        vec = pm8001_ha->int_vector;
+        PM8001_CHIP_DISP->isr(pm8001_ha, vec);
+}
+#endif
+
+static struct  pm8001_hba_info *outq_to_hba(u8 *outq)
+{
+        return container_of((outq - *outq), struct pm8001_hba_info, outq[0]);
 }
+
+/**
+ * pm8001_interrupt_handler_msix - main MSIX interrupt handler.
+ * It obtains the vector number and calls the equivalent bottom
+ * half or services directly.
+ * @opaque: the passed outbound queue/vector. Host structure is
+ * retrieved from the same.
+ */
+static irqreturn_t pm8001_interrupt_handler_msix(int irq, void *opaque)
+{
+        struct pm8001_hba_info *pm8001_ha = outq_to_hba(opaque);
+        u8 outq = *(u8 *)opaque;
+        irqreturn_t ret = IRQ_HANDLED;
+        if (unlikely(!pm8001_ha))
+                return IRQ_NONE;
+        if (!PM8001_CHIP_DISP->is_our_interupt(pm8001_ha))
+                return IRQ_NONE;
+        pm8001_ha->int_vector = outq;
+#ifdef PM8001_USE_TASKLET
+        tasklet_schedule(&pm8001_ha->tasklet);
+#else
+        ret = PM8001_CHIP_DISP->isr(pm8001_ha, outq);
 #endif
+        return ret;
+}
 
+/**
+ * pm8001_interrupt_handler_intx - main INTx interrupt handler.
+ * @dev_id: sas_ha structure. The HBA is retrieved from sas_has structure.
+ */
 
- /**
-  * pm8001_interrupt - when HBA originate a interrupt,we should invoke this
-  * dispatcher to handle each case.
-  * @irq: irq number.
-  * @opaque: the passed general host adapter struct
-  */
-static irqreturn_t pm8001_interrupt(int irq, void *opaque)
+static irqreturn_t pm8001_interrupt_handler_intx(int irq, void *dev_id)
 {
         struct pm8001_hba_info *pm8001_ha;
         irqreturn_t ret = IRQ_HANDLED;
-        struct sas_ha_struct *sha = opaque;
+        struct sas_ha_struct *sha = dev_id;
         pm8001_ha = sha->lldd_ha;
         if (unlikely(!pm8001_ha))
                 return IRQ_NONE;
         if (!PM8001_CHIP_DISP->is_our_interupt(pm8001_ha))
                 return IRQ_NONE;
+
+        pm8001_ha->int_vector = 0;
 #ifdef PM8001_USE_TASKLET
         tasklet_schedule(&pm8001_ha->tasklet);
 #else
-        ret = PM8001_CHIP_DISP->isr(pm8001_ha);
+        ret = PM8001_CHIP_DISP->isr(pm8001_ha, 0);
 #endif
         return ret;
 }
@@ -195,10 +241,14 @@ static irqreturn_t pm8001_interrupt(int irq, void *opaque)
  * @pm8001_ha:our hba structure.
  *
  */
-static int pm8001_alloc(struct pm8001_hba_info *pm8001_ha)
+static int pm8001_alloc(struct pm8001_hba_info *pm8001_ha,
+                        const struct pci_device_id *ent)
 {
         int i;
         spin_lock_init(&pm8001_ha->lock);
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("pm8001_alloc: PHY:%x\n",
+                                pm8001_ha->chip->n_phy));
         for (i = 0; i < pm8001_ha->chip->n_phy; i++) {
                 pm8001_phy_init(pm8001_ha, i);
                 pm8001_ha->port[i].wide_port_phymap = 0;
@@ -222,30 +272,57 @@ static int pm8001_alloc(struct pm8001_hba_info *pm8001_ha)
         pm8001_ha->memoryMap.region[IOP].total_len = PM8001_EVENT_LOG_SIZE;
         pm8001_ha->memoryMap.region[IOP].alignment = 32;
 
-        /* MPI Memory region 3 for consumer Index of inbound queues */
-        pm8001_ha->memoryMap.region[CI].num_elements = 1;
-        pm8001_ha->memoryMap.region[CI].element_size = 4;
-        pm8001_ha->memoryMap.region[CI].total_len = 4;
-        pm8001_ha->memoryMap.region[CI].alignment = 4;
-
-        /* MPI Memory region 4 for producer Index of outbound queues */
-        pm8001_ha->memoryMap.region[PI].num_elements = 1;
-        pm8001_ha->memoryMap.region[PI].element_size = 4;
-        pm8001_ha->memoryMap.region[PI].total_len = 4;
-        pm8001_ha->memoryMap.region[PI].alignment = 4;
-
-        /* MPI Memory region 5 inbound queues */
-        pm8001_ha->memoryMap.region[IB].num_elements = PM8001_MPI_QUEUE;
-        pm8001_ha->memoryMap.region[IB].element_size = 64;
-        pm8001_ha->memoryMap.region[IB].total_len = PM8001_MPI_QUEUE * 64;
-        pm8001_ha->memoryMap.region[IB].alignment = 64;
-
-        /* MPI Memory region 6 outbound queues */
-        pm8001_ha->memoryMap.region[OB].num_elements = PM8001_MPI_QUEUE;
-        pm8001_ha->memoryMap.region[OB].element_size = 64;
-        pm8001_ha->memoryMap.region[OB].total_len = PM8001_MPI_QUEUE * 64;
-        pm8001_ha->memoryMap.region[OB].alignment = 64;
+        for (i = 0; i < PM8001_MAX_SPCV_INB_NUM; i++) {
+                /* MPI Memory region 3 for consumer Index of inbound queues */
+                pm8001_ha->memoryMap.region[CI+i].num_elements = 1;
+                pm8001_ha->memoryMap.region[CI+i].element_size = 4;
+                pm8001_ha->memoryMap.region[CI+i].total_len = 4;
+                pm8001_ha->memoryMap.region[CI+i].alignment = 4;
+
+                if ((ent->driver_data) != chip_8001) {
+                        /* MPI Memory region 5 inbound queues */
+                        pm8001_ha->memoryMap.region[IB+i].num_elements =
+                                                PM8001_MPI_QUEUE;
+                        pm8001_ha->memoryMap.region[IB+i].element_size = 128;
+                        pm8001_ha->memoryMap.region[IB+i].total_len =
+                                                PM8001_MPI_QUEUE * 128;
+                        pm8001_ha->memoryMap.region[IB+i].alignment = 128;
+                } else {
+                        pm8001_ha->memoryMap.region[IB+i].num_elements =
+                                                PM8001_MPI_QUEUE;
+                        pm8001_ha->memoryMap.region[IB+i].element_size = 64;
+                        pm8001_ha->memoryMap.region[IB+i].total_len =
+                                                PM8001_MPI_QUEUE * 64;
+                        pm8001_ha->memoryMap.region[IB+i].alignment = 64;
+                }
+        }
+
+        for (i = 0; i < PM8001_MAX_SPCV_OUTB_NUM; i++) {
+                /* MPI Memory region 4 for producer Index of outbound queues */
+                pm8001_ha->memoryMap.region[PI+i].num_elements = 1;
+                pm8001_ha->memoryMap.region[PI+i].element_size = 4;
+                pm8001_ha->memoryMap.region[PI+i].total_len = 4;
+                pm8001_ha->memoryMap.region[PI+i].alignment = 4;
+
+                if (ent->driver_data != chip_8001) {
+                        /* MPI Memory region 6 Outbound queues */
+                        pm8001_ha->memoryMap.region[OB+i].num_elements =
+                                                PM8001_MPI_QUEUE;
+                        pm8001_ha->memoryMap.region[OB+i].element_size = 128;
+                        pm8001_ha->memoryMap.region[OB+i].total_len =
+                                                PM8001_MPI_QUEUE * 128;
+                        pm8001_ha->memoryMap.region[OB+i].alignment = 128;
+                } else {
+                        /* MPI Memory region 6 Outbound queues */
+                        pm8001_ha->memoryMap.region[OB+i].num_elements =
+                                                PM8001_MPI_QUEUE;
+                        pm8001_ha->memoryMap.region[OB+i].element_size = 64;
+                        pm8001_ha->memoryMap.region[OB+i].total_len =
+                                                PM8001_MPI_QUEUE * 64;
+                        pm8001_ha->memoryMap.region[OB+i].alignment = 64;
+                }
 
+        }
         /* Memory region write DMA*/
         pm8001_ha->memoryMap.region[NVMD].num_elements = 1;
         pm8001_ha->memoryMap.region[NVMD].element_size = 4096;
@@ -264,6 +341,9 @@ static int pm8001_alloc(struct pm8001_hba_info *pm8001_ha)
         pm8001_ha->memoryMap.region[CCB_MEM].total_len = PM8001_MAX_CCB *
                 sizeof(struct pm8001_ccb_info);
 
+        /* Memory region for fw flash */
+        pm8001_ha->memoryMap.region[FW_FLASH].total_len = 4096;
+
         for (i = 0; i < USI_MAX_MEMCNT; i++) {
                 if (pm8001_mem_alloc(pm8001_ha->pdev,
                         &pm8001_ha->memoryMap.region[i].virt_ptr,
@@ -281,7 +361,7 @@ static int pm8001_alloc(struct pm8001_hba_info *pm8001_ha)
 
         pm8001_ha->devices = pm8001_ha->memoryMap.region[DEV_MEM].virt_ptr;
         for (i = 0; i < PM8001_MAX_DEVICES; i++) {
-                pm8001_ha->devices[i].dev_type = NO_DEVICE;
+                pm8001_ha->devices[i].dev_type = SAS_PHY_UNUSED;
                 pm8001_ha->devices[i].id = i;
                 pm8001_ha->devices[i].device_id = PM8001_MAX_DEVICES;
                 pm8001_ha->devices[i].running_req = 0;
@@ -339,10 +419,12 @@ static int pm8001_ioremap(struct pm8001_hba_info *pm8001_ha)
                                 ioremap(pm8001_ha->io_mem[logicalBar].membase,
                                 pm8001_ha->io_mem[logicalBar].memsize);
                         PM8001_INIT_DBG(pm8001_ha,
-                                pm8001_printk("PCI: bar %d, logicalBar %d "
-                                "virt_addr=%lx,len=%d\n", bar, logicalBar,
-                                (unsigned long)
-                                pm8001_ha->io_mem[logicalBar].memvirtaddr,
+                                pm8001_printk("PCI: bar %d, logicalBar %d ",
+                                bar, logicalBar));
+                        PM8001_INIT_DBG(pm8001_ha, pm8001_printk(
+                                "base addr %llx virt_addr=%llx len=%d\n",
+                                (u64)pm8001_ha->io_mem[logicalBar].membase,
+                                (u64)pm8001_ha->io_mem[logicalBar].memvirtaddr,
                                 pm8001_ha->io_mem[logicalBar].memsize));
                 } else {
                         pm8001_ha->io_mem[logicalBar].membase   = 0;
@@ -361,8 +443,9 @@ static int pm8001_ioremap(struct pm8001_hba_info *pm8001_ha)
  * @shost: scsi host struct which has been initialized before.
  */
 static struct pm8001_hba_info *pm8001_pci_alloc(struct pci_dev *pdev,
-                                                u32 chip_id,
-                                                struct Scsi_Host *shost)
+                                 const struct pci_device_id *ent,
+                                struct Scsi_Host *shost)
+
 {
         struct pm8001_hba_info *pm8001_ha;
         struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
@@ -374,7 +457,7 @@ static struct pm8001_hba_info *pm8001_pci_alloc(struct pci_dev *pdev,
 
         pm8001_ha->pdev = pdev;
         pm8001_ha->dev = &pdev->dev;
-        pm8001_ha->chip_id = chip_id;
+        pm8001_ha->chip_id = ent->driver_data;
         pm8001_ha->chip = &pm8001_chips[pm8001_ha->chip_id];
         pm8001_ha->irq = pdev->irq;
         pm8001_ha->sas = sha;
@@ -382,12 +465,22 @@ static struct pm8001_hba_info *pm8001_pci_alloc(struct pci_dev *pdev,
         pm8001_ha->id = pm8001_id++;
         pm8001_ha->logging_level = 0x01;
         sprintf(pm8001_ha->name, "%s%d", DRV_NAME, pm8001_ha->id);
+        /* IOMB size is 128 for 8088/89 controllers */
+        if (pm8001_ha->chip_id != chip_8001)
+                pm8001_ha->iomb_size = IOMB_SIZE_SPCV;
+        else
+                pm8001_ha->iomb_size = IOMB_SIZE_SPC;
+
 #ifdef PM8001_USE_TASKLET
+        /**
+        * default tasklet for non msi-x interrupt handler/first msi-x
+        * interrupt handler
+        **/
         tasklet_init(&pm8001_ha->tasklet, pm8001_tasklet,
-                (unsigned long)pm8001_ha);
+                        (unsigned long)pm8001_ha);
 #endif
         pm8001_ioremap(pm8001_ha);
-        if (!pm8001_alloc(pm8001_ha))
+        if (!pm8001_alloc(pm8001_ha, ent))
                 return pm8001_ha;
         pm8001_free(pm8001_ha);
         return NULL;
@@ -512,21 +605,50 @@ static void  pm8001_post_sas_ha_init(struct Scsi_Host *shost,
  */
 static void pm8001_init_sas_add(struct pm8001_hba_info *pm8001_ha)
 {
-        u8 i;
+        u8 i, j;
 #ifdef PM8001_READ_VPD
+        /* For new SPC controllers WWN is stored in flash vpd
+        *  For SPC/SPCve controllers WWN is stored in EEPROM
+        *  For Older SPC WWN is stored in NVMD
+        */
         DECLARE_COMPLETION_ONSTACK(completion);
         struct pm8001_ioctl_payload payload;
+        u16 deviceid;
+        pci_read_config_word(pm8001_ha->pdev, PCI_DEVICE_ID, &deviceid);
         pm8001_ha->nvmd_completion = &completion;
-        payload.minor_function = 0;
-        payload.length = 128;
-        payload.func_specific = kzalloc(128, GFP_KERNEL);
+
+        if (pm8001_ha->chip_id == chip_8001) {
+                if (deviceid == 0x8081) {
+                        payload.minor_function = 4;
+                        payload.length = 4096;
+                } else {
+                        payload.minor_function = 0;
+                        payload.length = 128;
+                }
+        } else {
+                payload.minor_function = 1;
+                payload.length = 4096;
+        }
+        payload.offset = 0;
+        payload.func_specific = kzalloc(payload.length, GFP_KERNEL);
         PM8001_CHIP_DISP->get_nvmd_req(pm8001_ha, &payload);
         wait_for_completion(&completion);
+
+        for (i = 0, j = 0; i <= 7; i++, j++) {
+                if (pm8001_ha->chip_id == chip_8001) {
+                        if (deviceid == 0x8081)
+                                pm8001_ha->sas_addr[j] =
+                                        payload.func_specific[0x704 + i];
+                } else
+                        pm8001_ha->sas_addr[j] =
+                                        payload.func_specific[0x804 + i];
+        }
+
         for (i = 0; i < pm8001_ha->chip->n_phy; i++) {
-                memcpy(&pm8001_ha->phy[i].dev_sas_addr, pm8001_ha->sas_addr,
-                        SAS_ADDR_SIZE);
+                memcpy(&pm8001_ha->phy[i].dev_sas_addr,
+                        pm8001_ha->sas_addr, SAS_ADDR_SIZE);
                 PM8001_INIT_DBG(pm8001_ha,
-                        pm8001_printk("phy %d sas_addr = %016llx \n", i,
+                        pm8001_printk("phy %d sas_addr = %016llx\n", i,
                         pm8001_ha->phy[i].dev_sas_addr));
         }
 #else
@@ -547,31 +669,50 @@ static void pm8001_init_sas_add(struct pm8001_hba_info *pm8001_ha)
  * @chip_info: our ha struct.
  * @irq_handler: irq_handler
  */
-static u32 pm8001_setup_msix(struct pm8001_hba_info *pm8001_ha,
-        irq_handler_t irq_handler)
+static u32 pm8001_setup_msix(struct pm8001_hba_info *pm8001_ha)
 {
         u32 i = 0, j = 0;
-        u32 number_of_intr = 1;
+        u32 number_of_intr;
         int flag = 0;
         u32 max_entry;
         int rc;
+        static char intr_drvname[PM8001_MAX_MSIX_VEC][sizeof(DRV_NAME)+3];
+
+        /* SPCv controllers supports 64 msi-x */
+        if (pm8001_ha->chip_id == chip_8001) {
+                number_of_intr = 1;
+                flag |= IRQF_DISABLED;
+        } else {
+                number_of_intr = PM8001_MAX_MSIX_VEC;
+                flag &= ~IRQF_SHARED;
+                flag |= IRQF_DISABLED;
+        }
+
         max_entry = sizeof(pm8001_ha->msix_entries) /
                 sizeof(pm8001_ha->msix_entries[0]);
-        flag |= IRQF_DISABLED;
         for (i = 0; i < max_entry ; i++)
                 pm8001_ha->msix_entries[i].entry = i;
         rc = pci_enable_msix(pm8001_ha->pdev, pm8001_ha->msix_entries,
                 number_of_intr);
         pm8001_ha->number_of_intr = number_of_intr;
         if (!rc) {
+                PM8001_INIT_DBG(pm8001_ha, pm8001_printk(
+                        "pci_enable_msix request ret:%d no of intr %d\n",
+                                        rc, pm8001_ha->number_of_intr));
+
+                for (i = 0; i < number_of_intr; i++)
+                        pm8001_ha->outq[i] = i;
+
                 for (i = 0; i < number_of_intr; i++) {
+                        snprintf(intr_drvname[i], sizeof(intr_drvname[0]),
+                                        DRV_NAME"%d", i);
                         if (request_irq(pm8001_ha->msix_entries[i].vector,
-                                irq_handler, flag, DRV_NAME,
-                                SHOST_TO_SAS_HA(pm8001_ha->shost))) {
+                                pm8001_interrupt_handler_msix, flag,
+                                intr_drvname[i], &pm8001_ha->outq[i])) {
                                 for (j = 0; j < i; j++)
                                         free_irq(
                                         pm8001_ha->msix_entries[j].vector,
-                                        SHOST_TO_SAS_HA(pm8001_ha->shost));
+                                        &pm8001_ha->outq[j]);
                                 pci_disable_msix(pm8001_ha->pdev);
                                 break;
                         }
@@ -588,22 +729,24 @@ static u32 pm8001_setup_msix(struct pm8001_hba_info *pm8001_ha,
 static u32 pm8001_request_irq(struct pm8001_hba_info *pm8001_ha)
 {
         struct pci_dev *pdev;
-        irq_handler_t irq_handler = pm8001_interrupt;
         int rc;
 
         pdev = pm8001_ha->pdev;
 
 #ifdef PM8001_USE_MSIX
         if (pci_find_capability(pdev, PCI_CAP_ID_MSIX))
-                return pm8001_setup_msix(pm8001_ha, irq_handler);
-        else
+                return pm8001_setup_msix(pm8001_ha);
+        else {
+                PM8001_INIT_DBG(pm8001_ha,
+                        pm8001_printk("MSIX not supported!!!\n"));
                 goto intx;
+        }
 #endif
 
 intx:
         /* initialize the INT-X interrupt */
-        rc = request_irq(pdev->irq, irq_handler, IRQF_SHARED, DRV_NAME,
-                SHOST_TO_SAS_HA(pm8001_ha->shost));
+        rc = request_irq(pdev->irq, pm8001_interrupt_handler_intx, IRQF_SHARED,
+                DRV_NAME, SHOST_TO_SAS_HA(pm8001_ha->shost));
         return rc;
 }
 
@@ -621,12 +764,13 @@ static int pm8001_pci_probe(struct pci_dev *pdev,
 {
         unsigned int rc;
         u32     pci_reg;
+        u8      i = 0;
         struct pm8001_hba_info *pm8001_ha;
         struct Scsi_Host *shost = NULL;
         const struct pm8001_chip_info *chip;
 
         dev_printk(KERN_INFO, &pdev->dev,
-                "pm8001: driver version %s\n", DRV_VERSION);
+                "pm80xx: driver version %s\n", DRV_VERSION);
         rc = pci_enable_device(pdev);
         if (rc)
                 goto err_out_enable;
@@ -665,25 +809,39 @@ static int pm8001_pci_probe(struct pci_dev *pdev,
                 goto err_out_free;
         }
         pci_set_drvdata(pdev, SHOST_TO_SAS_HA(shost));
-        pm8001_ha = pm8001_pci_alloc(pdev, chip_8001, shost);
+        /* ent->driver variable is used to differentiate between controllers */
+        pm8001_ha = pm8001_pci_alloc(pdev, ent, shost);
         if (!pm8001_ha) {
                 rc = -ENOMEM;
                 goto err_out_free;
         }
         list_add_tail(&pm8001_ha->list, &hba_list);
-        PM8001_CHIP_DISP->chip_soft_rst(pm8001_ha, 0x252acbcd);
+        PM8001_CHIP_DISP->chip_soft_rst(pm8001_ha);
         rc = PM8001_CHIP_DISP->chip_init(pm8001_ha);
-        if (rc)
+        if (rc) {
+                PM8001_FAIL_DBG(pm8001_ha, pm8001_printk(
+                        "chip_init failed [ret: %d]\n", rc));
                 goto err_out_ha_free;
+        }
 
         rc = scsi_add_host(shost, &pdev->dev);
         if (rc)
                 goto err_out_ha_free;
         rc = pm8001_request_irq(pm8001_ha);
-        if (rc)
+        if (rc) {
+                PM8001_FAIL_DBG(pm8001_ha, pm8001_printk(
+                        "pm8001_request_irq failed [ret: %d]\n", rc));
                 goto err_out_shost;
+        }
+
+        PM8001_CHIP_DISP->interrupt_enable(pm8001_ha, 0);
+        if (pm8001_ha->chip_id != chip_8001) {
+                for (i = 1; i < pm8001_ha->number_of_intr; i++)
+                        PM8001_CHIP_DISP->interrupt_enable(pm8001_ha, i);
+                /* setup thermal configuration. */
+                pm80xx_set_thermal_config(pm8001_ha);
+        }
 
-        PM8001_CHIP_DISP->interrupt_enable(pm8001_ha);
         pm8001_init_sas_add(pm8001_ha);
         pm8001_post_sas_ha_init(shost, chip);
         rc = sas_register_ha(SHOST_TO_SAS_HA(shost));
@@ -719,14 +877,15 @@ static void pm8001_pci_remove(struct pci_dev *pdev)
         sas_remove_host(pm8001_ha->shost);
         list_del(&pm8001_ha->list);
         scsi_remove_host(pm8001_ha->shost);
-        PM8001_CHIP_DISP->interrupt_disable(pm8001_ha);
-        PM8001_CHIP_DISP->chip_soft_rst(pm8001_ha, 0x252acbcd);
+        PM8001_CHIP_DISP->interrupt_disable(pm8001_ha, 0xFF);
+        PM8001_CHIP_DISP->chip_soft_rst(pm8001_ha);
 
 #ifdef PM8001_USE_MSIX
         for (i = 0; i < pm8001_ha->number_of_intr; i++)
                 synchronize_irq(pm8001_ha->msix_entries[i].vector);
         for (i = 0; i < pm8001_ha->number_of_intr; i++)
-                free_irq(pm8001_ha->msix_entries[i].vector, sha);
+                free_irq(pm8001_ha->msix_entries[i].vector,
+                                &pm8001_ha->outq[i]);
         pci_disable_msix(pdev);
 #else
         free_irq(pm8001_ha->irq, sha);
@@ -763,13 +922,14 @@ static int pm8001_pci_suspend(struct pci_dev *pdev, pm_message_t state)
                 printk(KERN_ERR " PCI PM not supported\n");
                 return -ENODEV;
         }
-        PM8001_CHIP_DISP->interrupt_disable(pm8001_ha);
-        PM8001_CHIP_DISP->chip_soft_rst(pm8001_ha, 0x252acbcd);
+        PM8001_CHIP_DISP->interrupt_disable(pm8001_ha, 0xFF);
+        PM8001_CHIP_DISP->chip_soft_rst(pm8001_ha);
 #ifdef PM8001_USE_MSIX
         for (i = 0; i < pm8001_ha->number_of_intr; i++)
                 synchronize_irq(pm8001_ha->msix_entries[i].vector);
         for (i = 0; i < pm8001_ha->number_of_intr; i++)
-                free_irq(pm8001_ha->msix_entries[i].vector, sha);
+                free_irq(pm8001_ha->msix_entries[i].vector,
+                                &pm8001_ha->outq[i]);
         pci_disable_msix(pdev);
 #else
         free_irq(pm8001_ha->irq, sha);
@@ -798,6 +958,7 @@ static int pm8001_pci_resume(struct pci_dev *pdev)
         struct sas_ha_struct *sha = pci_get_drvdata(pdev);
         struct pm8001_hba_info *pm8001_ha;
         int rc;
+        u8 i = 0;
         u32 device_state;
         pm8001_ha = sha->lldd_ha;
         device_state = pdev->current_state;
@@ -820,19 +981,33 @@ static int pm8001_pci_resume(struct pci_dev *pdev)
         if (rc)
                 goto err_out_disable;
 
-        PM8001_CHIP_DISP->chip_soft_rst(pm8001_ha, 0x252acbcd);
+        /* chip soft rst only for spc */
+        if (pm8001_ha->chip_id == chip_8001) {
+                PM8001_CHIP_DISP->chip_soft_rst(pm8001_ha);
+                PM8001_INIT_DBG(pm8001_ha,
+                        pm8001_printk("chip soft reset successful\n"));
+        }
         rc = PM8001_CHIP_DISP->chip_init(pm8001_ha);
         if (rc)
                 goto err_out_disable;
-        PM8001_CHIP_DISP->interrupt_disable(pm8001_ha);
+
+        /* disable all the interrupt bits */
+        PM8001_CHIP_DISP->interrupt_disable(pm8001_ha, 0xFF);
+
         rc = pm8001_request_irq(pm8001_ha);
         if (rc)
                 goto err_out_disable;
-        #ifdef PM8001_USE_TASKLET
+#ifdef PM8001_USE_TASKLET
+        /* default tasklet for non msi-x interrupt handler/first msi-x
+        * interrupt handler */
         tasklet_init(&pm8001_ha->tasklet, pm8001_tasklet,
-                    (unsigned long)pm8001_ha);
-        #endif
-        PM8001_CHIP_DISP->interrupt_enable(pm8001_ha);
+                        (unsigned long)pm8001_ha);
+#endif
+        PM8001_CHIP_DISP->interrupt_enable(pm8001_ha, 0);
+        if (pm8001_ha->chip_id != chip_8001) {
+                for (i = 1; i < pm8001_ha->number_of_intr; i++)
+                        PM8001_CHIP_DISP->interrupt_enable(pm8001_ha, i);
+        }
         scsi_unblock_requests(pm8001_ha->shost);
         return 0;
 
@@ -843,14 +1018,45 @@ err_out_enable:
         return rc;
 }
 
+/* update of pci device, vendor id and driver data with
+ * unique value for each of the controller
+ */
 static struct pci_device_id pm8001_pci_table[] = {
-        {
-                PCI_VDEVICE(PMC_Sierra, 0x8001), chip_8001
-        },
+        { PCI_VDEVICE(PMC_Sierra, 0x8001), chip_8001 },
         {
                 PCI_DEVICE(0x117c, 0x0042),
                 .driver_data = chip_8001
         },
+        /* Support for SPC/SPCv/SPCve controllers */
+        { PCI_VDEVICE(ADAPTEC2, 0x8001), chip_8001 },
+        { PCI_VDEVICE(PMC_Sierra, 0x8008), chip_8008 },
+        { PCI_VDEVICE(ADAPTEC2, 0x8008), chip_8008 },
+        { PCI_VDEVICE(PMC_Sierra, 0x8018), chip_8018 },
+        { PCI_VDEVICE(ADAPTEC2, 0x8018), chip_8018 },
+        { PCI_VDEVICE(PMC_Sierra, 0x8009), chip_8009 },
+        { PCI_VDEVICE(ADAPTEC2, 0x8009), chip_8009 },
+        { PCI_VDEVICE(PMC_Sierra, 0x8019), chip_8019 },
+        { PCI_VDEVICE(ADAPTEC2, 0x8019), chip_8019 },
+        { PCI_VENDOR_ID_ADAPTEC2, 0x8081,
+                PCI_VENDOR_ID_ADAPTEC2, 0x0400, 0, 0, chip_8001 },
+        { PCI_VENDOR_ID_ADAPTEC2, 0x8081,
+                PCI_VENDOR_ID_ADAPTEC2, 0x0800, 0, 0, chip_8001 },
+        { PCI_VENDOR_ID_ADAPTEC2, 0x8088,
+                PCI_VENDOR_ID_ADAPTEC2, 0x0008, 0, 0, chip_8008 },
+        { PCI_VENDOR_ID_ADAPTEC2, 0x8088,
+                PCI_VENDOR_ID_ADAPTEC2, 0x0800, 0, 0, chip_8008 },
+        { PCI_VENDOR_ID_ADAPTEC2, 0x8089,
+                PCI_VENDOR_ID_ADAPTEC2, 0x0008, 0, 0, chip_8009 },
+        { PCI_VENDOR_ID_ADAPTEC2, 0x8089,
+                PCI_VENDOR_ID_ADAPTEC2, 0x0800, 0, 0, chip_8009 },
+        { PCI_VENDOR_ID_ADAPTEC2, 0x8088,
+                PCI_VENDOR_ID_ADAPTEC2, 0x0016, 0, 0, chip_8018 },
+        { PCI_VENDOR_ID_ADAPTEC2, 0x8088,
+                PCI_VENDOR_ID_ADAPTEC2, 0x1600, 0, 0, chip_8018 },
+        { PCI_VENDOR_ID_ADAPTEC2, 0x8089,
+                PCI_VENDOR_ID_ADAPTEC2, 0x0016, 0, 0, chip_8019 },
+        { PCI_VENDOR_ID_ADAPTEC2, 0x8089,
+                PCI_VENDOR_ID_ADAPTEC2, 0x1600, 0, 0, chip_8019 },
         {} /* terminate list */
 };
 
@@ -870,7 +1076,7 @@ static int __init pm8001_init(void)
 {
         int rc = -ENOMEM;
 
-        pm8001_wq = alloc_workqueue("pm8001", 0, 0);
+        pm8001_wq = alloc_workqueue("pm80xx", 0, 0);
         if (!pm8001_wq)
                 goto err;
 
@@ -902,7 +1108,8 @@ module_init(pm8001_init);
 module_exit(pm8001_exit);
 
 MODULE_AUTHOR("Jack Wang <jack_wang@usish.com>");
-MODULE_DESCRIPTION("PMC-Sierra PM8001 SAS/SATA controller driver");
+MODULE_DESCRIPTION(
+                "PMC-Sierra PM8001/8081/8088/8089 SAS/SATA controller driver");
 MODULE_VERSION(DRV_VERSION);
 MODULE_LICENSE("GPL");
 MODULE_DEVICE_TABLE(pci, pm8001_pci_table);
diff --git a/drivers/scsi/pm8001/pm8001_sas.c b/drivers/scsi/pm8001/pm8001_sas.c
index b961112395d5..a85d73de7c80 100644
--- a/drivers/scsi/pm8001/pm8001_sas.c
+++ b/drivers/scsi/pm8001/pm8001_sas.c
@@ -1,5 +1,5 @@
 /*
- * PMC-Sierra SPC 8001 SAS/SATA based host adapters driver
+ * PMC-Sierra PM8001/8081/8088/8089 SAS/SATA based host adapters driver
  *
  * Copyright (c) 2008-2009 USI Co., Ltd.
  * All rights reserved.
@@ -68,7 +68,7 @@ static void pm8001_tag_clear(struct pm8001_hba_info *pm8001_ha, u32 tag)
         clear_bit(tag, bitmap);
 }
 
-static void pm8001_tag_free(struct pm8001_hba_info *pm8001_ha, u32 tag)
+void pm8001_tag_free(struct pm8001_hba_info *pm8001_ha, u32 tag)
 {
         pm8001_tag_clear(pm8001_ha, tag);
 }
@@ -212,10 +212,12 @@ int pm8001_phy_control(struct asd_sas_phy *sas_phy, enum phy_func func,
                 break;
         case PHY_FUNC_GET_EVENTS:
                 spin_lock_irqsave(&pm8001_ha->lock, flags);
-                if (-1 == pm8001_bar4_shift(pm8001_ha,
+                if (pm8001_ha->chip_id == chip_8001) {
+                        if (-1 == pm8001_bar4_shift(pm8001_ha,
                                         (phy_id < 4) ? 0x30000 : 0x40000)) {
-                        spin_unlock_irqrestore(&pm8001_ha->lock, flags);
-                        return -EINVAL;
+                                spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+                                return -EINVAL;
+                        }
                 }
                 {
                         struct sas_phy *phy = sas_phy->phy;
@@ -228,7 +230,8 @@ int pm8001_phy_control(struct asd_sas_phy *sas_phy, enum phy_func func,
                         phy->loss_of_dword_sync_count = qp[3];
                         phy->phy_reset_problem_count = qp[4];
                 }
-                pm8001_bar4_shift(pm8001_ha, 0);
+                if (pm8001_ha->chip_id == chip_8001)
+                        pm8001_bar4_shift(pm8001_ha, 0);
                 spin_unlock_irqrestore(&pm8001_ha->lock, flags);
                 return 0;
         default:
@@ -249,7 +252,9 @@ void pm8001_scan_start(struct Scsi_Host *shost)
         struct pm8001_hba_info *pm8001_ha;
         struct sas_ha_struct *sha = SHOST_TO_SAS_HA(shost);
         pm8001_ha = sha->lldd_ha;
-        PM8001_CHIP_DISP->sas_re_init_req(pm8001_ha);
+        /* SAS_RE_INITIALIZATION not available in SPCv/ve */
+        if (pm8001_ha->chip_id == chip_8001)
+                PM8001_CHIP_DISP->sas_re_init_req(pm8001_ha);
         for (i = 0; i < pm8001_ha->chip->n_phy; ++i)
                 PM8001_CHIP_DISP->phy_start_req(pm8001_ha, i);
 }
@@ -352,7 +357,7 @@ static int sas_find_local_port_id(struct domain_device *dev)
   * @tmf: the task management IU
   */
 #define DEV_IS_GONE(pm8001_dev) \
-        ((!pm8001_dev || (pm8001_dev->dev_type == NO_DEVICE)))
+        ((!pm8001_dev || (pm8001_dev->dev_type == SAS_PHY_UNUSED)))
 static int pm8001_task_exec(struct sas_task *task, const int num,
         gfp_t gfp_flags, int is_tmf, struct pm8001_tmf_task *tmf)
 {
@@ -370,7 +375,7 @@ static int pm8001_task_exec(struct sas_task *task, const int num,
                 struct task_status_struct *tsm = &t->task_status;
                 tsm->resp = SAS_TASK_UNDELIVERED;
                 tsm->stat = SAS_PHY_DOWN;
-                if (dev->dev_type != SATA_DEV)
+                if (dev->dev_type != SAS_SATA_DEV)
                         t->task_done(t);
                 return 0;
         }
@@ -548,7 +553,7 @@ struct pm8001_device *pm8001_alloc_dev(struct pm8001_hba_info *pm8001_ha)
 {
         u32 dev;
         for (dev = 0; dev < PM8001_MAX_DEVICES; dev++) {
-                if (pm8001_ha->devices[dev].dev_type == NO_DEVICE) {
+                if (pm8001_ha->devices[dev].dev_type == SAS_PHY_UNUSED) {
                         pm8001_ha->devices[dev].id = dev;
                         return &pm8001_ha->devices[dev];
                 }
@@ -560,13 +565,31 @@ struct pm8001_device *pm8001_alloc_dev(struct pm8001_hba_info *pm8001_ha)
         }
         return NULL;
 }
+/**
+  * pm8001_find_dev - find a matching pm8001_device
+  * @pm8001_ha: our hba card information
+  */
+struct pm8001_device *pm8001_find_dev(struct pm8001_hba_info *pm8001_ha,
+                                        u32 device_id)
+{
+        u32 dev;
+        for (dev = 0; dev < PM8001_MAX_DEVICES; dev++) {
+                if (pm8001_ha->devices[dev].device_id == device_id)
+                        return &pm8001_ha->devices[dev];
+        }
+        if (dev == PM8001_MAX_DEVICES) {
+                PM8001_FAIL_DBG(pm8001_ha, pm8001_printk("NO MATCHING "
+                                "DEVICE FOUND !!!\n"));
+        }
+        return NULL;
+}
 
 static void pm8001_free_dev(struct pm8001_device *pm8001_dev)
 {
         u32 id = pm8001_dev->id;
         memset(pm8001_dev, 0, sizeof(*pm8001_dev));
         pm8001_dev->id = id;
-        pm8001_dev->dev_type = NO_DEVICE;
+        pm8001_dev->dev_type = SAS_PHY_UNUSED;
         pm8001_dev->device_id = PM8001_MAX_DEVICES;
         pm8001_dev->sas_device = NULL;
 }
@@ -624,7 +647,7 @@ static int pm8001_dev_found_notify(struct domain_device *dev)
                         res = -1;
                 }
         } else {
-                if (dev->dev_type == SATA_DEV) {
+                if (dev->dev_type == SAS_SATA_DEV) {
                         pm8001_device->attached_phy =
                                 dev->rphy->identify.phy_identifier;
                                 flag = 1; /* directly sata*/
@@ -634,7 +657,7 @@ static int pm8001_dev_found_notify(struct domain_device *dev)
         PM8001_CHIP_DISP->reg_dev_req(pm8001_ha, pm8001_device, flag);
         spin_unlock_irqrestore(&pm8001_ha->lock, flags);
         wait_for_completion(&completion);
-        if (dev->dev_type == SAS_END_DEV)
+        if (dev->dev_type == SAS_END_DEVICE)
                 msleep(50);
         pm8001_ha->flags = PM8001F_RUN_TIME;
         return 0;
@@ -648,7 +671,7 @@ int pm8001_dev_found(struct domain_device *dev)
         return pm8001_dev_found_notify(dev);
 }
 
-static void pm8001_task_done(struct sas_task *task)
+void pm8001_task_done(struct sas_task *task)
 {
         if (!del_timer(&task->slow_task->timer))
                 return;
@@ -904,7 +927,7 @@ void pm8001_open_reject_retry(
                 struct pm8001_ccb_info *ccb = &pm8001_ha->ccb_info[i];
 
                 pm8001_dev = ccb->device;
-                if (!pm8001_dev || (pm8001_dev->dev_type == NO_DEVICE))
+                if (!pm8001_dev || (pm8001_dev->dev_type == SAS_PHY_UNUSED))
                         continue;
                 if (!device_to_close) {
                         uintptr_t d = (uintptr_t)pm8001_dev
@@ -995,6 +1018,72 @@ int pm8001_I_T_nexus_reset(struct domain_device *dev)
         return rc;
 }
 
+/*
+* This function handle the IT_NEXUS_XXX event or completion
+* status code for SSP/SATA/SMP I/O request.
+*/
+int pm8001_I_T_nexus_event_handler(struct domain_device *dev)
+{
+        int rc = TMF_RESP_FUNC_FAILED;
+        struct pm8001_device *pm8001_dev;
+        struct pm8001_hba_info *pm8001_ha;
+        struct sas_phy *phy;
+        u32 device_id = 0;
+
+        if (!dev || !dev->lldd_dev)
+                return -1;
+
+        pm8001_dev = dev->lldd_dev;
+        device_id = pm8001_dev->device_id;
+        pm8001_ha = pm8001_find_ha_by_dev(dev);
+
+        PM8001_EH_DBG(pm8001_ha,
+                        pm8001_printk("I_T_Nexus handler invoked !!"));
+
+        phy = sas_get_local_phy(dev);
+
+        if (dev_is_sata(dev)) {
+                DECLARE_COMPLETION_ONSTACK(completion_setstate);
+                if (scsi_is_sas_phy_local(phy)) {
+                        rc = 0;
+                        goto out;
+                }
+                /* send internal ssp/sata/smp abort command to FW */
+                rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev ,
+                                                        dev, 1, 0);
+                msleep(100);
+
+                /* deregister the target device */
+                pm8001_dev_gone_notify(dev);
+                msleep(200);
+
+                /*send phy reset to hard reset target */
+                rc = sas_phy_reset(phy, 1);
+                msleep(2000);
+                pm8001_dev->setds_completion = &completion_setstate;
+
+                wait_for_completion(&completion_setstate);
+        } else {
+                /* send internal ssp/sata/smp abort command to FW */
+                rc = pm8001_exec_internal_task_abort(pm8001_ha, pm8001_dev ,
+                                                        dev, 1, 0);
+                msleep(100);
+
+                /* deregister the target device */
+                pm8001_dev_gone_notify(dev);
+                msleep(200);
+
+                /*send phy reset to hard reset target */
+                rc = sas_phy_reset(phy, 1);
+                msleep(2000);
+        }
+        PM8001_EH_DBG(pm8001_ha, pm8001_printk(" for device[%x]:rc=%d\n",
+                pm8001_dev->device_id, rc));
+out:
+        sas_put_local_phy(phy);
+
+        return rc;
+}
 /* mandatory SAM-3, the task reset the specified LUN*/
 int pm8001_lu_reset(struct domain_device *dev, u8 *lun)
 {
diff --git a/drivers/scsi/pm8001/pm8001_sas.h b/drivers/scsi/pm8001/pm8001_sas.h
index 11008205aeb3..570819464d90 100644
--- a/drivers/scsi/pm8001/pm8001_sas.h
+++ b/drivers/scsi/pm8001/pm8001_sas.h
@@ -1,5 +1,5 @@
 /*
- * PMC-Sierra SPC 8001 SAS/SATA based host adapters driver
+ * PMC-Sierra PM8001/8081/8088/8089 SAS/SATA based host adapters driver
  *
  * Copyright (c) 2008-2009 USI Co., Ltd.
  * All rights reserved.
@@ -57,8 +57,8 @@
 #include <linux/atomic.h>
 #include "pm8001_defs.h"
 
-#define DRV_NAME                "pm8001"
-#define DRV_VERSION             "0.1.36"
+#define DRV_NAME                "pm80xx"
+#define DRV_VERSION             "0.1.37"
 #define PM8001_FAIL_LOGGING     0x01 /* Error message logging */
 #define PM8001_INIT_LOGGING     0x02 /* driver init logging */
 #define PM8001_DISC_LOGGING     0x04 /* discovery layer logging */
@@ -66,8 +66,8 @@
 #define PM8001_EH_LOGGING       0x10 /* libsas EH function logging*/
 #define PM8001_IOCTL_LOGGING    0x20 /* IOCTL message logging */
 #define PM8001_MSG_LOGGING      0x40 /* misc message logging */
-#define pm8001_printk(format, arg...)   printk(KERN_INFO "%s %d:" format,\
-                                __func__, __LINE__, ## arg)
+#define pm8001_printk(format, arg...)   printk(KERN_INFO "pm80xx %s %d:" \
+                        format, __func__, __LINE__, ## arg)
 #define PM8001_CHECK_LOGGING(HBA, LEVEL, CMD)   \
 do {                                            \
         if (unlikely(HBA->logging_level & LEVEL))       \
@@ -103,11 +103,12 @@ do {						\
 #define PM8001_READ_VPD
 
 
-#define DEV_IS_EXPANDER(type)   ((type == EDGE_DEV) || (type == FANOUT_DEV))
+#define DEV_IS_EXPANDER(type)   ((type == SAS_EDGE_EXPANDER_DEVICE) || (type == SAS_FANOUT_EXPANDER_DEVICE))
 
 #define PM8001_NAME_LENGTH              32/* generic length of strings */
 extern struct list_head hba_list;
 extern const struct pm8001_dispatch pm8001_8001_dispatch;
+extern const struct pm8001_dispatch pm8001_80xx_dispatch;
 
 struct pm8001_hba_info;
 struct pm8001_ccb_info;
@@ -131,15 +132,15 @@ struct pm8001_ioctl_payload {
 struct pm8001_dispatch {
         char *name;
         int (*chip_init)(struct pm8001_hba_info *pm8001_ha);
-        int (*chip_soft_rst)(struct pm8001_hba_info *pm8001_ha, u32 signature);
+        int (*chip_soft_rst)(struct pm8001_hba_info *pm8001_ha);
         void (*chip_rst)(struct pm8001_hba_info *pm8001_ha);
         int (*chip_ioremap)(struct pm8001_hba_info *pm8001_ha);
         void (*chip_iounmap)(struct pm8001_hba_info *pm8001_ha);
-        irqreturn_t (*isr)(struct pm8001_hba_info *pm8001_ha);
+        irqreturn_t (*isr)(struct pm8001_hba_info *pm8001_ha, u8 vec);
         u32 (*is_our_interupt)(struct pm8001_hba_info *pm8001_ha);
-        int (*isr_process_oq)(struct pm8001_hba_info *pm8001_ha);
-        void (*interrupt_enable)(struct pm8001_hba_info *pm8001_ha);
-        void (*interrupt_disable)(struct pm8001_hba_info *pm8001_ha);
+        int (*isr_process_oq)(struct pm8001_hba_info *pm8001_ha, u8 vec);
+        void (*interrupt_enable)(struct pm8001_hba_info *pm8001_ha, u8 vec);
+        void (*interrupt_disable)(struct pm8001_hba_info *pm8001_ha, u8 vec);
         void (*make_prd)(struct scatterlist *scatter, int nr, void *prd);
         int (*smp_req)(struct pm8001_hba_info *pm8001_ha,
                 struct pm8001_ccb_info *ccb);
@@ -173,6 +174,7 @@ struct pm8001_dispatch {
 };
 
 struct pm8001_chip_info {
+        u32     encrypt;
         u32     n_phy;
         const struct pm8001_dispatch    *dispatch;
 };
@@ -204,7 +206,7 @@ struct pm8001_phy {
 };
 
 struct pm8001_device {
-        enum sas_dev_type       dev_type;
+        enum sas_device_type    dev_type;
         struct domain_device    *sas_device;
         u32                     attached_phy;
         u32                     id;
@@ -256,7 +258,20 @@ struct mpi_mem_req {
         struct mpi_mem          region[USI_MAX_MEMCNT];
 };
 
-struct main_cfg_table {
+struct encrypt {
+        u32     cipher_mode;
+        u32     sec_mode;
+        u32     status;
+        u32     flag;
+};
+
+struct sas_phy_attribute_table {
+        u32     phystart1_16[16];
+        u32     outbound_hw_event_pid1_16[16];
+};
+
+union main_cfg_table {
+        struct {
         u32                     signature;
         u32                     interface_rev;
         u32                     firmware_rev;
@@ -292,19 +307,69 @@ struct main_cfg_table {
         u32                     fatal_err_dump_length1;
         u32                     hda_mode_flag;
         u32                     anolog_setup_table_offset;
+        u32                     rsvd[4];
+        } pm8001_tbl;
+
+        struct {
+        u32                     signature;
+        u32                     interface_rev;
+        u32                     firmware_rev;
+        u32                     max_out_io;
+        u32                     max_sgl;
+        u32                     ctrl_cap_flag;
+        u32                     gst_offset;
+        u32                     inbound_queue_offset;
+        u32                     outbound_queue_offset;
+        u32                     inbound_q_nppd_hppd;
+        u32                     rsvd[8];
+        u32                     crc_core_dump;
+        u32                     rsvd1;
+        u32                     upper_event_log_addr;
+        u32                     lower_event_log_addr;
+        u32                     event_log_size;
+        u32                     event_log_severity;
+        u32                     upper_pcs_event_log_addr;
+        u32                     lower_pcs_event_log_addr;
+        u32                     pcs_event_log_size;
+        u32                     pcs_event_log_severity;
+        u32                     fatal_err_interrupt;
+        u32                     fatal_err_dump_offset0;
+        u32                     fatal_err_dump_length0;
+        u32                     fatal_err_dump_offset1;
+        u32                     fatal_err_dump_length1;
+        u32                     gpio_led_mapping;
+        u32                     analog_setup_table_offset;
+        u32                     int_vec_table_offset;
+        u32                     phy_attr_table_offset;
+        u32                     port_recovery_timer;
+        u32                     interrupt_reassertion_delay;
+        } pm80xx_tbl;
 };
-struct general_status_table {
+
+union general_status_table {
+        struct {
         u32                     gst_len_mpistate;
         u32                     iq_freeze_state0;
         u32                     iq_freeze_state1;
         u32                     msgu_tcnt;
         u32                     iop_tcnt;
-        u32                     reserved;
+        u32                     rsvd;
         u32                     phy_state[8];
-        u32                     reserved1;
-        u32                     reserved2;
-        u32                     reserved3;
+        u32                     gpio_input_val;
+        u32                     rsvd1[2];
+        u32                     recover_err_info[8];
+        } pm8001_tbl;
+        struct {
+        u32                     gst_len_mpistate;
+        u32                     iq_freeze_state0;
+        u32                     iq_freeze_state1;
+        u32                     msgu_tcnt;
+        u32                     iop_tcnt;
+        u32                     rsvd[9];
+        u32                     gpio_input_val;
+        u32                     rsvd1[2];
         u32                     recover_err_info[8];
+        } pm80xx_tbl;
 };
 struct inbound_queue_table {
         u32                     element_pri_size_cnt;
@@ -351,15 +416,21 @@ struct pm8001_hba_info {
         struct device           *dev;
         struct pm8001_hba_memspace io_mem[6];
         struct mpi_mem_req      memoryMap;
+        struct encrypt          encrypt_info; /* support encryption */
         void __iomem    *msg_unit_tbl_addr;/*Message Unit Table Addr*/
         void __iomem    *main_cfg_tbl_addr;/*Main Config Table Addr*/
         void __iomem    *general_stat_tbl_addr;/*General Status Table Addr*/
         void __iomem    *inbnd_q_tbl_addr;/*Inbound Queue Config Table Addr*/
         void __iomem    *outbnd_q_tbl_addr;/*Outbound Queue Config Table Addr*/
-        struct main_cfg_table   main_cfg_tbl;
-        struct general_status_table     gs_tbl;
-        struct inbound_queue_table      inbnd_q_tbl[PM8001_MAX_INB_NUM];
-        struct outbound_queue_table     outbnd_q_tbl[PM8001_MAX_OUTB_NUM];
+        void __iomem    *pspa_q_tbl_addr;
+                        /*MPI SAS PHY attributes Queue Config Table Addr*/
+        void __iomem    *ivt_tbl_addr; /*MPI IVT Table Addr */
+        union main_cfg_table    main_cfg_tbl;
+        union general_status_table      gs_tbl;
+        struct inbound_queue_table      inbnd_q_tbl[PM8001_MAX_SPCV_INB_NUM];
+        struct outbound_queue_table     outbnd_q_tbl[PM8001_MAX_SPCV_OUTB_NUM];
+        struct sas_phy_attribute_table  phy_attr_table;
+                                        /* MPI SAS PHY attributes */
         u8                      sas_addr[SAS_ADDR_SIZE];
         struct sas_ha_struct    *sas;/* SCSI/SAS glue */
         struct Scsi_Host        *shost;
@@ -372,10 +443,12 @@ struct pm8001_hba_info {
         struct pm8001_port      port[PM8001_MAX_PHYS];
         u32                     id;
         u32                     irq;
+        u32                     iomb_size; /* SPC and SPCV IOMB size */
         struct pm8001_device    *devices;
         struct pm8001_ccb_info  *ccb_info;
 #ifdef PM8001_USE_MSIX
-        struct msix_entry       msix_entries[16];/*for msi-x interrupt*/
+        struct msix_entry       msix_entries[PM8001_MAX_MSIX_VEC];
+                                        /*for msi-x interrupt*/
         int                     number_of_intr;/*will be used in remove()*/
 #endif
 #ifdef PM8001_USE_TASKLET
@@ -383,7 +456,10 @@ struct pm8001_hba_info {
 #endif
         u32                     logging_level;
         u32                     fw_status;
+        u32                     smp_exp_mode;
+        u32                     int_vector;
         const struct firmware   *fw_image;
+        u8                      outq[PM8001_MAX_MSIX_VEC];
 };
 
 struct pm8001_work {
@@ -419,6 +495,9 @@ struct pm8001_fw_image_header {
 #define FLASH_UPDATE_DNLD_NOT_SUPPORTED         0x10
 #define FLASH_UPDATE_DISABLED                   0x11
 
+#define NCQ_READ_LOG_FLAG                       0x80000000
+#define NCQ_ABORT_ALL_FLAG                      0x40000000
+#define NCQ_2ND_RLE_FLAG                        0x20000000
 /**
  * brief param structure for firmware flash update.
  */
@@ -484,6 +563,7 @@ int pm8001_dev_found(struct domain_device *dev);
 void pm8001_dev_gone(struct domain_device *dev);
 int pm8001_lu_reset(struct domain_device *dev, u8 *lun);
 int pm8001_I_T_nexus_reset(struct domain_device *dev);
+int pm8001_I_T_nexus_event_handler(struct domain_device *dev);
 int pm8001_query_task(struct sas_task *task);
 void pm8001_open_reject_retry(
         struct pm8001_hba_info *pm8001_ha,
@@ -493,6 +573,61 @@ int pm8001_mem_alloc(struct pci_dev *pdev, void **virt_addr,
         dma_addr_t *pphys_addr, u32 *pphys_addr_hi, u32 *pphys_addr_lo,
         u32 mem_size, u32 align);
 
+void pm8001_chip_iounmap(struct pm8001_hba_info *pm8001_ha);
+int pm8001_mpi_build_cmd(struct pm8001_hba_info *pm8001_ha,
+                        struct inbound_queue_table *circularQ,
+                        u32 opCode, void *payload, u32 responseQueue);
+int pm8001_mpi_msg_free_get(struct inbound_queue_table *circularQ,
+                                u16 messageSize, void **messagePtr);
+u32 pm8001_mpi_msg_free_set(struct pm8001_hba_info *pm8001_ha, void *pMsg,
+                        struct outbound_queue_table *circularQ, u8 bc);
+u32 pm8001_mpi_msg_consume(struct pm8001_hba_info *pm8001_ha,
+                        struct outbound_queue_table *circularQ,
+                        void **messagePtr1, u8 *pBC);
+int pm8001_chip_set_dev_state_req(struct pm8001_hba_info *pm8001_ha,
+                        struct pm8001_device *pm8001_dev, u32 state);
+int pm8001_chip_fw_flash_update_req(struct pm8001_hba_info *pm8001_ha,
+                                        void *payload);
+int pm8001_chip_fw_flash_update_build(struct pm8001_hba_info *pm8001_ha,
+                                        void *fw_flash_updata_info, u32 tag);
+int pm8001_chip_set_nvmd_req(struct pm8001_hba_info *pm8001_ha, void *payload);
+int pm8001_chip_get_nvmd_req(struct pm8001_hba_info *pm8001_ha, void *payload);
+int pm8001_chip_ssp_tm_req(struct pm8001_hba_info *pm8001_ha,
+                                struct pm8001_ccb_info *ccb,
+                                struct pm8001_tmf_task *tmf);
+int pm8001_chip_abort_task(struct pm8001_hba_info *pm8001_ha,
+                                struct pm8001_device *pm8001_dev,
+                                u8 flag, u32 task_tag, u32 cmd_tag);
+int pm8001_chip_dereg_dev_req(struct pm8001_hba_info *pm8001_ha, u32 device_id);
+void pm8001_chip_make_sg(struct scatterlist *scatter, int nr, void *prd);
+void pm8001_work_fn(struct work_struct *work);
+int pm8001_handle_event(struct pm8001_hba_info *pm8001_ha,
+                                        void *data, int handler);
+void pm8001_mpi_set_dev_state_resp(struct pm8001_hba_info *pm8001_ha,
+                                                        void *piomb);
+void pm8001_mpi_set_nvmd_resp(struct pm8001_hba_info *pm8001_ha,
+                                                        void *piomb);
+void pm8001_mpi_get_nvmd_resp(struct pm8001_hba_info *pm8001_ha,
+                                                        void *piomb);
+int pm8001_mpi_local_phy_ctl(struct pm8001_hba_info *pm8001_ha,
+                                                        void *piomb);
+void pm8001_get_lrate_mode(struct pm8001_phy *phy, u8 link_rate);
+void pm8001_get_attached_sas_addr(struct pm8001_phy *phy, u8 *sas_addr);
+void pm8001_bytes_dmaed(struct pm8001_hba_info *pm8001_ha, int i);
+int pm8001_mpi_reg_resp(struct pm8001_hba_info *pm8001_ha, void *piomb);
+int pm8001_mpi_dereg_resp(struct pm8001_hba_info *pm8001_ha, void *piomb);
+int pm8001_mpi_fw_flash_update_resp(struct pm8001_hba_info *pm8001_ha,
+                                                        void *piomb);
+int pm8001_mpi_general_event(struct pm8001_hba_info *pm8001_ha , void *piomb);
+int pm8001_mpi_task_abort_resp(struct pm8001_hba_info *pm8001_ha, void *piomb);
+struct sas_task *pm8001_alloc_task(void);
+void pm8001_task_done(struct sas_task *task);
+void pm8001_free_task(struct sas_task *task);
+void pm8001_tag_free(struct pm8001_hba_info *pm8001_ha, u32 tag);
+struct pm8001_device *pm8001_find_dev(struct pm8001_hba_info *pm8001_ha,
+                                        u32 device_id);
+int pm80xx_set_thermal_config(struct pm8001_hba_info *pm8001_ha);
+
 int pm8001_bar4_shift(struct pm8001_hba_info *pm8001_ha, u32 shiftValue);
 
 /* ctl shared API */
diff --git a/drivers/scsi/pm8001/pm80xx_hwi.c b/drivers/scsi/pm8001/pm80xx_hwi.c
new file mode 100644
index 000000000000..302514d8157b
--- /dev/null
+++ b/drivers/scsi/pm8001/pm80xx_hwi.c
@@ -0,0 +1,4130 @@
+/*
+ * PMC-Sierra SPCv/ve 8088/8089 SAS/SATA based host adapters driver
+ *
+ * Copyright (c) 2008-2009 PMC-Sierra, Inc.,
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions, and the following disclaimer,
+ * without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ * substantially similar to the "NO WARRANTY" disclaimer below
+ * ("Disclaimer") and any redistribution must be conditioned upon
+ * including a substantially similar Disclaimer requirement for further
+ * binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ * of any contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ *
+ */
+ #include <linux/slab.h>
+ #include "pm8001_sas.h"
+ #include "pm80xx_hwi.h"
+ #include "pm8001_chips.h"
+ #include "pm8001_ctl.h"
+
+#define SMP_DIRECT 1
+#define SMP_INDIRECT 2
+/**
+ * read_main_config_table - read the configure table and save it.
+ * @pm8001_ha: our hba card information
+ */
+static void read_main_config_table(struct pm8001_hba_info *pm8001_ha)
+{
+        void __iomem *address = pm8001_ha->main_cfg_tbl_addr;
+
+        pm8001_ha->main_cfg_tbl.pm80xx_tbl.signature    =
+                pm8001_mr32(address, MAIN_SIGNATURE_OFFSET);
+        pm8001_ha->main_cfg_tbl.pm80xx_tbl.interface_rev =
+                pm8001_mr32(address, MAIN_INTERFACE_REVISION);
+        pm8001_ha->main_cfg_tbl.pm80xx_tbl.firmware_rev =
+                pm8001_mr32(address, MAIN_FW_REVISION);
+        pm8001_ha->main_cfg_tbl.pm80xx_tbl.max_out_io   =
+                pm8001_mr32(address, MAIN_MAX_OUTSTANDING_IO_OFFSET);
+        pm8001_ha->main_cfg_tbl.pm80xx_tbl.max_sgl      =
+                pm8001_mr32(address, MAIN_MAX_SGL_OFFSET);
+        pm8001_ha->main_cfg_tbl.pm80xx_tbl.ctrl_cap_flag =
+                pm8001_mr32(address, MAIN_CNTRL_CAP_OFFSET);
+        pm8001_ha->main_cfg_tbl.pm80xx_tbl.gst_offset   =
+                pm8001_mr32(address, MAIN_GST_OFFSET);
+        pm8001_ha->main_cfg_tbl.pm80xx_tbl.inbound_queue_offset =
+                pm8001_mr32(address, MAIN_IBQ_OFFSET);
+        pm8001_ha->main_cfg_tbl.pm80xx_tbl.outbound_queue_offset =
+                pm8001_mr32(address, MAIN_OBQ_OFFSET);
+
+        /* read Error Dump Offset and Length */
+        pm8001_ha->main_cfg_tbl.pm80xx_tbl.fatal_err_dump_offset0 =
+                pm8001_mr32(address, MAIN_FATAL_ERROR_RDUMP0_OFFSET);
+        pm8001_ha->main_cfg_tbl.pm80xx_tbl.fatal_err_dump_length0 =
+                pm8001_mr32(address, MAIN_FATAL_ERROR_RDUMP0_LENGTH);
+        pm8001_ha->main_cfg_tbl.pm80xx_tbl.fatal_err_dump_offset1 =
+                pm8001_mr32(address, MAIN_FATAL_ERROR_RDUMP1_OFFSET);
+        pm8001_ha->main_cfg_tbl.pm80xx_tbl.fatal_err_dump_length1 =
+                pm8001_mr32(address, MAIN_FATAL_ERROR_RDUMP1_LENGTH);
+
+        /* read GPIO LED settings from the configuration table */
+        pm8001_ha->main_cfg_tbl.pm80xx_tbl.gpio_led_mapping =
+                pm8001_mr32(address, MAIN_GPIO_LED_FLAGS_OFFSET);
+
+        /* read analog Setting offset from the configuration table */
+        pm8001_ha->main_cfg_tbl.pm80xx_tbl.analog_setup_table_offset =
+                pm8001_mr32(address, MAIN_ANALOG_SETUP_OFFSET);
+
+        pm8001_ha->main_cfg_tbl.pm80xx_tbl.int_vec_table_offset =
+                pm8001_mr32(address, MAIN_INT_VECTOR_TABLE_OFFSET);
+        pm8001_ha->main_cfg_tbl.pm80xx_tbl.phy_attr_table_offset =
+                pm8001_mr32(address, MAIN_SAS_PHY_ATTR_TABLE_OFFSET);
+}
+
+/**
+ * read_general_status_table - read the general status table and save it.
+ * @pm8001_ha: our hba card information
+ */
+static void read_general_status_table(struct pm8001_hba_info *pm8001_ha)
+{
+        void __iomem *address = pm8001_ha->general_stat_tbl_addr;
+        pm8001_ha->gs_tbl.pm80xx_tbl.gst_len_mpistate   =
+                        pm8001_mr32(address, GST_GSTLEN_MPIS_OFFSET);
+        pm8001_ha->gs_tbl.pm80xx_tbl.iq_freeze_state0   =
+                        pm8001_mr32(address, GST_IQ_FREEZE_STATE0_OFFSET);
+        pm8001_ha->gs_tbl.pm80xx_tbl.iq_freeze_state1   =
+                        pm8001_mr32(address, GST_IQ_FREEZE_STATE1_OFFSET);
+        pm8001_ha->gs_tbl.pm80xx_tbl.msgu_tcnt          =
+                        pm8001_mr32(address, GST_MSGUTCNT_OFFSET);
+        pm8001_ha->gs_tbl.pm80xx_tbl.iop_tcnt           =
+                        pm8001_mr32(address, GST_IOPTCNT_OFFSET);
+        pm8001_ha->gs_tbl.pm80xx_tbl.gpio_input_val     =
+                        pm8001_mr32(address, GST_GPIO_INPUT_VAL);
+        pm8001_ha->gs_tbl.pm80xx_tbl.recover_err_info[0] =
+                        pm8001_mr32(address, GST_RERRINFO_OFFSET0);
+        pm8001_ha->gs_tbl.pm80xx_tbl.recover_err_info[1] =
+                        pm8001_mr32(address, GST_RERRINFO_OFFSET1);
+        pm8001_ha->gs_tbl.pm80xx_tbl.recover_err_info[2] =
+                        pm8001_mr32(address, GST_RERRINFO_OFFSET2);
+        pm8001_ha->gs_tbl.pm80xx_tbl.recover_err_info[3] =
+                        pm8001_mr32(address, GST_RERRINFO_OFFSET3);
+        pm8001_ha->gs_tbl.pm80xx_tbl.recover_err_info[4] =
+                        pm8001_mr32(address, GST_RERRINFO_OFFSET4);
+        pm8001_ha->gs_tbl.pm80xx_tbl.recover_err_info[5] =
+                        pm8001_mr32(address, GST_RERRINFO_OFFSET5);
+        pm8001_ha->gs_tbl.pm80xx_tbl.recover_err_info[6] =
+                        pm8001_mr32(address, GST_RERRINFO_OFFSET6);
+        pm8001_ha->gs_tbl.pm80xx_tbl.recover_err_info[7] =
+                         pm8001_mr32(address, GST_RERRINFO_OFFSET7);
+}
+/**
+ * read_phy_attr_table - read the phy attribute table and save it.
+ * @pm8001_ha: our hba card information
+ */
+static void read_phy_attr_table(struct pm8001_hba_info *pm8001_ha)
+{
+        void __iomem *address = pm8001_ha->pspa_q_tbl_addr;
+        pm8001_ha->phy_attr_table.phystart1_16[0] =
+                        pm8001_mr32(address, PSPA_PHYSTATE0_OFFSET);
+        pm8001_ha->phy_attr_table.phystart1_16[1] =
+                        pm8001_mr32(address, PSPA_PHYSTATE1_OFFSET);
+        pm8001_ha->phy_attr_table.phystart1_16[2] =
+                        pm8001_mr32(address, PSPA_PHYSTATE2_OFFSET);
+        pm8001_ha->phy_attr_table.phystart1_16[3] =
+                        pm8001_mr32(address, PSPA_PHYSTATE3_OFFSET);
+        pm8001_ha->phy_attr_table.phystart1_16[4] =
+                        pm8001_mr32(address, PSPA_PHYSTATE4_OFFSET);
+        pm8001_ha->phy_attr_table.phystart1_16[5] =
+                        pm8001_mr32(address, PSPA_PHYSTATE5_OFFSET);
+        pm8001_ha->phy_attr_table.phystart1_16[6] =
+                        pm8001_mr32(address, PSPA_PHYSTATE6_OFFSET);
+        pm8001_ha->phy_attr_table.phystart1_16[7] =
+                        pm8001_mr32(address, PSPA_PHYSTATE7_OFFSET);
+        pm8001_ha->phy_attr_table.phystart1_16[8] =
+                        pm8001_mr32(address, PSPA_PHYSTATE8_OFFSET);
+        pm8001_ha->phy_attr_table.phystart1_16[9] =
+                        pm8001_mr32(address, PSPA_PHYSTATE9_OFFSET);
+        pm8001_ha->phy_attr_table.phystart1_16[10] =
+                        pm8001_mr32(address, PSPA_PHYSTATE10_OFFSET);
+        pm8001_ha->phy_attr_table.phystart1_16[11] =
+                        pm8001_mr32(address, PSPA_PHYSTATE11_OFFSET);
+        pm8001_ha->phy_attr_table.phystart1_16[12] =
+                        pm8001_mr32(address, PSPA_PHYSTATE12_OFFSET);
+        pm8001_ha->phy_attr_table.phystart1_16[13] =
+                        pm8001_mr32(address, PSPA_PHYSTATE13_OFFSET);
+        pm8001_ha->phy_attr_table.phystart1_16[14] =
+                        pm8001_mr32(address, PSPA_PHYSTATE14_OFFSET);
+        pm8001_ha->phy_attr_table.phystart1_16[15] =
+                        pm8001_mr32(address, PSPA_PHYSTATE15_OFFSET);
+
+        pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[0] =
+                        pm8001_mr32(address, PSPA_OB_HW_EVENT_PID0_OFFSET);
+        pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[1] =
+                        pm8001_mr32(address, PSPA_OB_HW_EVENT_PID1_OFFSET);
+        pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[2] =
+                        pm8001_mr32(address, PSPA_OB_HW_EVENT_PID2_OFFSET);
+        pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[3] =
+                        pm8001_mr32(address, PSPA_OB_HW_EVENT_PID3_OFFSET);
+        pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[4] =
+                        pm8001_mr32(address, PSPA_OB_HW_EVENT_PID4_OFFSET);
+        pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[5] =
+                        pm8001_mr32(address, PSPA_OB_HW_EVENT_PID5_OFFSET);
+        pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[6] =
+                        pm8001_mr32(address, PSPA_OB_HW_EVENT_PID6_OFFSET);
+        pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[7] =
+                        pm8001_mr32(address, PSPA_OB_HW_EVENT_PID7_OFFSET);
+        pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[8] =
+                        pm8001_mr32(address, PSPA_OB_HW_EVENT_PID8_OFFSET);
+        pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[9] =
+                        pm8001_mr32(address, PSPA_OB_HW_EVENT_PID9_OFFSET);
+        pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[10] =
+                        pm8001_mr32(address, PSPA_OB_HW_EVENT_PID10_OFFSET);
+        pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[11] =
+                        pm8001_mr32(address, PSPA_OB_HW_EVENT_PID11_OFFSET);
+        pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[12] =
+                        pm8001_mr32(address, PSPA_OB_HW_EVENT_PID12_OFFSET);
+        pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[13] =
+                        pm8001_mr32(address, PSPA_OB_HW_EVENT_PID13_OFFSET);
+        pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[14] =
+                        pm8001_mr32(address, PSPA_OB_HW_EVENT_PID14_OFFSET);
+        pm8001_ha->phy_attr_table.outbound_hw_event_pid1_16[15] =
+                        pm8001_mr32(address, PSPA_OB_HW_EVENT_PID15_OFFSET);
+
+}
+
+/**
+ * read_inbnd_queue_table - read the inbound queue table and save it.
+ * @pm8001_ha: our hba card information
+ */
+static void read_inbnd_queue_table(struct pm8001_hba_info *pm8001_ha)
+{
+        int i;
+        void __iomem *address = pm8001_ha->inbnd_q_tbl_addr;
+        for (i = 0; i < PM8001_MAX_SPCV_INB_NUM; i++) {
+                u32 offset = i * 0x20;
+                pm8001_ha->inbnd_q_tbl[i].pi_pci_bar =
+                        get_pci_bar_index(pm8001_mr32(address,
+                                (offset + IB_PIPCI_BAR)));
+                pm8001_ha->inbnd_q_tbl[i].pi_offset =
+                        pm8001_mr32(address, (offset + IB_PIPCI_BAR_OFFSET));
+        }
+}
+
+/**
+ * read_outbnd_queue_table - read the outbound queue table and save it.
+ * @pm8001_ha: our hba card information
+ */
+static void read_outbnd_queue_table(struct pm8001_hba_info *pm8001_ha)
+{
+        int i;
+        void __iomem *address = pm8001_ha->outbnd_q_tbl_addr;
+        for (i = 0; i < PM8001_MAX_SPCV_OUTB_NUM; i++) {
+                u32 offset = i * 0x24;
+                pm8001_ha->outbnd_q_tbl[i].ci_pci_bar =
+                        get_pci_bar_index(pm8001_mr32(address,
+                                (offset + OB_CIPCI_BAR)));
+                pm8001_ha->outbnd_q_tbl[i].ci_offset =
+                        pm8001_mr32(address, (offset + OB_CIPCI_BAR_OFFSET));
+        }
+}
+
+/**
+ * init_default_table_values - init the default table.
+ * @pm8001_ha: our hba card information
+ */
+static void init_default_table_values(struct pm8001_hba_info *pm8001_ha)
+{
+        int i;
+        u32 offsetib, offsetob;
+        void __iomem *addressib = pm8001_ha->inbnd_q_tbl_addr;
+        void __iomem *addressob = pm8001_ha->outbnd_q_tbl_addr;
+
+        pm8001_ha->main_cfg_tbl.pm80xx_tbl.upper_event_log_addr         =
+                pm8001_ha->memoryMap.region[AAP1].phys_addr_hi;
+        pm8001_ha->main_cfg_tbl.pm80xx_tbl.lower_event_log_addr         =
+                pm8001_ha->memoryMap.region[AAP1].phys_addr_lo;
+        pm8001_ha->main_cfg_tbl.pm80xx_tbl.event_log_size               =
+                                                        PM8001_EVENT_LOG_SIZE;
+        pm8001_ha->main_cfg_tbl.pm80xx_tbl.event_log_severity           = 0x01;
+        pm8001_ha->main_cfg_tbl.pm80xx_tbl.upper_pcs_event_log_addr     =
+                pm8001_ha->memoryMap.region[IOP].phys_addr_hi;
+        pm8001_ha->main_cfg_tbl.pm80xx_tbl.lower_pcs_event_log_addr     =
+                pm8001_ha->memoryMap.region[IOP].phys_addr_lo;
+        pm8001_ha->main_cfg_tbl.pm80xx_tbl.pcs_event_log_size           =
+                                                        PM8001_EVENT_LOG_SIZE;
+        pm8001_ha->main_cfg_tbl.pm80xx_tbl.pcs_event_log_severity       = 0x01;
+        pm8001_ha->main_cfg_tbl.pm80xx_tbl.fatal_err_interrupt          = 0x01;
+
+        /* Disable end to end CRC checking */
+        pm8001_ha->main_cfg_tbl.pm80xx_tbl.crc_core_dump = (0x1 << 16);
+
+        for (i = 0; i < PM8001_MAX_SPCV_INB_NUM; i++) {
+                pm8001_ha->inbnd_q_tbl[i].element_pri_size_cnt  =
+                        PM8001_MPI_QUEUE | (64 << 16) | (0x00<<30);
+                pm8001_ha->inbnd_q_tbl[i].upper_base_addr       =
+                        pm8001_ha->memoryMap.region[IB + i].phys_addr_hi;
+                pm8001_ha->inbnd_q_tbl[i].lower_base_addr       =
+                pm8001_ha->memoryMap.region[IB + i].phys_addr_lo;
+                pm8001_ha->inbnd_q_tbl[i].base_virt             =
+                        (u8 *)pm8001_ha->memoryMap.region[IB + i].virt_ptr;
+                pm8001_ha->inbnd_q_tbl[i].total_length          =
+                        pm8001_ha->memoryMap.region[IB + i].total_len;
+                pm8001_ha->inbnd_q_tbl[i].ci_upper_base_addr    =
+                        pm8001_ha->memoryMap.region[CI + i].phys_addr_hi;
+                pm8001_ha->inbnd_q_tbl[i].ci_lower_base_addr    =
+                        pm8001_ha->memoryMap.region[CI + i].phys_addr_lo;
+                pm8001_ha->inbnd_q_tbl[i].ci_virt               =
+                        pm8001_ha->memoryMap.region[CI + i].virt_ptr;
+                offsetib = i * 0x20;
+                pm8001_ha->inbnd_q_tbl[i].pi_pci_bar            =
+                        get_pci_bar_index(pm8001_mr32(addressib,
+                                (offsetib + 0x14)));
+                pm8001_ha->inbnd_q_tbl[i].pi_offset             =
+                        pm8001_mr32(addressib, (offsetib + 0x18));
+                pm8001_ha->inbnd_q_tbl[i].producer_idx          = 0;
+                pm8001_ha->inbnd_q_tbl[i].consumer_index        = 0;
+        }
+        for (i = 0; i < PM8001_MAX_SPCV_OUTB_NUM; i++) {
+                pm8001_ha->outbnd_q_tbl[i].element_size_cnt     =
+                        PM8001_MPI_QUEUE | (64 << 16) | (0x01<<30);
+                pm8001_ha->outbnd_q_tbl[i].upper_base_addr      =
+                        pm8001_ha->memoryMap.region[OB + i].phys_addr_hi;
+                pm8001_ha->outbnd_q_tbl[i].lower_base_addr      =
+                        pm8001_ha->memoryMap.region[OB + i].phys_addr_lo;
+                pm8001_ha->outbnd_q_tbl[i].base_virt            =
+                        (u8 *)pm8001_ha->memoryMap.region[OB + i].virt_ptr;
+                pm8001_ha->outbnd_q_tbl[i].total_length         =
+                        pm8001_ha->memoryMap.region[OB + i].total_len;
+                pm8001_ha->outbnd_q_tbl[i].pi_upper_base_addr   =
+                        pm8001_ha->memoryMap.region[PI + i].phys_addr_hi;
+                pm8001_ha->outbnd_q_tbl[i].pi_lower_base_addr   =
+                        pm8001_ha->memoryMap.region[PI + i].phys_addr_lo;
+                /* interrupt vector based on oq */
+                pm8001_ha->outbnd_q_tbl[i].interrup_vec_cnt_delay = (i << 24);
+                pm8001_ha->outbnd_q_tbl[i].pi_virt              =
+                        pm8001_ha->memoryMap.region[PI + i].virt_ptr;
+                offsetob = i * 0x24;
+                pm8001_ha->outbnd_q_tbl[i].ci_pci_bar           =
+                        get_pci_bar_index(pm8001_mr32(addressob,
+                        offsetob + 0x14));
+                pm8001_ha->outbnd_q_tbl[i].ci_offset            =
+                        pm8001_mr32(addressob, (offsetob + 0x18));
+                pm8001_ha->outbnd_q_tbl[i].consumer_idx         = 0;
+                pm8001_ha->outbnd_q_tbl[i].producer_index       = 0;
+        }
+}
+
+/**
+ * update_main_config_table - update the main default table to the HBA.
+ * @pm8001_ha: our hba card information
+ */
+static void update_main_config_table(struct pm8001_hba_info *pm8001_ha)
+{
+        void __iomem *address = pm8001_ha->main_cfg_tbl_addr;
+        pm8001_mw32(address, MAIN_IQNPPD_HPPD_OFFSET,
+                pm8001_ha->main_cfg_tbl.pm80xx_tbl.inbound_q_nppd_hppd);
+        pm8001_mw32(address, MAIN_EVENT_LOG_ADDR_HI,
+                pm8001_ha->main_cfg_tbl.pm80xx_tbl.upper_event_log_addr);
+        pm8001_mw32(address, MAIN_EVENT_LOG_ADDR_LO,
+                pm8001_ha->main_cfg_tbl.pm80xx_tbl.lower_event_log_addr);
+        pm8001_mw32(address, MAIN_EVENT_LOG_BUFF_SIZE,
+                pm8001_ha->main_cfg_tbl.pm80xx_tbl.event_log_size);
+        pm8001_mw32(address, MAIN_EVENT_LOG_OPTION,
+                pm8001_ha->main_cfg_tbl.pm80xx_tbl.event_log_severity);
+        pm8001_mw32(address, MAIN_PCS_EVENT_LOG_ADDR_HI,
+                pm8001_ha->main_cfg_tbl.pm80xx_tbl.upper_pcs_event_log_addr);
+        pm8001_mw32(address, MAIN_PCS_EVENT_LOG_ADDR_LO,
+                pm8001_ha->main_cfg_tbl.pm80xx_tbl.lower_pcs_event_log_addr);
+        pm8001_mw32(address, MAIN_PCS_EVENT_LOG_BUFF_SIZE,
+                pm8001_ha->main_cfg_tbl.pm80xx_tbl.pcs_event_log_size);
+        pm8001_mw32(address, MAIN_PCS_EVENT_LOG_OPTION,
+                pm8001_ha->main_cfg_tbl.pm80xx_tbl.pcs_event_log_severity);
+        pm8001_mw32(address, MAIN_FATAL_ERROR_INTERRUPT,
+                pm8001_ha->main_cfg_tbl.pm80xx_tbl.fatal_err_interrupt);
+        pm8001_mw32(address, MAIN_EVENT_CRC_CHECK,
+                pm8001_ha->main_cfg_tbl.pm80xx_tbl.crc_core_dump);
+
+        /* SPCv specific */
+        pm8001_ha->main_cfg_tbl.pm80xx_tbl.gpio_led_mapping &= 0xCFFFFFFF;
+        /* Set GPIOLED to 0x2 for LED indicator */
+        pm8001_ha->main_cfg_tbl.pm80xx_tbl.gpio_led_mapping |= 0x20000000;
+        pm8001_mw32(address, MAIN_GPIO_LED_FLAGS_OFFSET,
+                pm8001_ha->main_cfg_tbl.pm80xx_tbl.gpio_led_mapping);
+
+        pm8001_mw32(address, MAIN_PORT_RECOVERY_TIMER,
+                pm8001_ha->main_cfg_tbl.pm80xx_tbl.port_recovery_timer);
+        pm8001_mw32(address, MAIN_INT_REASSERTION_DELAY,
+                pm8001_ha->main_cfg_tbl.pm80xx_tbl.interrupt_reassertion_delay);
+}
+
+/**
+ * update_inbnd_queue_table - update the inbound queue table to the HBA.
+ * @pm8001_ha: our hba card information
+ */
+static void update_inbnd_queue_table(struct pm8001_hba_info *pm8001_ha,
+                                         int number)
+{
+        void __iomem *address = pm8001_ha->inbnd_q_tbl_addr;
+        u16 offset = number * 0x20;
+        pm8001_mw32(address, offset + IB_PROPERITY_OFFSET,
+                pm8001_ha->inbnd_q_tbl[number].element_pri_size_cnt);
+        pm8001_mw32(address, offset + IB_BASE_ADDR_HI_OFFSET,
+                pm8001_ha->inbnd_q_tbl[number].upper_base_addr);
+        pm8001_mw32(address, offset + IB_BASE_ADDR_LO_OFFSET,
+                pm8001_ha->inbnd_q_tbl[number].lower_base_addr);
+        pm8001_mw32(address, offset + IB_CI_BASE_ADDR_HI_OFFSET,
+                pm8001_ha->inbnd_q_tbl[number].ci_upper_base_addr);
+        pm8001_mw32(address, offset + IB_CI_BASE_ADDR_LO_OFFSET,
+                pm8001_ha->inbnd_q_tbl[number].ci_lower_base_addr);
+}
+
+/**
+ * update_outbnd_queue_table - update the outbound queue table to the HBA.
+ * @pm8001_ha: our hba card information
+ */
+static void update_outbnd_queue_table(struct pm8001_hba_info *pm8001_ha,
+                                                 int number)
+{
+        void __iomem *address = pm8001_ha->outbnd_q_tbl_addr;
+        u16 offset = number * 0x24;
+        pm8001_mw32(address, offset + OB_PROPERITY_OFFSET,
+                pm8001_ha->outbnd_q_tbl[number].element_size_cnt);
+        pm8001_mw32(address, offset + OB_BASE_ADDR_HI_OFFSET,
+                pm8001_ha->outbnd_q_tbl[number].upper_base_addr);
+        pm8001_mw32(address, offset + OB_BASE_ADDR_LO_OFFSET,
+                pm8001_ha->outbnd_q_tbl[number].lower_base_addr);
+        pm8001_mw32(address, offset + OB_PI_BASE_ADDR_HI_OFFSET,
+                pm8001_ha->outbnd_q_tbl[number].pi_upper_base_addr);
+        pm8001_mw32(address, offset + OB_PI_BASE_ADDR_LO_OFFSET,
+                pm8001_ha->outbnd_q_tbl[number].pi_lower_base_addr);
+        pm8001_mw32(address, offset + OB_INTERRUPT_COALES_OFFSET,
+                pm8001_ha->outbnd_q_tbl[number].interrup_vec_cnt_delay);
+}
+
+/**
+ * mpi_init_check - check firmware initialization status.
+ * @pm8001_ha: our hba card information
+ */
+static int mpi_init_check(struct pm8001_hba_info *pm8001_ha)
+{
+        u32 max_wait_count;
+        u32 value;
+        u32 gst_len_mpistate;
+
+        /* Write bit0=1 to Inbound DoorBell Register to tell the SPC FW the
+        table is updated */
+        pm8001_cw32(pm8001_ha, 0, MSGU_IBDB_SET, SPCv_MSGU_CFG_TABLE_UPDATE);
+        /* wait until Inbound DoorBell Clear Register toggled */
+        max_wait_count = 2 * 1000 * 1000;/* 2 sec for spcv/ve */
+        do {
+                udelay(1);
+                value = pm8001_cr32(pm8001_ha, 0, MSGU_IBDB_SET);
+                value &= SPCv_MSGU_CFG_TABLE_UPDATE;
+        } while ((value != 0) && (--max_wait_count));
+
+        if (!max_wait_count)
+                return -1;
+        /* check the MPI-State for initialization upto 100ms*/
+        max_wait_count = 100 * 1000;/* 100 msec */
+        do {
+                udelay(1);
+                gst_len_mpistate =
+                        pm8001_mr32(pm8001_ha->general_stat_tbl_addr,
+                                        GST_GSTLEN_MPIS_OFFSET);
+        } while ((GST_MPI_STATE_INIT !=
+                (gst_len_mpistate & GST_MPI_STATE_MASK)) && (--max_wait_count));
+        if (!max_wait_count)
+                return -1;
+
+        /* check MPI Initialization error */
+        gst_len_mpistate = gst_len_mpistate >> 16;
+        if (0x0000 != gst_len_mpistate)
+                return -1;
+
+        return 0;
+}
+
+/**
+ * check_fw_ready - The LLDD check if the FW is ready, if not, return error.
+ * @pm8001_ha: our hba card information
+ */
+static int check_fw_ready(struct pm8001_hba_info *pm8001_ha)
+{
+        u32 value;
+        u32 max_wait_count;
+        u32 max_wait_time;
+        int ret = 0;
+
+        /* reset / PCIe ready */
+        max_wait_time = max_wait_count = 100 * 1000;    /* 100 milli sec */
+        do {
+                udelay(1);
+                value = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_1);
+        } while ((value == 0xFFFFFFFF) && (--max_wait_count));
+
+        /* check ila status */
+        max_wait_time = max_wait_count = 1000 * 1000;   /* 1000 milli sec */
+        do {
+                udelay(1);
+                value = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_1);
+        } while (((value & SCRATCH_PAD_ILA_READY) !=
+                        SCRATCH_PAD_ILA_READY) && (--max_wait_count));
+        if (!max_wait_count)
+                ret = -1;
+        else {
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(" ila ready status in %d millisec\n",
+                                (max_wait_time - max_wait_count)));
+        }
+
+        /* check RAAE status */
+        max_wait_time = max_wait_count = 1800 * 1000;   /* 1800 milli sec */
+        do {
+                udelay(1);
+                value = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_1);
+        } while (((value & SCRATCH_PAD_RAAE_READY) !=
+                                SCRATCH_PAD_RAAE_READY) && (--max_wait_count));
+        if (!max_wait_count)
+                ret = -1;
+        else {
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(" raae ready status in %d millisec\n",
+                                        (max_wait_time - max_wait_count)));
+        }
+
+        /* check iop0 status */
+        max_wait_time = max_wait_count = 600 * 1000;    /* 600 milli sec */
+        do {
+                udelay(1);
+                value = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_1);
+        } while (((value & SCRATCH_PAD_IOP0_READY) != SCRATCH_PAD_IOP0_READY) &&
+                        (--max_wait_count));
+        if (!max_wait_count)
+                ret = -1;
+        else {
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(" iop0 ready status in %d millisec\n",
+                                (max_wait_time - max_wait_count)));
+        }
+
+        /* check iop1 status only for 16 port controllers */
+        if ((pm8001_ha->chip_id != chip_8008) &&
+                        (pm8001_ha->chip_id != chip_8009)) {
+                /* 200 milli sec */
+                max_wait_time = max_wait_count = 200 * 1000;
+                do {
+                        udelay(1);
+                        value = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_1);
+                } while (((value & SCRATCH_PAD_IOP1_READY) !=
+                                SCRATCH_PAD_IOP1_READY) && (--max_wait_count));
+                if (!max_wait_count)
+                        ret = -1;
+                else {
+                        PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+                                "iop1 ready status in %d millisec\n",
+                                (max_wait_time - max_wait_count)));
+                }
+        }
+
+        return ret;
+}
+
+static void init_pci_device_addresses(struct pm8001_hba_info *pm8001_ha)
+{
+        void __iomem *base_addr;
+        u32     value;
+        u32     offset;
+        u32     pcibar;
+        u32     pcilogic;
+
+        value = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_0);
+        offset = value & 0x03FFFFFF; /* scratch pad 0 TBL address */
+
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("Scratchpad 0 Offset: 0x%x value 0x%x\n",
+                                offset, value));
+        pcilogic = (value & 0xFC000000) >> 26;
+        pcibar = get_pci_bar_index(pcilogic);
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("Scratchpad 0 PCI BAR: %d\n", pcibar));
+        pm8001_ha->main_cfg_tbl_addr = base_addr =
+                pm8001_ha->io_mem[pcibar].memvirtaddr + offset;
+        pm8001_ha->general_stat_tbl_addr =
+                base_addr + (pm8001_cr32(pm8001_ha, pcibar, offset + 0x18) &
+                                        0xFFFFFF);
+        pm8001_ha->inbnd_q_tbl_addr =
+                base_addr + (pm8001_cr32(pm8001_ha, pcibar, offset + 0x1C) &
+                                        0xFFFFFF);
+        pm8001_ha->outbnd_q_tbl_addr =
+                base_addr + (pm8001_cr32(pm8001_ha, pcibar, offset + 0x20) &
+                                        0xFFFFFF);
+        pm8001_ha->ivt_tbl_addr =
+                base_addr + (pm8001_cr32(pm8001_ha, pcibar, offset + 0x8C) &
+                                        0xFFFFFF);
+        pm8001_ha->pspa_q_tbl_addr =
+                base_addr + (pm8001_cr32(pm8001_ha, pcibar, offset + 0x90) &
+                                        0xFFFFFF);
+
+        PM8001_INIT_DBG(pm8001_ha,
+                        pm8001_printk("GST OFFSET 0x%x\n",
+                        pm8001_cr32(pm8001_ha, pcibar, offset + 0x18)));
+        PM8001_INIT_DBG(pm8001_ha,
+                        pm8001_printk("INBND OFFSET 0x%x\n",
+                        pm8001_cr32(pm8001_ha, pcibar, offset + 0x1C)));
+        PM8001_INIT_DBG(pm8001_ha,
+                        pm8001_printk("OBND OFFSET 0x%x\n",
+                        pm8001_cr32(pm8001_ha, pcibar, offset + 0x20)));
+        PM8001_INIT_DBG(pm8001_ha,
+                        pm8001_printk("IVT OFFSET 0x%x\n",
+                        pm8001_cr32(pm8001_ha, pcibar, offset + 0x8C)));
+        PM8001_INIT_DBG(pm8001_ha,
+                        pm8001_printk("PSPA OFFSET 0x%x\n",
+                        pm8001_cr32(pm8001_ha, pcibar, offset + 0x90)));
+        PM8001_INIT_DBG(pm8001_ha,
+                        pm8001_printk("addr - main cfg %p general status %p\n",
+                        pm8001_ha->main_cfg_tbl_addr,
+                        pm8001_ha->general_stat_tbl_addr));
+        PM8001_INIT_DBG(pm8001_ha,
+                        pm8001_printk("addr - inbnd %p obnd %p\n",
+                        pm8001_ha->inbnd_q_tbl_addr,
+                        pm8001_ha->outbnd_q_tbl_addr));
+        PM8001_INIT_DBG(pm8001_ha,
+                        pm8001_printk("addr - pspa %p ivt %p\n",
+                        pm8001_ha->pspa_q_tbl_addr,
+                        pm8001_ha->ivt_tbl_addr));
+}
+
+/**
+ * pm80xx_set_thermal_config - support the thermal configuration
+ * @pm8001_ha: our hba card information.
+ */
+int
+pm80xx_set_thermal_config(struct pm8001_hba_info *pm8001_ha)
+{
+        struct set_ctrl_cfg_req payload;
+        struct inbound_queue_table *circularQ;
+        int rc;
+        u32 tag;
+        u32 opc = OPC_INB_SET_CONTROLLER_CONFIG;
+
+        memset(&payload, 0, sizeof(struct set_ctrl_cfg_req));
+        rc = pm8001_tag_alloc(pm8001_ha, &tag);
+        if (rc)
+                return -1;
+
+        circularQ = &pm8001_ha->inbnd_q_tbl[0];
+        payload.tag = cpu_to_le32(tag);
+        payload.cfg_pg[0] = (THERMAL_LOG_ENABLE << 9) |
+                        (THERMAL_ENABLE << 8) | THERMAL_OP_CODE;
+        payload.cfg_pg[1] = (LTEMPHIL << 24) | (RTEMPHIL << 8);
+
+        rc = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &payload, 0);
+        return rc;
+
+}
+
+/**
+* pm80xx_set_sas_protocol_timer_config - support the SAS Protocol
+* Timer configuration page
+* @pm8001_ha: our hba card information.
+*/
+static int
+pm80xx_set_sas_protocol_timer_config(struct pm8001_hba_info *pm8001_ha)
+{
+        struct set_ctrl_cfg_req payload;
+        struct inbound_queue_table *circularQ;
+        SASProtocolTimerConfig_t SASConfigPage;
+        int rc;
+        u32 tag;
+        u32 opc = OPC_INB_SET_CONTROLLER_CONFIG;
+
+        memset(&payload, 0, sizeof(struct set_ctrl_cfg_req));
+        memset(&SASConfigPage, 0, sizeof(SASProtocolTimerConfig_t));
+
+        rc = pm8001_tag_alloc(pm8001_ha, &tag);
+
+        if (rc)
+                return -1;
+
+        circularQ = &pm8001_ha->inbnd_q_tbl[0];
+        payload.tag = cpu_to_le32(tag);
+
+        SASConfigPage.pageCode        =  SAS_PROTOCOL_TIMER_CONFIG_PAGE;
+        SASConfigPage.MST_MSI         =  3 << 15;
+        SASConfigPage.STP_SSP_MCT_TMO =  (STP_MCT_TMO << 16) | SSP_MCT_TMO;
+        SASConfigPage.STP_FRM_TMO     = (SAS_MAX_OPEN_TIME << 24) |
+                                (SMP_MAX_CONN_TIMER << 16) | STP_FRM_TIMER;
+        SASConfigPage.STP_IDLE_TMO    =  STP_IDLE_TIME;
+
+        if (SASConfigPage.STP_IDLE_TMO > 0x3FFFFFF)
+                SASConfigPage.STP_IDLE_TMO = 0x3FFFFFF;
+
+
+        SASConfigPage.OPNRJT_RTRY_INTVL =         (SAS_MFD << 16) |
+                                                SAS_OPNRJT_RTRY_INTVL;
+        SASConfigPage.Data_Cmd_OPNRJT_RTRY_TMO =  (SAS_DOPNRJT_RTRY_TMO << 16)
+                                                | SAS_COPNRJT_RTRY_TMO;
+        SASConfigPage.Data_Cmd_OPNRJT_RTRY_THR =  (SAS_DOPNRJT_RTRY_THR << 16)
+                                                | SAS_COPNRJT_RTRY_THR;
+        SASConfigPage.MAX_AIP =  SAS_MAX_AIP;
+
+        PM8001_INIT_DBG(pm8001_ha,
+                        pm8001_printk("SASConfigPage.pageCode "
+                        "0x%08x\n", SASConfigPage.pageCode));
+        PM8001_INIT_DBG(pm8001_ha,
+                        pm8001_printk("SASConfigPage.MST_MSI "
+                        " 0x%08x\n", SASConfigPage.MST_MSI));
+        PM8001_INIT_DBG(pm8001_ha,
+                        pm8001_printk("SASConfigPage.STP_SSP_MCT_TMO "
+                        " 0x%08x\n", SASConfigPage.STP_SSP_MCT_TMO));
+        PM8001_INIT_DBG(pm8001_ha,
+                        pm8001_printk("SASConfigPage.STP_FRM_TMO "
+                        " 0x%08x\n", SASConfigPage.STP_FRM_TMO));
+        PM8001_INIT_DBG(pm8001_ha,
+                        pm8001_printk("SASConfigPage.STP_IDLE_TMO "
+                        " 0x%08x\n", SASConfigPage.STP_IDLE_TMO));
+        PM8001_INIT_DBG(pm8001_ha,
+                        pm8001_printk("SASConfigPage.OPNRJT_RTRY_INTVL "
+                        " 0x%08x\n", SASConfigPage.OPNRJT_RTRY_INTVL));
+        PM8001_INIT_DBG(pm8001_ha,
+                        pm8001_printk("SASConfigPage.Data_Cmd_OPNRJT_RTRY_TMO "
+                        " 0x%08x\n", SASConfigPage.Data_Cmd_OPNRJT_RTRY_TMO));
+        PM8001_INIT_DBG(pm8001_ha,
+                        pm8001_printk("SASConfigPage.Data_Cmd_OPNRJT_RTRY_THR "
+                        " 0x%08x\n", SASConfigPage.Data_Cmd_OPNRJT_RTRY_THR));
+        PM8001_INIT_DBG(pm8001_ha, pm8001_printk("SASConfigPage.MAX_AIP "
+                        " 0x%08x\n", SASConfigPage.MAX_AIP));
+
+        memcpy(&payload.cfg_pg, &SASConfigPage,
+                         sizeof(SASProtocolTimerConfig_t));
+
+        rc = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &payload, 0);
+
+        return rc;
+}
+
+/**
+ * pm80xx_get_encrypt_info - Check for encryption
+ * @pm8001_ha: our hba card information.
+ */
+static int
+pm80xx_get_encrypt_info(struct pm8001_hba_info *pm8001_ha)
+{
+        u32 scratch3_value;
+        int ret;
+
+        /* Read encryption status from SCRATCH PAD 3 */
+        scratch3_value = pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_3);
+
+        if ((scratch3_value & SCRATCH_PAD3_ENC_MASK) ==
+                                        SCRATCH_PAD3_ENC_READY) {
+                if (scratch3_value & SCRATCH_PAD3_XTS_ENABLED)
+                        pm8001_ha->encrypt_info.cipher_mode = CIPHER_MODE_XTS;
+                if ((scratch3_value & SCRATCH_PAD3_SM_MASK) ==
+                                                SCRATCH_PAD3_SMF_ENABLED)
+                        pm8001_ha->encrypt_info.sec_mode = SEC_MODE_SMF;
+                if ((scratch3_value & SCRATCH_PAD3_SM_MASK) ==
+                                                SCRATCH_PAD3_SMA_ENABLED)
+                        pm8001_ha->encrypt_info.sec_mode = SEC_MODE_SMA;
+                if ((scratch3_value & SCRATCH_PAD3_SM_MASK) ==
+                                                SCRATCH_PAD3_SMB_ENABLED)
+                        pm8001_ha->encrypt_info.sec_mode = SEC_MODE_SMB;
+                pm8001_ha->encrypt_info.status = 0;
+                PM8001_INIT_DBG(pm8001_ha, pm8001_printk(
+                        "Encryption: SCRATCH_PAD3_ENC_READY 0x%08X."
+                        "Cipher mode 0x%x Sec mode 0x%x status 0x%x\n",
+                        scratch3_value, pm8001_ha->encrypt_info.cipher_mode,
+                        pm8001_ha->encrypt_info.sec_mode,
+                        pm8001_ha->encrypt_info.status));
+                ret = 0;
+        } else if ((scratch3_value & SCRATCH_PAD3_ENC_READY) ==
+                                        SCRATCH_PAD3_ENC_DISABLED) {
+                PM8001_INIT_DBG(pm8001_ha, pm8001_printk(
+                        "Encryption: SCRATCH_PAD3_ENC_DISABLED 0x%08X\n",
+                        scratch3_value));
+                pm8001_ha->encrypt_info.status = 0xFFFFFFFF;
+                pm8001_ha->encrypt_info.cipher_mode = 0;
+                pm8001_ha->encrypt_info.sec_mode = 0;
+                return 0;
+        } else if ((scratch3_value & SCRATCH_PAD3_ENC_MASK) ==
+                                SCRATCH_PAD3_ENC_DIS_ERR) {
+                pm8001_ha->encrypt_info.status =
+                        (scratch3_value & SCRATCH_PAD3_ERR_CODE) >> 16;
+                if (scratch3_value & SCRATCH_PAD3_XTS_ENABLED)
+                        pm8001_ha->encrypt_info.cipher_mode = CIPHER_MODE_XTS;
+                if ((scratch3_value & SCRATCH_PAD3_SM_MASK) ==
+                                        SCRATCH_PAD3_SMF_ENABLED)
+                        pm8001_ha->encrypt_info.sec_mode = SEC_MODE_SMF;
+                if ((scratch3_value & SCRATCH_PAD3_SM_MASK) ==
+                                        SCRATCH_PAD3_SMA_ENABLED)
+                        pm8001_ha->encrypt_info.sec_mode = SEC_MODE_SMA;
+                if ((scratch3_value & SCRATCH_PAD3_SM_MASK) ==
+                                        SCRATCH_PAD3_SMB_ENABLED)
+                        pm8001_ha->encrypt_info.sec_mode = SEC_MODE_SMB;
+                PM8001_INIT_DBG(pm8001_ha, pm8001_printk(
+                        "Encryption: SCRATCH_PAD3_DIS_ERR 0x%08X."
+                        "Cipher mode 0x%x sec mode 0x%x status 0x%x\n",
+                        scratch3_value, pm8001_ha->encrypt_info.cipher_mode,
+                        pm8001_ha->encrypt_info.sec_mode,
+                        pm8001_ha->encrypt_info.status));
+                ret = -1;
+        } else if ((scratch3_value & SCRATCH_PAD3_ENC_MASK) ==
+                                 SCRATCH_PAD3_ENC_ENA_ERR) {
+
+                pm8001_ha->encrypt_info.status =
+                        (scratch3_value & SCRATCH_PAD3_ERR_CODE) >> 16;
+                if (scratch3_value & SCRATCH_PAD3_XTS_ENABLED)
+                        pm8001_ha->encrypt_info.cipher_mode = CIPHER_MODE_XTS;
+                if ((scratch3_value & SCRATCH_PAD3_SM_MASK) ==
+                                        SCRATCH_PAD3_SMF_ENABLED)
+                        pm8001_ha->encrypt_info.sec_mode = SEC_MODE_SMF;
+                if ((scratch3_value & SCRATCH_PAD3_SM_MASK) ==
+                                        SCRATCH_PAD3_SMA_ENABLED)
+                        pm8001_ha->encrypt_info.sec_mode = SEC_MODE_SMA;
+                if ((scratch3_value & SCRATCH_PAD3_SM_MASK) ==
+                                        SCRATCH_PAD3_SMB_ENABLED)
+                        pm8001_ha->encrypt_info.sec_mode = SEC_MODE_SMB;
+
+                PM8001_INIT_DBG(pm8001_ha, pm8001_printk(
+                        "Encryption: SCRATCH_PAD3_ENA_ERR 0x%08X."
+                        "Cipher mode 0x%x sec mode 0x%x status 0x%x\n",
+                        scratch3_value, pm8001_ha->encrypt_info.cipher_mode,
+                        pm8001_ha->encrypt_info.sec_mode,
+                        pm8001_ha->encrypt_info.status));
+                ret = -1;
+        }
+        return ret;
+}
+
+/**
+ * pm80xx_encrypt_update - update flash with encryption informtion
+ * @pm8001_ha: our hba card information.
+ */
+static int pm80xx_encrypt_update(struct pm8001_hba_info *pm8001_ha)
+{
+        struct kek_mgmt_req payload;
+        struct inbound_queue_table *circularQ;
+        int rc;
+        u32 tag;
+        u32 opc = OPC_INB_KEK_MANAGEMENT;
+
+        memset(&payload, 0, sizeof(struct kek_mgmt_req));
+        rc = pm8001_tag_alloc(pm8001_ha, &tag);
+        if (rc)
+                return -1;
+
+        circularQ = &pm8001_ha->inbnd_q_tbl[0];
+        payload.tag = cpu_to_le32(tag);
+        /* Currently only one key is used. New KEK index is 1.
+         * Current KEK index is 1. Store KEK to NVRAM is 1.
+         */
+        payload.new_curidx_ksop = ((1 << 24) | (1 << 16) | (1 << 8) |
+                                        KEK_MGMT_SUBOP_KEYCARDUPDATE);
+
+        rc = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &payload, 0);
+
+        return rc;
+}
+
+/**
+ * pm8001_chip_init - the main init function that initialize whole PM8001 chip.
+ * @pm8001_ha: our hba card information
+ */
+static int pm80xx_chip_init(struct pm8001_hba_info *pm8001_ha)
+{
+        int ret;
+        u8 i = 0;
+
+        /* check the firmware status */
+        if (-1 == check_fw_ready(pm8001_ha)) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("Firmware is not ready!\n"));
+                return -EBUSY;
+        }
+
+        /* Initialize pci space address eg: mpi offset */
+        init_pci_device_addresses(pm8001_ha);
+        init_default_table_values(pm8001_ha);
+        read_main_config_table(pm8001_ha);
+        read_general_status_table(pm8001_ha);
+        read_inbnd_queue_table(pm8001_ha);
+        read_outbnd_queue_table(pm8001_ha);
+        read_phy_attr_table(pm8001_ha);
+
+        /* update main config table ,inbound table and outbound table */
+        update_main_config_table(pm8001_ha);
+        for (i = 0; i < PM8001_MAX_SPCV_INB_NUM; i++)
+                update_inbnd_queue_table(pm8001_ha, i);
+        for (i = 0; i < PM8001_MAX_SPCV_OUTB_NUM; i++)
+                update_outbnd_queue_table(pm8001_ha, i);
+
+        /* notify firmware update finished and check initialization status */
+        if (0 == mpi_init_check(pm8001_ha)) {
+                PM8001_INIT_DBG(pm8001_ha,
+                        pm8001_printk("MPI initialize successful!\n"));
+        } else
+                return -EBUSY;
+
+        /* send SAS protocol timer configuration page to FW */
+        ret = pm80xx_set_sas_protocol_timer_config(pm8001_ha);
+
+        /* Check for encryption */
+        if (pm8001_ha->chip->encrypt) {
+                PM8001_INIT_DBG(pm8001_ha,
+                        pm8001_printk("Checking for encryption\n"));
+                ret = pm80xx_get_encrypt_info(pm8001_ha);
+                if (ret == -1) {
+                        PM8001_INIT_DBG(pm8001_ha,
+                                pm8001_printk("Encryption error !!\n"));
+                        if (pm8001_ha->encrypt_info.status == 0x81) {
+                                PM8001_INIT_DBG(pm8001_ha, pm8001_printk(
+                                        "Encryption enabled with error."
+                                        "Saving encryption key to flash\n"));
+                                pm80xx_encrypt_update(pm8001_ha);
+                        }
+                }
+        }
+        return 0;
+}
+
+static int mpi_uninit_check(struct pm8001_hba_info *pm8001_ha)
+{
+        u32 max_wait_count;
+        u32 value;
+        u32 gst_len_mpistate;
+        init_pci_device_addresses(pm8001_ha);
+        /* Write bit1=1 to Inbound DoorBell Register to tell the SPC FW the
+        table is stop */
+        pm8001_cw32(pm8001_ha, 0, MSGU_IBDB_SET, SPCv_MSGU_CFG_TABLE_RESET);
+
+        /* wait until Inbound DoorBell Clear Register toggled */
+        max_wait_count = 2 * 1000 * 1000;       /* 2 sec for spcv/ve */
+        do {
+                udelay(1);
+                value = pm8001_cr32(pm8001_ha, 0, MSGU_IBDB_SET);
+                value &= SPCv_MSGU_CFG_TABLE_RESET;
+        } while ((value != 0) && (--max_wait_count));
+
+        if (!max_wait_count) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("TIMEOUT:IBDB value/=%x\n", value));
+                return -1;
+        }
+
+        /* check the MPI-State for termination in progress */
+        /* wait until Inbound DoorBell Clear Register toggled */
+        max_wait_count = 2 * 1000 * 1000;       /* 2 sec for spcv/ve */
+        do {
+                udelay(1);
+                gst_len_mpistate =
+                        pm8001_mr32(pm8001_ha->general_stat_tbl_addr,
+                        GST_GSTLEN_MPIS_OFFSET);
+                if (GST_MPI_STATE_UNINIT ==
+                        (gst_len_mpistate & GST_MPI_STATE_MASK))
+                        break;
+        } while (--max_wait_count);
+        if (!max_wait_count) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk(" TIME OUT MPI State = 0x%x\n",
+                                gst_len_mpistate & GST_MPI_STATE_MASK));
+                return -1;
+        }
+
+        return 0;
+}
+
+/**
+ * pm8001_chip_soft_rst - soft reset the PM8001 chip, so that the clear all
+ * the FW register status to the originated status.
+ * @pm8001_ha: our hba card information
+ */
+
+static int
+pm80xx_chip_soft_rst(struct pm8001_hba_info *pm8001_ha)
+{
+        u32 regval;
+        u32 bootloader_state;
+
+        /* Check if MPI is in ready state to reset */
+        if (mpi_uninit_check(pm8001_ha) != 0) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("MPI state is not ready\n"));
+                return -1;
+        }
+
+        /* checked for reset register normal state; 0x0 */
+        regval = pm8001_cr32(pm8001_ha, 0, SPC_REG_SOFT_RESET);
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("reset register before write : 0x%x\n", regval));
+
+        pm8001_cw32(pm8001_ha, 0, SPC_REG_SOFT_RESET, SPCv_NORMAL_RESET_VALUE);
+        mdelay(500);
+
+        regval = pm8001_cr32(pm8001_ha, 0, SPC_REG_SOFT_RESET);
+        PM8001_INIT_DBG(pm8001_ha,
+        pm8001_printk("reset register after write 0x%x\n", regval));
+
+        if ((regval & SPCv_SOFT_RESET_READ_MASK) ==
+                        SPCv_SOFT_RESET_NORMAL_RESET_OCCURED) {
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(" soft reset successful [regval: 0x%x]\n",
+                                        regval));
+        } else {
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(" soft reset failed [regval: 0x%x]\n",
+                                        regval));
+
+                /* check bootloader is successfully executed or in HDA mode */
+                bootloader_state =
+                        pm8001_cr32(pm8001_ha, 0, MSGU_SCRATCH_PAD_1) &
+                        SCRATCH_PAD1_BOOTSTATE_MASK;
+
+                if (bootloader_state == SCRATCH_PAD1_BOOTSTATE_HDA_SEEPROM) {
+                        PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+                                "Bootloader state - HDA mode SEEPROM\n"));
+                } else if (bootloader_state ==
+                                SCRATCH_PAD1_BOOTSTATE_HDA_BOOTSTRAP) {
+                        PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+                                "Bootloader state - HDA mode Bootstrap Pin\n"));
+                } else if (bootloader_state ==
+                                SCRATCH_PAD1_BOOTSTATE_HDA_SOFTRESET) {
+                        PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+                                "Bootloader state - HDA mode soft reset\n"));
+                } else if (bootloader_state ==
+                                        SCRATCH_PAD1_BOOTSTATE_CRIT_ERROR) {
+                        PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+                                "Bootloader state-HDA mode critical error\n"));
+                }
+                return -EBUSY;
+        }
+
+        /* check the firmware status after reset */
+        if (-1 == check_fw_ready(pm8001_ha)) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("Firmware is not ready!\n"));
+                return -EBUSY;
+        }
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("SPCv soft reset Complete\n"));
+        return 0;
+}
+
+static void pm80xx_hw_chip_rst(struct pm8001_hba_info *pm8001_ha)
+{
+         u32 i;
+
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("chip reset start\n"));
+
+        /* do SPCv chip reset. */
+        pm8001_cw32(pm8001_ha, 0, SPC_REG_SOFT_RESET, 0x11);
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("SPC soft reset Complete\n"));
+
+        /* Check this ..whether delay is required or no */
+        /* delay 10 usec */
+        udelay(10);
+
+        /* wait for 20 msec until the firmware gets reloaded */
+        i = 20;
+        do {
+                mdelay(1);
+        } while ((--i) != 0);
+
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("chip reset finished\n"));
+}
+
+/**
+ * pm8001_chip_interrupt_enable - enable PM8001 chip interrupt
+ * @pm8001_ha: our hba card information
+ */
+static void
+pm80xx_chip_intx_interrupt_enable(struct pm8001_hba_info *pm8001_ha)
+{
+        pm8001_cw32(pm8001_ha, 0, MSGU_ODMR, ODMR_CLEAR_ALL);
+        pm8001_cw32(pm8001_ha, 0, MSGU_ODCR, ODCR_CLEAR_ALL);
+}
+
+/**
+ * pm8001_chip_intx_interrupt_disable- disable PM8001 chip interrupt
+ * @pm8001_ha: our hba card information
+ */
+static void
+pm80xx_chip_intx_interrupt_disable(struct pm8001_hba_info *pm8001_ha)
+{
+        pm8001_cw32(pm8001_ha, 0, MSGU_ODMR_CLR, ODMR_MASK_ALL);
+}
+
+/**
+ * pm8001_chip_interrupt_enable - enable PM8001 chip interrupt
+ * @pm8001_ha: our hba card information
+ */
+static void
+pm80xx_chip_interrupt_enable(struct pm8001_hba_info *pm8001_ha, u8 vec)
+{
+#ifdef PM8001_USE_MSIX
+        u32 mask;
+        mask = (u32)(1 << vec);
+
+        pm8001_cw32(pm8001_ha, 0, MSGU_ODMR_CLR, (u32)(mask & 0xFFFFFFFF));
+        return;
+#endif
+        pm80xx_chip_intx_interrupt_enable(pm8001_ha);
+
+}
+
+/**
+ * pm8001_chip_interrupt_disable- disable PM8001 chip interrupt
+ * @pm8001_ha: our hba card information
+ */
+static void
+pm80xx_chip_interrupt_disable(struct pm8001_hba_info *pm8001_ha, u8 vec)
+{
+#ifdef PM8001_USE_MSIX
+        u32 mask;
+        if (vec == 0xFF)
+                mask = 0xFFFFFFFF;
+        else
+                mask = (u32)(1 << vec);
+        pm8001_cw32(pm8001_ha, 0, MSGU_ODMR, (u32)(mask & 0xFFFFFFFF));
+        return;
+#endif
+        pm80xx_chip_intx_interrupt_disable(pm8001_ha);
+}
+
+static void pm80xx_send_abort_all(struct pm8001_hba_info *pm8001_ha,
+                struct pm8001_device *pm8001_ha_dev)
+{
+        int res;
+        u32 ccb_tag;
+        struct pm8001_ccb_info *ccb;
+        struct sas_task *task = NULL;
+        struct task_abort_req task_abort;
+        struct inbound_queue_table *circularQ;
+        u32 opc = OPC_INB_SATA_ABORT;
+        int ret;
+
+        if (!pm8001_ha_dev) {
+                PM8001_FAIL_DBG(pm8001_ha, pm8001_printk("dev is null\n"));
+                return;
+        }
+
+        task = sas_alloc_slow_task(GFP_ATOMIC);
+
+        if (!task) {
+                PM8001_FAIL_DBG(pm8001_ha, pm8001_printk("cannot "
+                                                "allocate task\n"));
+                return;
+        }
+
+        task->task_done = pm8001_task_done;
+
+        res = pm8001_tag_alloc(pm8001_ha, &ccb_tag);
+        if (res)
+                return;
+
+        ccb = &pm8001_ha->ccb_info[ccb_tag];
+        ccb->device = pm8001_ha_dev;
+        ccb->ccb_tag = ccb_tag;
+        ccb->task = task;
+
+        circularQ = &pm8001_ha->inbnd_q_tbl[0];
+
+        memset(&task_abort, 0, sizeof(task_abort));
+        task_abort.abort_all = cpu_to_le32(1);
+        task_abort.device_id = cpu_to_le32(pm8001_ha_dev->device_id);
+        task_abort.tag = cpu_to_le32(ccb_tag);
+
+        ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &task_abort, 0);
+
+}
+
+static void pm80xx_send_read_log(struct pm8001_hba_info *pm8001_ha,
+                struct pm8001_device *pm8001_ha_dev)
+{
+        struct sata_start_req sata_cmd;
+        int res;
+        u32 ccb_tag;
+        struct pm8001_ccb_info *ccb;
+        struct sas_task *task = NULL;
+        struct host_to_dev_fis fis;
+        struct domain_device *dev;
+        struct inbound_queue_table *circularQ;
+        u32 opc = OPC_INB_SATA_HOST_OPSTART;
+
+        task = sas_alloc_slow_task(GFP_ATOMIC);
+
+        if (!task) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("cannot allocate task !!!\n"));
+                return;
+        }
+        task->task_done = pm8001_task_done;
+
+        res = pm8001_tag_alloc(pm8001_ha, &ccb_tag);
+        if (res) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("cannot allocate tag !!!\n"));
+                return;
+        }
+
+        /* allocate domain device by ourselves as libsas
+         * is not going to provide any
+        */
+        dev = kzalloc(sizeof(struct domain_device), GFP_ATOMIC);
+        if (!dev) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("Domain device cannot be allocated\n"));
+                sas_free_task(task);
+                return;
+        } else {
+                task->dev = dev;
+                task->dev->lldd_dev = pm8001_ha_dev;
+        }
+
+        ccb = &pm8001_ha->ccb_info[ccb_tag];
+        ccb->device = pm8001_ha_dev;
+        ccb->ccb_tag = ccb_tag;
+        ccb->task = task;
+        pm8001_ha_dev->id |= NCQ_READ_LOG_FLAG;
+        pm8001_ha_dev->id |= NCQ_2ND_RLE_FLAG;
+
+        memset(&sata_cmd, 0, sizeof(sata_cmd));
+        circularQ = &pm8001_ha->inbnd_q_tbl[0];
+
+        /* construct read log FIS */
+        memset(&fis, 0, sizeof(struct host_to_dev_fis));
+        fis.fis_type = 0x27;
+        fis.flags = 0x80;
+        fis.command = ATA_CMD_READ_LOG_EXT;
+        fis.lbal = 0x10;
+        fis.sector_count = 0x1;
+
+        sata_cmd.tag = cpu_to_le32(ccb_tag);
+        sata_cmd.device_id = cpu_to_le32(pm8001_ha_dev->device_id);
+        sata_cmd.ncqtag_atap_dir_m_dad |= ((0x1 << 7) | (0x5 << 9));
+        memcpy(&sata_cmd.sata_fis, &fis, sizeof(struct host_to_dev_fis));
+
+        res = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &sata_cmd, 0);
+
+}
+
+/**
+ * mpi_ssp_completion- process the event that FW response to the SSP request.
+ * @pm8001_ha: our hba card information
+ * @piomb: the message contents of this outbound message.
+ *
+ * When FW has completed a ssp request for example a IO request, after it has
+ * filled the SG data with the data, it will trigger this event represent
+ * that he has finished the job,please check the coresponding buffer.
+ * So we will tell the caller who maybe waiting the result to tell upper layer
+ * that the task has been finished.
+ */
+static void
+mpi_ssp_completion(struct pm8001_hba_info *pm8001_ha , void *piomb)
+{
+        struct sas_task *t;
+        struct pm8001_ccb_info *ccb;
+        unsigned long flags;
+        u32 status;
+        u32 param;
+        u32 tag;
+        struct ssp_completion_resp *psspPayload;
+        struct task_status_struct *ts;
+        struct ssp_response_iu *iu;
+        struct pm8001_device *pm8001_dev;
+        psspPayload = (struct ssp_completion_resp *)(piomb + 4);
+        status = le32_to_cpu(psspPayload->status);
+        tag = le32_to_cpu(psspPayload->tag);
+        ccb = &pm8001_ha->ccb_info[tag];
+        if ((status == IO_ABORTED) && ccb->open_retry) {
+                /* Being completed by another */
+                ccb->open_retry = 0;
+                return;
+        }
+        pm8001_dev = ccb->device;
+        param = le32_to_cpu(psspPayload->param);
+        t = ccb->task;
+
+        if (status && status != IO_UNDERFLOW)
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("sas IO status 0x%x\n", status));
+        if (unlikely(!t || !t->lldd_task || !t->dev))
+                return;
+        ts = &t->task_status;
+        switch (status) {
+        case IO_SUCCESS:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_SUCCESS ,param = 0x%x\n",
+                                param));
+                if (param == 0) {
+                        ts->resp = SAS_TASK_COMPLETE;
+                        ts->stat = SAM_STAT_GOOD;
+                } else {
+                        ts->resp = SAS_TASK_COMPLETE;
+                        ts->stat = SAS_PROTO_RESPONSE;
+                        ts->residual = param;
+                        iu = &psspPayload->ssp_resp_iu;
+                        sas_ssp_task_response(pm8001_ha->dev, t, iu);
+                }
+                if (pm8001_dev)
+                        pm8001_dev->running_req--;
+                break;
+        case IO_ABORTED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_ABORTED IOMB Tag\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_ABORTED_TASK;
+                break;
+        case IO_UNDERFLOW:
+                /* SSP Completion with error */
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_UNDERFLOW ,param = 0x%x\n",
+                                param));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DATA_UNDERRUN;
+                ts->residual = param;
+                if (pm8001_dev)
+                        pm8001_dev->running_req--;
+                break;
+        case IO_NO_DEVICE:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_NO_DEVICE\n"));
+                ts->resp = SAS_TASK_UNDELIVERED;
+                ts->stat = SAS_PHY_DOWN;
+                break;
+        case IO_XFER_ERROR_BREAK:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_BREAK\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                /* Force the midlayer to retry */
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+                break;
+        case IO_XFER_ERROR_PHY_NOT_READY:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_PHY_NOT_READY\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+                break;
+        case IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED:
+                PM8001_IO_DBG(pm8001_ha,
+                pm8001_printk("IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_EPROTO;
+                break;
+        case IO_OPEN_CNX_ERROR_ZONE_VIOLATION:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+                break;
+        case IO_OPEN_CNX_ERROR_BREAK:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_BREAK\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+                break;
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS:
+        case IO_XFER_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED:
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO:
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST:
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE:
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+                if (!t->uldd_task)
+                        pm8001_handle_event(pm8001_ha,
+                                pm8001_dev,
+                                IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS);
+                break;
+        case IO_OPEN_CNX_ERROR_BAD_DESTINATION:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_BAD_DESTINATION\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_BAD_DEST;
+                break;
+        case IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED:
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+                        "IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_CONN_RATE;
+                break;
+        case IO_OPEN_CNX_ERROR_WRONG_DESTINATION:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n"));
+                ts->resp = SAS_TASK_UNDELIVERED;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_WRONG_DEST;
+                break;
+        case IO_XFER_ERROR_NAK_RECEIVED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_NAK_RECEIVED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+                break;
+        case IO_XFER_ERROR_ACK_NAK_TIMEOUT:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_ACK_NAK_TIMEOUT\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_NAK_R_ERR;
+                break;
+        case IO_XFER_ERROR_DMA:
+                PM8001_IO_DBG(pm8001_ha,
+                pm8001_printk("IO_XFER_ERROR_DMA\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                break;
+        case IO_XFER_OPEN_RETRY_TIMEOUT:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_OPEN_RETRY_TIMEOUT\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+                break;
+        case IO_XFER_ERROR_OFFSET_MISMATCH:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_OFFSET_MISMATCH\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                break;
+        case IO_PORT_IN_RESET:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_PORT_IN_RESET\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                break;
+        case IO_DS_NON_OPERATIONAL:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_DS_NON_OPERATIONAL\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                if (!t->uldd_task)
+                        pm8001_handle_event(pm8001_ha,
+                                pm8001_dev,
+                                IO_DS_NON_OPERATIONAL);
+                break;
+        case IO_DS_IN_RECOVERY:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_DS_IN_RECOVERY\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                break;
+        case IO_TM_TAG_NOT_FOUND:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_TM_TAG_NOT_FOUND\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                break;
+        case IO_SSP_EXT_IU_ZERO_LEN_ERROR:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_SSP_EXT_IU_ZERO_LEN_ERROR\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                break;
+        case IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+                break;
+        default:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("Unknown status 0x%x\n", status));
+                /* not allowed case. Therefore, return failed status */
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                break;
+        }
+        PM8001_IO_DBG(pm8001_ha,
+                pm8001_printk("scsi_status = 0x%x\n ",
+                psspPayload->ssp_resp_iu.status));
+        spin_lock_irqsave(&t->task_state_lock, flags);
+        t->task_state_flags &= ~SAS_TASK_STATE_PENDING;
+        t->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
+        t->task_state_flags |= SAS_TASK_STATE_DONE;
+        if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
+                spin_unlock_irqrestore(&t->task_state_lock, flags);
+                PM8001_FAIL_DBG(pm8001_ha, pm8001_printk(
+                        "task 0x%p done with io_status 0x%x resp 0x%x "
+                        "stat 0x%x but aborted by upper layer!\n",
+                        t, status, ts->resp, ts->stat));
+                pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+        } else {
+                spin_unlock_irqrestore(&t->task_state_lock, flags);
+                pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+                mb();/* in order to force CPU ordering */
+                t->task_done(t);
+        }
+}
+
+/*See the comments for mpi_ssp_completion */
+static void mpi_ssp_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+{
+        struct sas_task *t;
+        unsigned long flags;
+        struct task_status_struct *ts;
+        struct pm8001_ccb_info *ccb;
+        struct pm8001_device *pm8001_dev;
+        struct ssp_event_resp *psspPayload =
+                (struct ssp_event_resp *)(piomb + 4);
+        u32 event = le32_to_cpu(psspPayload->event);
+        u32 tag = le32_to_cpu(psspPayload->tag);
+        u32 port_id = le32_to_cpu(psspPayload->port_id);
+
+        ccb = &pm8001_ha->ccb_info[tag];
+        t = ccb->task;
+        pm8001_dev = ccb->device;
+        if (event)
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("sas IO status 0x%x\n", event));
+        if (unlikely(!t || !t->lldd_task || !t->dev))
+                return;
+        ts = &t->task_status;
+        PM8001_IO_DBG(pm8001_ha,
+                pm8001_printk("port_id:0x%x, tag:0x%x, event:0x%x\n",
+                                port_id, tag, event));
+        switch (event) {
+        case IO_OVERFLOW:
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_UNDERFLOW\n");)
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DATA_OVERRUN;
+                ts->residual = 0;
+                if (pm8001_dev)
+                        pm8001_dev->running_req--;
+                break;
+        case IO_XFER_ERROR_BREAK:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_BREAK\n"));
+                pm8001_handle_event(pm8001_ha, t, IO_XFER_ERROR_BREAK);
+                return;
+        case IO_XFER_ERROR_PHY_NOT_READY:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_PHY_NOT_READY\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+                break;
+        case IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED:
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+                        "IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_EPROTO;
+                break;
+        case IO_OPEN_CNX_ERROR_ZONE_VIOLATION:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+                break;
+        case IO_OPEN_CNX_ERROR_BREAK:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_BREAK\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+                break;
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS:
+        case IO_XFER_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED:
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO:
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST:
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE:
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+                if (!t->uldd_task)
+                        pm8001_handle_event(pm8001_ha,
+                                pm8001_dev,
+                                IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS);
+                break;
+        case IO_OPEN_CNX_ERROR_BAD_DESTINATION:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_BAD_DESTINATION\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_BAD_DEST;
+                break;
+        case IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED:
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+                        "IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_CONN_RATE;
+                break;
+        case IO_OPEN_CNX_ERROR_WRONG_DESTINATION:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_WRONG_DEST;
+                break;
+        case IO_XFER_ERROR_NAK_RECEIVED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_NAK_RECEIVED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+                break;
+        case IO_XFER_ERROR_ACK_NAK_TIMEOUT:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_ACK_NAK_TIMEOUT\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_NAK_R_ERR;
+                break;
+        case IO_XFER_OPEN_RETRY_TIMEOUT:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_OPEN_RETRY_TIMEOUT\n"));
+                pm8001_handle_event(pm8001_ha, t, IO_XFER_OPEN_RETRY_TIMEOUT);
+                return;
+        case IO_XFER_ERROR_UNEXPECTED_PHASE:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_UNEXPECTED_PHASE\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DATA_OVERRUN;
+                break;
+        case IO_XFER_ERROR_XFER_RDY_OVERRUN:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_XFER_RDY_OVERRUN\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DATA_OVERRUN;
+                break;
+        case IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DATA_OVERRUN;
+                break;
+        case IO_XFER_ERROR_CMD_ISSUE_ACK_NAK_TIMEOUT:
+                PM8001_IO_DBG(pm8001_ha,
+                pm8001_printk("IO_XFER_ERROR_CMD_ISSUE_ACK_NAK_TIMEOUT\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DATA_OVERRUN;
+                break;
+        case IO_XFER_ERROR_OFFSET_MISMATCH:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_OFFSET_MISMATCH\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DATA_OVERRUN;
+                break;
+        case IO_XFER_ERROR_XFER_ZERO_DATA_LEN:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_XFER_ZERO_DATA_LEN\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DATA_OVERRUN;
+                break;
+        case IO_XFER_ERROR_INTERNAL_CRC_ERROR:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFR_ERROR_INTERNAL_CRC_ERROR\n"));
+                /* TBC: used default set values */
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DATA_OVERRUN;
+                break;
+        case IO_XFER_CMD_FRAME_ISSUED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_CMD_FRAME_ISSUED\n"));
+                return;
+        default:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("Unknown status 0x%x\n", event));
+                /* not allowed case. Therefore, return failed status */
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DATA_OVERRUN;
+                break;
+        }
+        spin_lock_irqsave(&t->task_state_lock, flags);
+        t->task_state_flags &= ~SAS_TASK_STATE_PENDING;
+        t->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
+        t->task_state_flags |= SAS_TASK_STATE_DONE;
+        if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
+                spin_unlock_irqrestore(&t->task_state_lock, flags);
+                PM8001_FAIL_DBG(pm8001_ha, pm8001_printk(
+                        "task 0x%p done with event 0x%x resp 0x%x "
+                        "stat 0x%x but aborted by upper layer!\n",
+                        t, event, ts->resp, ts->stat));
+                pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+        } else {
+                spin_unlock_irqrestore(&t->task_state_lock, flags);
+                pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+                mb();/* in order to force CPU ordering */
+                t->task_done(t);
+        }
+}
+
+/*See the comments for mpi_ssp_completion */
+static void
+mpi_sata_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+{
+        struct sas_task *t;
+        struct pm8001_ccb_info *ccb;
+        u32 param;
+        u32 status;
+        u32 tag;
+        struct sata_completion_resp *psataPayload;
+        struct task_status_struct *ts;
+        struct ata_task_resp *resp ;
+        u32 *sata_resp;
+        struct pm8001_device *pm8001_dev;
+        unsigned long flags;
+
+        psataPayload = (struct sata_completion_resp *)(piomb + 4);
+        status = le32_to_cpu(psataPayload->status);
+        tag = le32_to_cpu(psataPayload->tag);
+
+        if (!tag) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("tag null\n"));
+                return;
+        }
+        ccb = &pm8001_ha->ccb_info[tag];
+        param = le32_to_cpu(psataPayload->param);
+        if (ccb) {
+                t = ccb->task;
+                pm8001_dev = ccb->device;
+        } else {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("ccb null\n"));
+                return;
+        }
+
+        if (t) {
+                if (t->dev && (t->dev->lldd_dev))
+                        pm8001_dev = t->dev->lldd_dev;
+        } else {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("task null\n"));
+                return;
+        }
+
+        if ((pm8001_dev && !(pm8001_dev->id & NCQ_READ_LOG_FLAG))
+                && unlikely(!t || !t->lldd_task || !t->dev)) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("task or dev null\n"));
+                return;
+        }
+
+        ts = &t->task_status;
+        if (!ts) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("ts null\n"));
+                return;
+        }
+
+        switch (status) {
+        case IO_SUCCESS:
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_SUCCESS\n"));
+                if (param == 0) {
+                        ts->resp = SAS_TASK_COMPLETE;
+                        ts->stat = SAM_STAT_GOOD;
+                        /* check if response is for SEND READ LOG */
+                        if (pm8001_dev &&
+                                (pm8001_dev->id & NCQ_READ_LOG_FLAG)) {
+                                /* set new bit for abort_all */
+                                pm8001_dev->id |= NCQ_ABORT_ALL_FLAG;
+                                /* clear bit for read log */
+                                pm8001_dev->id = pm8001_dev->id & 0x7FFFFFFF;
+                                pm80xx_send_abort_all(pm8001_ha, pm8001_dev);
+                                /* Free the tag */
+                                pm8001_tag_free(pm8001_ha, tag);
+                                sas_free_task(t);
+                                return;
+                        }
+                } else {
+                        u8 len;
+                        ts->resp = SAS_TASK_COMPLETE;
+                        ts->stat = SAS_PROTO_RESPONSE;
+                        ts->residual = param;
+                        PM8001_IO_DBG(pm8001_ha,
+                                pm8001_printk("SAS_PROTO_RESPONSE len = %d\n",
+                                param));
+                        sata_resp = &psataPayload->sata_resp[0];
+                        resp = (struct ata_task_resp *)ts->buf;
+                        if (t->ata_task.dma_xfer == 0 &&
+                        t->data_dir == PCI_DMA_FROMDEVICE) {
+                                len = sizeof(struct pio_setup_fis);
+                                PM8001_IO_DBG(pm8001_ha,
+                                pm8001_printk("PIO read len = %d\n", len));
+                        } else if (t->ata_task.use_ncq) {
+                                len = sizeof(struct set_dev_bits_fis);
+                                PM8001_IO_DBG(pm8001_ha,
+                                        pm8001_printk("FPDMA len = %d\n", len));
+                        } else {
+                                len = sizeof(struct dev_to_host_fis);
+                                PM8001_IO_DBG(pm8001_ha,
+                                pm8001_printk("other len = %d\n", len));
+                        }
+                        if (SAS_STATUS_BUF_SIZE >= sizeof(*resp)) {
+                                resp->frame_len = len;
+                                memcpy(&resp->ending_fis[0], sata_resp, len);
+                                ts->buf_valid_size = sizeof(*resp);
+                        } else
+                                PM8001_IO_DBG(pm8001_ha,
+                                        pm8001_printk("response to large\n"));
+                }
+                if (pm8001_dev)
+                        pm8001_dev->running_req--;
+                break;
+        case IO_ABORTED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_ABORTED IOMB Tag\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_ABORTED_TASK;
+                if (pm8001_dev)
+                        pm8001_dev->running_req--;
+                break;
+                /* following cases are to do cases */
+        case IO_UNDERFLOW:
+                /* SATA Completion with error */
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_UNDERFLOW param = %d\n", param));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DATA_UNDERRUN;
+                ts->residual = param;
+                if (pm8001_dev)
+                        pm8001_dev->running_req--;
+                break;
+        case IO_NO_DEVICE:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_NO_DEVICE\n"));
+                ts->resp = SAS_TASK_UNDELIVERED;
+                ts->stat = SAS_PHY_DOWN;
+                break;
+        case IO_XFER_ERROR_BREAK:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_BREAK\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_INTERRUPTED;
+                break;
+        case IO_XFER_ERROR_PHY_NOT_READY:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_PHY_NOT_READY\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+                break;
+        case IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED:
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+                        "IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_EPROTO;
+                break;
+        case IO_OPEN_CNX_ERROR_ZONE_VIOLATION:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+                break;
+        case IO_OPEN_CNX_ERROR_BREAK:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_BREAK\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_CONT0;
+                break;
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS:
+        case IO_XFER_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED:
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO:
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST:
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE:
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DEV_NO_RESPONSE;
+                if (!t->uldd_task) {
+                        pm8001_handle_event(pm8001_ha,
+                                pm8001_dev,
+                                IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS);
+                        ts->resp = SAS_TASK_UNDELIVERED;
+                        ts->stat = SAS_QUEUE_FULL;
+                        pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+                        mb();/*in order to force CPU ordering*/
+                        spin_unlock_irq(&pm8001_ha->lock);
+                        t->task_done(t);
+                        spin_lock_irq(&pm8001_ha->lock);
+                        return;
+                }
+                break;
+        case IO_OPEN_CNX_ERROR_BAD_DESTINATION:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_BAD_DESTINATION\n"));
+                ts->resp = SAS_TASK_UNDELIVERED;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_BAD_DEST;
+                if (!t->uldd_task) {
+                        pm8001_handle_event(pm8001_ha,
+                                pm8001_dev,
+                                IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS);
+                        ts->resp = SAS_TASK_UNDELIVERED;
+                        ts->stat = SAS_QUEUE_FULL;
+                        pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+                        mb();/*ditto*/
+                        spin_unlock_irq(&pm8001_ha->lock);
+                        t->task_done(t);
+                        spin_lock_irq(&pm8001_ha->lock);
+                        return;
+                }
+                break;
+        case IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED:
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+                        "IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_CONN_RATE;
+                break;
+        case IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY:
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+                        "IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DEV_NO_RESPONSE;
+                if (!t->uldd_task) {
+                        pm8001_handle_event(pm8001_ha,
+                                pm8001_dev,
+                                IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY);
+                        ts->resp = SAS_TASK_UNDELIVERED;
+                        ts->stat = SAS_QUEUE_FULL;
+                        pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+                        mb();/* ditto*/
+                        spin_unlock_irq(&pm8001_ha->lock);
+                        t->task_done(t);
+                        spin_lock_irq(&pm8001_ha->lock);
+                        return;
+                }
+                break;
+        case IO_OPEN_CNX_ERROR_WRONG_DESTINATION:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_WRONG_DEST;
+                break;
+        case IO_XFER_ERROR_NAK_RECEIVED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_NAK_RECEIVED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_NAK_R_ERR;
+                break;
+        case IO_XFER_ERROR_ACK_NAK_TIMEOUT:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_ACK_NAK_TIMEOUT\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_NAK_R_ERR;
+                break;
+        case IO_XFER_ERROR_DMA:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_DMA\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_ABORTED_TASK;
+                break;
+        case IO_XFER_ERROR_SATA_LINK_TIMEOUT:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_SATA_LINK_TIMEOUT\n"));
+                ts->resp = SAS_TASK_UNDELIVERED;
+                ts->stat = SAS_DEV_NO_RESPONSE;
+                break;
+        case IO_XFER_ERROR_REJECTED_NCQ_MODE:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_REJECTED_NCQ_MODE\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DATA_UNDERRUN;
+                break;
+        case IO_XFER_OPEN_RETRY_TIMEOUT:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_OPEN_RETRY_TIMEOUT\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_TO;
+                break;
+        case IO_PORT_IN_RESET:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_PORT_IN_RESET\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DEV_NO_RESPONSE;
+                break;
+        case IO_DS_NON_OPERATIONAL:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_DS_NON_OPERATIONAL\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DEV_NO_RESPONSE;
+                if (!t->uldd_task) {
+                        pm8001_handle_event(pm8001_ha, pm8001_dev,
+                                        IO_DS_NON_OPERATIONAL);
+                        ts->resp = SAS_TASK_UNDELIVERED;
+                        ts->stat = SAS_QUEUE_FULL;
+                        pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+                        mb();/*ditto*/
+                        spin_unlock_irq(&pm8001_ha->lock);
+                        t->task_done(t);
+                        spin_lock_irq(&pm8001_ha->lock);
+                        return;
+                }
+                break;
+        case IO_DS_IN_RECOVERY:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_DS_IN_RECOVERY\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DEV_NO_RESPONSE;
+                break;
+        case IO_DS_IN_ERROR:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_DS_IN_ERROR\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DEV_NO_RESPONSE;
+                if (!t->uldd_task) {
+                        pm8001_handle_event(pm8001_ha, pm8001_dev,
+                                        IO_DS_IN_ERROR);
+                        ts->resp = SAS_TASK_UNDELIVERED;
+                        ts->stat = SAS_QUEUE_FULL;
+                        pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+                        mb();/*ditto*/
+                        spin_unlock_irq(&pm8001_ha->lock);
+                        t->task_done(t);
+                        spin_lock_irq(&pm8001_ha->lock);
+                        return;
+                }
+                break;
+        case IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+        default:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("Unknown status 0x%x\n", status));
+                /* not allowed case. Therefore, return failed status */
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DEV_NO_RESPONSE;
+                break;
+        }
+        spin_lock_irqsave(&t->task_state_lock, flags);
+        t->task_state_flags &= ~SAS_TASK_STATE_PENDING;
+        t->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
+        t->task_state_flags |= SAS_TASK_STATE_DONE;
+        if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
+                spin_unlock_irqrestore(&t->task_state_lock, flags);
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("task 0x%p done with io_status 0x%x"
+                        " resp 0x%x stat 0x%x but aborted by upper layer!\n",
+                        t, status, ts->resp, ts->stat));
+                pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+        } else if (t->uldd_task) {
+                spin_unlock_irqrestore(&t->task_state_lock, flags);
+                pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+                mb();/* ditto */
+                spin_unlock_irq(&pm8001_ha->lock);
+                t->task_done(t);
+                spin_lock_irq(&pm8001_ha->lock);
+        } else if (!t->uldd_task) {
+                spin_unlock_irqrestore(&t->task_state_lock, flags);
+                pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+                mb();/*ditto*/
+                spin_unlock_irq(&pm8001_ha->lock);
+                t->task_done(t);
+                spin_lock_irq(&pm8001_ha->lock);
+        }
+}
+
+/*See the comments for mpi_ssp_completion */
+static void mpi_sata_event(struct pm8001_hba_info *pm8001_ha , void *piomb)
+{
+        struct sas_task *t;
+        struct task_status_struct *ts;
+        struct pm8001_ccb_info *ccb;
+        struct pm8001_device *pm8001_dev;
+        struct sata_event_resp *psataPayload =
+                (struct sata_event_resp *)(piomb + 4);
+        u32 event = le32_to_cpu(psataPayload->event);
+        u32 tag = le32_to_cpu(psataPayload->tag);
+        u32 port_id = le32_to_cpu(psataPayload->port_id);
+        u32 dev_id = le32_to_cpu(psataPayload->device_id);
+        unsigned long flags;
+
+        ccb = &pm8001_ha->ccb_info[tag];
+
+        if (ccb) {
+                t = ccb->task;
+                pm8001_dev = ccb->device;
+        } else {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("No CCB !!!. returning\n"));
+                return;
+        }
+        if (event)
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("SATA EVENT 0x%x\n", event));
+
+        /* Check if this is NCQ error */
+        if (event == IO_XFER_ERROR_ABORTED_NCQ_MODE) {
+                /* find device using device id */
+                pm8001_dev = pm8001_find_dev(pm8001_ha, dev_id);
+                /* send read log extension */
+                if (pm8001_dev)
+                        pm80xx_send_read_log(pm8001_ha, pm8001_dev);
+                return;
+        }
+
+        if (unlikely(!t || !t->lldd_task || !t->dev)) {
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("task or dev null\n"));
+                return;
+        }
+
+        ts = &t->task_status;
+        PM8001_IO_DBG(pm8001_ha,
+                pm8001_printk("port_id:0x%x, tag:0x%x, event:0x%x\n",
+                                port_id, tag, event));
+        switch (event) {
+        case IO_OVERFLOW:
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_UNDERFLOW\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DATA_OVERRUN;
+                ts->residual = 0;
+                if (pm8001_dev)
+                        pm8001_dev->running_req--;
+                break;
+        case IO_XFER_ERROR_BREAK:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_BREAK\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_INTERRUPTED;
+                break;
+        case IO_XFER_ERROR_PHY_NOT_READY:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_PHY_NOT_READY\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+                break;
+        case IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED:
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+                        "IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_EPROTO;
+                break;
+        case IO_OPEN_CNX_ERROR_ZONE_VIOLATION:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+                break;
+        case IO_OPEN_CNX_ERROR_BREAK:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_BREAK\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_CONT0;
+                break;
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS:
+        case IO_XFER_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED:
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO:
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST:
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE:
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED:
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n"));
+                ts->resp = SAS_TASK_UNDELIVERED;
+                ts->stat = SAS_DEV_NO_RESPONSE;
+                if (!t->uldd_task) {
+                        pm8001_handle_event(pm8001_ha,
+                                pm8001_dev,
+                                IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS);
+                        ts->resp = SAS_TASK_COMPLETE;
+                        ts->stat = SAS_QUEUE_FULL;
+                        pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+                        mb();/*ditto*/
+                        spin_unlock_irq(&pm8001_ha->lock);
+                        t->task_done(t);
+                        spin_lock_irq(&pm8001_ha->lock);
+                        return;
+                }
+                break;
+        case IO_OPEN_CNX_ERROR_BAD_DESTINATION:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_BAD_DESTINATION\n"));
+                ts->resp = SAS_TASK_UNDELIVERED;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_BAD_DEST;
+                break;
+        case IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED:
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+                        "IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_CONN_RATE;
+                break;
+        case IO_OPEN_CNX_ERROR_WRONG_DESTINATION:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_WRONG_DEST;
+                break;
+        case IO_XFER_ERROR_NAK_RECEIVED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_NAK_RECEIVED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_NAK_R_ERR;
+                break;
+        case IO_XFER_ERROR_PEER_ABORTED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_PEER_ABORTED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_NAK_R_ERR;
+                break;
+        case IO_XFER_ERROR_REJECTED_NCQ_MODE:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_REJECTED_NCQ_MODE\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DATA_UNDERRUN;
+                break;
+        case IO_XFER_OPEN_RETRY_TIMEOUT:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_OPEN_RETRY_TIMEOUT\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_TO;
+                break;
+        case IO_XFER_ERROR_UNEXPECTED_PHASE:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_UNEXPECTED_PHASE\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_TO;
+                break;
+        case IO_XFER_ERROR_XFER_RDY_OVERRUN:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_XFER_RDY_OVERRUN\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_TO;
+                break;
+        case IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_TO;
+                break;
+        case IO_XFER_ERROR_OFFSET_MISMATCH:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_OFFSET_MISMATCH\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_TO;
+                break;
+        case IO_XFER_ERROR_XFER_ZERO_DATA_LEN:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_XFER_ZERO_DATA_LEN\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_TO;
+                break;
+        case IO_XFER_CMD_FRAME_ISSUED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_CMD_FRAME_ISSUED\n"));
+                break;
+        case IO_XFER_PIO_SETUP_ERROR:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_PIO_SETUP_ERROR\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_TO;
+                break;
+        case IO_XFER_ERROR_INTERNAL_CRC_ERROR:
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFR_ERROR_INTERNAL_CRC_ERROR\n"));
+                /* TBC: used default set values */
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_TO;
+                break;
+        case IO_XFER_DMA_ACTIVATE_TIMEOUT:
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFR_DMA_ACTIVATE_TIMEOUT\n"));
+                /* TBC: used default set values */
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_TO;
+                break;
+        default:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("Unknown status 0x%x\n", event));
+                /* not allowed case. Therefore, return failed status */
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_TO;
+                break;
+        }
+        spin_lock_irqsave(&t->task_state_lock, flags);
+        t->task_state_flags &= ~SAS_TASK_STATE_PENDING;
+        t->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
+        t->task_state_flags |= SAS_TASK_STATE_DONE;
+        if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
+                spin_unlock_irqrestore(&t->task_state_lock, flags);
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("task 0x%p done with io_status 0x%x"
+                        " resp 0x%x stat 0x%x but aborted by upper layer!\n",
+                        t, event, ts->resp, ts->stat));
+                pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+        } else if (t->uldd_task) {
+                spin_unlock_irqrestore(&t->task_state_lock, flags);
+                pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+                mb();/* ditto */
+                spin_unlock_irq(&pm8001_ha->lock);
+                t->task_done(t);
+                spin_lock_irq(&pm8001_ha->lock);
+        } else if (!t->uldd_task) {
+                spin_unlock_irqrestore(&t->task_state_lock, flags);
+                pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+                mb();/*ditto*/
+                spin_unlock_irq(&pm8001_ha->lock);
+                t->task_done(t);
+                spin_lock_irq(&pm8001_ha->lock);
+        }
+}
+
+/*See the comments for mpi_ssp_completion */
+static void
+mpi_smp_completion(struct pm8001_hba_info *pm8001_ha, void *piomb)
+{
+        u32 param, i;
+        struct sas_task *t;
+        struct pm8001_ccb_info *ccb;
+        unsigned long flags;
+        u32 status;
+        u32 tag;
+        struct smp_completion_resp *psmpPayload;
+        struct task_status_struct *ts;
+        struct pm8001_device *pm8001_dev;
+        char *pdma_respaddr = NULL;
+
+        psmpPayload = (struct smp_completion_resp *)(piomb + 4);
+        status = le32_to_cpu(psmpPayload->status);
+        tag = le32_to_cpu(psmpPayload->tag);
+
+        ccb = &pm8001_ha->ccb_info[tag];
+        param = le32_to_cpu(psmpPayload->param);
+        t = ccb->task;
+        ts = &t->task_status;
+        pm8001_dev = ccb->device;
+        if (status)
+                PM8001_FAIL_DBG(pm8001_ha,
+                        pm8001_printk("smp IO status 0x%x\n", status));
+        if (unlikely(!t || !t->lldd_task || !t->dev))
+                return;
+
+        switch (status) {
+
+        case IO_SUCCESS:
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_SUCCESS\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAM_STAT_GOOD;
+                if (pm8001_dev)
+                        pm8001_dev->running_req--;
+                if (pm8001_ha->smp_exp_mode == SMP_DIRECT) {
+                        PM8001_IO_DBG(pm8001_ha,
+                                pm8001_printk("DIRECT RESPONSE Length:%d\n",
+                                                param));
+                        pdma_respaddr = (char *)(phys_to_virt(cpu_to_le64
+                                                ((u64)sg_dma_address
+                                                (&t->smp_task.smp_resp))));
+                        for (i = 0; i < param; i++) {
+                                *(pdma_respaddr+i) = psmpPayload->_r_a[i];
+                                PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+                                        "SMP Byte%d DMA data 0x%x psmp 0x%x\n",
+                                        i, *(pdma_respaddr+i),
+                                        psmpPayload->_r_a[i]));
+                        }
+                }
+                break;
+        case IO_ABORTED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_ABORTED IOMB\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_ABORTED_TASK;
+                if (pm8001_dev)
+                        pm8001_dev->running_req--;
+                break;
+        case IO_OVERFLOW:
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_UNDERFLOW\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DATA_OVERRUN;
+                ts->residual = 0;
+                if (pm8001_dev)
+                        pm8001_dev->running_req--;
+                break;
+        case IO_NO_DEVICE:
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk("IO_NO_DEVICE\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_PHY_DOWN;
+                break;
+        case IO_ERROR_HW_TIMEOUT:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_ERROR_HW_TIMEOUT\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAM_STAT_BUSY;
+                break;
+        case IO_XFER_ERROR_BREAK:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_BREAK\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAM_STAT_BUSY;
+                break;
+        case IO_XFER_ERROR_PHY_NOT_READY:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_PHY_NOT_READY\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAM_STAT_BUSY;
+                break;
+        case IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED:
+                PM8001_IO_DBG(pm8001_ha,
+                pm8001_printk("IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+                break;
+        case IO_OPEN_CNX_ERROR_ZONE_VIOLATION:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_ZONE_VIOLATION\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+                break;
+        case IO_OPEN_CNX_ERROR_BREAK:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_BREAK\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_CONT0;
+                break;
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS:
+        case IO_XFER_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED:
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO:
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST:
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE:
+        case IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_UNKNOWN;
+                pm8001_handle_event(pm8001_ha,
+                                pm8001_dev,
+                                IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS);
+                break;
+        case IO_OPEN_CNX_ERROR_BAD_DESTINATION:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_BAD_DESTINATION\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_BAD_DEST;
+                break;
+        case IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED:
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk(\
+                        "IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_CONN_RATE;
+                break;
+        case IO_OPEN_CNX_ERROR_WRONG_DESTINATION:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_WRONG_DESTINATION\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_WRONG_DEST;
+                break;
+        case IO_XFER_ERROR_RX_FRAME:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_ERROR_RX_FRAME\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DEV_NO_RESPONSE;
+                break;
+        case IO_XFER_OPEN_RETRY_TIMEOUT:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_XFER_OPEN_RETRY_TIMEOUT\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+                break;
+        case IO_ERROR_INTERNAL_SMP_RESOURCE:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_ERROR_INTERNAL_SMP_RESOURCE\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_QUEUE_FULL;
+                break;
+        case IO_PORT_IN_RESET:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_PORT_IN_RESET\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+                break;
+        case IO_DS_NON_OPERATIONAL:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_DS_NON_OPERATIONAL\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DEV_NO_RESPONSE;
+                break;
+        case IO_DS_IN_RECOVERY:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_DS_IN_RECOVERY\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+                break;
+        case IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY\n"));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_OPEN_REJECT;
+                ts->open_rej_reason = SAS_OREJ_RSVD_RETRY;
+                break;
+        default:
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("Unknown status 0x%x\n", status));
+                ts->resp = SAS_TASK_COMPLETE;
+                ts->stat = SAS_DEV_NO_RESPONSE;
+                /* not allowed case. Therefore, return failed status */
+                break;
+        }
+        spin_lock_irqsave(&t->task_state_lock, flags);
+        t->task_state_flags &= ~SAS_TASK_STATE_PENDING;
+        t->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
+        t->task_state_flags |= SAS_TASK_STATE_DONE;
+        if (unlikely((t->task_state_flags & SAS_TASK_STATE_ABORTED))) {
+                spin_unlock_irqrestore(&t->task_state_lock, flags);
+                PM8001_FAIL_DBG(pm8001_ha, pm8001_printk(
+                        "task 0x%p done with io_status 0x%x resp 0x%x"
+                        "stat 0x%x but aborted by upper layer!\n",
+                        t, status, ts->resp, ts->stat));
+                pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+        } else {
+                spin_unlock_irqrestore(&t->task_state_lock, flags);
+                pm8001_ccb_task_free(pm8001_ha, t, ccb, tag);
+                mb();/* in order to force CPU ordering */
+                t->task_done(t);
+        }
+}
+
+/**
+ * pm80xx_hw_event_ack_req- For PM8001,some events need to acknowage to FW.
+ * @pm8001_ha: our hba card information
+ * @Qnum: the outbound queue message number.
+ * @SEA: source of event to ack
+ * @port_id: port id.
+ * @phyId: phy id.
+ * @param0: parameter 0.
+ * @param1: parameter 1.
+ */
+static void pm80xx_hw_event_ack_req(struct pm8001_hba_info *pm8001_ha,
+        u32 Qnum, u32 SEA, u32 port_id, u32 phyId, u32 param0, u32 param1)
+{
+        struct hw_event_ack_req  payload;
+        u32 opc = OPC_INB_SAS_HW_EVENT_ACK;
+
+        struct inbound_queue_table *circularQ;
+
+        memset((u8 *)&payload, 0, sizeof(payload));
+        circularQ = &pm8001_ha->inbnd_q_tbl[Qnum];
+        payload.tag = cpu_to_le32(1);
+        payload.phyid_sea_portid = cpu_to_le32(((SEA & 0xFFFF) << 8) |
+                ((phyId & 0xFF) << 24) | (port_id & 0xFF));
+        payload.param0 = cpu_to_le32(param0);
+        payload.param1 = cpu_to_le32(param1);
+        pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &payload, 0);
+}
+
+static int pm80xx_chip_phy_ctl_req(struct pm8001_hba_info *pm8001_ha,
+        u32 phyId, u32 phy_op);
+
+/**
+ * hw_event_sas_phy_up -FW tells me a SAS phy up event.
+ * @pm8001_ha: our hba card information
+ * @piomb: IO message buffer
+ */
+static void
+hw_event_sas_phy_up(struct pm8001_hba_info *pm8001_ha, void *piomb)
+{
+        struct hw_event_resp *pPayload =
+                (struct hw_event_resp *)(piomb + 4);
+        u32 lr_status_evt_portid =
+                le32_to_cpu(pPayload->lr_status_evt_portid);
+        u32 phyid_npip_portstate = le32_to_cpu(pPayload->phyid_npip_portstate);
+
+        u8 link_rate =
+                (u8)((lr_status_evt_portid & 0xF0000000) >> 28);
+        u8 port_id = (u8)(lr_status_evt_portid & 0x000000FF);
+        u8 phy_id =
+                (u8)((phyid_npip_portstate & 0xFF0000) >> 16);
+        u8 portstate = (u8)(phyid_npip_portstate & 0x0000000F);
+
+        struct pm8001_port *port = &pm8001_ha->port[port_id];
+        struct sas_ha_struct *sas_ha = pm8001_ha->sas;
+        struct pm8001_phy *phy = &pm8001_ha->phy[phy_id];
+        unsigned long flags;
+        u8 deviceType = pPayload->sas_identify.dev_type;
+        port->port_state = portstate;
+        PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+                "portid:%d; phyid:%d; linkrate:%d; "
+                "portstate:%x; devicetype:%x\n",
+                port_id, phy_id, link_rate, portstate, deviceType));
+
+        switch (deviceType) {
+        case SAS_PHY_UNUSED:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("device type no device.\n"));
+                break;
+        case SAS_END_DEVICE:
+                PM8001_MSG_DBG(pm8001_ha, pm8001_printk("end device.\n"));
+                pm80xx_chip_phy_ctl_req(pm8001_ha, phy_id,
+                        PHY_NOTIFY_ENABLE_SPINUP);
+                port->port_attached = 1;
+                pm8001_get_lrate_mode(phy, link_rate);
+                break;
+        case SAS_EDGE_EXPANDER_DEVICE:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("expander device.\n"));
+                port->port_attached = 1;
+                pm8001_get_lrate_mode(phy, link_rate);
+                break;
+        case SAS_FANOUT_EXPANDER_DEVICE:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("fanout expander device.\n"));
+                port->port_attached = 1;
+                pm8001_get_lrate_mode(phy, link_rate);
+                break;
+        default:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("unknown device type(%x)\n", deviceType));
+                break;
+        }
+        phy->phy_type |= PORT_TYPE_SAS;
+        phy->identify.device_type = deviceType;
+        phy->phy_attached = 1;
+        if (phy->identify.device_type == SAS_END_DEVICE)
+                phy->identify.target_port_protocols = SAS_PROTOCOL_SSP;
+        else if (phy->identify.device_type != SAS_PHY_UNUSED)
+                phy->identify.target_port_protocols = SAS_PROTOCOL_SMP;
+        phy->sas_phy.oob_mode = SAS_OOB_MODE;
+        sas_ha->notify_phy_event(&phy->sas_phy, PHYE_OOB_DONE);
+        spin_lock_irqsave(&phy->sas_phy.frame_rcvd_lock, flags);
+        memcpy(phy->frame_rcvd, &pPayload->sas_identify,
+                sizeof(struct sas_identify_frame)-4);
+        phy->frame_rcvd_size = sizeof(struct sas_identify_frame) - 4;
+        pm8001_get_attached_sas_addr(phy, phy->sas_phy.attached_sas_addr);
+        spin_unlock_irqrestore(&phy->sas_phy.frame_rcvd_lock, flags);
+        if (pm8001_ha->flags == PM8001F_RUN_TIME)
+                mdelay(200);/*delay a moment to wait disk to spinup*/
+        pm8001_bytes_dmaed(pm8001_ha, phy_id);
+}
+
+/**
+ * hw_event_sata_phy_up -FW tells me a SATA phy up event.
+ * @pm8001_ha: our hba card information
+ * @piomb: IO message buffer
+ */
+static void
+hw_event_sata_phy_up(struct pm8001_hba_info *pm8001_ha, void *piomb)
+{
+        struct hw_event_resp *pPayload =
+                (struct hw_event_resp *)(piomb + 4);
+        u32 phyid_npip_portstate = le32_to_cpu(pPayload->phyid_npip_portstate);
+        u32 lr_status_evt_portid =
+                le32_to_cpu(pPayload->lr_status_evt_portid);
+        u8 link_rate =
+                (u8)((lr_status_evt_portid & 0xF0000000) >> 28);
+        u8 port_id = (u8)(lr_status_evt_portid & 0x000000FF);
+        u8 phy_id =
+                (u8)((phyid_npip_portstate & 0xFF0000) >> 16);
+
+        u8 portstate = (u8)(phyid_npip_portstate & 0x0000000F);
+
+        struct pm8001_port *port = &pm8001_ha->port[port_id];
+        struct sas_ha_struct *sas_ha = pm8001_ha->sas;
+        struct pm8001_phy *phy = &pm8001_ha->phy[phy_id];
+        unsigned long flags;
+        PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+                "port id %d, phy id %d link_rate %d portstate 0x%x\n",
+                                port_id, phy_id, link_rate, portstate));
+
+        port->port_state = portstate;
+        port->port_attached = 1;
+        pm8001_get_lrate_mode(phy, link_rate);
+        phy->phy_type |= PORT_TYPE_SATA;
+        phy->phy_attached = 1;
+        phy->sas_phy.oob_mode = SATA_OOB_MODE;
+        sas_ha->notify_phy_event(&phy->sas_phy, PHYE_OOB_DONE);
+        spin_lock_irqsave(&phy->sas_phy.frame_rcvd_lock, flags);
+        memcpy(phy->frame_rcvd, ((u8 *)&pPayload->sata_fis - 4),
+                sizeof(struct dev_to_host_fis));
+        phy->frame_rcvd_size = sizeof(struct dev_to_host_fis);
+        phy->identify.target_port_protocols = SAS_PROTOCOL_SATA;
+        phy->identify.device_type = SAS_SATA_DEV;
+        pm8001_get_attached_sas_addr(phy, phy->sas_phy.attached_sas_addr);
+        spin_unlock_irqrestore(&phy->sas_phy.frame_rcvd_lock, flags);
+        pm8001_bytes_dmaed(pm8001_ha, phy_id);
+}
+
+/**
+ * hw_event_phy_down -we should notify the libsas the phy is down.
+ * @pm8001_ha: our hba card information
+ * @piomb: IO message buffer
+ */
+static void
+hw_event_phy_down(struct pm8001_hba_info *pm8001_ha, void *piomb)
+{
+        struct hw_event_resp *pPayload =
+                (struct hw_event_resp *)(piomb + 4);
+
+        u32 lr_status_evt_portid =
+                le32_to_cpu(pPayload->lr_status_evt_portid);
+        u8 port_id = (u8)(lr_status_evt_portid & 0x000000FF);
+        u32 phyid_npip_portstate = le32_to_cpu(pPayload->phyid_npip_portstate);
+        u8 phy_id =
+                (u8)((phyid_npip_portstate & 0xFF0000) >> 16);
+        u8 portstate = (u8)(phyid_npip_portstate & 0x0000000F);
+
+        struct pm8001_port *port = &pm8001_ha->port[port_id];
+        struct pm8001_phy *phy = &pm8001_ha->phy[phy_id];
+        port->port_state = portstate;
+        phy->phy_type = 0;
+        phy->identify.device_type = 0;
+        phy->phy_attached = 0;
+        memset(&phy->dev_sas_addr, 0, SAS_ADDR_SIZE);
+        switch (portstate) {
+        case PORT_VALID:
+                break;
+        case PORT_INVALID:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(" PortInvalid portID %d\n", port_id));
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(" Last phy Down and port invalid\n"));
+                port->port_attached = 0;
+                pm80xx_hw_event_ack_req(pm8001_ha, 0, HW_EVENT_PHY_DOWN,
+                        port_id, phy_id, 0, 0);
+                break;
+        case PORT_IN_RESET:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(" Port In Reset portID %d\n", port_id));
+                break;
+        case PORT_NOT_ESTABLISHED:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(" phy Down and PORT_NOT_ESTABLISHED\n"));
+                port->port_attached = 0;
+                break;
+        case PORT_LOSTCOMM:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(" phy Down and PORT_LOSTCOMM\n"));
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(" Last phy Down and port invalid\n"));
+                port->port_attached = 0;
+                pm80xx_hw_event_ack_req(pm8001_ha, 0, HW_EVENT_PHY_DOWN,
+                        port_id, phy_id, 0, 0);
+                break;
+        default:
+                port->port_attached = 0;
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(" phy Down and(default) = 0x%x\n",
+                        portstate));
+                break;
+
+        }
+}
+
+static int mpi_phy_start_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+{
+        struct phy_start_resp *pPayload =
+                (struct phy_start_resp *)(piomb + 4);
+        u32 status =
+                le32_to_cpu(pPayload->status);
+        u32 phy_id =
+                le32_to_cpu(pPayload->phyid);
+        struct pm8001_phy *phy = &pm8001_ha->phy[phy_id];
+
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("phy start resp status:0x%x, phyid:0x%x\n",
+                                status, phy_id));
+        if (status == 0) {
+                phy->phy_state = 1;
+                if (pm8001_ha->flags == PM8001F_RUN_TIME)
+                        complete(phy->enable_completion);
+        }
+        return 0;
+
+}
+
+/**
+ * mpi_thermal_hw_event -The hw event has come.
+ * @pm8001_ha: our hba card information
+ * @piomb: IO message buffer
+ */
+static int mpi_thermal_hw_event(struct pm8001_hba_info *pm8001_ha, void *piomb)
+{
+        struct thermal_hw_event *pPayload =
+                (struct thermal_hw_event *)(piomb + 4);
+
+        u32 thermal_event = le32_to_cpu(pPayload->thermal_event);
+        u32 rht_lht = le32_to_cpu(pPayload->rht_lht);
+
+        if (thermal_event & 0x40) {
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+                        "Thermal Event: Local high temperature violated!\n"));
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+                        "Thermal Event: Measured local high temperature %d\n",
+                                ((rht_lht & 0xFF00) >> 8)));
+        }
+        if (thermal_event & 0x10) {
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+                        "Thermal Event: Remote high temperature violated!\n"));
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+                        "Thermal Event: Measured remote high temperature %d\n",
+                                ((rht_lht & 0xFF000000) >> 24)));
+        }
+        return 0;
+}
+
+/**
+ * mpi_hw_event -The hw event has come.
+ * @pm8001_ha: our hba card information
+ * @piomb: IO message buffer
+ */
+static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void *piomb)
+{
+        unsigned long flags;
+        struct hw_event_resp *pPayload =
+                (struct hw_event_resp *)(piomb + 4);
+        u32 lr_status_evt_portid =
+                le32_to_cpu(pPayload->lr_status_evt_portid);
+        u32 phyid_npip_portstate = le32_to_cpu(pPayload->phyid_npip_portstate);
+        u8 port_id = (u8)(lr_status_evt_portid & 0x000000FF);
+        u8 phy_id =
+                (u8)((phyid_npip_portstate & 0xFF0000) >> 16);
+        u16 eventType =
+                (u16)((lr_status_evt_portid & 0x00FFFF00) >> 8);
+        u8 status =
+                (u8)((lr_status_evt_portid & 0x0F000000) >> 24);
+
+        struct sas_ha_struct *sas_ha = pm8001_ha->sas;
+        struct pm8001_phy *phy = &pm8001_ha->phy[phy_id];
+        struct asd_sas_phy *sas_phy = sas_ha->sas_phy[phy_id];
+        PM8001_MSG_DBG(pm8001_ha,
+                pm8001_printk("portid:%d phyid:%d event:0x%x status:0x%x\n",
+                                port_id, phy_id, eventType, status));
+
+        switch (eventType) {
+
+        case HW_EVENT_SAS_PHY_UP:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_PHY_START_STATUS\n"));
+                hw_event_sas_phy_up(pm8001_ha, piomb);
+                break;
+        case HW_EVENT_SATA_PHY_UP:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_SATA_PHY_UP\n"));
+                hw_event_sata_phy_up(pm8001_ha, piomb);
+                break;
+        case HW_EVENT_SATA_SPINUP_HOLD:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_SATA_SPINUP_HOLD\n"));
+                sas_ha->notify_phy_event(&phy->sas_phy, PHYE_SPINUP_HOLD);
+                break;
+        case HW_EVENT_PHY_DOWN:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_PHY_DOWN\n"));
+                sas_ha->notify_phy_event(&phy->sas_phy, PHYE_LOSS_OF_SIGNAL);
+                phy->phy_attached = 0;
+                phy->phy_state = 0;
+                hw_event_phy_down(pm8001_ha, piomb);
+                break;
+        case HW_EVENT_PORT_INVALID:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_PORT_INVALID\n"));
+                sas_phy_disconnected(sas_phy);
+                phy->phy_attached = 0;
+                sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+                break;
+        /* the broadcast change primitive received, tell the LIBSAS this event
+        to revalidate the sas domain*/
+        case HW_EVENT_BROADCAST_CHANGE:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_BROADCAST_CHANGE\n"));
+                pm80xx_hw_event_ack_req(pm8001_ha, 0, HW_EVENT_BROADCAST_CHANGE,
+                        port_id, phy_id, 1, 0);
+                spin_lock_irqsave(&sas_phy->sas_prim_lock, flags);
+                sas_phy->sas_prim = HW_EVENT_BROADCAST_CHANGE;
+                spin_unlock_irqrestore(&sas_phy->sas_prim_lock, flags);
+                sas_ha->notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
+                break;
+        case HW_EVENT_PHY_ERROR:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_PHY_ERROR\n"));
+                sas_phy_disconnected(&phy->sas_phy);
+                phy->phy_attached = 0;
+                sas_ha->notify_phy_event(&phy->sas_phy, PHYE_OOB_ERROR);
+                break;
+        case HW_EVENT_BROADCAST_EXP:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_BROADCAST_EXP\n"));
+                spin_lock_irqsave(&sas_phy->sas_prim_lock, flags);
+                sas_phy->sas_prim = HW_EVENT_BROADCAST_EXP;
+                spin_unlock_irqrestore(&sas_phy->sas_prim_lock, flags);
+                sas_ha->notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
+                break;
+        case HW_EVENT_LINK_ERR_INVALID_DWORD:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_LINK_ERR_INVALID_DWORD\n"));
+                pm80xx_hw_event_ack_req(pm8001_ha, 0,
+                        HW_EVENT_LINK_ERR_INVALID_DWORD, port_id, phy_id, 0, 0);
+                sas_phy_disconnected(sas_phy);
+                phy->phy_attached = 0;
+                sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+                break;
+        case HW_EVENT_LINK_ERR_DISPARITY_ERROR:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_LINK_ERR_DISPARITY_ERROR\n"));
+                pm80xx_hw_event_ack_req(pm8001_ha, 0,
+                        HW_EVENT_LINK_ERR_DISPARITY_ERROR,
+                        port_id, phy_id, 0, 0);
+                sas_phy_disconnected(sas_phy);
+                phy->phy_attached = 0;
+                sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+                break;
+        case HW_EVENT_LINK_ERR_CODE_VIOLATION:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_LINK_ERR_CODE_VIOLATION\n"));
+                pm80xx_hw_event_ack_req(pm8001_ha, 0,
+                        HW_EVENT_LINK_ERR_CODE_VIOLATION,
+                        port_id, phy_id, 0, 0);
+                sas_phy_disconnected(sas_phy);
+                phy->phy_attached = 0;
+                sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+                break;
+        case HW_EVENT_LINK_ERR_LOSS_OF_DWORD_SYNCH:
+                PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+                                "HW_EVENT_LINK_ERR_LOSS_OF_DWORD_SYNCH\n"));
+                pm80xx_hw_event_ack_req(pm8001_ha, 0,
+                        HW_EVENT_LINK_ERR_LOSS_OF_DWORD_SYNCH,
+                        port_id, phy_id, 0, 0);
+                sas_phy_disconnected(sas_phy);
+                phy->phy_attached = 0;
+                sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+                break;
+        case HW_EVENT_MALFUNCTION:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_MALFUNCTION\n"));
+                break;
+        case HW_EVENT_BROADCAST_SES:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_BROADCAST_SES\n"));
+                spin_lock_irqsave(&sas_phy->sas_prim_lock, flags);
+                sas_phy->sas_prim = HW_EVENT_BROADCAST_SES;
+                spin_unlock_irqrestore(&sas_phy->sas_prim_lock, flags);
+                sas_ha->notify_port_event(sas_phy, PORTE_BROADCAST_RCVD);
+                break;
+        case HW_EVENT_INBOUND_CRC_ERROR:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_INBOUND_CRC_ERROR\n"));
+                pm80xx_hw_event_ack_req(pm8001_ha, 0,
+                        HW_EVENT_INBOUND_CRC_ERROR,
+                        port_id, phy_id, 0, 0);
+                break;
+        case HW_EVENT_HARD_RESET_RECEIVED:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_HARD_RESET_RECEIVED\n"));
+                sas_ha->notify_port_event(sas_phy, PORTE_HARD_RESET);
+                break;
+        case HW_EVENT_ID_FRAME_TIMEOUT:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_ID_FRAME_TIMEOUT\n"));
+                sas_phy_disconnected(sas_phy);
+                phy->phy_attached = 0;
+                sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+                break;
+        case HW_EVENT_LINK_ERR_PHY_RESET_FAILED:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_LINK_ERR_PHY_RESET_FAILED\n"));
+                pm80xx_hw_event_ack_req(pm8001_ha, 0,
+                        HW_EVENT_LINK_ERR_PHY_RESET_FAILED,
+                        port_id, phy_id, 0, 0);
+                sas_phy_disconnected(sas_phy);
+                phy->phy_attached = 0;
+                sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+                break;
+        case HW_EVENT_PORT_RESET_TIMER_TMO:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_PORT_RESET_TIMER_TMO\n"));
+                sas_phy_disconnected(sas_phy);
+                phy->phy_attached = 0;
+                sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+                break;
+        case HW_EVENT_PORT_RECOVERY_TIMER_TMO:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_PORT_RECOVERY_TIMER_TMO\n"));
+                pm80xx_hw_event_ack_req(pm8001_ha, 0,
+                        HW_EVENT_PORT_RECOVERY_TIMER_TMO,
+                        port_id, phy_id, 0, 0);
+                sas_phy_disconnected(sas_phy);
+                phy->phy_attached = 0;
+                sas_ha->notify_port_event(sas_phy, PORTE_LINK_RESET_ERR);
+                break;
+        case HW_EVENT_PORT_RECOVER:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_PORT_RECOVER\n"));
+                break;
+        case HW_EVENT_PORT_RESET_COMPLETE:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("HW_EVENT_PORT_RESET_COMPLETE\n"));
+                break;
+        case EVENT_BROADCAST_ASYNCH_EVENT:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("EVENT_BROADCAST_ASYNCH_EVENT\n"));
+                break;
+        default:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("Unknown event type 0x%x\n", eventType));
+                break;
+        }
+        return 0;
+}
+
+/**
+ * mpi_phy_stop_resp - SPCv specific
+ * @pm8001_ha: our hba card information
+ * @piomb: IO message buffer
+ */
+static int mpi_phy_stop_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+{
+        struct phy_stop_resp *pPayload =
+                (struct phy_stop_resp *)(piomb + 4);
+        u32 status =
+                le32_to_cpu(pPayload->status);
+        u32 phyid =
+                le32_to_cpu(pPayload->phyid);
+        struct pm8001_phy *phy = &pm8001_ha->phy[phyid];
+        PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("phy:0x%x status:0x%x\n",
+                                        phyid, status));
+        if (status == 0)
+                phy->phy_state = 0;
+        return 0;
+}
+
+/**
+ * mpi_set_controller_config_resp - SPCv specific
+ * @pm8001_ha: our hba card information
+ * @piomb: IO message buffer
+ */
+static int mpi_set_controller_config_resp(struct pm8001_hba_info *pm8001_ha,
+                        void *piomb)
+{
+        struct set_ctrl_cfg_resp *pPayload =
+                        (struct set_ctrl_cfg_resp *)(piomb + 4);
+        u32 status = le32_to_cpu(pPayload->status);
+        u32 err_qlfr_pgcd = le32_to_cpu(pPayload->err_qlfr_pgcd);
+
+        PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+                        "SET CONTROLLER RESP: status 0x%x qlfr_pgcd 0x%x\n",
+                        status, err_qlfr_pgcd));
+
+        return 0;
+}
+
+/**
+ * mpi_get_controller_config_resp - SPCv specific
+ * @pm8001_ha: our hba card information
+ * @piomb: IO message buffer
+ */
+static int mpi_get_controller_config_resp(struct pm8001_hba_info *pm8001_ha,
+                        void *piomb)
+{
+        PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(" pm80xx_addition_functionality\n"));
+
+        return 0;
+}
+
+/**
+ * mpi_get_phy_profile_resp - SPCv specific
+ * @pm8001_ha: our hba card information
+ * @piomb: IO message buffer
+ */
+static int mpi_get_phy_profile_resp(struct pm8001_hba_info *pm8001_ha,
+                        void *piomb)
+{
+        PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(" pm80xx_addition_functionality\n"));
+
+        return 0;
+}
+
+/**
+ * mpi_flash_op_ext_resp - SPCv specific
+ * @pm8001_ha: our hba card information
+ * @piomb: IO message buffer
+ */
+static int mpi_flash_op_ext_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
+{
+        PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(" pm80xx_addition_functionality\n"));
+
+        return 0;
+}
+
+/**
+ * mpi_set_phy_profile_resp - SPCv specific
+ * @pm8001_ha: our hba card information
+ * @piomb: IO message buffer
+ */
+static int mpi_set_phy_profile_resp(struct pm8001_hba_info *pm8001_ha,
+                        void *piomb)
+{
+        PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(" pm80xx_addition_functionality\n"));
+
+        return 0;
+}
+
+/**
+ * mpi_kek_management_resp - SPCv specific
+ * @pm8001_ha: our hba card information
+ * @piomb: IO message buffer
+ */
+static int mpi_kek_management_resp(struct pm8001_hba_info *pm8001_ha,
+                        void *piomb)
+{
+        struct kek_mgmt_resp *pPayload = (struct kek_mgmt_resp *)(piomb + 4);
+
+        u32 status = le32_to_cpu(pPayload->status);
+        u32 kidx_new_curr_ksop = le32_to_cpu(pPayload->kidx_new_curr_ksop);
+        u32 err_qlfr = le32_to_cpu(pPayload->err_qlfr);
+
+        PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+                "KEK MGMT RESP. Status 0x%x idx_ksop 0x%x err_qlfr 0x%x\n",
+                status, kidx_new_curr_ksop, err_qlfr));
+
+        return 0;
+}
+
+/**
+ * mpi_dek_management_resp - SPCv specific
+ * @pm8001_ha: our hba card information
+ * @piomb: IO message buffer
+ */
+static int mpi_dek_management_resp(struct pm8001_hba_info *pm8001_ha,
+                        void *piomb)
+{
+        PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(" pm80xx_addition_functionality\n"));
+
+        return 0;
+}
+
+/**
+ * ssp_coalesced_comp_resp - SPCv specific
+ * @pm8001_ha: our hba card information
+ * @piomb: IO message buffer
+ */
+static int ssp_coalesced_comp_resp(struct pm8001_hba_info *pm8001_ha,
+                        void *piomb)
+{
+        PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk(" pm80xx_addition_functionality\n"));
+
+        return 0;
+}
+
+/**
+ * process_one_iomb - process one outbound Queue memory block
+ * @pm8001_ha: our hba card information
+ * @piomb: IO message buffer
+ */
+static void process_one_iomb(struct pm8001_hba_info *pm8001_ha, void *piomb)
+{
+        __le32 pHeader = *(__le32 *)piomb;
+        u32 opc = (u32)((le32_to_cpu(pHeader)) & 0xFFF);
+
+        switch (opc) {
+        case OPC_OUB_ECHO:
+                PM8001_MSG_DBG(pm8001_ha, pm8001_printk("OPC_OUB_ECHO\n"));
+                break;
+        case OPC_OUB_HW_EVENT:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_HW_EVENT\n"));
+                mpi_hw_event(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_THERM_HW_EVENT:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_THERMAL_EVENT\n"));
+                mpi_thermal_hw_event(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_SSP_COMP:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SSP_COMP\n"));
+                mpi_ssp_completion(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_SMP_COMP:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SMP_COMP\n"));
+                mpi_smp_completion(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_LOCAL_PHY_CNTRL:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_LOCAL_PHY_CNTRL\n"));
+                pm8001_mpi_local_phy_ctl(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_DEV_REGIST:
+                PM8001_MSG_DBG(pm8001_ha,
+                pm8001_printk("OPC_OUB_DEV_REGIST\n"));
+                pm8001_mpi_reg_resp(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_DEREG_DEV:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("unresgister the deviece\n"));
+                pm8001_mpi_dereg_resp(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_GET_DEV_HANDLE:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_GET_DEV_HANDLE\n"));
+                break;
+        case OPC_OUB_SATA_COMP:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SATA_COMP\n"));
+                mpi_sata_completion(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_SATA_EVENT:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SATA_EVENT\n"));
+                mpi_sata_event(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_SSP_EVENT:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SSP_EVENT\n"));
+                mpi_ssp_event(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_DEV_HANDLE_ARRIV:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_DEV_HANDLE_ARRIV\n"));
+                /*This is for target*/
+                break;
+        case OPC_OUB_SSP_RECV_EVENT:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SSP_RECV_EVENT\n"));
+                /*This is for target*/
+                break;
+        case OPC_OUB_FW_FLASH_UPDATE:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_FW_FLASH_UPDATE\n"));
+                pm8001_mpi_fw_flash_update_resp(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_GPIO_RESPONSE:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_GPIO_RESPONSE\n"));
+                break;
+        case OPC_OUB_GPIO_EVENT:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_GPIO_EVENT\n"));
+                break;
+        case OPC_OUB_GENERAL_EVENT:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_GENERAL_EVENT\n"));
+                pm8001_mpi_general_event(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_SSP_ABORT_RSP:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SSP_ABORT_RSP\n"));
+                pm8001_mpi_task_abort_resp(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_SATA_ABORT_RSP:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SATA_ABORT_RSP\n"));
+                pm8001_mpi_task_abort_resp(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_SAS_DIAG_MODE_START_END:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SAS_DIAG_MODE_START_END\n"));
+                break;
+        case OPC_OUB_SAS_DIAG_EXECUTE:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SAS_DIAG_EXECUTE\n"));
+                break;
+        case OPC_OUB_GET_TIME_STAMP:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_GET_TIME_STAMP\n"));
+                break;
+        case OPC_OUB_SAS_HW_EVENT_ACK:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SAS_HW_EVENT_ACK\n"));
+                break;
+        case OPC_OUB_PORT_CONTROL:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_PORT_CONTROL\n"));
+                break;
+        case OPC_OUB_SMP_ABORT_RSP:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SMP_ABORT_RSP\n"));
+                pm8001_mpi_task_abort_resp(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_GET_NVMD_DATA:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_GET_NVMD_DATA\n"));
+                pm8001_mpi_get_nvmd_resp(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_SET_NVMD_DATA:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SET_NVMD_DATA\n"));
+                pm8001_mpi_set_nvmd_resp(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_DEVICE_HANDLE_REMOVAL:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_DEVICE_HANDLE_REMOVAL\n"));
+                break;
+        case OPC_OUB_SET_DEVICE_STATE:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SET_DEVICE_STATE\n"));
+                pm8001_mpi_set_dev_state_resp(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_GET_DEVICE_STATE:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_GET_DEVICE_STATE\n"));
+                break;
+        case OPC_OUB_SET_DEV_INFO:
+                PM8001_MSG_DBG(pm8001_ha,
+                        pm8001_printk("OPC_OUB_SET_DEV_INFO\n"));
+                break;
+        /* spcv specifc commands */
+        case OPC_OUB_PHY_START_RESP:
+                PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+                        "OPC_OUB_PHY_START_RESP opcode:%x\n", opc));
+                mpi_phy_start_resp(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_PHY_STOP_RESP:
+                PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+                        "OPC_OUB_PHY_STOP_RESP opcode:%x\n", opc));
+                mpi_phy_stop_resp(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_SET_CONTROLLER_CONFIG:
+                PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+                        "OPC_OUB_SET_CONTROLLER_CONFIG opcode:%x\n", opc));
+                mpi_set_controller_config_resp(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_GET_CONTROLLER_CONFIG:
+                PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+                        "OPC_OUB_GET_CONTROLLER_CONFIG opcode:%x\n", opc));
+                mpi_get_controller_config_resp(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_GET_PHY_PROFILE:
+                PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+                        "OPC_OUB_GET_PHY_PROFILE opcode:%x\n", opc));
+                mpi_get_phy_profile_resp(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_FLASH_OP_EXT:
+                PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+                        "OPC_OUB_FLASH_OP_EXT opcode:%x\n", opc));
+                mpi_flash_op_ext_resp(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_SET_PHY_PROFILE:
+                PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+                        "OPC_OUB_SET_PHY_PROFILE opcode:%x\n", opc));
+                mpi_set_phy_profile_resp(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_KEK_MANAGEMENT_RESP:
+                PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+                        "OPC_OUB_KEK_MANAGEMENT_RESP opcode:%x\n", opc));
+                mpi_kek_management_resp(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_DEK_MANAGEMENT_RESP:
+                PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+                        "OPC_OUB_DEK_MANAGEMENT_RESP opcode:%x\n", opc));
+                mpi_dek_management_resp(pm8001_ha, piomb);
+                break;
+        case OPC_OUB_SSP_COALESCED_COMP_RESP:
+                PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+                        "OPC_OUB_SSP_COALESCED_COMP_RESP opcode:%x\n", opc));
+                ssp_coalesced_comp_resp(pm8001_ha, piomb);
+                break;
+        default:
+                PM8001_MSG_DBG(pm8001_ha, pm8001_printk(
+                        "Unknown outbound Queue IOMB OPC = 0x%x\n", opc));
+                break;
+        }
+}
+
+static int process_oq(struct pm8001_hba_info *pm8001_ha, u8 vec)
+{
+        struct outbound_queue_table *circularQ;
+        void *pMsg1 = NULL;
+        u8 uninitialized_var(bc);
+        u32 ret = MPI_IO_STATUS_FAIL;
+        unsigned long flags;
+
+        spin_lock_irqsave(&pm8001_ha->lock, flags);
+        circularQ = &pm8001_ha->outbnd_q_tbl[vec];
+        do {
+                ret = pm8001_mpi_msg_consume(pm8001_ha, circularQ, &pMsg1, &bc);
+                if (MPI_IO_STATUS_SUCCESS == ret) {
+                        /* process the outbound message */
+                        process_one_iomb(pm8001_ha, (void *)(pMsg1 - 4));
+                        /* free the message from the outbound circular buffer */
+                        pm8001_mpi_msg_free_set(pm8001_ha, pMsg1,
+                                                        circularQ, bc);
+                }
+                if (MPI_IO_STATUS_BUSY == ret) {
+                        /* Update the producer index from SPC */
+                        circularQ->producer_index =
+                                cpu_to_le32(pm8001_read_32(circularQ->pi_virt));
+                        if (le32_to_cpu(circularQ->producer_index) ==
+                                circularQ->consumer_idx)
+                                /* OQ is empty */
+                                break;
+                }
+        } while (1);
+        spin_unlock_irqrestore(&pm8001_ha->lock, flags);
+        return ret;
+}
+
+/* PCI_DMA_... to our direction translation. */
+static const u8 data_dir_flags[] = {
+        [PCI_DMA_BIDIRECTIONAL] = DATA_DIR_BYRECIPIENT,/* UNSPECIFIED */
+        [PCI_DMA_TODEVICE]      = DATA_DIR_OUT,/* OUTBOUND */
+        [PCI_DMA_FROMDEVICE]    = DATA_DIR_IN,/* INBOUND */
+        [PCI_DMA_NONE]          = DATA_DIR_NONE,/* NO TRANSFER */
+};
+
+static void build_smp_cmd(u32 deviceID, __le32 hTag,
+                        struct smp_req *psmp_cmd, int mode, int length)
+{
+        psmp_cmd->tag = hTag;
+        psmp_cmd->device_id = cpu_to_le32(deviceID);
+        if (mode == SMP_DIRECT) {
+                length = length - 4; /* subtract crc */
+                psmp_cmd->len_ip_ir = cpu_to_le32(length << 16);
+        } else {
+                psmp_cmd->len_ip_ir = cpu_to_le32(1|(1 << 1));
+        }
+}
+
+/**
+ * pm8001_chip_smp_req - send a SMP task to FW
+ * @pm8001_ha: our hba card information.
+ * @ccb: the ccb information this request used.
+ */
+static int pm80xx_chip_smp_req(struct pm8001_hba_info *pm8001_ha,
+        struct pm8001_ccb_info *ccb)
+{
+        int elem, rc;
+        struct sas_task *task = ccb->task;
+        struct domain_device *dev = task->dev;
+        struct pm8001_device *pm8001_dev = dev->lldd_dev;
+        struct scatterlist *sg_req, *sg_resp;
+        u32 req_len, resp_len;
+        struct smp_req smp_cmd;
+        u32 opc;
+        struct inbound_queue_table *circularQ;
+        char *preq_dma_addr = NULL;
+        __le64 tmp_addr;
+        u32 i, length;
+
+        memset(&smp_cmd, 0, sizeof(smp_cmd));
+        /*
+         * DMA-map SMP request, response buffers
+         */
+        sg_req = &task->smp_task.smp_req;
+        elem = dma_map_sg(pm8001_ha->dev, sg_req, 1, PCI_DMA_TODEVICE);
+        if (!elem)
+                return -ENOMEM;
+        req_len = sg_dma_len(sg_req);
+
+        sg_resp = &task->smp_task.smp_resp;
+        elem = dma_map_sg(pm8001_ha->dev, sg_resp, 1, PCI_DMA_FROMDEVICE);
+        if (!elem) {
+                rc = -ENOMEM;
+                goto err_out;
+        }
+        resp_len = sg_dma_len(sg_resp);
+        /* must be in dwords */
+        if ((req_len & 0x3) || (resp_len & 0x3)) {
+                rc = -EINVAL;
+                goto err_out_2;
+        }
+
+        opc = OPC_INB_SMP_REQUEST;
+        circularQ = &pm8001_ha->inbnd_q_tbl[0];
+        smp_cmd.tag = cpu_to_le32(ccb->ccb_tag);
+
+        length = sg_req->length;
+        PM8001_IO_DBG(pm8001_ha,
+                pm8001_printk("SMP Frame Length %d\n", sg_req->length));
+        if (!(length - 8))
+                pm8001_ha->smp_exp_mode = SMP_DIRECT;
+        else
+                pm8001_ha->smp_exp_mode = SMP_INDIRECT;
+
+        /* DIRECT MODE support only in spcv/ve */
+        pm8001_ha->smp_exp_mode = SMP_DIRECT;
+
+        tmp_addr = cpu_to_le64((u64)sg_dma_address(&task->smp_task.smp_req));
+        preq_dma_addr = (char *)phys_to_virt(tmp_addr);
+
+        /* INDIRECT MODE command settings. Use DMA */
+        if (pm8001_ha->smp_exp_mode == SMP_INDIRECT) {
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("SMP REQUEST INDIRECT MODE\n"));
+                /* for SPCv indirect mode. Place the top 4 bytes of
+                 * SMP Request header here. */
+                for (i = 0; i < 4; i++)
+                        smp_cmd.smp_req16[i] = *(preq_dma_addr + i);
+                /* exclude top 4 bytes for SMP req header */
+                smp_cmd.long_smp_req.long_req_addr =
+                        cpu_to_le64((u64)sg_dma_address
+                                (&task->smp_task.smp_req) - 4);
+                /* exclude 4 bytes for SMP req header and CRC */
+                smp_cmd.long_smp_req.long_req_size =
+                        cpu_to_le32((u32)sg_dma_len(&task->smp_task.smp_req)-8);
+                smp_cmd.long_smp_req.long_resp_addr =
+                                cpu_to_le64((u64)sg_dma_address
+                                        (&task->smp_task.smp_resp));
+                smp_cmd.long_smp_req.long_resp_size =
+                                cpu_to_le32((u32)sg_dma_len
+                                        (&task->smp_task.smp_resp)-4);
+        } else { /* DIRECT MODE */
+                smp_cmd.long_smp_req.long_req_addr =
+                        cpu_to_le64((u64)sg_dma_address
+                                        (&task->smp_task.smp_req));
+                smp_cmd.long_smp_req.long_req_size =
+                        cpu_to_le32((u32)sg_dma_len(&task->smp_task.smp_req)-4);
+                smp_cmd.long_smp_req.long_resp_addr =
+                        cpu_to_le64((u64)sg_dma_address
+                                (&task->smp_task.smp_resp));
+                smp_cmd.long_smp_req.long_resp_size =
+                        cpu_to_le32
+                        ((u32)sg_dma_len(&task->smp_task.smp_resp)-4);
+        }
+        if (pm8001_ha->smp_exp_mode == SMP_DIRECT) {
+                PM8001_IO_DBG(pm8001_ha,
+                        pm8001_printk("SMP REQUEST DIRECT MODE\n"));
+                for (i = 0; i < length; i++)
+                        if (i < 16) {
+                                smp_cmd.smp_req16[i] = *(preq_dma_addr+i);
+                                PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+                                        "Byte[%d]:%x (DMA data:%x)\n",
+                                        i, smp_cmd.smp_req16[i],
+                                        *(preq_dma_addr)));
+                        } else {
+                                smp_cmd.smp_req[i] = *(preq_dma_addr+i);
+                                PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+                                        "Byte[%d]:%x (DMA data:%x)\n",
+                                        i, smp_cmd.smp_req[i],
+                                        *(preq_dma_addr)));
+                        }
+        }
+
+        build_smp_cmd(pm8001_dev->device_id, smp_cmd.tag,
+                                &smp_cmd, pm8001_ha->smp_exp_mode, length);
+        pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, (u32 *)&smp_cmd, 0);
+        return 0;
+
+err_out_2:
+        dma_unmap_sg(pm8001_ha->dev, &ccb->task->smp_task.smp_resp, 1,
+                        PCI_DMA_FROMDEVICE);
+err_out:
+        dma_unmap_sg(pm8001_ha->dev, &ccb->task->smp_task.smp_req, 1,
+                        PCI_DMA_TODEVICE);
+        return rc;
+}
+
+static int check_enc_sas_cmd(struct sas_task *task)
+{
+        if ((task->ssp_task.cdb[0] == READ_10)
+                || (task->ssp_task.cdb[0] == WRITE_10)
+                || (task->ssp_task.cdb[0] == WRITE_VERIFY))
+                return 1;
+        else
+                return 0;
+}
+
+static int check_enc_sat_cmd(struct sas_task *task)
+{
+        int ret = 0;
+        switch (task->ata_task.fis.command) {
+        case ATA_CMD_FPDMA_READ:
+        case ATA_CMD_READ_EXT:
+        case ATA_CMD_READ:
+        case ATA_CMD_FPDMA_WRITE:
+        case ATA_CMD_WRITE_EXT:
+        case ATA_CMD_WRITE:
+        case ATA_CMD_PIO_READ:
+        case ATA_CMD_PIO_READ_EXT:
+        case ATA_CMD_PIO_WRITE:
+        case ATA_CMD_PIO_WRITE_EXT:
+                ret = 1;
+                break;
+        default:
+                ret = 0;
+                break;
+        }
+        return ret;
+}
+
+/**
+ * pm80xx_chip_ssp_io_req - send a SSP task to FW
+ * @pm8001_ha: our hba card information.
+ * @ccb: the ccb information this request used.
+ */
+static int pm80xx_chip_ssp_io_req(struct pm8001_hba_info *pm8001_ha,
+        struct pm8001_ccb_info *ccb)
+{
+        struct sas_task *task = ccb->task;
+        struct domain_device *dev = task->dev;
+        struct pm8001_device *pm8001_dev = dev->lldd_dev;
+        struct ssp_ini_io_start_req ssp_cmd;
+        u32 tag = ccb->ccb_tag;
+        int ret;
+        u64 phys_addr;
+        struct inbound_queue_table *circularQ;
+        static u32 inb;
+        static u32 outb;
+        u32 opc = OPC_INB_SSPINIIOSTART;
+        memset(&ssp_cmd, 0, sizeof(ssp_cmd));
+        memcpy(ssp_cmd.ssp_iu.lun, task->ssp_task.LUN, 8);
+        /* data address domain added for spcv; set to 0 by host,
+         * used internally by controller
+         * 0 for SAS 1.1 and SAS 2.0 compatible TLR
+         */
+        ssp_cmd.dad_dir_m_tlr =
+                cpu_to_le32(data_dir_flags[task->data_dir] << 8 | 0x0);
+        ssp_cmd.data_len = cpu_to_le32(task->total_xfer_len);
+        ssp_cmd.device_id = cpu_to_le32(pm8001_dev->device_id);
+        ssp_cmd.tag = cpu_to_le32(tag);
+        if (task->ssp_task.enable_first_burst)
+                ssp_cmd.ssp_iu.efb_prio_attr |= 0x80;
+        ssp_cmd.ssp_iu.efb_prio_attr |= (task->ssp_task.task_prio << 3);
+        ssp_cmd.ssp_iu.efb_prio_attr |= (task->ssp_task.task_attr & 7);
+        memcpy(ssp_cmd.ssp_iu.cdb, task->ssp_task.cdb, 16);
+        circularQ = &pm8001_ha->inbnd_q_tbl[0];
+
+        /* Check if encryption is set */
+        if (pm8001_ha->chip->encrypt &&
+                !(pm8001_ha->encrypt_info.status) && check_enc_sas_cmd(task)) {
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+                        "Encryption enabled.Sending Encrypt SAS command 0x%x\n",
+                        task->ssp_task.cdb[0]));
+                opc = OPC_INB_SSP_INI_DIF_ENC_IO;
+                /* enable encryption. 0 for SAS 1.1 and SAS 2.0 compatible TLR*/
+                ssp_cmd.dad_dir_m_tlr = cpu_to_le32
+                        ((data_dir_flags[task->data_dir] << 8) | 0x20 | 0x0);
+
+                /* fill in PRD (scatter/gather) table, if any */
+                if (task->num_scatter > 1) {
+                        pm8001_chip_make_sg(task->scatter,
+                                                ccb->n_elem, ccb->buf_prd);
+                        phys_addr = ccb->ccb_dma_handle +
+                                offsetof(struct pm8001_ccb_info, buf_prd[0]);
+                        ssp_cmd.enc_addr_low =
+                                cpu_to_le32(lower_32_bits(phys_addr));
+                        ssp_cmd.enc_addr_high =
+                                cpu_to_le32(upper_32_bits(phys_addr));
+                        ssp_cmd.enc_esgl = cpu_to_le32(1<<31);
+                } else if (task->num_scatter == 1) {
+                        u64 dma_addr = sg_dma_address(task->scatter);
+                        ssp_cmd.enc_addr_low =
+                                cpu_to_le32(lower_32_bits(dma_addr));
+                        ssp_cmd.enc_addr_high =
+                                cpu_to_le32(upper_32_bits(dma_addr));
+                        ssp_cmd.enc_len = cpu_to_le32(task->total_xfer_len);
+                        ssp_cmd.enc_esgl = 0;
+                } else if (task->num_scatter == 0) {
+                        ssp_cmd.enc_addr_low = 0;
+                        ssp_cmd.enc_addr_high = 0;
+                        ssp_cmd.enc_len = cpu_to_le32(task->total_xfer_len);
+                        ssp_cmd.enc_esgl = 0;
+                }
+                /* XTS mode. All other fields are 0 */
+                ssp_cmd.key_cmode = 0x6 << 4;
+                /* set tweak values. Should be the start lba */
+                ssp_cmd.twk_val0 = cpu_to_le32((task->ssp_task.cdb[2] << 24) |
+                                                (task->ssp_task.cdb[3] << 16) |
+                                                (task->ssp_task.cdb[4] << 8) |
+                                                (task->ssp_task.cdb[5]));
+        } else {
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+                        "Sending Normal SAS command 0x%x inb q %x\n",
+                        task->ssp_task.cdb[0], inb));
+                /* fill in PRD (scatter/gather) table, if any */
+                if (task->num_scatter > 1) {
+                        pm8001_chip_make_sg(task->scatter, ccb->n_elem,
+                                        ccb->buf_prd);
+                        phys_addr = ccb->ccb_dma_handle +
+                                offsetof(struct pm8001_ccb_info, buf_prd[0]);
+                        ssp_cmd.addr_low =
+                                cpu_to_le32(lower_32_bits(phys_addr));
+                        ssp_cmd.addr_high =
+                                cpu_to_le32(upper_32_bits(phys_addr));
+                        ssp_cmd.esgl = cpu_to_le32(1<<31);
+                } else if (task->num_scatter == 1) {
+                        u64 dma_addr = sg_dma_address(task->scatter);
+                        ssp_cmd.addr_low = cpu_to_le32(lower_32_bits(dma_addr));
+                        ssp_cmd.addr_high =
+                                cpu_to_le32(upper_32_bits(dma_addr));
+                        ssp_cmd.len = cpu_to_le32(task->total_xfer_len);
+                        ssp_cmd.esgl = 0;
+                } else if (task->num_scatter == 0) {
+                        ssp_cmd.addr_low = 0;
+                        ssp_cmd.addr_high = 0;
+                        ssp_cmd.len = cpu_to_le32(task->total_xfer_len);
+                        ssp_cmd.esgl = 0;
+                }
+        }
+        ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &ssp_cmd, outb++);
+
+        /* rotate the outb queue */
+        outb = outb%PM8001_MAX_SPCV_OUTB_NUM;
+
+        return ret;
+}
+
+static int pm80xx_chip_sata_req(struct pm8001_hba_info *pm8001_ha,
+        struct pm8001_ccb_info *ccb)
+{
+        struct sas_task *task = ccb->task;
+        struct domain_device *dev = task->dev;
+        struct pm8001_device *pm8001_ha_dev = dev->lldd_dev;
+        u32 tag = ccb->ccb_tag;
+        int ret;
+        static u32 inb;
+        static u32 outb;
+        struct sata_start_req sata_cmd;
+        u32 hdr_tag, ncg_tag = 0;
+        u64 phys_addr;
+        u32 ATAP = 0x0;
+        u32 dir;
+        struct inbound_queue_table *circularQ;
+        unsigned long flags;
+        u32 opc = OPC_INB_SATA_HOST_OPSTART;
+        memset(&sata_cmd, 0, sizeof(sata_cmd));
+        circularQ = &pm8001_ha->inbnd_q_tbl[0];
+
+        if (task->data_dir == PCI_DMA_NONE) {
+                ATAP = 0x04; /* no data*/
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk("no data\n"));
+        } else if (likely(!task->ata_task.device_control_reg_update)) {
+                if (task->ata_task.dma_xfer) {
+                        ATAP = 0x06; /* DMA */
+                        PM8001_IO_DBG(pm8001_ha, pm8001_printk("DMA\n"));
+                } else {
+                        ATAP = 0x05; /* PIO*/
+                        PM8001_IO_DBG(pm8001_ha, pm8001_printk("PIO\n"));
+                }
+                if (task->ata_task.use_ncq &&
+                        dev->sata_dev.command_set != ATAPI_COMMAND_SET) {
+                        ATAP = 0x07; /* FPDMA */
+                        PM8001_IO_DBG(pm8001_ha, pm8001_printk("FPDMA\n"));
+                }
+        }
+        if (task->ata_task.use_ncq && pm8001_get_ncq_tag(task, &hdr_tag)) {
+                task->ata_task.fis.sector_count |= (u8) (hdr_tag << 3);
+                ncg_tag = hdr_tag;
+        }
+        dir = data_dir_flags[task->data_dir] << 8;
+        sata_cmd.tag = cpu_to_le32(tag);
+        sata_cmd.device_id = cpu_to_le32(pm8001_ha_dev->device_id);
+        sata_cmd.data_len = cpu_to_le32(task->total_xfer_len);
+
+        sata_cmd.sata_fis = task->ata_task.fis;
+        if (likely(!task->ata_task.device_control_reg_update))
+                sata_cmd.sata_fis.flags |= 0x80;/* C=1: update ATA cmd reg */
+        sata_cmd.sata_fis.flags &= 0xF0;/* PM_PORT field shall be 0 */
+
+        /* Check if encryption is set */
+        if (pm8001_ha->chip->encrypt &&
+                !(pm8001_ha->encrypt_info.status) && check_enc_sat_cmd(task)) {
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+                        "Encryption enabled.Sending Encrypt SATA cmd 0x%x\n",
+                        sata_cmd.sata_fis.command));
+                opc = OPC_INB_SATA_DIF_ENC_IO;
+
+                /* set encryption bit */
+                sata_cmd.ncqtag_atap_dir_m_dad =
+                        cpu_to_le32(((ncg_tag & 0xff)<<16)|
+                                ((ATAP & 0x3f) << 10) | 0x20 | dir);
+                                                        /* dad (bit 0-1) is 0 */
+                /* fill in PRD (scatter/gather) table, if any */
+                if (task->num_scatter > 1) {
+                        pm8001_chip_make_sg(task->scatter,
+                                                ccb->n_elem, ccb->buf_prd);
+                        phys_addr = ccb->ccb_dma_handle +
+                                offsetof(struct pm8001_ccb_info, buf_prd[0]);
+                        sata_cmd.enc_addr_low = lower_32_bits(phys_addr);
+                        sata_cmd.enc_addr_high = upper_32_bits(phys_addr);
+                        sata_cmd.enc_esgl = cpu_to_le32(1 << 31);
+                } else if (task->num_scatter == 1) {
+                        u64 dma_addr = sg_dma_address(task->scatter);
+                        sata_cmd.enc_addr_low = lower_32_bits(dma_addr);
+                        sata_cmd.enc_addr_high = upper_32_bits(dma_addr);
+                        sata_cmd.enc_len = cpu_to_le32(task->total_xfer_len);
+                        sata_cmd.enc_esgl = 0;
+                } else if (task->num_scatter == 0) {
+                        sata_cmd.enc_addr_low = 0;
+                        sata_cmd.enc_addr_high = 0;
+                        sata_cmd.enc_len = cpu_to_le32(task->total_xfer_len);
+                        sata_cmd.enc_esgl = 0;
+                }
+                /* XTS mode. All other fields are 0 */
+                sata_cmd.key_index_mode = 0x6 << 4;
+                /* set tweak values. Should be the start lba */
+                sata_cmd.twk_val0 =
+                        cpu_to_le32((sata_cmd.sata_fis.lbal_exp << 24) |
+                                        (sata_cmd.sata_fis.lbah << 16) |
+                                        (sata_cmd.sata_fis.lbam << 8) |
+                                        (sata_cmd.sata_fis.lbal));
+                sata_cmd.twk_val1 =
+                        cpu_to_le32((sata_cmd.sata_fis.lbah_exp << 8) |
+                                         (sata_cmd.sata_fis.lbam_exp));
+        } else {
+                PM8001_IO_DBG(pm8001_ha, pm8001_printk(
+                        "Sending Normal SATA command 0x%x inb %x\n",
+                        sata_cmd.sata_fis.command, inb));
+                /* dad (bit 0-1) is 0 */
+                sata_cmd.ncqtag_atap_dir_m_dad =
+                        cpu_to_le32(((ncg_tag & 0xff)<<16) |
+                                        ((ATAP & 0x3f) << 10) | dir);
+
+                /* fill in PRD (scatter/gather) table, if any */
+                if (task->num_scatter > 1) {
+                        pm8001_chip_make_sg(task->scatter,
+                                        ccb->n_elem, ccb->buf_prd);
+                        phys_addr = ccb->ccb_dma_handle +
+                                offsetof(struct pm8001_ccb_info, buf_prd[0]);
+                        sata_cmd.addr_low = lower_32_bits(phys_addr);
+                        sata_cmd.addr_high = upper_32_bits(phys_addr);
+                        sata_cmd.esgl = cpu_to_le32(1 << 31);
+                } else if (task->num_scatter == 1) {
+                        u64 dma_addr = sg_dma_address(task->scatter);
+                        sata_cmd.addr_low = lower_32_bits(dma_addr);
+                        sata_cmd.addr_high = upper_32_bits(dma_addr);
+                        sata_cmd.len = cpu_to_le32(task->total_xfer_len);
+                        sata_cmd.esgl = 0;
+                } else if (task->num_scatter == 0) {
+                        sata_cmd.addr_low = 0;
+                        sata_cmd.addr_high = 0;
+                        sata_cmd.len = cpu_to_le32(task->total_xfer_len);
+                        sata_cmd.esgl = 0;
+                }
+                        /* scsi cdb */
+                        sata_cmd.atapi_scsi_cdb[0] =
+                                cpu_to_le32(((task->ata_task.atapi_packet[0]) |
+                                (task->ata_task.atapi_packet[1] << 8) |
+                                (task->ata_task.atapi_packet[2] << 16) |
+                                (task->ata_task.atapi_packet[3] << 24)));
+                        sata_cmd.atapi_scsi_cdb[1] =
+                                cpu_to_le32(((task->ata_task.atapi_packet[4]) |
+                                (task->ata_task.atapi_packet[5] << 8) |
+                                (task->ata_task.atapi_packet[6] << 16) |
+                                (task->ata_task.atapi_packet[7] << 24)));
+                        sata_cmd.atapi_scsi_cdb[2] =
+                                cpu_to_le32(((task->ata_task.atapi_packet[8]) |
+                                (task->ata_task.atapi_packet[9] << 8) |
+                                (task->ata_task.atapi_packet[10] << 16) |
+                                (task->ata_task.atapi_packet[11] << 24)));
+                        sata_cmd.atapi_scsi_cdb[3] =
+                                cpu_to_le32(((task->ata_task.atapi_packet[12]) |
+                                (task->ata_task.atapi_packet[13] << 8) |
+                                (task->ata_task.atapi_packet[14] << 16) |
+                                (task->ata_task.atapi_packet[15] << 24)));
+        }
+
+        /* Check for read log for failed drive and return */
+        if (sata_cmd.sata_fis.command == 0x2f) {
+                if (pm8001_ha_dev && ((pm8001_ha_dev->id & NCQ_READ_LOG_FLAG) ||
+                        (pm8001_ha_dev->id & NCQ_ABORT_ALL_FLAG) ||
+                        (pm8001_ha_dev->id & NCQ_2ND_RLE_FLAG))) {
+                        struct task_status_struct *ts;
+
+                        pm8001_ha_dev->id &= 0xDFFFFFFF;
+                        ts = &task->task_status;
+
+                        spin_lock_irqsave(&task->task_state_lock, flags);
+                        ts->resp = SAS_TASK_COMPLETE;
+                        ts->stat = SAM_STAT_GOOD;
+                        task->task_state_flags &= ~SAS_TASK_STATE_PENDING;
+                        task->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
+                        task->task_state_flags |= SAS_TASK_STATE_DONE;
+                        if (unlikely((task->task_state_flags &
+                                        SAS_TASK_STATE_ABORTED))) {
+                                spin_unlock_irqrestore(&task->task_state_lock,
+                                                        flags);
+                                PM8001_FAIL_DBG(pm8001_ha,
+                                        pm8001_printk("task 0x%p resp 0x%x "
+                                        " stat 0x%x but aborted by upper layer "
+                                        "\n", task, ts->resp, ts->stat));
+                                pm8001_ccb_task_free(pm8001_ha, task, ccb, tag);
+                                return 0;
+                        } else if (task->uldd_task) {
+                                spin_unlock_irqrestore(&task->task_state_lock,
+                                                        flags);
+                                pm8001_ccb_task_free(pm8001_ha, task, ccb, tag);
+                                mb();/* ditto */
+                                spin_unlock_irq(&pm8001_ha->lock);
+                                task->task_done(task);
+                                spin_lock_irq(&pm8001_ha->lock);
+                                return 0;
+                        } else if (!task->uldd_task) {
+                                spin_unlock_irqrestore(&task->task_state_lock,
+                                                        flags);
+                                pm8001_ccb_task_free(pm8001_ha, task, ccb, tag);
+                                mb();/*ditto*/
+                                spin_unlock_irq(&pm8001_ha->lock);
+                                task->task_done(task);
+                                spin_lock_irq(&pm8001_ha->lock);
+                                return 0;
+                        }
+                }
+        }
+
+        ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc,
+                                                &sata_cmd, outb++);
+
+        /* rotate the outb queue */
+        outb = outb%PM8001_MAX_SPCV_OUTB_NUM;
+        return ret;
+}
+
+/**
+ * pm80xx_chip_phy_start_req - start phy via PHY_START COMMAND
+ * @pm8001_ha: our hba card information.
+ * @num: the inbound queue number
+ * @phy_id: the phy id which we wanted to start up.
+ */
+static int
+pm80xx_chip_phy_start_req(struct pm8001_hba_info *pm8001_ha, u8 phy_id)
+{
+        struct phy_start_req payload;
+        struct inbound_queue_table *circularQ;
+        int ret;
+        u32 tag = 0x01;
+        u32 opcode = OPC_INB_PHYSTART;
+        circularQ = &pm8001_ha->inbnd_q_tbl[0];
+        memset(&payload, 0, sizeof(payload));
+        payload.tag = cpu_to_le32(tag);
+
+        PM8001_INIT_DBG(pm8001_ha,
+                pm8001_printk("PHY START REQ for phy_id %d\n", phy_id));
+        /*
+         ** [0:7]       PHY Identifier
+         ** [8:11]      link rate 1.5G, 3G, 6G
+         ** [12:13] link mode 01b SAS mode; 10b SATA mode; 11b Auto mode
+         ** [14]        0b disable spin up hold; 1b enable spin up hold
+         ** [15] ob no change in current PHY analig setup 1b enable using SPAST
+         */
+        payload.ase_sh_lm_slr_phyid = cpu_to_le32(SPINHOLD_DISABLE |
+                        LINKMODE_AUTO | LINKRATE_15 |
+                        LINKRATE_30 | LINKRATE_60 | phy_id);
+        /* SSC Disable and SAS Analog ST configuration */
+        /**
+        payload.ase_sh_lm_slr_phyid =
+                cpu_to_le32(SSC_DISABLE_30 | SAS_ASE | SPINHOLD_DISABLE |
+                LINKMODE_AUTO | LINKRATE_15 | LINKRATE_30 | LINKRATE_60 |
+                phy_id);
+        Have to add "SAS PHY Analog Setup SPASTI 1 Byte" Based on need
+        **/
+
+        payload.sas_identify.dev_type = SAS_END_DEVICE;
+        payload.sas_identify.initiator_bits = SAS_PROTOCOL_ALL;
+        memcpy(payload.sas_identify.sas_addr,
+                pm8001_ha->sas_addr, SAS_ADDR_SIZE);
+        payload.sas_identify.phy_id = phy_id;
+        ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opcode, &payload, 0);
+        return ret;
+}
+
+/**
+ * pm8001_chip_phy_stop_req - start phy via PHY_STOP COMMAND
+ * @pm8001_ha: our hba card information.
+ * @num: the inbound queue number
+ * @phy_id: the phy id which we wanted to start up.
+ */
+static int pm80xx_chip_phy_stop_req(struct pm8001_hba_info *pm8001_ha,
+        u8 phy_id)
+{
+        struct phy_stop_req payload;
+        struct inbound_queue_table *circularQ;
+        int ret;
+        u32 tag = 0x01;
+        u32 opcode = OPC_INB_PHYSTOP;
+        circularQ = &pm8001_ha->inbnd_q_tbl[0];
+        memset(&payload, 0, sizeof(payload));
+        payload.tag = cpu_to_le32(tag);
+        payload.phy_id = cpu_to_le32(phy_id);
+        ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opcode, &payload, 0);
+        return ret;
+}
+
+/**
+ * see comments on pm8001_mpi_reg_resp.
+ */
+static int pm80xx_chip_reg_dev_req(struct pm8001_hba_info *pm8001_ha,
+        struct pm8001_device *pm8001_dev, u32 flag)
+{
+        struct reg_dev_req payload;
+        u32     opc;
+        u32 stp_sspsmp_sata = 0x4;
+        struct inbound_queue_table *circularQ;
+        u32 linkrate, phy_id;
+        int rc, tag = 0xdeadbeef;
+        struct pm8001_ccb_info *ccb;
+        u8 retryFlag = 0x1;
+        u16 firstBurstSize = 0;
+        u16 ITNT = 2000;
+        struct domain_device *dev = pm8001_dev->sas_device;
+        struct domain_device *parent_dev = dev->parent;
+        circularQ = &pm8001_ha->inbnd_q_tbl[0];
+
+        memset(&payload, 0, sizeof(payload));
+        rc = pm8001_tag_alloc(pm8001_ha, &tag);
+        if (rc)
+                return rc;
+        ccb = &pm8001_ha->ccb_info[tag];
+        ccb->device = pm8001_dev;
+        ccb->ccb_tag = tag;
+        payload.tag = cpu_to_le32(tag);
+
+        if (flag == 1) {
+                stp_sspsmp_sata = 0x02; /*direct attached sata */
+        } else {
+                if (pm8001_dev->dev_type == SAS_SATA_DEV)
+                        stp_sspsmp_sata = 0x00; /* stp*/
+                else if (pm8001_dev->dev_type == SAS_END_DEVICE ||
+                        pm8001_dev->dev_type == SAS_EDGE_EXPANDER_DEVICE ||
+                        pm8001_dev->dev_type == SAS_FANOUT_EXPANDER_DEVICE)
+                        stp_sspsmp_sata = 0x01; /*ssp or smp*/
+        }
+        if (parent_dev && DEV_IS_EXPANDER(parent_dev->dev_type))
+                phy_id = parent_dev->ex_dev.ex_phy->phy_id;
+        else
+                phy_id = pm8001_dev->attached_phy;
+
+        opc = OPC_INB_REG_DEV;
+
+        linkrate = (pm8001_dev->sas_device->linkrate < dev->port->linkrate) ?
+                        pm8001_dev->sas_device->linkrate : dev->port->linkrate;
+
+        payload.phyid_portid =
+                cpu_to_le32(((pm8001_dev->sas_device->port->id) & 0xFF) |
+                ((phy_id & 0xFF) << 8));
+
+        payload.dtype_dlr_mcn_ir_retry = cpu_to_le32((retryFlag & 0x01) |
+                ((linkrate & 0x0F) << 24) |
+                ((stp_sspsmp_sata & 0x03) << 28));
+        payload.firstburstsize_ITNexustimeout =
+                cpu_to_le32(ITNT | (firstBurstSize * 0x10000));
+
+        memcpy(payload.sas_addr, pm8001_dev->sas_device->sas_addr,
+                SAS_ADDR_SIZE);
+
+        rc = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &payload, 0);
+
+        return rc;
+}
+
+/**
+ * pm80xx_chip_phy_ctl_req - support the local phy operation
+ * @pm8001_ha: our hba card information.
+ * @num: the inbound queue number
+ * @phy_id: the phy id which we wanted to operate
+ * @phy_op:
+ */
+static int pm80xx_chip_phy_ctl_req(struct pm8001_hba_info *pm8001_ha,
+        u32 phyId, u32 phy_op)
+{
+        struct local_phy_ctl_req payload;
+        struct inbound_queue_table *circularQ;
+        int ret;
+        u32 opc = OPC_INB_LOCAL_PHY_CONTROL;
+        memset(&payload, 0, sizeof(payload));
+        circularQ = &pm8001_ha->inbnd_q_tbl[0];
+        payload.tag = cpu_to_le32(1);
+        payload.phyop_phyid =
+                cpu_to_le32(((phy_op & 0xFF) << 8) | (phyId & 0xFF));
+        ret = pm8001_mpi_build_cmd(pm8001_ha, circularQ, opc, &payload, 0);
+        return ret;
+}
+
+static u32 pm80xx_chip_is_our_interupt(struct pm8001_hba_info *pm8001_ha)
+{
+        u32 value;
+#ifdef PM8001_USE_MSIX
+        return 1;
+#endif
+        value = pm8001_cr32(pm8001_ha, 0, MSGU_ODR);
+        if (value)
+                return 1;
+        return 0;
+
+}
+
+/**
+ * pm8001_chip_isr - PM8001 isr handler.
+ * @pm8001_ha: our hba card information.
+ * @irq: irq number.
+ * @stat: stat.
+ */
+static irqreturn_t
+pm80xx_chip_isr(struct pm8001_hba_info *pm8001_ha, u8 vec)
+{
+        pm80xx_chip_interrupt_disable(pm8001_ha, vec);
+        process_oq(pm8001_ha, vec);
+        pm80xx_chip_interrupt_enable(pm8001_ha, vec);
+        return IRQ_HANDLED;
+}
+
+const struct pm8001_dispatch pm8001_80xx_dispatch = {
+        .name                   = "pmc80xx",
+        .chip_init              = pm80xx_chip_init,
+        .chip_soft_rst          = pm80xx_chip_soft_rst,
+        .chip_rst               = pm80xx_hw_chip_rst,
+        .chip_iounmap           = pm8001_chip_iounmap,
+        .isr                    = pm80xx_chip_isr,
+        .is_our_interupt        = pm80xx_chip_is_our_interupt,
+        .isr_process_oq         = process_oq,
+        .interrupt_enable       = pm80xx_chip_interrupt_enable,
+        .interrupt_disable      = pm80xx_chip_interrupt_disable,
+        .make_prd               = pm8001_chip_make_sg,
+        .smp_req                = pm80xx_chip_smp_req,
+        .ssp_io_req             = pm80xx_chip_ssp_io_req,
+        .sata_req               = pm80xx_chip_sata_req,
+        .phy_start_req          = pm80xx_chip_phy_start_req,
+        .phy_stop_req           = pm80xx_chip_phy_stop_req,
+        .reg_dev_req            = pm80xx_chip_reg_dev_req,
+        .dereg_dev_req          = pm8001_chip_dereg_dev_req,
+        .phy_ctl_req            = pm80xx_chip_phy_ctl_req,
+        .task_abort             = pm8001_chip_abort_task,
+        .ssp_tm_req             = pm8001_chip_ssp_tm_req,
+        .get_nvmd_req           = pm8001_chip_get_nvmd_req,
+        .set_nvmd_req           = pm8001_chip_set_nvmd_req,
+        .fw_flash_update_req    = pm8001_chip_fw_flash_update_req,
+        .set_dev_state_req      = pm8001_chip_set_dev_state_req,
+};
diff --git a/drivers/scsi/pm8001/pm80xx_hwi.h b/drivers/scsi/pm8001/pm80xx_hwi.h
new file mode 100644
index 000000000000..2b760ba75d7b
--- /dev/null
+++ b/drivers/scsi/pm8001/pm80xx_hwi.h
@@ -0,0 +1,1523 @@
+/*
+ * PMC-Sierra SPCv/ve 8088/8089 SAS/SATA based host adapters driver
+ *
+ * Copyright (c) 2008-2009 USI Co., Ltd.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions, and the following disclaimer,
+ *      without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *      substantially similar to the "NO WARRANTY" disclaimer below
+ *      ("Disclaimer") and any redistribution must be conditioned upon
+ *      including a substantially similar Disclaimer requirement for further
+ *      binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *      of any contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ *
+ */
+
+#ifndef _PMC8001_REG_H_
+#define _PMC8001_REG_H_
+
+#include <linux/types.h>
+#include <scsi/libsas.h>
+
+/* for Request Opcode of IOMB */
+#define OPC_INB_ECHO                            1       /* 0x000 */
+#define OPC_INB_PHYSTART                        4       /* 0x004 */
+#define OPC_INB_PHYSTOP                         5       /* 0x005 */
+#define OPC_INB_SSPINIIOSTART                   6       /* 0x006 */
+#define OPC_INB_SSPINITMSTART                   7       /* 0x007 */
+/* 0x8 RESV IN SPCv */
+#define OPC_INB_RSVD                            8       /* 0x008 */
+#define OPC_INB_DEV_HANDLE_ACCEPT               9       /* 0x009 */
+#define OPC_INB_SSPTGTIOSTART                   10      /* 0x00A */
+#define OPC_INB_SSPTGTRSPSTART                  11      /* 0x00B */
+/* 0xC, 0xD, 0xE removed in SPCv */
+#define OPC_INB_SSP_ABORT                       15      /* 0x00F */
+#define OPC_INB_DEREG_DEV_HANDLE                16      /* 0x010 */
+#define OPC_INB_GET_DEV_HANDLE                  17      /* 0x011 */
+#define OPC_INB_SMP_REQUEST                     18      /* 0x012 */
+/* 0x13 SMP_RESPONSE is removed in SPCv */
+#define OPC_INB_SMP_ABORT                       20      /* 0x014 */
+/* 0x16 RESV IN SPCv */
+#define OPC_INB_RSVD1                           22      /* 0x016 */
+#define OPC_INB_SATA_HOST_OPSTART               23      /* 0x017 */
+#define OPC_INB_SATA_ABORT                      24      /* 0x018 */
+#define OPC_INB_LOCAL_PHY_CONTROL               25      /* 0x019 */
+/* 0x1A RESV IN SPCv */
+#define OPC_INB_RSVD2                           26      /* 0x01A */
+#define OPC_INB_FW_FLASH_UPDATE                 32      /* 0x020 */
+#define OPC_INB_GPIO                            34      /* 0x022 */
+#define OPC_INB_SAS_DIAG_MODE_START_END         35      /* 0x023 */
+#define OPC_INB_SAS_DIAG_EXECUTE                36      /* 0x024 */
+/* 0x25 RESV IN SPCv */
+#define OPC_INB_RSVD3                           37      /* 0x025 */
+#define OPC_INB_GET_TIME_STAMP                  38      /* 0x026 */
+#define OPC_INB_PORT_CONTROL                    39      /* 0x027 */
+#define OPC_INB_GET_NVMD_DATA                   40      /* 0x028 */
+#define OPC_INB_SET_NVMD_DATA                   41      /* 0x029 */
+#define OPC_INB_SET_DEVICE_STATE                42      /* 0x02A */
+#define OPC_INB_GET_DEVICE_STATE                43      /* 0x02B */
+#define OPC_INB_SET_DEV_INFO                    44      /* 0x02C */
+/* 0x2D RESV IN SPCv */
+#define OPC_INB_RSVD4                           45      /* 0x02D */
+#define OPC_INB_SGPIO_REGISTER                  46      /* 0x02E */
+#define OPC_INB_PCIE_DIAG_EXEC                  47      /* 0x02F */
+#define OPC_INB_SET_CONTROLLER_CONFIG           48      /* 0x030 */
+#define OPC_INB_GET_CONTROLLER_CONFIG           49      /* 0x031 */
+#define OPC_INB_REG_DEV                         50      /* 0x032 */
+#define OPC_INB_SAS_HW_EVENT_ACK                51      /* 0x033 */
+#define OPC_INB_GET_DEVICE_INFO                 52      /* 0x034 */
+#define OPC_INB_GET_PHY_PROFILE                 53      /* 0x035 */
+#define OPC_INB_FLASH_OP_EXT                    54      /* 0x036 */
+#define OPC_INB_SET_PHY_PROFILE                 55      /* 0x037 */
+#define OPC_INB_KEK_MANAGEMENT                  256     /* 0x100 */
+#define OPC_INB_DEK_MANAGEMENT                  257     /* 0x101 */
+#define OPC_INB_SSP_INI_DIF_ENC_IO              258     /* 0x102 */
+#define OPC_INB_SATA_DIF_ENC_IO                 259     /* 0x103 */
+
+/* for Response Opcode of IOMB */
+#define OPC_OUB_ECHO                                    1       /* 0x001 */
+#define OPC_OUB_RSVD                                    4       /* 0x004 */
+#define OPC_OUB_SSP_COMP                                5       /* 0x005 */
+#define OPC_OUB_SMP_COMP                                6       /* 0x006 */
+#define OPC_OUB_LOCAL_PHY_CNTRL                         7       /* 0x007 */
+#define OPC_OUB_RSVD1                                   10      /* 0x00A */
+#define OPC_OUB_DEREG_DEV                               11      /* 0x00B */
+#define OPC_OUB_GET_DEV_HANDLE                          12      /* 0x00C */
+#define OPC_OUB_SATA_COMP                               13      /* 0x00D */
+#define OPC_OUB_SATA_EVENT                              14      /* 0x00E */
+#define OPC_OUB_SSP_EVENT                               15      /* 0x00F */
+#define OPC_OUB_RSVD2                                   16      /* 0x010 */
+/* 0x11 - SMP_RECEIVED Notification removed in SPCv*/
+#define OPC_OUB_SSP_RECV_EVENT                          18      /* 0x012 */
+#define OPC_OUB_RSVD3                                   19      /* 0x013 */
+#define OPC_OUB_FW_FLASH_UPDATE                         20      /* 0x014 */
+#define OPC_OUB_GPIO_RESPONSE                           22      /* 0x016 */
+#define OPC_OUB_GPIO_EVENT                              23      /* 0x017 */
+#define OPC_OUB_GENERAL_EVENT                           24      /* 0x018 */
+#define OPC_OUB_SSP_ABORT_RSP                           26      /* 0x01A */
+#define OPC_OUB_SATA_ABORT_RSP                          27      /* 0x01B */
+#define OPC_OUB_SAS_DIAG_MODE_START_END                 28      /* 0x01C */
+#define OPC_OUB_SAS_DIAG_EXECUTE                        29      /* 0x01D */
+#define OPC_OUB_GET_TIME_STAMP                          30      /* 0x01E */
+#define OPC_OUB_RSVD4                                   31      /* 0x01F */
+#define OPC_OUB_PORT_CONTROL                            32      /* 0x020 */
+#define OPC_OUB_SKIP_ENTRY                              33      /* 0x021 */
+#define OPC_OUB_SMP_ABORT_RSP                           34      /* 0x022 */
+#define OPC_OUB_GET_NVMD_DATA                           35      /* 0x023 */
+#define OPC_OUB_SET_NVMD_DATA                           36      /* 0x024 */
+#define OPC_OUB_DEVICE_HANDLE_REMOVAL                   37      /* 0x025 */
+#define OPC_OUB_SET_DEVICE_STATE                        38      /* 0x026 */
+#define OPC_OUB_GET_DEVICE_STATE                        39      /* 0x027 */
+#define OPC_OUB_SET_DEV_INFO                            40      /* 0x028 */
+#define OPC_OUB_RSVD5                                   41      /* 0x029 */
+#define OPC_OUB_HW_EVENT                                1792    /* 0x700 */
+#define OPC_OUB_DEV_HANDLE_ARRIV                        1824    /* 0x720 */
+#define OPC_OUB_THERM_HW_EVENT                          1840    /* 0x730 */
+#define OPC_OUB_SGPIO_RESP                              2094    /* 0x82E */
+#define OPC_OUB_PCIE_DIAG_EXECUTE                       2095    /* 0x82F */
+#define OPC_OUB_DEV_REGIST                              2098    /* 0x832 */
+#define OPC_OUB_SAS_HW_EVENT_ACK                        2099    /* 0x833 */
+#define OPC_OUB_GET_DEVICE_INFO                         2100    /* 0x834 */
+/* spcv specific commands */
+#define OPC_OUB_PHY_START_RESP                          2052    /* 0x804 */
+#define OPC_OUB_PHY_STOP_RESP                           2053    /* 0x805 */
+#define OPC_OUB_SET_CONTROLLER_CONFIG                   2096    /* 0x830 */
+#define OPC_OUB_GET_CONTROLLER_CONFIG                   2097    /* 0x831 */
+#define OPC_OUB_GET_PHY_PROFILE                         2101    /* 0x835 */
+#define OPC_OUB_FLASH_OP_EXT                            2102    /* 0x836 */
+#define OPC_OUB_SET_PHY_PROFILE                         2103    /* 0x837 */
+#define OPC_OUB_KEK_MANAGEMENT_RESP                     2304    /* 0x900 */
+#define OPC_OUB_DEK_MANAGEMENT_RESP                     2305    /* 0x901 */
+#define OPC_OUB_SSP_COALESCED_COMP_RESP                 2306    /* 0x902 */
+
+/* for phy start*/
+#define SSC_DISABLE_15                  (0x01 << 16)
+#define SSC_DISABLE_30                  (0x02 << 16)
+#define SSC_DISABLE_60                  (0x04 << 16)
+#define SAS_ASE                         (0x01 << 15)
+#define SPINHOLD_DISABLE                (0x00 << 14)
+#define SPINHOLD_ENABLE                 (0x01 << 14)
+#define LINKMODE_SAS                    (0x01 << 12)
+#define LINKMODE_DSATA                  (0x02 << 12)
+#define LINKMODE_AUTO                   (0x03 << 12)
+#define LINKRATE_15                     (0x01 << 8)
+#define LINKRATE_30                     (0x02 << 8)
+#define LINKRATE_60                     (0x06 << 8)
+
+/* Thermal related */
+#define THERMAL_ENABLE                  0x1
+#define THERMAL_LOG_ENABLE              0x1
+#define THERMAL_OP_CODE                 0x6
+#define LTEMPHIL                         70
+#define RTEMPHIL                        100
+
+/* Encryption info */
+#define SCRATCH_PAD3_ENC_DISABLED       0x00000000
+#define SCRATCH_PAD3_ENC_DIS_ERR        0x00000001
+#define SCRATCH_PAD3_ENC_ENA_ERR        0x00000002
+#define SCRATCH_PAD3_ENC_READY          0x00000003
+#define SCRATCH_PAD3_ENC_MASK           SCRATCH_PAD3_ENC_READY
+
+#define SCRATCH_PAD3_XTS_ENABLED                (1 << 14)
+#define SCRATCH_PAD3_SMA_ENABLED                (1 << 4)
+#define SCRATCH_PAD3_SMB_ENABLED                (1 << 5)
+#define SCRATCH_PAD3_SMF_ENABLED                0
+#define SCRATCH_PAD3_SM_MASK                    0x000000F0
+#define SCRATCH_PAD3_ERR_CODE                   0x00FF0000
+
+#define SEC_MODE_SMF                            0x0
+#define SEC_MODE_SMA                            0x100
+#define SEC_MODE_SMB                            0x200
+#define CIPHER_MODE_ECB                         0x00000001
+#define CIPHER_MODE_XTS                         0x00000002
+#define KEK_MGMT_SUBOP_KEYCARDUPDATE            0x4
+
+/* SAS protocol timer configuration page */
+#define SAS_PROTOCOL_TIMER_CONFIG_PAGE  0x04
+#define STP_MCT_TMO                     32
+#define SSP_MCT_TMO                     32
+#define SAS_MAX_OPEN_TIME                               5
+#define SMP_MAX_CONN_TIMER              0xFF
+#define STP_FRM_TIMER                   0
+#define STP_IDLE_TIME                   5 /* 5 us; controller default */
+#define SAS_MFD                         0
+#define SAS_OPNRJT_RTRY_INTVL           2
+#define SAS_DOPNRJT_RTRY_TMO            128
+#define SAS_COPNRJT_RTRY_TMO            128
+
+/*
+  Making ORR bigger than IT NEXUS LOSS which is 2000000us = 2 second.
+  Assuming a bigger value 3 second, 3000000/128 = 23437.5 where 128
+  is DOPNRJT_RTRY_TMO
+*/
+#define SAS_DOPNRJT_RTRY_THR            23438
+#define SAS_COPNRJT_RTRY_THR            23438
+#define SAS_MAX_AIP                     0x200000
+#define IT_NEXUS_TIMEOUT       0x7D0
+#define PORT_RECOVERY_TIMEOUT  ((IT_NEXUS_TIMEOUT/100) + 30)
+
+struct mpi_msg_hdr {
+        __le32  header; /* Bits [11:0] - Message operation code */
+        /* Bits [15:12] - Message Category */
+        /* Bits [21:16] - Outboundqueue ID for the
+        operation completion message */
+        /* Bits [23:22] - Reserved */
+        /* Bits [28:24] - Buffer Count, indicates how
+        many buffer are allocated for the massage */
+        /* Bits [30:29] - Reserved */
+        /* Bits [31] - Message Valid bit */
+} __attribute__((packed, aligned(4)));
+
+/*
+ * brief the data structure of PHY Start Command
+ * use to describe enable the phy (128 bytes)
+ */
+struct phy_start_req {
+        __le32  tag;
+        __le32  ase_sh_lm_slr_phyid;
+        struct sas_identify_frame sas_identify; /* 28 Bytes */
+        __le32 spasti;
+        u32     reserved[21];
+} __attribute__((packed, aligned(4)));
+
+/*
+ * brief the data structure of PHY Start Command
+ * use to disable the phy (128 bytes)
+ */
+struct phy_stop_req {
+        __le32  tag;
+        __le32  phy_id;
+        u32     reserved[29];
+} __attribute__((packed, aligned(4)));
+
+/* set device bits fis - device to host */
+struct set_dev_bits_fis {
+        u8      fis_type;       /* 0xA1*/
+        u8      n_i_pmport;
+        /* b7 : n Bit. Notification bit. If set device needs attention. */
+        /* b6 : i Bit. Interrupt Bit */
+        /* b5-b4: reserved2 */
+        /* b3-b0: PM Port */
+        u8      status;
+        u8      error;
+        u32     _r_a;
+} __attribute__ ((packed));
+/* PIO setup FIS - device to host */
+struct pio_setup_fis {
+        u8      fis_type;       /* 0x5f */
+        u8      i_d_pmPort;
+        /* b7 : reserved */
+        /* b6 : i bit. Interrupt bit */
+        /* b5 : d bit. data transfer direction. set to 1 for device to host
+        xfer */
+        /* b4 : reserved */
+        /* b3-b0: PM Port */
+        u8      status;
+        u8      error;
+        u8      lbal;
+        u8      lbam;
+        u8      lbah;
+        u8      device;
+        u8      lbal_exp;
+        u8      lbam_exp;
+        u8      lbah_exp;
+        u8      _r_a;
+        u8      sector_count;
+        u8      sector_count_exp;
+        u8      _r_b;
+        u8      e_status;
+        u8      _r_c[2];
+        u8      transfer_count;
+} __attribute__ ((packed));
+
+/*
+ * brief the data structure of SATA Completion Response
+ * use to describe the sata task response (64 bytes)
+ */
+struct sata_completion_resp {
+        __le32  tag;
+        __le32  status;
+        __le32  param;
+        u32     sata_resp[12];
+} __attribute__((packed, aligned(4)));
+
+/*
+ * brief the data structure of SAS HW Event Notification
+ * use to alert the host about the hardware event(64 bytes)
+ */
+/* updated outbound struct for spcv */
+
+struct hw_event_resp {
+        __le32  lr_status_evt_portid;
+        __le32  evt_param;
+        __le32  phyid_npip_portstate;
+        struct sas_identify_frame       sas_identify;
+        struct dev_to_host_fis  sata_fis;
+} __attribute__((packed, aligned(4)));
+
+/*
+ * brief the data structure for thermal event notification
+ */
+
+struct thermal_hw_event {
+        __le32  thermal_event;
+        __le32  rht_lht;
+} __attribute__((packed, aligned(4)));
+
+/*
+ * brief the data structure of REGISTER DEVICE Command
+ * use to describe MPI REGISTER DEVICE Command (64 bytes)
+ */
+
+struct reg_dev_req {
+        __le32  tag;
+        __le32  phyid_portid;
+        __le32  dtype_dlr_mcn_ir_retry;
+        __le32  firstburstsize_ITNexustimeout;
+        u8      sas_addr[SAS_ADDR_SIZE];
+        __le32  upper_device_id;
+        u32     reserved[24];
+} __attribute__((packed, aligned(4)));
+
+/*
+ * brief the data structure of DEREGISTER DEVICE Command
+ * use to request spc to remove all internal resources associated
+ * with the device id (64 bytes)
+ */
+
+struct dereg_dev_req {
+        __le32  tag;
+        __le32  device_id;
+        u32     reserved[29];
+} __attribute__((packed, aligned(4)));
+
+/*
+ * brief the data structure of DEVICE_REGISTRATION Response
+ * use to notify the completion of the device registration (64 bytes)
+ */
+struct dev_reg_resp {
+        __le32  tag;
+        __le32  status;
+        __le32  device_id;
+        u32     reserved[12];
+} __attribute__((packed, aligned(4)));
+
+/*
+ * brief the data structure of Local PHY Control Command
+ * use to issue PHY CONTROL to local phy (64 bytes)
+ */
+struct local_phy_ctl_req {
+        __le32  tag;
+        __le32  phyop_phyid;
+        u32     reserved1[29];
+} __attribute__((packed, aligned(4)));
+
+/**
+ * brief the data structure of Local Phy Control Response
+ * use to describe MPI Local Phy Control Response (64 bytes)
+ */
+ struct local_phy_ctl_resp {
+        __le32  tag;
+        __le32  phyop_phyid;
+        __le32  status;
+        u32     reserved[12];
+} __attribute__((packed, aligned(4)));
+
+#define OP_BITS 0x0000FF00
+#define ID_BITS 0x000000FF
+
+/*
+ * brief the data structure of PORT Control Command
+ * use to control port properties (64 bytes)
+ */
+
+struct port_ctl_req {
+        __le32  tag;
+        __le32  portop_portid;
+        __le32  param0;
+        __le32  param1;
+        u32     reserved1[27];
+} __attribute__((packed, aligned(4)));
+
+/*
+ * brief the data structure of HW Event Ack Command
+ * use to acknowledge receive HW event (64 bytes)
+ */
+struct hw_event_ack_req {
+        __le32  tag;
+        __le32  phyid_sea_portid;
+        __le32  param0;
+        __le32  param1;
+        u32     reserved1[27];
+} __attribute__((packed, aligned(4)));
+
+/*
+ * brief the data structure of PHY_START Response Command
+ * indicates the completion of PHY_START command (64 bytes)
+ */
+struct phy_start_resp {
+        __le32  tag;
+        __le32  status;
+        __le32  phyid;
+        u32     reserved[12];
+} __attribute__((packed, aligned(4)));
+
+/*
+ * brief the data structure of PHY_STOP Response Command
+ * indicates the completion of PHY_STOP command (64 bytes)
+ */
+struct phy_stop_resp {
+        __le32  tag;
+        __le32  status;
+        __le32  phyid;
+        u32     reserved[12];
+} __attribute__((packed, aligned(4)));
+
+/*
+ * brief the data structure of SSP Completion Response
+ * use to indicate a SSP Completion (n bytes)
+ */
+struct ssp_completion_resp {
+        __le32  tag;
+        __le32  status;
+        __le32  param;
+        __le32  ssptag_rescv_rescpad;
+        struct ssp_response_iu ssp_resp_iu;
+        __le32  residual_count;
+} __attribute__((packed, aligned(4)));
+
+#define SSP_RESCV_BIT   0x00010000
+
+/*
+ * brief the data structure of SATA EVNET response
+ * use to indicate a SATA Completion (64 bytes)
+ */
+struct sata_event_resp {
+        __le32 tag;
+        __le32 event;
+        __le32 port_id;
+        __le32 device_id;
+        u32 reserved;
+        __le32 event_param0;
+        __le32 event_param1;
+        __le32 sata_addr_h32;
+        __le32 sata_addr_l32;
+        __le32 e_udt1_udt0_crc;
+        __le32 e_udt5_udt4_udt3_udt2;
+        __le32 a_udt1_udt0_crc;
+        __le32 a_udt5_udt4_udt3_udt2;
+        __le32 hwdevid_diferr;
+        __le32 err_framelen_byteoffset;
+        __le32 err_dataframe;
+} __attribute__((packed, aligned(4)));
+
+/*
+ * brief the data structure of SSP EVNET esponse
+ * use to indicate a SSP Completion (64 bytes)
+ */
+struct ssp_event_resp {
+        __le32 tag;
+        __le32 event;
+        __le32 port_id;
+        __le32 device_id;
+        __le32 ssp_tag;
+        __le32 event_param0;
+        __le32 event_param1;
+        __le32 sas_addr_h32;
+        __le32 sas_addr_l32;
+        __le32 e_udt1_udt0_crc;
+        __le32 e_udt5_udt4_udt3_udt2;
+        __le32 a_udt1_udt0_crc;
+        __le32 a_udt5_udt4_udt3_udt2;
+        __le32 hwdevid_diferr;
+        __le32 err_framelen_byteoffset;
+        __le32 err_dataframe;
+} __attribute__((packed, aligned(4)));
+
+/**
+ * brief the data structure of General Event Notification Response
+ * use to describe MPI General Event Notification Response (64 bytes)
+ */
+struct general_event_resp {
+        __le32  status;
+        __le32  inb_IOMB_payload[14];
+} __attribute__((packed, aligned(4)));
+
+#define GENERAL_EVENT_PAYLOAD   14
+#define OPCODE_BITS     0x00000fff
+
+/*
+ * brief the data structure of SMP Request Command
+ * use to describe MPI SMP REQUEST Command (64 bytes)
+ */
+struct smp_req {
+        __le32  tag;
+        __le32  device_id;
+        __le32  len_ip_ir;
+        /* Bits [0] - Indirect response */
+        /* Bits [1] - Indirect Payload */
+        /* Bits [15:2] - Reserved */
+        /* Bits [23:16] - direct payload Len */
+        /* Bits [31:24] - Reserved */
+        u8      smp_req16[16];
+        union {
+                u8      smp_req[32];
+                struct {
+                        __le64 long_req_addr;/* sg dma address, LE */
+                        __le32 long_req_size;/* LE */
+                        u32     _r_a;
+                        __le64 long_resp_addr;/* sg dma address, LE */
+                        __le32 long_resp_size;/* LE */
+                        u32     _r_b;
+                        } long_smp_req;/* sequencer extension */
+        };
+        __le32  rsvd[16];
+} __attribute__((packed, aligned(4)));
+/*
+ * brief the data structure of SMP Completion Response
+ * use to describe MPI SMP Completion Response (64 bytes)
+ */
+struct smp_completion_resp {
+        __le32  tag;
+        __le32  status;
+        __le32  param;
+        u8      _r_a[252];
+} __attribute__((packed, aligned(4)));
+
+/*
+ *brief the data structure of SSP SMP SATA Abort Command
+ * use to describe MPI SSP SMP & SATA Abort Command (64 bytes)
+ */
+struct task_abort_req {
+        __le32  tag;
+        __le32  device_id;
+        __le32  tag_to_abort;
+        __le32  abort_all;
+        u32     reserved[27];
+} __attribute__((packed, aligned(4)));
+
+/* These flags used for SSP SMP & SATA Abort */
+#define ABORT_MASK              0x3
+#define ABORT_SINGLE            0x0
+#define ABORT_ALL               0x1
+
+/**
+ * brief the data structure of SSP SATA SMP Abort Response
+ * use to describe SSP SMP & SATA Abort Response ( 64 bytes)
+ */
+struct task_abort_resp {
+        __le32  tag;
+        __le32  status;
+        __le32  scp;
+        u32     reserved[12];
+} __attribute__((packed, aligned(4)));
+
+/**
+ * brief the data structure of SAS Diagnostic Start/End Command
+ * use to describe MPI SAS Diagnostic Start/End Command (64 bytes)
+ */
+struct sas_diag_start_end_req {
+        __le32  tag;
+        __le32  operation_phyid;
+        u32     reserved[29];
+} __attribute__((packed, aligned(4)));
+
+/**
+ * brief the data structure of SAS Diagnostic Execute Command
+ * use to describe MPI SAS Diagnostic Execute Command (64 bytes)
+ */
+struct sas_diag_execute_req {
+        __le32  tag;
+        __le32  cmdtype_cmddesc_phyid;
+        __le32  pat1_pat2;
+        __le32  threshold;
+        __le32  codepat_errmsk;
+        __le32  pmon;
+        __le32  pERF1CTL;
+        u32     reserved[24];
+} __attribute__((packed, aligned(4)));
+
+#define SAS_DIAG_PARAM_BYTES 24
+
+/*
+ * brief the data structure of Set Device State Command
+ * use to describe MPI Set Device State Command (64 bytes)
+ */
+struct set_dev_state_req {
+        __le32  tag;
+        __le32  device_id;
+        __le32  nds;
+        u32     reserved[28];
+} __attribute__((packed, aligned(4)));
+
+/*
+ * brief the data structure of SATA Start Command
+ * use to describe MPI SATA IO Start Command (64 bytes)
+ * Note: This structure is common for normal / encryption I/O
+ */
+
+struct sata_start_req {
+        __le32  tag;
+        __le32  device_id;
+        __le32  data_len;
+        __le32  ncqtag_atap_dir_m_dad;
+        struct host_to_dev_fis  sata_fis;
+        u32     reserved1;
+        u32     reserved2;      /* dword 11. rsvd for normal I/O. */
+                                /* EPLE Descl for enc I/O */
+        u32     addr_low;       /* dword 12. rsvd for enc I/O */
+        u32     addr_high;      /* dword 13. reserved for enc I/O */
+        __le32  len;            /* dword 14: length for normal I/O. */
+                                /* EPLE Desch for enc I/O */
+        __le32  esgl;           /* dword 15. rsvd for enc I/O */
+        __le32  atapi_scsi_cdb[4];      /* dword 16-19. rsvd for enc I/O */
+        /* The below fields are reserved for normal I/O */
+        __le32  key_index_mode; /* dword 20 */
+        __le32  sector_cnt_enss;/* dword 21 */
+        __le32  keytagl;        /* dword 22 */
+        __le32  keytagh;        /* dword 23 */
+        __le32  twk_val0;       /* dword 24 */
+        __le32  twk_val1;       /* dword 25 */
+        __le32  twk_val2;       /* dword 26 */
+        __le32  twk_val3;       /* dword 27 */
+        __le32  enc_addr_low;   /* dword 28. Encryption SGL address high */
+        __le32  enc_addr_high;  /* dword 29. Encryption SGL address low */
+        __le32  enc_len;        /* dword 30. Encryption length */
+        __le32  enc_esgl;       /* dword 31. Encryption esgl bit */
+} __attribute__((packed, aligned(4)));
+
+/**
+ * brief the data structure of SSP INI TM Start Command
+ * use to describe MPI SSP INI TM Start Command (64 bytes)
+ */
+struct ssp_ini_tm_start_req {
+        __le32  tag;
+        __le32  device_id;
+        __le32  relate_tag;
+        __le32  tmf;
+        u8      lun[8];
+        __le32  ds_ads_m;
+        u32     reserved[24];
+} __attribute__((packed, aligned(4)));
+
+struct ssp_info_unit {
+        u8      lun[8];/* SCSI Logical Unit Number */
+        u8      reserved1;/* reserved */
+        u8      efb_prio_attr;
+        /* B7 : enabledFirstBurst */
+        /* B6-3 : taskPriority */
+        /* B2-0 : taskAttribute */
+        u8      reserved2;      /* reserved */
+        u8      additional_cdb_len;
+        /* B7-2 : additional_cdb_len */
+        /* B1-0 : reserved */
+        u8      cdb[16];/* The SCSI CDB up to 16 bytes length */
+} __attribute__((packed, aligned(4)));
+
+/**
+ * brief the data structure of SSP INI IO Start Command
+ * use to describe MPI SSP INI IO Start Command (64 bytes)
+ * Note: This structure is common for normal / encryption I/O
+ */
+struct ssp_ini_io_start_req {
+        __le32  tag;
+        __le32  device_id;
+        __le32  data_len;
+        __le32  dad_dir_m_tlr;
+        struct ssp_info_unit    ssp_iu;
+        __le32  addr_low;       /* dword 12: sgl low for normal I/O. */
+                                /* epl_descl for encryption I/O */
+        __le32  addr_high;      /* dword 13: sgl hi for normal I/O */
+                                /* dpl_descl for encryption I/O */
+        __le32  len;            /* dword 14: len for normal I/O. */
+                                /* edpl_desch for encryption I/O */
+        __le32  esgl;           /* dword 15: ESGL bit for normal I/O. */
+                                /* user defined tag mask for enc I/O */
+        /* The below fields are reserved for normal I/O */
+        u8      udt[12];        /* dword 16-18 */
+        __le32  sectcnt_ios;    /* dword 19 */
+        __le32  key_cmode;      /* dword 20 */
+        __le32  ks_enss;        /* dword 21 */
+        __le32  keytagl;        /* dword 22 */
+        __le32  keytagh;        /* dword 23 */
+        __le32  twk_val0;       /* dword 24 */
+        __le32  twk_val1;       /* dword 25 */
+        __le32  twk_val2;       /* dword 26 */
+        __le32  twk_val3;       /* dword 27 */
+        __le32  enc_addr_low;   /* dword 28: Encryption sgl addr low */
+        __le32  enc_addr_high;  /* dword 29: Encryption sgl addr hi */
+        __le32  enc_len;        /* dword 30: Encryption length */
+        __le32  enc_esgl;       /* dword 31: ESGL bit for encryption */
+} __attribute__((packed, aligned(4)));
+
+/**
+ * brief the data structure for SSP_INI_DIF_ENC_IO COMMAND
+ * use to initiate SSP I/O operation with optional DIF/ENC
+ */
+struct ssp_dif_enc_io_req {
+        __le32  tag;
+        __le32  device_id;
+        __le32  data_len;
+        __le32  dirMTlr;
+        __le32  sspiu0;
+        __le32  sspiu1;
+        __le32  sspiu2;
+        __le32  sspiu3;
+        __le32  sspiu4;
+        __le32  sspiu5;
+        __le32  sspiu6;
+        __le32  epl_des;
+        __le32  dpl_desl_ndplr;
+        __le32  dpl_desh;
+        __le32  uum_uuv_bss_difbits;
+        u8      udt[12];
+        __le32  sectcnt_ios;
+        __le32  key_cmode;
+        __le32  ks_enss;
+        __le32  keytagl;
+        __le32  keytagh;
+        __le32  twk_val0;
+        __le32  twk_val1;
+        __le32  twk_val2;
+        __le32  twk_val3;
+        __le32  addr_low;
+        __le32  addr_high;
+        __le32  len;
+        __le32  esgl;
+} __attribute__((packed, aligned(4)));
+
+/**
+ * brief the data structure of Firmware download
+ * use to describe MPI FW DOWNLOAD Command (64 bytes)
+ */
+struct fw_flash_Update_req {
+        __le32  tag;
+        __le32  cur_image_offset;
+        __le32  cur_image_len;
+        __le32  total_image_len;
+        u32     reserved0[7];
+        __le32  sgl_addr_lo;
+        __le32  sgl_addr_hi;
+        __le32  len;
+        __le32  ext_reserved;
+        u32     reserved1[16];
+} __attribute__((packed, aligned(4)));
+
+#define FWFLASH_IOMB_RESERVED_LEN 0x07
+/**
+ * brief the data structure of FW_FLASH_UPDATE Response
+ * use to describe MPI FW_FLASH_UPDATE Response (64 bytes)
+ *
+ */
+ struct fw_flash_Update_resp {
+        __le32  tag;
+        __le32  status;
+        u32     reserved[13];
+} __attribute__((packed, aligned(4)));
+
+/**
+ * brief the data structure of Get NVM Data Command
+ * use to get data from NVM in HBA(64 bytes)
+ */
+struct get_nvm_data_req {
+        __le32  tag;
+        __le32  len_ir_vpdd;
+        __le32  vpd_offset;
+        u32     reserved[8];
+        __le32  resp_addr_lo;
+        __le32  resp_addr_hi;
+        __le32  resp_len;
+        u32     reserved1[17];
+} __attribute__((packed, aligned(4)));
+
+struct set_nvm_data_req {
+        __le32  tag;
+        __le32  len_ir_vpdd;
+        __le32  vpd_offset;
+        u32     reserved[8];
+        __le32  resp_addr_lo;
+        __le32  resp_addr_hi;
+        __le32  resp_len;
+        u32     reserved1[17];
+} __attribute__((packed, aligned(4)));
+
+/**
+ * brief the data structure for SET CONTROLLER CONFIG COMMAND
+ * use to modify controller configuration
+ */
+struct set_ctrl_cfg_req {
+        __le32  tag;
+        __le32  cfg_pg[14];
+        u32     reserved[16];
+} __attribute__((packed, aligned(4)));
+
+/**
+ * brief the data structure for GET CONTROLLER CONFIG COMMAND
+ * use to get controller configuration page
+ */
+struct get_ctrl_cfg_req {
+        __le32  tag;
+        __le32  pgcd;
+        __le32  int_vec;
+        u32     reserved[28];
+} __attribute__((packed, aligned(4)));
+
+/**
+ * brief the data structure for KEK_MANAGEMENT COMMAND
+ * use for KEK management
+ */
+struct kek_mgmt_req {
+        __le32  tag;
+        __le32  new_curidx_ksop;
+        u32     reserved;
+        __le32  kblob[12];
+        u32     reserved1[16];
+} __attribute__((packed, aligned(4)));
+
+/**
+ * brief the data structure for DEK_MANAGEMENT COMMAND
+ * use for DEK management
+ */
+struct dek_mgmt_req {
+        __le32  tag;
+        __le32  kidx_dsop;
+        __le32  dekidx;
+        __le32  addr_l;
+        __le32  addr_h;
+        __le32  nent;
+        __le32  dbf_tblsize;
+        u32     reserved[24];
+} __attribute__((packed, aligned(4)));
+
+/**
+ * brief the data structure for SET PHY PROFILE COMMAND
+ * use to retrive phy specific information
+ */
+struct set_phy_profile_req {
+        __le32  tag;
+        __le32  ppc_phyid;
+        u32     reserved[29];
+} __attribute__((packed, aligned(4)));
+
+/**
+ * brief the data structure for GET PHY PROFILE COMMAND
+ * use to retrive phy specific information
+ */
+struct get_phy_profile_req {
+        __le32  tag;
+        __le32  ppc_phyid;
+        __le32  profile[29];
+} __attribute__((packed, aligned(4)));
+
+/**
+ * brief the data structure for EXT FLASH PARTITION
+ * use to manage ext flash partition
+ */
+struct ext_flash_partition_req {
+        __le32  tag;
+        __le32  cmd;
+        __le32  offset;
+        __le32  len;
+        u32     reserved[7];
+        __le32  addr_low;
+        __le32  addr_high;
+        __le32  len1;
+        __le32  ext;
+        u32     reserved1[16];
+} __attribute__((packed, aligned(4)));
+
+#define TWI_DEVICE      0x0
+#define C_SEEPROM       0x1
+#define VPD_FLASH       0x4
+#define AAP1_RDUMP      0x5
+#define IOP_RDUMP       0x6
+#define EXPAN_ROM       0x7
+
+#define IPMode          0x80000000
+#define NVMD_TYPE       0x0000000F
+#define NVMD_STAT       0x0000FFFF
+#define NVMD_LEN        0xFF000000
+/**
+ * brief the data structure of Get NVMD Data Response
+ * use to describe MPI Get NVMD Data Response (64 bytes)
+ */
+struct get_nvm_data_resp {
+        __le32          tag;
+        __le32          ir_tda_bn_dps_das_nvm;
+        __le32          dlen_status;
+        __le32          nvm_data[12];
+} __attribute__((packed, aligned(4)));
+
+/**
+ * brief the data structure of SAS Diagnostic Start/End Response
+ * use to describe MPI SAS Diagnostic Start/End Response (64 bytes)
+ *
+ */
+struct sas_diag_start_end_resp {
+        __le32          tag;
+        __le32          status;
+        u32             reserved[13];
+} __attribute__((packed, aligned(4)));
+
+/**
+ * brief the data structure of SAS Diagnostic Execute Response
+ * use to describe MPI SAS Diagnostic Execute Response (64 bytes)
+ *
+ */
+struct sas_diag_execute_resp {
+        __le32          tag;
+        __le32          cmdtype_cmddesc_phyid;
+        __le32          Status;
+        __le32          ReportData;
+        u32             reserved[11];
+} __attribute__((packed, aligned(4)));
+
+/**
+ * brief the data structure of Set Device State Response
+ * use to describe MPI Set Device State Response (64 bytes)
+ *
+ */
+struct set_dev_state_resp {
+        __le32          tag;
+        __le32          status;
+        __le32          device_id;
+        __le32          pds_nds;
+        u32             reserved[11];
+} __attribute__((packed, aligned(4)));
+
+/* new outbound structure for spcv - begins */
+/**
+ * brief the data structure for SET CONTROLLER CONFIG COMMAND
+ * use to modify controller configuration
+ */
+struct set_ctrl_cfg_resp {
+        __le32 tag;
+        __le32 status;
+        __le32 err_qlfr_pgcd;
+        u32 reserved[12];
+} __attribute__((packed, aligned(4)));
+
+struct get_ctrl_cfg_resp {
+        __le32 tag;
+        __le32 status;
+        __le32 err_qlfr;
+        __le32 confg_page[12];
+} __attribute__((packed, aligned(4)));
+
+struct kek_mgmt_resp {
+        __le32 tag;
+        __le32 status;
+        __le32 kidx_new_curr_ksop;
+        __le32 err_qlfr;
+        u32 reserved[11];
+} __attribute__((packed, aligned(4)));
+
+struct dek_mgmt_resp {
+        __le32 tag;
+        __le32 status;
+        __le32 kekidx_tbls_dsop;
+        __le32 dekidx;
+        __le32 err_qlfr;
+        u32 reserved[10];
+} __attribute__((packed, aligned(4)));
+
+struct get_phy_profile_resp {
+        __le32 tag;
+        __le32 status;
+        __le32 ppc_phyid;
+        __le32 ppc_specific_rsp[12];
+} __attribute__((packed, aligned(4)));
+
+struct flash_op_ext_resp {
+        __le32 tag;
+        __le32 cmd;
+        __le32 status;
+        __le32 epart_size;
+        __le32 epart_sect_size;
+        u32 reserved[10];
+} __attribute__((packed, aligned(4)));
+
+struct set_phy_profile_resp {
+        __le32 tag;
+        __le32 status;
+        __le32 ppc_phyid;
+        __le32 ppc_specific_rsp[12];
+} __attribute__((packed, aligned(4)));
+
+struct ssp_coalesced_comp_resp {
+        __le32 coal_cnt;
+        __le32 tag0;
+        __le32 ssp_tag0;
+        __le32 tag1;
+        __le32 ssp_tag1;
+        __le32 add_tag_ssp_tag[10];
+} __attribute__((packed, aligned(4)));
+
+/* new outbound structure for spcv - ends */
+
+/* brief data structure for SAS protocol timer configuration page.
+ *
+ */
+struct SASProtocolTimerConfig {
+        __le32 pageCode;                        /* 0 */
+        __le32 MST_MSI;                         /* 1 */
+        __le32 STP_SSP_MCT_TMO;                 /* 2 */
+        __le32 STP_FRM_TMO;                     /* 3 */
+        __le32 STP_IDLE_TMO;                    /* 4 */
+        __le32 OPNRJT_RTRY_INTVL;               /* 5 */
+        __le32 Data_Cmd_OPNRJT_RTRY_TMO;        /* 6 */
+        __le32 Data_Cmd_OPNRJT_RTRY_THR;        /* 7 */
+        __le32 MAX_AIP;                         /* 8 */
+} __attribute__((packed, aligned(4)));
+
+typedef struct SASProtocolTimerConfig SASProtocolTimerConfig_t;
+
+#define NDS_BITS 0x0F
+#define PDS_BITS 0xF0
+
+/*
+ * HW Events type
+ */
+
+#define HW_EVENT_RESET_START                    0x01
+#define HW_EVENT_CHIP_RESET_COMPLETE            0x02
+#define HW_EVENT_PHY_STOP_STATUS                0x03
+#define HW_EVENT_SAS_PHY_UP                     0x04
+#define HW_EVENT_SATA_PHY_UP                    0x05
+#define HW_EVENT_SATA_SPINUP_HOLD               0x06
+#define HW_EVENT_PHY_DOWN                       0x07
+#define HW_EVENT_PORT_INVALID                   0x08
+#define HW_EVENT_BROADCAST_CHANGE               0x09
+#define HW_EVENT_PHY_ERROR                      0x0A
+#define HW_EVENT_BROADCAST_SES                  0x0B
+#define HW_EVENT_INBOUND_CRC_ERROR              0x0C
+#define HW_EVENT_HARD_RESET_RECEIVED            0x0D
+#define HW_EVENT_MALFUNCTION                    0x0E
+#define HW_EVENT_ID_FRAME_TIMEOUT               0x0F
+#define HW_EVENT_BROADCAST_EXP                  0x10
+#define HW_EVENT_PHY_START_STATUS               0x11
+#define HW_EVENT_LINK_ERR_INVALID_DWORD         0x12
+#define HW_EVENT_LINK_ERR_DISPARITY_ERROR       0x13
+#define HW_EVENT_LINK_ERR_CODE_VIOLATION        0x14
+#define HW_EVENT_LINK_ERR_LOSS_OF_DWORD_SYNCH   0x15
+#define HW_EVENT_LINK_ERR_PHY_RESET_FAILED      0x16
+#define HW_EVENT_PORT_RECOVERY_TIMER_TMO        0x17
+#define HW_EVENT_PORT_RECOVER                   0x18
+#define HW_EVENT_PORT_RESET_TIMER_TMO           0x19
+#define HW_EVENT_PORT_RESET_COMPLETE            0x20
+#define EVENT_BROADCAST_ASYNCH_EVENT            0x21
+
+/* port state */
+#define PORT_NOT_ESTABLISHED                    0x00
+#define PORT_VALID                              0x01
+#define PORT_LOSTCOMM                           0x02
+#define PORT_IN_RESET                           0x04
+#define PORT_3RD_PARTY_RESET                    0x07
+#define PORT_INVALID                            0x08
+
+/*
+ * SSP/SMP/SATA IO Completion Status values
+ */
+
+#define IO_SUCCESS                              0x00
+#define IO_ABORTED                              0x01
+#define IO_OVERFLOW                             0x02
+#define IO_UNDERFLOW                            0x03
+#define IO_FAILED                               0x04
+#define IO_ABORT_RESET                          0x05
+#define IO_NOT_VALID                            0x06
+#define IO_NO_DEVICE                            0x07
+#define IO_ILLEGAL_PARAMETER                    0x08
+#define IO_LINK_FAILURE                         0x09
+#define IO_PROG_ERROR                           0x0A
+
+#define IO_EDC_IN_ERROR                         0x0B
+#define IO_EDC_OUT_ERROR                        0x0C
+#define IO_ERROR_HW_TIMEOUT                     0x0D
+#define IO_XFER_ERROR_BREAK                     0x0E
+#define IO_XFER_ERROR_PHY_NOT_READY             0x0F
+#define IO_OPEN_CNX_ERROR_PROTOCOL_NOT_SUPPORTED        0x10
+#define IO_OPEN_CNX_ERROR_ZONE_VIOLATION                0x11
+#define IO_OPEN_CNX_ERROR_BREAK                         0x12
+#define IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS                 0x13
+#define IO_OPEN_CNX_ERROR_BAD_DESTINATION               0x14
+#define IO_OPEN_CNX_ERROR_CONNECTION_RATE_NOT_SUPPORTED 0x15
+#define IO_OPEN_CNX_ERROR_STP_RESOURCES_BUSY            0x16
+#define IO_OPEN_CNX_ERROR_WRONG_DESTINATION             0x17
+/* This error code 0x18 is not used on SPCv */
+#define IO_OPEN_CNX_ERROR_UNKNOWN_ERROR                 0x18
+#define IO_XFER_ERROR_NAK_RECEIVED                      0x19
+#define IO_XFER_ERROR_ACK_NAK_TIMEOUT                   0x1A
+#define IO_XFER_ERROR_PEER_ABORTED                      0x1B
+#define IO_XFER_ERROR_RX_FRAME                          0x1C
+#define IO_XFER_ERROR_DMA                               0x1D
+#define IO_XFER_ERROR_CREDIT_TIMEOUT                    0x1E
+#define IO_XFER_ERROR_SATA_LINK_TIMEOUT                 0x1F
+#define IO_XFER_ERROR_SATA                              0x20
+
+/* This error code 0x22 is not used on SPCv */
+#define IO_XFER_ERROR_ABORTED_DUE_TO_SRST               0x22
+#define IO_XFER_ERROR_REJECTED_NCQ_MODE                 0x21
+#define IO_XFER_ERROR_ABORTED_NCQ_MODE                  0x23
+#define IO_XFER_OPEN_RETRY_TIMEOUT                      0x24
+/* This error code 0x25 is not used on SPCv */
+#define IO_XFER_SMP_RESP_CONNECTION_ERROR               0x25
+#define IO_XFER_ERROR_UNEXPECTED_PHASE                  0x26
+#define IO_XFER_ERROR_XFER_RDY_OVERRUN                  0x27
+#define IO_XFER_ERROR_XFER_RDY_NOT_EXPECTED             0x28
+#define IO_XFER_ERROR_CMD_ISSUE_ACK_NAK_TIMEOUT         0x30
+
+/* The following error code 0x31 and 0x32 are not using (obsolete) */
+#define IO_XFER_ERROR_CMD_ISSUE_BREAK_BEFORE_ACK_NAK    0x31
+#define IO_XFER_ERROR_CMD_ISSUE_PHY_DOWN_BEFORE_ACK_NAK 0x32
+
+#define IO_XFER_ERROR_OFFSET_MISMATCH                   0x34
+#define IO_XFER_ERROR_XFER_ZERO_DATA_LEN                0x35
+#define IO_XFER_CMD_FRAME_ISSUED                        0x36
+#define IO_ERROR_INTERNAL_SMP_RESOURCE                  0x37
+#define IO_PORT_IN_RESET                                0x38
+#define IO_DS_NON_OPERATIONAL                           0x39
+#define IO_DS_IN_RECOVERY                               0x3A
+#define IO_TM_TAG_NOT_FOUND                             0x3B
+#define IO_XFER_PIO_SETUP_ERROR                         0x3C
+#define IO_SSP_EXT_IU_ZERO_LEN_ERROR                    0x3D
+#define IO_DS_IN_ERROR                                  0x3E
+#define IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY              0x3F
+#define IO_ABORT_IN_PROGRESS                            0x40
+#define IO_ABORT_DELAYED                                0x41
+#define IO_INVALID_LENGTH                               0x42
+
+/********** additional response event values *****************/
+
+#define IO_OPEN_CNX_ERROR_HW_RESOURCE_BUSY_ALT          0x43
+#define IO_XFER_OPEN_RETRY_BACKOFF_THRESHOLD_REACHED    0x44
+#define IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_TMO        0x45
+#define IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_NO_DEST         0x46
+#define IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_OPEN_COLLIDE    0x47
+#define IO_OPEN_CNX_ERROR_IT_NEXUS_LOSS_PATHWAY_BLOCKED 0x48
+#define IO_DS_INVALID                                   0x49
+/* WARNING: the value is not contiguous from here */
+#define IO_XFER_ERR_LAST_PIO_DATAIN_CRC_ERR     0x52
+#define IO_XFER_DMA_ACTIVATE_TIMEOUT            0x53
+#define IO_XFER_ERROR_INTERNAL_CRC_ERROR        0x54
+#define MPI_IO_RQE_BUSY_FULL                    0x55
+#define IO_XFER_ERR_EOB_DATA_OVERRUN            0x56
+#define IO_XFR_ERROR_INVALID_SSP_RSP_FRAME      0x57
+#define IO_OPEN_CNX_ERROR_OPEN_PREEMPTED        0x58
+
+#define MPI_ERR_IO_RESOURCE_UNAVAILABLE         0x1004
+#define MPI_ERR_ATAPI_DEVICE_BUSY               0x1024
+
+#define IO_XFR_ERROR_DEK_KEY_CACHE_MISS         0x2040
+/*
+ * An encryption IO request failed due to DEK Key Tag mismatch.
+ * The key tag supplied in the encryption IOMB does not match with
+ * the Key Tag in the referenced DEK Entry.
+ */
+#define IO_XFR_ERROR_DEK_KEY_TAG_MISMATCH       0x2041
+#define IO_XFR_ERROR_CIPHER_MODE_INVALID        0x2042
+/*
+ * An encryption I/O request failed because the initial value (IV)
+ * in the unwrapped DEK blob didn't match the IV used to unwrap it.
+ */
+#define IO_XFR_ERROR_DEK_IV_MISMATCH            0x2043
+/* An encryption I/O request failed due to an internal RAM ECC or
+ * interface error while unwrapping the DEK. */
+#define IO_XFR_ERROR_DEK_RAM_INTERFACE_ERROR    0x2044
+/* An encryption I/O request failed due to an internal RAM ECC or
+ * interface error while unwrapping the DEK. */
+#define IO_XFR_ERROR_INTERNAL_RAM               0x2045
+/*
+ * An encryption I/O request failed
+ * because the DEK index specified in the I/O was outside the bounds of
+ * the total number of entries in the host DEK table.
+ */
+#define IO_XFR_ERROR_DEK_INDEX_OUT_OF_BOUNDS0x2046
+
+/* define DIF IO response error status code */
+#define IO_XFR_ERROR_DIF_MISMATCH                       0x3000
+#define IO_XFR_ERROR_DIF_APPLICATION_TAG_MISMATCH       0x3001
+#define IO_XFR_ERROR_DIF_REFERENCE_TAG_MISMATCH         0x3002
+#define IO_XFR_ERROR_DIF_CRC_MISMATCH                   0x3003
+
+/* define operator management response status and error qualifier code */
+#define OPR_MGMT_OP_NOT_SUPPORTED                       0x2060
+#define OPR_MGMT_MPI_ENC_ERR_OPR_PARAM_ILLEGAL          0x2061
+#define OPR_MGMT_MPI_ENC_ERR_OPR_ID_NOT_FOUND           0x2062
+#define OPR_MGMT_MPI_ENC_ERR_OPR_ROLE_NOT_MATCH         0x2063
+#define OPR_MGMT_MPI_ENC_ERR_OPR_MAX_NUM_EXCEEDED       0x2064
+#define OPR_MGMT_MPI_ENC_ERR_KEK_UNWRAP_FAIL            0x2022
+#define OPR_MGMT_MPI_ENC_ERR_NVRAM_OPERATION_FAILURE    0x2023
+/***************** additional response event values ***************/
+
+/* WARNING: This error code must always be the last number.
+ * If you add error code, modify this code also
+ * It is used as an index
+ */
+#define IO_ERROR_UNKNOWN_GENERIC                        0x2023
+
+/* MSGU CONFIGURATION TABLE*/
+
+#define SPCv_MSGU_CFG_TABLE_UPDATE              0x01
+#define SPCv_MSGU_CFG_TABLE_RESET               0x02
+#define SPCv_MSGU_CFG_TABLE_FREEZE              0x04
+#define SPCv_MSGU_CFG_TABLE_UNFREEZE            0x08
+#define MSGU_IBDB_SET                           0x00
+#define MSGU_HOST_INT_STATUS                    0x08
+#define MSGU_HOST_INT_MASK                      0x0C
+#define MSGU_IOPIB_INT_STATUS                   0x18
+#define MSGU_IOPIB_INT_MASK                     0x1C
+#define MSGU_IBDB_CLEAR                         0x20
+
+#define MSGU_MSGU_CONTROL                       0x24
+#define MSGU_ODR                                0x20
+#define MSGU_ODCR                               0x28
+
+#define MSGU_ODMR                               0x30
+#define MSGU_ODMR_U                             0x34
+#define MSGU_ODMR_CLR                           0x38
+#define MSGU_ODMR_CLR_U                         0x3C
+#define MSGU_OD_RSVD                            0x40
+
+#define MSGU_SCRATCH_PAD_0                      0x44
+#define MSGU_SCRATCH_PAD_1                      0x48
+#define MSGU_SCRATCH_PAD_2                      0x4C
+#define MSGU_SCRATCH_PAD_3                      0x50
+#define MSGU_HOST_SCRATCH_PAD_0                 0x54
+#define MSGU_HOST_SCRATCH_PAD_1                 0x58
+#define MSGU_HOST_SCRATCH_PAD_2                 0x5C
+#define MSGU_HOST_SCRATCH_PAD_3                 0x60
+#define MSGU_HOST_SCRATCH_PAD_4                 0x64
+#define MSGU_HOST_SCRATCH_PAD_5                 0x68
+#define MSGU_HOST_SCRATCH_PAD_6                 0x6C
+#define MSGU_HOST_SCRATCH_PAD_7                 0x70
+
+/* bit definition for ODMR register */
+#define ODMR_MASK_ALL                   0xFFFFFFFF/* mask all
+                                        interrupt vector */
+#define ODMR_CLEAR_ALL                  0       /* clear all
+                                        interrupt vector */
+/* bit definition for ODCR register */
+#define ODCR_CLEAR_ALL                  0xFFFFFFFF /* mask all
+                                        interrupt vector*/
+/* MSIX Interupts */
+#define MSIX_TABLE_OFFSET               0x2000
+#define MSIX_TABLE_ELEMENT_SIZE         0x10
+#define MSIX_INTERRUPT_CONTROL_OFFSET   0xC
+#define MSIX_TABLE_BASE                 (MSIX_TABLE_OFFSET + \
+                                        MSIX_INTERRUPT_CONTROL_OFFSET)
+#define MSIX_INTERRUPT_DISABLE          0x1
+#define MSIX_INTERRUPT_ENABLE           0x0
+
+/* state definition for Scratch Pad1 register */
+#define SCRATCH_PAD_RAAE_READY          0x3
+#define SCRATCH_PAD_ILA_READY           0xC
+#define SCRATCH_PAD_BOOT_LOAD_SUCCESS   0x0
+#define SCRATCH_PAD_IOP0_READY          0xC00
+#define SCRATCH_PAD_IOP1_READY          0x3000
+
+/* boot loader state */
+#define SCRATCH_PAD1_BOOTSTATE_MASK             0x70    /* Bit 4-6 */
+#define SCRATCH_PAD1_BOOTSTATE_SUCESS           0x0     /* Load successful */
+#define SCRATCH_PAD1_BOOTSTATE_HDA_SEEPROM      0x10    /* HDA SEEPROM */
+#define SCRATCH_PAD1_BOOTSTATE_HDA_BOOTSTRAP    0x20    /* HDA BootStrap Pins */
+#define SCRATCH_PAD1_BOOTSTATE_HDA_SOFTRESET    0x30    /* HDA Soft Reset */
+#define SCRATCH_PAD1_BOOTSTATE_CRIT_ERROR       0x40    /* HDA critical error */
+#define SCRATCH_PAD1_BOOTSTATE_R1               0x50    /* Reserved */
+#define SCRATCH_PAD1_BOOTSTATE_R2               0x60    /* Reserved */
+#define SCRATCH_PAD1_BOOTSTATE_FATAL            0x70    /* Fatal Error */
+
+ /* state definition for Scratch Pad2 register */
+#define SCRATCH_PAD2_POR                0x00    /* power on state */
+#define SCRATCH_PAD2_SFR                0x01    /* soft reset state */
+#define SCRATCH_PAD2_ERR                0x02    /* error state */
+#define SCRATCH_PAD2_RDY                0x03    /* ready state */
+#define SCRATCH_PAD2_FWRDY_RST          0x04    /* FW rdy for soft reset flag */
+#define SCRATCH_PAD2_IOPRDY_RST         0x08    /* IOP ready for soft reset */
+#define SCRATCH_PAD2_STATE_MASK         0xFFFFFFF4 /* ScratchPad 2
+ Mask, bit1-0 State */
+#define SCRATCH_PAD2_RESERVED           0x000003FC/* Scratch Pad1
+ Reserved bit 2 to 9 */
+
+#define SCRATCH_PAD_ERROR_MASK          0xFFFFFC00 /* Error mask bits */
+#define SCRATCH_PAD_STATE_MASK          0x00000003 /* State Mask bits */
+
+/* main configuration offset - byte offset */
+#define MAIN_SIGNATURE_OFFSET           0x00 /* DWORD 0x00 */
+#define MAIN_INTERFACE_REVISION         0x04 /* DWORD 0x01 */
+#define MAIN_FW_REVISION                0x08 /* DWORD 0x02 */
+#define MAIN_MAX_OUTSTANDING_IO_OFFSET  0x0C /* DWORD 0x03 */
+#define MAIN_MAX_SGL_OFFSET             0x10 /* DWORD 0x04 */
+#define MAIN_CNTRL_CAP_OFFSET           0x14 /* DWORD 0x05 */
+#define MAIN_GST_OFFSET                 0x18 /* DWORD 0x06 */
+#define MAIN_IBQ_OFFSET                 0x1C /* DWORD 0x07 */
+#define MAIN_OBQ_OFFSET                 0x20 /* DWORD 0x08 */
+#define MAIN_IQNPPD_HPPD_OFFSET         0x24 /* DWORD 0x09 */
+
+/* 0x28 - 0x4C - RSVD */
+#define MAIN_EVENT_CRC_CHECK            0x48 /* DWORD 0x12 */
+#define MAIN_EVENT_LOG_ADDR_HI          0x50 /* DWORD 0x14 */
+#define MAIN_EVENT_LOG_ADDR_LO          0x54 /* DWORD 0x15 */
+#define MAIN_EVENT_LOG_BUFF_SIZE        0x58 /* DWORD 0x16 */
+#define MAIN_EVENT_LOG_OPTION           0x5C /* DWORD 0x17 */
+#define MAIN_PCS_EVENT_LOG_ADDR_HI      0x60 /* DWORD 0x18 */
+#define MAIN_PCS_EVENT_LOG_ADDR_LO      0x64 /* DWORD 0x19 */
+#define MAIN_PCS_EVENT_LOG_BUFF_SIZE    0x68 /* DWORD 0x1A */
+#define MAIN_PCS_EVENT_LOG_OPTION       0x6C /* DWORD 0x1B */
+#define MAIN_FATAL_ERROR_INTERRUPT      0x70 /* DWORD 0x1C */
+#define MAIN_FATAL_ERROR_RDUMP0_OFFSET  0x74 /* DWORD 0x1D */
+#define MAIN_FATAL_ERROR_RDUMP0_LENGTH  0x78 /* DWORD 0x1E */
+#define MAIN_FATAL_ERROR_RDUMP1_OFFSET  0x7C /* DWORD 0x1F */
+#define MAIN_FATAL_ERROR_RDUMP1_LENGTH  0x80 /* DWORD 0x20 */
+#define MAIN_GPIO_LED_FLAGS_OFFSET      0x84 /* DWORD 0x21 */
+#define MAIN_ANALOG_SETUP_OFFSET        0x88 /* DWORD 0x22 */
+
+#define MAIN_INT_VECTOR_TABLE_OFFSET    0x8C /* DWORD 0x23 */
+#define MAIN_SAS_PHY_ATTR_TABLE_OFFSET  0x90 /* DWORD 0x24 */
+#define MAIN_PORT_RECOVERY_TIMER        0x94 /* DWORD 0x25 */
+#define MAIN_INT_REASSERTION_DELAY      0x98 /* DWORD 0x26 */
+
+/* Gereral Status Table offset - byte offset */
+#define GST_GSTLEN_MPIS_OFFSET          0x00
+#define GST_IQ_FREEZE_STATE0_OFFSET     0x04
+#define GST_IQ_FREEZE_STATE1_OFFSET     0x08
+#define GST_MSGUTCNT_OFFSET             0x0C
+#define GST_IOPTCNT_OFFSET              0x10
+/* 0x14 - 0x34 - RSVD */
+#define GST_GPIO_INPUT_VAL              0x38
+/* 0x3c - 0x40 - RSVD */
+#define GST_RERRINFO_OFFSET0            0x44
+#define GST_RERRINFO_OFFSET1            0x48
+#define GST_RERRINFO_OFFSET2            0x4c
+#define GST_RERRINFO_OFFSET3            0x50
+#define GST_RERRINFO_OFFSET4            0x54
+#define GST_RERRINFO_OFFSET5            0x58
+#define GST_RERRINFO_OFFSET6            0x5c
+#define GST_RERRINFO_OFFSET7            0x60
+
+/* General Status Table - MPI state */
+#define GST_MPI_STATE_UNINIT            0x00
+#define GST_MPI_STATE_INIT              0x01
+#define GST_MPI_STATE_TERMINATION       0x02
+#define GST_MPI_STATE_ERROR             0x03
+#define GST_MPI_STATE_MASK              0x07
+
+/* Per SAS PHY Attributes */
+
+#define PSPA_PHYSTATE0_OFFSET           0x00 /* Dword V */
+#define PSPA_OB_HW_EVENT_PID0_OFFSET    0x04 /* DWORD V+1 */
+#define PSPA_PHYSTATE1_OFFSET           0x08 /* Dword V+2 */
+#define PSPA_OB_HW_EVENT_PID1_OFFSET    0x0C /* DWORD V+3 */
+#define PSPA_PHYSTATE2_OFFSET           0x10 /* Dword V+4 */
+#define PSPA_OB_HW_EVENT_PID2_OFFSET    0x14 /* DWORD V+5 */
+#define PSPA_PHYSTATE3_OFFSET           0x18 /* Dword V+6 */
+#define PSPA_OB_HW_EVENT_PID3_OFFSET    0x1C /* DWORD V+7 */
+#define PSPA_PHYSTATE4_OFFSET           0x20 /* Dword V+8 */
+#define PSPA_OB_HW_EVENT_PID4_OFFSET    0x24 /* DWORD V+9 */
+#define PSPA_PHYSTATE5_OFFSET           0x28 /* Dword V+10 */
+#define PSPA_OB_HW_EVENT_PID5_OFFSET    0x2C /* DWORD V+11 */
+#define PSPA_PHYSTATE6_OFFSET           0x30 /* Dword V+12 */
+#define PSPA_OB_HW_EVENT_PID6_OFFSET    0x34 /* DWORD V+13 */
+#define PSPA_PHYSTATE7_OFFSET           0x38 /* Dword V+14 */
+#define PSPA_OB_HW_EVENT_PID7_OFFSET    0x3C /* DWORD V+15 */
+#define PSPA_PHYSTATE8_OFFSET           0x40 /* DWORD V+16 */
+#define PSPA_OB_HW_EVENT_PID8_OFFSET    0x44 /* DWORD V+17 */
+#define PSPA_PHYSTATE9_OFFSET           0x48 /* DWORD V+18 */
+#define PSPA_OB_HW_EVENT_PID9_OFFSET    0x4C /* DWORD V+19 */
+#define PSPA_PHYSTATE10_OFFSET          0x50 /* DWORD V+20 */
+#define PSPA_OB_HW_EVENT_PID10_OFFSET   0x54 /* DWORD V+21 */
+#define PSPA_PHYSTATE11_OFFSET          0x58 /* DWORD V+22 */
+#define PSPA_OB_HW_EVENT_PID11_OFFSET   0x5C /* DWORD V+23 */
+#define PSPA_PHYSTATE12_OFFSET          0x60 /* DWORD V+24 */
+#define PSPA_OB_HW_EVENT_PID12_OFFSET   0x64 /* DWORD V+25 */
+#define PSPA_PHYSTATE13_OFFSET          0x68 /* DWORD V+26 */
+#define PSPA_OB_HW_EVENT_PID13_OFFSET   0x6c /* DWORD V+27 */
+#define PSPA_PHYSTATE14_OFFSET          0x70 /* DWORD V+28 */
+#define PSPA_OB_HW_EVENT_PID14_OFFSET   0x74 /* DWORD V+29 */
+#define PSPA_PHYSTATE15_OFFSET          0x78 /* DWORD V+30 */
+#define PSPA_OB_HW_EVENT_PID15_OFFSET   0x7c /* DWORD V+31 */
+/* end PSPA */
+
+/* inbound queue configuration offset - byte offset */
+#define IB_PROPERITY_OFFSET             0x00
+#define IB_BASE_ADDR_HI_OFFSET          0x04
+#define IB_BASE_ADDR_LO_OFFSET          0x08
+#define IB_CI_BASE_ADDR_HI_OFFSET       0x0C
+#define IB_CI_BASE_ADDR_LO_OFFSET       0x10
+#define IB_PIPCI_BAR                    0x14
+#define IB_PIPCI_BAR_OFFSET             0x18
+#define IB_RESERVED_OFFSET              0x1C
+
+/* outbound queue configuration offset - byte offset */
+#define OB_PROPERITY_OFFSET             0x00
+#define OB_BASE_ADDR_HI_OFFSET          0x04
+#define OB_BASE_ADDR_LO_OFFSET          0x08
+#define OB_PI_BASE_ADDR_HI_OFFSET       0x0C
+#define OB_PI_BASE_ADDR_LO_OFFSET       0x10
+#define OB_CIPCI_BAR                    0x14
+#define OB_CIPCI_BAR_OFFSET             0x18
+#define OB_INTERRUPT_COALES_OFFSET      0x1C
+#define OB_DYNAMIC_COALES_OFFSET        0x20
+#define OB_PROPERTY_INT_ENABLE          0x40000000
+
+#define MBIC_NMI_ENABLE_VPE0_IOP        0x000418
+#define MBIC_NMI_ENABLE_VPE0_AAP1       0x000418
+/* PCIE registers - BAR2(0x18), BAR1(win) 0x010000 */
+#define PCIE_EVENT_INTERRUPT_ENABLE     0x003040
+#define PCIE_EVENT_INTERRUPT            0x003044
+#define PCIE_ERROR_INTERRUPT_ENABLE     0x003048
+#define PCIE_ERROR_INTERRUPT            0x00304C
+
+/* SPCV soft reset */
+#define SPC_REG_SOFT_RESET 0x00001000
+#define SPCv_NORMAL_RESET_VALUE         0x1
+
+#define SPCv_SOFT_RESET_READ_MASK               0xC0
+#define SPCv_SOFT_RESET_NO_RESET                0x0
+#define SPCv_SOFT_RESET_NORMAL_RESET_OCCURED    0x40
+#define SPCv_SOFT_RESET_HDA_MODE_OCCURED        0x80
+#define SPCv_SOFT_RESET_CHIP_RESET_OCCURED      0xC0
+
+/* signature definition for host scratch pad0 register */
+#define SPC_SOFT_RESET_SIGNATURE        0x252acbcd
+/* Signature for Soft Reset */
+
+/* SPC Reset register - BAR4(0x20), BAR2(win) (need dynamic mapping) */
+#define SPC_REG_RESET                   0x000000/* reset register */
+
+/* bit definition for SPC_RESET register */
+#define SPC_REG_RESET_OSSP              0x00000001
+#define SPC_REG_RESET_RAAE              0x00000002
+#define SPC_REG_RESET_PCS_SPBC          0x00000004
+#define SPC_REG_RESET_PCS_IOP_SS        0x00000008
+#define SPC_REG_RESET_PCS_AAP1_SS       0x00000010
+#define SPC_REG_RESET_PCS_AAP2_SS       0x00000020
+#define SPC_REG_RESET_PCS_LM            0x00000040
+#define SPC_REG_RESET_PCS               0x00000080
+#define SPC_REG_RESET_GSM               0x00000100
+#define SPC_REG_RESET_DDR2              0x00010000
+#define SPC_REG_RESET_BDMA_CORE         0x00020000
+#define SPC_REG_RESET_BDMA_SXCBI        0x00040000
+#define SPC_REG_RESET_PCIE_AL_SXCBI     0x00080000
+#define SPC_REG_RESET_PCIE_PWR          0x00100000
+#define SPC_REG_RESET_PCIE_SFT          0x00200000
+#define SPC_REG_RESET_PCS_SXCBI         0x00400000
+#define SPC_REG_RESET_LMS_SXCBI         0x00800000
+#define SPC_REG_RESET_PMIC_SXCBI        0x01000000
+#define SPC_REG_RESET_PMIC_CORE         0x02000000
+#define SPC_REG_RESET_PCIE_PC_SXCBI     0x04000000
+#define SPC_REG_RESET_DEVICE            0x80000000
+
+/* registers for BAR Shifting - BAR2(0x18), BAR1(win) */
+#define SPCV_IBW_AXI_TRANSLATION_LOW    0x001010
+
+#define MBIC_AAP1_ADDR_BASE             0x060000
+#define MBIC_IOP_ADDR_BASE              0x070000
+#define GSM_ADDR_BASE                   0x0700000
+/* Dynamic map through Bar4 - 0x00700000 */
+#define GSM_CONFIG_RESET                0x00000000
+#define RAM_ECC_DB_ERR                  0x00000018
+#define GSM_READ_ADDR_PARITY_INDIC      0x00000058
+#define GSM_WRITE_ADDR_PARITY_INDIC     0x00000060
+#define GSM_WRITE_DATA_PARITY_INDIC     0x00000068
+#define GSM_READ_ADDR_PARITY_CHECK      0x00000038
+#define GSM_WRITE_ADDR_PARITY_CHECK     0x00000040
+#define GSM_WRITE_DATA_PARITY_CHECK     0x00000048
+
+#define RB6_ACCESS_REG                  0x6A0000
+#define HDAC_EXEC_CMD                   0x0002
+#define HDA_C_PA                        0xcb
+#define HDA_SEQ_ID_BITS                 0x00ff0000
+#define HDA_GSM_OFFSET_BITS             0x00FFFFFF
+#define HDA_GSM_CMD_OFFSET_BITS         0x42C0
+#define HDA_GSM_RSP_OFFSET_BITS         0x42E0
+
+#define MBIC_AAP1_ADDR_BASE             0x060000
+#define MBIC_IOP_ADDR_BASE              0x070000
+#define GSM_ADDR_BASE                   0x0700000
+#define SPC_TOP_LEVEL_ADDR_BASE         0x000000
+#define GSM_CONFIG_RESET_VALUE          0x00003b00
+#define GPIO_ADDR_BASE                  0x00090000
+#define GPIO_GPIO_0_0UTPUT_CTL_OFFSET   0x0000010c
+
+/* RB6 offset */
+#define SPC_RB6_OFFSET                  0x80C0
+/* Magic number of soft reset for RB6 */
+#define RB6_MAGIC_NUMBER_RST            0x1234
+
+/* Device Register status */
+#define DEVREG_SUCCESS                                  0x00
+#define DEVREG_FAILURE_OUT_OF_RESOURCE                  0x01
+#define DEVREG_FAILURE_DEVICE_ALREADY_REGISTERED        0x02
+#define DEVREG_FAILURE_INVALID_PHY_ID                   0x03
+#define DEVREG_FAILURE_PHY_ID_ALREADY_REGISTERED        0x04
+#define DEVREG_FAILURE_PORT_ID_OUT_OF_RANGE             0x05
+#define DEVREG_FAILURE_PORT_NOT_VALID_STATE             0x06
+#define DEVREG_FAILURE_DEVICE_TYPE_NOT_VALID            0x07
+
+#endif
diff --git a/drivers/scsi/qla2xxx/Kconfig b/drivers/scsi/qla2xxx/Kconfig
index 317a7fdc3b82..23d607218ae8 100644
--- a/drivers/scsi/qla2xxx/Kconfig
+++ b/drivers/scsi/qla2xxx/Kconfig
@@ -24,7 +24,9 @@ config SCSI_QLA_FC
 
         Firmware images can be retrieved from:
 
-                ftp://ftp.qlogic.com/outgoing/linux/firmware/
+                http://ldriver.qlogic.com/firmware/
+
+        They are also included in the linux-firmware tree as well.
 
 config TCM_QLA2XXX
         tristate "TCM_QLA2XXX fabric module for Qlogic 2xxx series target mode HBAs"
diff --git a/drivers/scsi/qla2xxx/qla_mr.c b/drivers/scsi/qla2xxx/qla_mr.c
index 729b74389f83..937fed8cb038 100644
--- a/drivers/scsi/qla2xxx/qla_mr.c
+++ b/drivers/scsi/qla2xxx/qla_mr.c
@@ -3003,12 +3003,10 @@ qlafx00_build_scsi_iocbs(srb_t *sp, struct cmd_type_7_fx00 *cmd_pkt,
 
         /* Set transfer direction */
         if (cmd->sc_data_direction == DMA_TO_DEVICE) {
-                lcmd_pkt->cntrl_flags =
-                    __constant_cpu_to_le16(TMF_WRITE_DATA);
+                lcmd_pkt->cntrl_flags = TMF_WRITE_DATA;
                 vha->qla_stats.output_bytes += scsi_bufflen(cmd);
         } else if (cmd->sc_data_direction == DMA_FROM_DEVICE) {
-                lcmd_pkt->cntrl_flags =
-                    __constant_cpu_to_le16(TMF_READ_DATA);
+                lcmd_pkt->cntrl_flags = TMF_READ_DATA;
                 vha->qla_stats.input_bytes += scsi_bufflen(cmd);
         }
 
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index 5307bf86d5e0..ad72c1d85111 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -644,7 +644,7 @@ qla2x00_sp_free_dma(void *vha, void *ptr)
         qla2x00_rel_sp(sp->fcport->vha, sp);
 }
 
-void
+static void
 qla2x00_sp_compl(void *data, void *ptr, int res)
 {
         struct qla_hw_data *ha = (struct qla_hw_data *)data;
diff --git a/drivers/scsi/qla4xxx/ql4_iocb.c b/drivers/scsi/qla4xxx/ql4_iocb.c
index 14fec976f634..fad71ed067ec 100644
--- a/drivers/scsi/qla4xxx/ql4_iocb.c
+++ b/drivers/scsi/qla4xxx/ql4_iocb.c
@@ -507,6 +507,7 @@ static int qla4xxx_send_mbox_iocb(struct scsi_qla_host *ha, struct mrb *mrb,
         mrb->mbox_cmd = in_mbox[0];
         wmb();
 
+        ha->iocb_cnt += mrb->iocb_cnt;
         ha->isp_ops->queue_iocb(ha);
 exit_mbox_iocb:
         spin_unlock_irqrestore(&ha->hardware_lock, flags);
diff --git a/drivers/scsi/qla4xxx/ql4_os.c b/drivers/scsi/qla4xxx/ql4_os.c
index a47f99957ba8..4d231c12463e 100644
--- a/drivers/scsi/qla4xxx/ql4_os.c
+++ b/drivers/scsi/qla4xxx/ql4_os.c
@@ -2216,14 +2216,14 @@ static int qla4xxx_copy_to_fwddb_param(struct iscsi_bus_flash_session *sess,
         fw_ddb_entry->iscsi_def_time2retain = cpu_to_le16(sess->time2retain);
         fw_ddb_entry->tgt_portal_grp = cpu_to_le16(sess->tpgt);
         fw_ddb_entry->mss = cpu_to_le16(conn->max_segment_size);
-        fw_ddb_entry->tcp_xmt_wsf = cpu_to_le16(conn->tcp_xmit_wsf);
-        fw_ddb_entry->tcp_rcv_wsf = cpu_to_le16(conn->tcp_recv_wsf);
+        fw_ddb_entry->tcp_xmt_wsf = (uint8_t) cpu_to_le32(conn->tcp_xmit_wsf);
+        fw_ddb_entry->tcp_rcv_wsf = (uint8_t) cpu_to_le32(conn->tcp_recv_wsf);
         fw_ddb_entry->ipv4_tos = conn->ipv4_tos;
         fw_ddb_entry->ipv6_flow_lbl = cpu_to_le16(conn->ipv6_flow_label);
         fw_ddb_entry->ka_timeout = cpu_to_le16(conn->keepalive_timeout);
         fw_ddb_entry->lcl_port = cpu_to_le16(conn->local_port);
-        fw_ddb_entry->stat_sn = cpu_to_le16(conn->statsn);
-        fw_ddb_entry->exp_stat_sn = cpu_to_le16(conn->exp_statsn);
+        fw_ddb_entry->stat_sn = cpu_to_le32(conn->statsn);
+        fw_ddb_entry->exp_stat_sn = cpu_to_le32(conn->exp_statsn);
         fw_ddb_entry->ddb_link = cpu_to_le16(sess->discovery_parent_type);
         fw_ddb_entry->chap_tbl_idx = cpu_to_le16(sess->chap_out_idx);
         fw_ddb_entry->tsid = cpu_to_le16(sess->tsid);
@@ -5504,9 +5504,9 @@ static int qla4xxx_sysfs_ddb_is_non_persistent(struct device *dev, void *data)
  * If this is invoked as a result of a userspace call then the entry is marked
  * as nonpersistent using flash_state field.
  **/
-int qla4xxx_sysfs_ddb_tgt_create(struct scsi_qla_host *ha,
-                                 struct dev_db_entry *fw_ddb_entry,
-                                 uint16_t *idx, int user)
+static int qla4xxx_sysfs_ddb_tgt_create(struct scsi_qla_host *ha,
+                                        struct dev_db_entry *fw_ddb_entry,
+                                        uint16_t *idx, int user)
 {
         struct iscsi_bus_flash_session *fnode_sess = NULL;
         struct iscsi_bus_flash_conn *fnode_conn = NULL;
@@ -5605,6 +5605,7 @@ static int qla4xxx_sysfs_ddb_add(struct Scsi_Host *shost, const char *buf,
                 ql4_printk(KERN_ERR, ha,
                            "%s: A non-persistent entry %s found\n",
                            __func__, dev->kobj.name);
+                put_device(dev);
                 goto exit_ddb_add;
         }
 
@@ -6112,8 +6113,7 @@ qla4xxx_sysfs_ddb_get_param(struct iscsi_bus_flash_session *fnode_sess,
         int parent_type, parent_index = 0xffff;
         int rc = 0;
 
-        dev = iscsi_find_flashnode_conn(fnode_sess, NULL,
-                                        iscsi_is_flashnode_conn_dev);
+        dev = iscsi_find_flashnode_conn(fnode_sess);
         if (!dev)
                 return -EIO;
 
@@ -6276,8 +6276,7 @@ qla4xxx_sysfs_ddb_get_param(struct iscsi_bus_flash_session *fnode_sess,
                         rc = sprintf(buf, "\n");
                 break;
         case ISCSI_FLASHNODE_DISCOVERY_PARENT_IDX:
-                if ((fnode_sess->discovery_parent_idx) >= 0  &&
-                    (fnode_sess->discovery_parent_idx < MAX_DDB_ENTRIES))
+                if (fnode_sess->discovery_parent_idx < MAX_DDB_ENTRIES)
                         parent_index = fnode_sess->discovery_parent_idx;
 
                 rc = sprintf(buf, "%u\n", parent_index);
@@ -6287,8 +6286,7 @@ qla4xxx_sysfs_ddb_get_param(struct iscsi_bus_flash_session *fnode_sess,
                         parent_type = ISCSI_DISC_PARENT_ISNS;
                 else if (fnode_sess->discovery_parent_type == DDB_NO_LINK)
                         parent_type = ISCSI_DISC_PARENT_UNKNOWN;
-                else if (fnode_sess->discovery_parent_type >= 0  &&
-                         fnode_sess->discovery_parent_type < MAX_DDB_ENTRIES)
+                else if (fnode_sess->discovery_parent_type < MAX_DDB_ENTRIES)
                         parent_type = ISCSI_DISC_PARENT_SENDTGT;
                 else
                         parent_type = ISCSI_DISC_PARENT_UNKNOWN;
@@ -6349,6 +6347,8 @@ qla4xxx_sysfs_ddb_get_param(struct iscsi_bus_flash_session *fnode_sess,
                 rc = -ENOSYS;
                 break;
         }
+
+        put_device(dev);
         return rc;
 }
 
@@ -6368,20 +6368,11 @@ qla4xxx_sysfs_ddb_set_param(struct iscsi_bus_flash_session *fnode_sess,
 {
         struct Scsi_Host *shost = iscsi_flash_session_to_shost(fnode_sess);
         struct scsi_qla_host *ha = to_qla_host(shost);
-        struct dev_db_entry *fw_ddb_entry = NULL;
         struct iscsi_flashnode_param_info *fnode_param;
         struct nlattr *attr;
         int rc = QLA_ERROR;
         uint32_t rem = len;
 
-        fw_ddb_entry = kzalloc(sizeof(*fw_ddb_entry), GFP_KERNEL);
-        if (!fw_ddb_entry) {
-                DEBUG2(ql4_printk(KERN_ERR, ha,
-                                  "%s: Unable to allocate ddb buffer\n",
-                                  __func__));
-                return -ENOMEM;
-        }
-
         nla_for_each_attr(attr, data, len, rem) {
                 fnode_param = nla_data(attr);
 
@@ -6590,16 +6581,11 @@ static int qla4xxx_sysfs_ddb_delete(struct iscsi_bus_flash_session *fnode_sess)
         struct dev_db_entry *fw_ddb_entry = NULL;
         dma_addr_t fw_ddb_entry_dma;
         uint16_t *ddb_cookie = NULL;
-        size_t ddb_size;
+        size_t ddb_size = 0;
         void *pddb = NULL;
         int target_id;
         int rc = 0;
 
-        if (!fnode_sess) {
-                rc = -EINVAL;
-                goto exit_ddb_del;
-        }
-
         if (fnode_sess->is_boot_target) {
                 rc = -EPERM;
                 DEBUG2(ql4_printk(KERN_ERR, ha,
@@ -6631,8 +6617,7 @@ static int qla4xxx_sysfs_ddb_delete(struct iscsi_bus_flash_session *fnode_sess)
 
                 dev_db_start_offset += (fnode_sess->target_id *
                                        sizeof(*fw_ddb_entry));
-                dev_db_start_offset += (void *)&(fw_ddb_entry->cookie) -
-                                       (void *)fw_ddb_entry;
+                dev_db_start_offset += offsetof(struct dev_db_entry, cookie);
 
                 ddb_size = sizeof(*ddb_cookie);
         }
diff --git a/drivers/scsi/qla4xxx/ql4_version.h b/drivers/scsi/qla4xxx/ql4_version.h
index 83e0fec35d56..fe873cf7570d 100644
--- a/drivers/scsi/qla4xxx/ql4_version.h
+++ b/drivers/scsi/qla4xxx/ql4_version.h
@@ -5,4 +5,4 @@
  * See LICENSE.qla4xxx for copyright and licensing details.
  */
 
-#define QLA4XXX_DRIVER_VERSION  "5.03.00-k8"
+#define QLA4XXX_DRIVER_VERSION  "5.03.00-k9"
diff --git a/drivers/scsi/scsi_debug.c b/drivers/scsi/scsi_debug.c
index 5add6f4e7928..0a537a0515ca 100644
--- a/drivers/scsi/scsi_debug.c
+++ b/drivers/scsi/scsi_debug.c
@@ -1997,24 +1997,39 @@ out:
         return ret;
 }
 
-static unsigned int map_state(sector_t lba, unsigned int *num)
+static unsigned long lba_to_map_index(sector_t lba)
+{
+        if (scsi_debug_unmap_alignment) {
+                lba += scsi_debug_unmap_granularity -
+                        scsi_debug_unmap_alignment;
+        }
+        do_div(lba, scsi_debug_unmap_granularity);
+
+        return lba;
+}
+
+static sector_t map_index_to_lba(unsigned long index)
 {
-        unsigned int granularity, alignment, mapped;
-        sector_t block, next, end;
+        return index * scsi_debug_unmap_granularity -
+                scsi_debug_unmap_alignment;
+}
 
-        granularity = scsi_debug_unmap_granularity;
-        alignment = granularity - scsi_debug_unmap_alignment;
-        block = lba + alignment;
-        do_div(block, granularity);
+static unsigned int map_state(sector_t lba, unsigned int *num)
+{
+        sector_t end;
+        unsigned int mapped;
+        unsigned long index;
+        unsigned long next;
 
-        mapped = test_bit(block, map_storep);
+        index = lba_to_map_index(lba);
+        mapped = test_bit(index, map_storep);
 
         if (mapped)
-                next = find_next_zero_bit(map_storep, map_size, block);
+                next = find_next_zero_bit(map_storep, map_size, index);
         else
-                next = find_next_bit(map_storep, map_size, block);
+                next = find_next_bit(map_storep, map_size, index);
 
-        end = next * granularity - scsi_debug_unmap_alignment;
+        end = min_t(sector_t, sdebug_store_sectors,  map_index_to_lba(next));
         *num = end - lba;
 
         return mapped;
@@ -2022,47 +2037,37 @@ static unsigned int map_state(sector_t lba, unsigned int *num)
 
 static void map_region(sector_t lba, unsigned int len)
 {
-        unsigned int granularity, alignment;
         sector_t end = lba + len;
 
-        granularity = scsi_debug_unmap_granularity;
-        alignment = granularity - scsi_debug_unmap_alignment;
-
         while (lba < end) {
-                sector_t block, rem;
-
-                block = lba + alignment;
-                rem = do_div(block, granularity);
+                unsigned long index = lba_to_map_index(lba);
 
-                if (block < map_size)
-                        set_bit(block, map_storep);
+                if (index < map_size)
+                        set_bit(index, map_storep);
 
-                lba += granularity - rem;
+                lba = map_index_to_lba(index + 1);
         }
 }
 
 static void unmap_region(sector_t lba, unsigned int len)
 {
-        unsigned int granularity, alignment;
         sector_t end = lba + len;
 
-        granularity = scsi_debug_unmap_granularity;
-        alignment = granularity - scsi_debug_unmap_alignment;
-
         while (lba < end) {
-                sector_t block, rem;
-
-                block = lba + alignment;
-                rem = do_div(block, granularity);
+                unsigned long index = lba_to_map_index(lba);
 
-                if (rem == 0 && lba + granularity < end && block < map_size) {
-                        clear_bit(block, map_storep);
-                        if (scsi_debug_lbprz)
+                if (lba == map_index_to_lba(index) &&
+                    lba + scsi_debug_unmap_granularity <= end &&
+                    index < map_size) {
+                        clear_bit(index, map_storep);
+                        if (scsi_debug_lbprz) {
                                 memset(fake_storep +
-                                       block * scsi_debug_sector_size, 0,
-                                       scsi_debug_sector_size);
+                                       lba * scsi_debug_sector_size, 0,
+                                       scsi_debug_sector_size *
+                                       scsi_debug_unmap_granularity);
+                        }
                 }
-                lba += granularity - rem;
+                lba = map_index_to_lba(index + 1);
         }
 }
 
@@ -2089,7 +2094,7 @@ static int resp_write(struct scsi_cmnd *SCpnt, unsigned long long lba,
 
         write_lock_irqsave(&atomic_rw, iflags);
         ret = do_device_access(SCpnt, devip, lba, num, 1);
-        if (scsi_debug_unmap_granularity)
+        if (scsi_debug_lbp())
                 map_region(lba, num);
         write_unlock_irqrestore(&atomic_rw, iflags);
         if (-1 == ret)
@@ -2122,7 +2127,7 @@ static int resp_write_same(struct scsi_cmnd *scmd, unsigned long long lba,
 
         write_lock_irqsave(&atomic_rw, iflags);
 
-        if (unmap && scsi_debug_unmap_granularity) {
+        if (unmap && scsi_debug_lbp()) {
                 unmap_region(lba, num);
                 goto out;
         }
@@ -2146,7 +2151,7 @@ static int resp_write_same(struct scsi_cmnd *scmd, unsigned long long lba,
                        fake_storep + (lba * scsi_debug_sector_size),
                        scsi_debug_sector_size);
 
-        if (scsi_debug_unmap_granularity)
+        if (scsi_debug_lbp())
                 map_region(lba, num);
 out:
         write_unlock_irqrestore(&atomic_rw, iflags);
@@ -3389,8 +3394,6 @@ static int __init scsi_debug_init(void)
 
         /* Logical Block Provisioning */
         if (scsi_debug_lbp()) {
-                unsigned int map_bytes;
-
                 scsi_debug_unmap_max_blocks =
                         clamp(scsi_debug_unmap_max_blocks, 0U, 0xffffffffU);
 
@@ -3401,16 +3404,16 @@ static int __init scsi_debug_init(void)
                         clamp(scsi_debug_unmap_granularity, 1U, 0xffffffffU);
 
                 if (scsi_debug_unmap_alignment &&
-                    scsi_debug_unmap_granularity < scsi_debug_unmap_alignment) {
+                    scsi_debug_unmap_granularity <=
+                    scsi_debug_unmap_alignment) {
                         printk(KERN_ERR
-                               "%s: ERR: unmap_granularity < unmap_alignment\n",
+                               "%s: ERR: unmap_granularity <= unmap_alignment\n",
                                __func__);
                         return -EINVAL;
                 }
 
-                map_size = (sdebug_store_sectors / scsi_debug_unmap_granularity);
-                map_bytes = map_size >> 3;
-                map_storep = vmalloc(map_bytes);
+                map_size = lba_to_map_index(sdebug_store_sectors - 1) + 1;
+                map_storep = vmalloc(BITS_TO_LONGS(map_size) * sizeof(long));
 
                 printk(KERN_INFO "scsi_debug_init: %lu provisioning blocks\n",
                        map_size);
@@ -3421,7 +3424,7 @@ static int __init scsi_debug_init(void)
                         goto free_vm;
                 }
 
-                memset(map_storep, 0x0, map_bytes);
+                bitmap_zero(map_storep, map_size);
 
                 /* Map first 1KB for partition table */
                 if (scsi_debug_num_parts)
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index c1b05a83d403..f43de1e56420 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -25,6 +25,7 @@
 #include <linux/interrupt.h>
 #include <linux/blkdev.h>
 #include <linux/delay.h>
+#include <linux/jiffies.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
@@ -791,32 +792,48 @@ static int scsi_send_eh_cmnd(struct scsi_cmnd *scmd, unsigned char *cmnd,
         struct scsi_device *sdev = scmd->device;
         struct Scsi_Host *shost = sdev->host;
         DECLARE_COMPLETION_ONSTACK(done);
-        unsigned long timeleft;
+        unsigned long timeleft = timeout;
         struct scsi_eh_save ses;
+        const unsigned long stall_for = msecs_to_jiffies(100);
         int rtn;
 
+retry:
         scsi_eh_prep_cmnd(scmd, &ses, cmnd, cmnd_size, sense_bytes);
         shost->eh_action = &done;
 
         scsi_log_send(scmd);
         scmd->scsi_done = scsi_eh_done;
-        shost->hostt->queuecommand(shost, scmd);
-
-        timeleft = wait_for_completion_timeout(&done, timeout);
+        rtn = shost->hostt->queuecommand(shost, scmd);
+        if (rtn) {
+                if (timeleft > stall_for) {
+                        scsi_eh_restore_cmnd(scmd, &ses);
+                        timeleft -= stall_for;
+                        msleep(jiffies_to_msecs(stall_for));
+                        goto retry;
+                }
+                /* signal not to enter either branch of the if () below */
+                timeleft = 0;
+                rtn = NEEDS_RETRY;
+        } else {
+                timeleft = wait_for_completion_timeout(&done, timeout);
+        }
 
         shost->eh_action = NULL;
 
-        scsi_log_completion(scmd, SUCCESS);
+        scsi_log_completion(scmd, rtn);
 
         SCSI_LOG_ERROR_RECOVERY(3,
                 printk("%s: scmd: %p, timeleft: %ld\n",
                         __func__, scmd, timeleft));
 
         /*
-         * If there is time left scsi_eh_done got called, and we will
-         * examine the actual status codes to see whether the command
-         * actually did complete normally, else tell the host to forget
-         * about this command.
+         * If there is time left scsi_eh_done got called, and we will examine
+         * the actual status codes to see whether the command actually did
+         * complete normally, else if we have a zero return and no time left,
+         * the command must still be pending, so abort it and return FAILED.
+         * If we never actually managed to issue the command, because
+         * ->queuecommand() kept returning non zero, use the rtn = FAILED
+         * value above (so don't execute either branch of the if)
          */
         if (timeleft) {
                 rtn = scsi_eh_completed_normally(scmd);
@@ -837,7 +854,7 @@ static int scsi_send_eh_cmnd(struct scsi_cmnd *scmd, unsigned char *cmnd,
                         rtn = FAILED;
                         break;
                 }
-        } else {
+        } else if (!rtn) {
                 scsi_abort_eh_cmnd(scmd);
                 rtn = FAILED;
         }
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index c31187d79343..86d522004a20 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -276,11 +276,10 @@ int scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
 }
 EXPORT_SYMBOL(scsi_execute);
 
-
-int scsi_execute_req(struct scsi_device *sdev, const unsigned char *cmd,
+int scsi_execute_req_flags(struct scsi_device *sdev, const unsigned char *cmd,
                      int data_direction, void *buffer, unsigned bufflen,
                      struct scsi_sense_hdr *sshdr, int timeout, int retries,
-                     int *resid)
+                     int *resid, int flags)
 {
         char *sense = NULL;
         int result;
@@ -291,14 +290,14 @@ int scsi_execute_req(struct scsi_device *sdev, const unsigned char *cmd,
                         return DRIVER_ERROR << 24;
         }
         result = scsi_execute(sdev, cmd, data_direction, buffer, bufflen,
-                              sense, timeout, retries, 0, resid);
+                              sense, timeout, retries, flags, resid);
         if (sshdr)
                 scsi_normalize_sense(sense, SCSI_SENSE_BUFFERSIZE, sshdr);
 
         kfree(sense);
         return result;
 }
-EXPORT_SYMBOL(scsi_execute_req);
+EXPORT_SYMBOL(scsi_execute_req_flags);
 
 /*
  * Function:    scsi_init_cmd_errh()
diff --git a/drivers/scsi/scsi_pm.c b/drivers/scsi/scsi_pm.c
index 8f6b12cbd224..42539ee2cb11 100644
--- a/drivers/scsi/scsi_pm.c
+++ b/drivers/scsi/scsi_pm.c
@@ -144,33 +144,83 @@ static int scsi_bus_restore(struct device *dev)
 
 #ifdef CONFIG_PM_RUNTIME
 
+static int sdev_blk_runtime_suspend(struct scsi_device *sdev,
+                                        int (*cb)(struct device *))
+{
+        int err;
+
+        err = blk_pre_runtime_suspend(sdev->request_queue);
+        if (err)
+                return err;
+        if (cb)
+                err = cb(&sdev->sdev_gendev);
+        blk_post_runtime_suspend(sdev->request_queue, err);
+
+        return err;
+}
+
+static int sdev_runtime_suspend(struct device *dev)
+{
+        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
+        int (*cb)(struct device *) = pm ? pm->runtime_suspend : NULL;
+        struct scsi_device *sdev = to_scsi_device(dev);
+        int err;
+
+        if (sdev->request_queue->dev)
+                return sdev_blk_runtime_suspend(sdev, cb);
+
+        err = scsi_dev_type_suspend(dev, cb);
+        if (err == -EAGAIN)
+                pm_schedule_suspend(dev, jiffies_to_msecs(
+                                        round_jiffies_up_relative(HZ/10)));
+        return err;
+}
+
 static int scsi_runtime_suspend(struct device *dev)
 {
         int err = 0;
-        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
 
         dev_dbg(dev, "scsi_runtime_suspend\n");
-        if (scsi_is_sdev_device(dev)) {
-                err = scsi_dev_type_suspend(dev,
-                                pm ? pm->runtime_suspend : NULL);
-                if (err == -EAGAIN)
-                        pm_schedule_suspend(dev, jiffies_to_msecs(
-                                round_jiffies_up_relative(HZ/10)));
-        }
+        if (scsi_is_sdev_device(dev))
+                err = sdev_runtime_suspend(dev);
 
         /* Insert hooks here for targets, hosts, and transport classes */
 
         return err;
 }
 
-static int scsi_runtime_resume(struct device *dev)
+static int sdev_blk_runtime_resume(struct scsi_device *sdev,
+                                        int (*cb)(struct device *))
 {
         int err = 0;
+
+        blk_pre_runtime_resume(sdev->request_queue);
+        if (cb)
+                err = cb(&sdev->sdev_gendev);
+        blk_post_runtime_resume(sdev->request_queue, err);
+
+        return err;
+}
+
+static int sdev_runtime_resume(struct device *dev)
+{
+        struct scsi_device *sdev = to_scsi_device(dev);
         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
+        int (*cb)(struct device *) = pm ? pm->runtime_resume : NULL;
+
+        if (sdev->request_queue->dev)
+                return sdev_blk_runtime_resume(sdev, cb);
+        else
+                return scsi_dev_type_resume(dev, cb);
+}
+
+static int scsi_runtime_resume(struct device *dev)
+{
+        int err = 0;
 
         dev_dbg(dev, "scsi_runtime_resume\n");
         if (scsi_is_sdev_device(dev))
-                err = scsi_dev_type_resume(dev, pm ? pm->runtime_resume : NULL);
+                err = sdev_runtime_resume(dev);
 
         /* Insert hooks here for targets, hosts, and transport classes */
 
@@ -185,10 +235,18 @@ static int scsi_runtime_idle(struct device *dev)
 
         /* Insert hooks here for targets, hosts, and transport classes */
 
-        if (scsi_is_sdev_device(dev))
-                err = pm_schedule_suspend(dev, 100);
-        else
+        if (scsi_is_sdev_device(dev)) {
+                struct scsi_device *sdev = to_scsi_device(dev);
+
+                if (sdev->request_queue->dev) {
+                        pm_runtime_mark_last_busy(dev);
+                        err = pm_runtime_autosuspend(dev);
+                } else {
+                        err = pm_runtime_suspend(dev);
+                }
+        } else {
                 err = pm_runtime_suspend(dev);
+        }
         return err;
 }
 
diff --git a/drivers/scsi/scsi_transport_iscsi.c b/drivers/scsi/scsi_transport_iscsi.c
index 47799a33d6ca..133926b1bb78 100644
--- a/drivers/scsi/scsi_transport_iscsi.c
+++ b/drivers/scsi/scsi_transport_iscsi.c
@@ -1019,8 +1019,7 @@ exit_match_index:
 /**
  * iscsi_get_flashnode_by_index -finds flashnode session entry by index
  * @shost: pointer to host data
- * @data: pointer to data containing value to use for comparison
- * @fn: function pointer that does actual comparison
+ * @idx: index to match
  *
  * Finds the flashnode session object for the passed index
  *
@@ -1029,13 +1028,13 @@ exit_match_index:
  *  %NULL on failure
  */
 static struct iscsi_bus_flash_session *
-iscsi_get_flashnode_by_index(struct Scsi_Host *shost, void *data,
-                             int (*fn)(struct device *dev, void *data))
+iscsi_get_flashnode_by_index(struct Scsi_Host *shost, uint32_t idx)
 {
         struct iscsi_bus_flash_session *fnode_sess = NULL;
         struct device *dev;
 
-        dev = device_find_child(&shost->shost_gendev, data, fn);
+        dev = device_find_child(&shost->shost_gendev, &idx,
+                                flashnode_match_index);
         if (dev)
                 fnode_sess = iscsi_dev_to_flash_session(dev);
 
@@ -1059,18 +1058,13 @@ struct device *
 iscsi_find_flashnode_sess(struct Scsi_Host *shost, void *data,
                           int (*fn)(struct device *dev, void *data))
 {
-        struct device *dev;
-
-        dev = device_find_child(&shost->shost_gendev, data, fn);
-        return dev;
+        return device_find_child(&shost->shost_gendev, data, fn);
 }
 EXPORT_SYMBOL_GPL(iscsi_find_flashnode_sess);
 
 /**
  * iscsi_find_flashnode_conn - finds flashnode connection entry
  * @fnode_sess: pointer to parent flashnode session entry
- * @data: pointer to data containing value to use for comparison
- * @fn: function pointer that does actual comparison
  *
  * Finds the flashnode connection object comparing the data passed using logic
  * defined in passed function pointer
@@ -1080,14 +1074,10 @@ EXPORT_SYMBOL_GPL(iscsi_find_flashnode_sess);
  *  %NULL on failure
  */
 struct device *
-iscsi_find_flashnode_conn(struct iscsi_bus_flash_session *fnode_sess,
-                          void *data,
-                          int (*fn)(struct device *dev, void *data))
+iscsi_find_flashnode_conn(struct iscsi_bus_flash_session *fnode_sess)
 {
-        struct device *dev;
-
-        dev = device_find_child(&fnode_sess->dev, data, fn);
-        return dev;
+        return device_find_child(&fnode_sess->dev, NULL,
+                                 iscsi_is_flashnode_conn_dev);
 }
 EXPORT_SYMBOL_GPL(iscsi_find_flashnode_conn);
 
@@ -2808,7 +2798,7 @@ static int iscsi_set_flashnode_param(struct iscsi_transport *transport,
         struct iscsi_bus_flash_session *fnode_sess;
         struct iscsi_bus_flash_conn *fnode_conn;
         struct device *dev;
-        uint32_t *idx;
+        uint32_t idx;
         int err = 0;
 
         if (!transport->set_flashnode_param) {
@@ -2824,25 +2814,27 @@ static int iscsi_set_flashnode_param(struct iscsi_transport *transport,
                 goto put_host;
         }
 
-        idx = &ev->u.set_flashnode.flashnode_idx;
-        fnode_sess = iscsi_get_flashnode_by_index(shost, idx,
-                                                  flashnode_match_index);
+        idx = ev->u.set_flashnode.flashnode_idx;
+        fnode_sess = iscsi_get_flashnode_by_index(shost, idx);
         if (!fnode_sess) {
                 pr_err("%s could not find flashnode %u for host no %u\n",
-                       __func__, *idx, ev->u.set_flashnode.host_no);
+                       __func__, idx, ev->u.set_flashnode.host_no);
                 err = -ENODEV;
                 goto put_host;
         }
 
-        dev = iscsi_find_flashnode_conn(fnode_sess, NULL,
-                                        iscsi_is_flashnode_conn_dev);
+        dev = iscsi_find_flashnode_conn(fnode_sess);
         if (!dev) {
                 err = -ENODEV;
-                goto put_host;
+                goto put_sess;
         }
 
         fnode_conn = iscsi_dev_to_flash_conn(dev);
         err = transport->set_flashnode_param(fnode_sess, fnode_conn, data, len);
+        put_device(dev);
+
+put_sess:
+        put_device(&fnode_sess->dev);
 
 put_host:
         scsi_host_put(shost);
@@ -2891,7 +2883,7 @@ static int iscsi_del_flashnode(struct iscsi_transport *transport,
 {
         struct Scsi_Host *shost;
         struct iscsi_bus_flash_session *fnode_sess;
-        uint32_t *idx;
+        uint32_t idx;
         int err = 0;
 
         if (!transport->del_flashnode) {
@@ -2907,17 +2899,17 @@ static int iscsi_del_flashnode(struct iscsi_transport *transport,
                 goto put_host;
         }
 
-        idx = &ev->u.del_flashnode.flashnode_idx;
-        fnode_sess = iscsi_get_flashnode_by_index(shost, idx,
-                                                  flashnode_match_index);
+        idx = ev->u.del_flashnode.flashnode_idx;
+        fnode_sess = iscsi_get_flashnode_by_index(shost, idx);
         if (!fnode_sess) {
                 pr_err("%s could not find flashnode %u for host no %u\n",
-                       __func__, *idx, ev->u.del_flashnode.host_no);
+                       __func__, idx, ev->u.del_flashnode.host_no);
                 err = -ENODEV;
                 goto put_host;
         }
 
         err = transport->del_flashnode(fnode_sess);
+        put_device(&fnode_sess->dev);
 
 put_host:
         scsi_host_put(shost);
@@ -2933,7 +2925,7 @@ static int iscsi_login_flashnode(struct iscsi_transport *transport,
         struct iscsi_bus_flash_session *fnode_sess;
         struct iscsi_bus_flash_conn *fnode_conn;
         struct device *dev;
-        uint32_t *idx;
+        uint32_t idx;
         int err = 0;
 
         if (!transport->login_flashnode) {
@@ -2949,25 +2941,27 @@ static int iscsi_login_flashnode(struct iscsi_transport *transport,
                 goto put_host;
         }
 
-        idx = &ev->u.login_flashnode.flashnode_idx;
-        fnode_sess = iscsi_get_flashnode_by_index(shost, idx,
-                                                  flashnode_match_index);
+        idx = ev->u.login_flashnode.flashnode_idx;
+        fnode_sess = iscsi_get_flashnode_by_index(shost, idx);
         if (!fnode_sess) {
                 pr_err("%s could not find flashnode %u for host no %u\n",
-                       __func__, *idx, ev->u.login_flashnode.host_no);
+                       __func__, idx, ev->u.login_flashnode.host_no);
                 err = -ENODEV;
                 goto put_host;
         }
 
-        dev = iscsi_find_flashnode_conn(fnode_sess, NULL,
-                                        iscsi_is_flashnode_conn_dev);
+        dev = iscsi_find_flashnode_conn(fnode_sess);
         if (!dev) {
                 err = -ENODEV;
-                goto put_host;
+                goto put_sess;
         }
 
         fnode_conn = iscsi_dev_to_flash_conn(dev);
         err = transport->login_flashnode(fnode_sess, fnode_conn);
+        put_device(dev);
+
+put_sess:
+        put_device(&fnode_sess->dev);
 
 put_host:
         scsi_host_put(shost);
@@ -2983,7 +2977,7 @@ static int iscsi_logout_flashnode(struct iscsi_transport *transport,
         struct iscsi_bus_flash_session *fnode_sess;
         struct iscsi_bus_flash_conn *fnode_conn;
         struct device *dev;
-        uint32_t *idx;
+        uint32_t idx;
         int err = 0;
 
         if (!transport->logout_flashnode) {
@@ -2999,26 +2993,28 @@ static int iscsi_logout_flashnode(struct iscsi_transport *transport,
                 goto put_host;
         }
 
-        idx = &ev->u.logout_flashnode.flashnode_idx;
-        fnode_sess = iscsi_get_flashnode_by_index(shost, idx,
-                                                  flashnode_match_index);
+        idx = ev->u.logout_flashnode.flashnode_idx;
+        fnode_sess = iscsi_get_flashnode_by_index(shost, idx);
         if (!fnode_sess) {
                 pr_err("%s could not find flashnode %u for host no %u\n",
-                       __func__, *idx, ev->u.logout_flashnode.host_no);
+                       __func__, idx, ev->u.logout_flashnode.host_no);
                 err = -ENODEV;
                 goto put_host;
         }
 
-        dev = iscsi_find_flashnode_conn(fnode_sess, NULL,
-                                        iscsi_is_flashnode_conn_dev);
+        dev = iscsi_find_flashnode_conn(fnode_sess);
         if (!dev) {
                 err = -ENODEV;
-                goto put_host;
+                goto put_sess;
         }
 
         fnode_conn = iscsi_dev_to_flash_conn(dev);
 
         err = transport->logout_flashnode(fnode_sess, fnode_conn);
+        put_device(dev);
+
+put_sess:
+        put_device(&fnode_sess->dev);
 
 put_host:
         scsi_host_put(shost);
@@ -3985,8 +3981,10 @@ static __init int iscsi_transport_init(void)
         }
 
         iscsi_eh_timer_workq = create_singlethread_workqueue("iscsi_eh");
-        if (!iscsi_eh_timer_workq)
+        if (!iscsi_eh_timer_workq) {
+                err = -ENOMEM;
                 goto release_nls;
+        }
 
         return 0;
 
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index e6689776b4f6..c1c555242d0d 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -142,6 +142,7 @@ sd_store_cache_type(struct device *dev, struct device_attribute *attr,
         char *buffer_data;
         struct scsi_mode_data data;
         struct scsi_sense_hdr sshdr;
+        const char *temp = "temporary ";
         int len;
 
         if (sdp->type != TYPE_DISK)
@@ -150,6 +151,13 @@ sd_store_cache_type(struct device *dev, struct device_attribute *attr,
                  * it's not worth the risk */
                 return -EINVAL;
 
+        if (strncmp(buf, temp, sizeof(temp) - 1) == 0) {
+                buf += sizeof(temp) - 1;
+                sdkp->cache_override = 1;
+        } else {
+                sdkp->cache_override = 0;
+        }
+
         for (i = 0; i < ARRAY_SIZE(sd_cache_types); i++) {
                 len = strlen(sd_cache_types[i]);
                 if (strncmp(sd_cache_types[i], buf, len) == 0 &&
@@ -162,6 +170,13 @@ sd_store_cache_type(struct device *dev, struct device_attribute *attr,
                 return -EINVAL;
         rcd = ct & 0x01 ? 1 : 0;
         wce = ct & 0x02 ? 1 : 0;
+
+        if (sdkp->cache_override) {
+                sdkp->WCE = wce;
+                sdkp->RCD = rcd;
+                return count;
+        }
+
         if (scsi_mode_sense(sdp, 0x08, 8, buffer, sizeof(buffer), SD_TIMEOUT,
                             SD_MAX_RETRIES, &data, NULL))
                 return -EINVAL;
@@ -1121,10 +1136,6 @@ static int sd_open(struct block_device *bdev, fmode_t mode)
 
         sdev = sdkp->device;
 
-        retval = scsi_autopm_get_device(sdev);
-        if (retval)
-                goto error_autopm;
-
         /*
          * If the device is in error recovery, wait until it is done.
          * If the device is offline, then disallow any access to it.
@@ -1169,8 +1180,6 @@ static int sd_open(struct block_device *bdev, fmode_t mode)
         return 0;
 
 error_out:
-        scsi_autopm_put_device(sdev);
-error_autopm:
         scsi_disk_put(sdkp);
         return retval;  
 }
@@ -1205,7 +1214,6 @@ static void sd_release(struct gendisk *disk, fmode_t mode)
          * XXX is followed by a "rmmod sd_mod"?
          */
 
-        scsi_autopm_put_device(sdev);
         scsi_disk_put(sdkp);
 }
 
@@ -1366,14 +1374,9 @@ static unsigned int sd_check_events(struct gendisk *disk, unsigned int clearing)
         retval = -ENODEV;
 
         if (scsi_block_when_processing_errors(sdp)) {
-                retval = scsi_autopm_get_device(sdp);
-                if (retval)
-                        goto out;
-
                 sshdr  = kzalloc(sizeof(*sshdr), GFP_KERNEL);
                 retval = scsi_test_unit_ready(sdp, SD_TIMEOUT, SD_MAX_RETRIES,
                                               sshdr);
-                scsi_autopm_put_device(sdp);
         }
 
         /* failed to execute TUR, assume media not present */
@@ -1423,8 +1426,9 @@ static int sd_sync_cache(struct scsi_disk *sdkp)
                  * Leave the rest of the command zero to indicate
                  * flush everything.
                  */
-                res = scsi_execute_req(sdp, cmd, DMA_NONE, NULL, 0, &sshdr,
-                                       SD_FLUSH_TIMEOUT, SD_MAX_RETRIES, NULL);
+                res = scsi_execute_req_flags(sdp, cmd, DMA_NONE, NULL, 0,
+                                             &sshdr, SD_FLUSH_TIMEOUT,
+                                             SD_MAX_RETRIES, NULL, REQ_PM);
                 if (res == 0)
                         break;
         }
@@ -2318,6 +2322,10 @@ sd_read_cache_type(struct scsi_disk *sdkp, unsigned char *buffer)
         int old_rcd = sdkp->RCD;
         int old_dpofua = sdkp->DPOFUA;
 
+
+        if (sdkp->cache_override)
+                return;
+
         first_len = 4;
         if (sdp->skip_ms_page_8) {
                 if (sdp->type == TYPE_RBC)
@@ -2811,6 +2819,7 @@ static void sd_probe_async(void *data, async_cookie_t cookie)
         sdkp->capacity = 0;
         sdkp->media_present = 1;
         sdkp->write_prot = 0;
+        sdkp->cache_override = 0;
         sdkp->WCE = 0;
         sdkp->RCD = 0;
         sdkp->ATO = 0;
@@ -2837,6 +2846,7 @@ static void sd_probe_async(void *data, async_cookie_t cookie)
 
         sd_printk(KERN_NOTICE, sdkp, "Attached SCSI %sdisk\n",
                   sdp->removable ? "removable " : "");
+        blk_pm_runtime_init(sdp->request_queue, dev);
         scsi_autopm_put_device(sdp);
         put_device(&sdkp->dev);
 }
@@ -3020,8 +3030,8 @@ static int sd_start_stop_device(struct scsi_disk *sdkp, int start)
         if (!scsi_device_online(sdp))
                 return -ENODEV;
 
-        res = scsi_execute_req(sdp, cmd, DMA_NONE, NULL, 0, &sshdr,
-                               SD_TIMEOUT, SD_MAX_RETRIES, NULL);
+        res = scsi_execute_req_flags(sdp, cmd, DMA_NONE, NULL, 0, &sshdr,
+                               SD_TIMEOUT, SD_MAX_RETRIES, NULL, REQ_PM);
         if (res) {
                 sd_printk(KERN_WARNING, sdkp, "START_STOP FAILED\n");
                 sd_print_result(sdkp, res);
diff --git a/drivers/scsi/sd.h b/drivers/scsi/sd.h
index 74a1e4ca5401..2386aeb41fe8 100644
--- a/drivers/scsi/sd.h
+++ b/drivers/scsi/sd.h
@@ -73,6 +73,7 @@ struct scsi_disk {
         u8              protection_type;/* Data Integrity Field */
         u8              provisioning_mode;
         unsigned        ATO : 1;        /* state of disk ATO bit */
+        unsigned        cache_override : 1; /* temp override of WCE,RCD */
         unsigned        WCE : 1;        /* state of disk WCE bit */
         unsigned        RCD : 1;        /* state of disk RCD bit, unused */
         unsigned        DPOFUA : 1;     /* state of disk DPOFUA bit */
diff --git a/drivers/scsi/sd_dif.c b/drivers/scsi/sd_dif.c
index 04998f36e507..6174ca4ea275 100644
--- a/drivers/scsi/sd_dif.c
+++ b/drivers/scsi/sd_dif.c
@@ -93,14 +93,6 @@ static int sd_dif_type1_verify(struct blk_integrity_exchg *bix, csum_fn *fn)
                 if (sdt->app_tag == 0xffff)
                         return 0;
 
-                /* Bad ref tag received from disk */
-                if (sdt->ref_tag == 0xffffffff) {
-                        printk(KERN_ERR
-                               "%s: bad phys ref tag on sector %lu\n",
-                               bix->disk_name, (unsigned long)sector);
-                        return -EIO;
-                }
-
                 if (be32_to_cpu(sdt->ref_tag) != (sector & 0xffffffff)) {
                         printk(KERN_ERR
                                "%s: ref tag error on sector %lu (rcvd %u)\n",
diff --git a/drivers/scsi/ufs/Kconfig b/drivers/scsi/ufs/Kconfig
index 0371047c5922..35faf24c6044 100644
--- a/drivers/scsi/ufs/Kconfig
+++ b/drivers/scsi/ufs/Kconfig
@@ -57,3 +57,14 @@ config SCSI_UFSHCD_PCI
           If you have a controller with this interface, say Y or M here.
 
           If unsure, say N.
+
+config SCSI_UFSHCD_PLATFORM
+        tristate "Platform bus based UFS Controller support"
+        depends on SCSI_UFSHCD
+        ---help---
+        This selects the UFS host controller support. Select this if
+        you have an UFS controller on Platform bus.
+
+        If you have a controller with this interface, say Y or M here.
+
+          If unsure, say N.
diff --git a/drivers/scsi/ufs/Makefile b/drivers/scsi/ufs/Makefile
index 9eda0dfbd6df..1e5bd48457d6 100644
--- a/drivers/scsi/ufs/Makefile
+++ b/drivers/scsi/ufs/Makefile
@@ -1,3 +1,4 @@
 # UFSHCD makefile
 obj-$(CONFIG_SCSI_UFSHCD) += ufshcd.o
 obj-$(CONFIG_SCSI_UFSHCD_PCI) += ufshcd-pci.o
+obj-$(CONFIG_SCSI_UFSHCD_PLATFORM) += ufshcd-pltfrm.o
diff --git a/drivers/scsi/ufs/ufshcd-pltfrm.c b/drivers/scsi/ufs/ufshcd-pltfrm.c
new file mode 100644
index 000000000000..03319acd9c72
--- /dev/null
+++ b/drivers/scsi/ufs/ufshcd-pltfrm.c
@@ -0,0 +1,217 @@
+/*
+ * Universal Flash Storage Host controller Platform bus based glue driver
+ *
+ * This code is based on drivers/scsi/ufs/ufshcd-pltfrm.c
+ * Copyright (C) 2011-2013 Samsung India Software Operations
+ *
+ * Authors:
+ *      Santosh Yaraganavi <santosh.sy@samsung.com>
+ *      Vinayak Holikatti <h.vinayak@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ * See the COPYING file in the top-level directory or visit
+ * <http://www.gnu.org/licenses/gpl-2.0.html>
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * This program is provided "AS IS" and "WITH ALL FAULTS" and
+ * without warranty of any kind. You are solely responsible for
+ * determining the appropriateness of using and distributing
+ * the program and assume all risks associated with your exercise
+ * of rights with respect to the program, including but not limited
+ * to infringement of third party rights, the risks and costs of
+ * program errors, damage to or loss of data, programs or equipment,
+ * and unavailability or interruption of operations. Under no
+ * circumstances will the contributor of this Program be liable for
+ * any damages of any kind arising from your use or distribution of
+ * this program.
+ */
+
+#include "ufshcd.h"
+#include <linux/platform_device.h>
+
+#ifdef CONFIG_PM
+/**
+ * ufshcd_pltfrm_suspend - suspend power management function
+ * @dev: pointer to device handle
+ *
+ *
+ * Returns 0
+ */
+static int ufshcd_pltfrm_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct ufs_hba *hba =  platform_get_drvdata(pdev);
+
+        /*
+         * TODO:
+         * 1. Call ufshcd_suspend
+         * 2. Do bus specific power management
+         */
+
+        disable_irq(hba->irq);
+
+        return 0;
+}
+
+/**
+ * ufshcd_pltfrm_resume - resume power management function
+ * @dev: pointer to device handle
+ *
+ * Returns 0
+ */
+static int ufshcd_pltfrm_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct ufs_hba *hba =  platform_get_drvdata(pdev);
+
+        /*
+         * TODO:
+         * 1. Call ufshcd_resume.
+         * 2. Do bus specific wake up
+         */
+
+        enable_irq(hba->irq);
+
+        return 0;
+}
+#else
+#define ufshcd_pltfrm_suspend   NULL
+#define ufshcd_pltfrm_resume    NULL
+#endif
+
+/**
+ * ufshcd_pltfrm_probe - probe routine of the driver
+ * @pdev: pointer to Platform device handle
+ *
+ * Returns 0 on success, non-zero value on failure
+ */
+static int ufshcd_pltfrm_probe(struct platform_device *pdev)
+{
+        struct ufs_hba *hba;
+        void __iomem *mmio_base;
+        struct resource *mem_res;
+        struct resource *irq_res;
+        resource_size_t mem_size;
+        int err;
+        struct device *dev = &pdev->dev;
+
+        mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!mem_res) {
+                dev_err(&pdev->dev,
+                        "Memory resource not available\n");
+                err = -ENODEV;
+                goto out_error;
+        }
+
+        mem_size = resource_size(mem_res);
+        if (!request_mem_region(mem_res->start, mem_size, "ufshcd")) {
+                dev_err(&pdev->dev,
+                        "Cannot reserve the memory resource\n");
+                err = -EBUSY;
+                goto out_error;
+        }
+
+        mmio_base = ioremap_nocache(mem_res->start, mem_size);
+        if (!mmio_base) {
+                dev_err(&pdev->dev, "memory map failed\n");
+                err = -ENOMEM;
+                goto out_release_regions;
+        }
+
+        irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (!irq_res) {
+                dev_err(&pdev->dev, "IRQ resource not available\n");
+                err = -ENODEV;
+                goto out_iounmap;
+        }
+
+        err = dma_set_coherent_mask(dev, dev->coherent_dma_mask);
+        if (err) {
+                dev_err(&pdev->dev, "set dma mask failed\n");
+                goto out_iounmap;
+        }
+
+        err = ufshcd_init(&pdev->dev, &hba, mmio_base, irq_res->start);
+        if (err) {
+                dev_err(&pdev->dev, "Intialization failed\n");
+                goto out_iounmap;
+        }
+
+        platform_set_drvdata(pdev, hba);
+
+        return 0;
+
+out_iounmap:
+        iounmap(mmio_base);
+out_release_regions:
+        release_mem_region(mem_res->start, mem_size);
+out_error:
+        return err;
+}
+
+/**
+ * ufshcd_pltfrm_remove - remove platform driver routine
+ * @pdev: pointer to platform device handle
+ *
+ * Returns 0 on success, non-zero value on failure
+ */
+static int ufshcd_pltfrm_remove(struct platform_device *pdev)
+{
+        struct resource *mem_res;
+        resource_size_t mem_size;
+        struct ufs_hba *hba =  platform_get_drvdata(pdev);
+
+        disable_irq(hba->irq);
+
+        /* Some buggy controllers raise interrupt after
+         * the resources are removed. So first we unregister the
+         * irq handler and then the resources used by driver
+         */
+
+        free_irq(hba->irq, hba);
+        ufshcd_remove(hba);
+        mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!mem_res)
+                dev_err(&pdev->dev, "ufshcd: Memory resource not available\n");
+        else {
+                mem_size = resource_size(mem_res);
+                release_mem_region(mem_res->start, mem_size);
+        }
+        platform_set_drvdata(pdev, NULL);
+        return 0;
+}
+
+static const struct of_device_id ufs_of_match[] = {
+        { .compatible = "jedec,ufs-1.1"},
+};
+
+static const struct dev_pm_ops ufshcd_dev_pm_ops = {
+        .suspend        = ufshcd_pltfrm_suspend,
+        .resume         = ufshcd_pltfrm_resume,
+};
+
+static struct platform_driver ufshcd_pltfrm_driver = {
+        .probe  = ufshcd_pltfrm_probe,
+        .remove = ufshcd_pltfrm_remove,
+        .driver = {
+                .name   = "ufshcd",
+                .owner  = THIS_MODULE,
+                .pm     = &ufshcd_dev_pm_ops,
+                .of_match_table = ufs_of_match,
+        },
+};
+
+module_platform_driver(ufshcd_pltfrm_driver);
+
+MODULE_AUTHOR("Santosh Yaragnavi <santosh.sy@samsung.com>");
+MODULE_AUTHOR("Vinayak Holikatti <h.vinayak@samsung.com>");
+MODULE_DESCRIPTION("UFS host controller Pltform bus based glue driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(UFSHCD_DRIVER_VERSION);
diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
index 60fd40c4e4c2..c32a478df81b 100644
--- a/drivers/scsi/ufs/ufshcd.c
+++ b/drivers/scsi/ufs/ufshcd.c
@@ -478,7 +478,7 @@ static void ufshcd_compose_upiu(struct ufshcd_lrb *lrbp)
                 ucd_cmd_ptr->header.dword_2 = 0;
 
                 ucd_cmd_ptr->exp_data_transfer_len =
-                        cpu_to_be32(lrbp->cmd->transfersize);
+                        cpu_to_be32(lrbp->cmd->sdb.length);
 
                 memcpy(ucd_cmd_ptr->cdb,
                        lrbp->cmd->cmnd,