Merge tag 'scsi-misc' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi

Pull SCSI misc update from James Bottomley:
 "The patch contains the usual assortment of driver updates (be2iscsi,
  bfa, bnx2i, fcoe, hpsa, isci, lpfc, megaraid, mpt2sas, pm8001, sg)
  plus an assortment of other changes and fixes.  Also new is the fact
  that the isci update is delivered as a git merge (with signed tag)."

* tag 'scsi-misc' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi: (158 commits)
  isci: End the RNC resumption wait when the RNC is destroyed.
  isci: Fixed RNC bug that lost the suspension or resumption during destroy
  isci: Fix RNC AWAIT_SUSPENSION->INVALIDATING transition.
  isci: Manage the IREQ_NO_AUTO_FREE_TAG under scic_lock.
  isci: Remove obviated host callback list.
  isci: Check IDEV_GONE before performing abort path operations.
  isci: Restore the ATAPI device RNC management code.
  isci: Don't wait for an RNC suspend if it's being destroyed.
  isci: Change the phy control and link reset interface for HW reasons.
  isci: Added timeouts to RNC suspensions in the abort path.
  isci: Add protocol indicator for TMF requests.
  isci: Directly control IREQ_ABORT_PATH_ACTIVE when completing TMFs.
  isci: Wait for RNC resumption before leaving the abort path.
  isci: Fix RNC suspend call for SCI_RESUMING state.
  isci: Manage tag releases differently when aborting tasks.
  isci: Callbacks to libsas occur under scic_lock and are synchronized.
  isci: When in the abort path, defeat other resume calls until done.
  isci: Implement waiting for suspend in the abort path.
  isci: Make sure all TCs are terminated and cleaned in LUN reset.
  isci: Manage the LLHANG timer enable/disable per-device.
  ...

99 files changed, 6500 insertions, 4257 deletions

diff --git a/Documentation/scsi/ChangeLog.megaraid_sas b/Documentation/scsi/ChangeLog.megaraid_sas
index 83f8ea8b79eb..80441ab608e4 100644
--- a/Documentation/scsi/ChangeLog.megaraid_sas
+++ b/Documentation/scsi/ChangeLog.megaraid_sas
@@ -1,3 +1,11 @@
+Release Date    : Mon. Mar 19, 2012 17:00:00 PST 2012 -
+                        (emaild-id:megaraidlinux@lsi.com)
+                        Adam Radford
+Current Version : 00.00.06.15-rc1
+Old Version     : 00.00.06.14-rc1
+    1. Optimize HostMSIxVectors setting.
+    2. Add fpRead/WriteCapable, fpRead/WriteAcrossStripe checks.
+-------------------------------------------------------------------------------
 Release Date    : Fri. Jan 6, 2012 17:00:00 PST 2010 -
                         (emaild-id:megaraidlinux@lsi.com)
                         Adam Radford
diff --git a/MAINTAINERS b/MAINTAINERS
index 7560921a4e15..fddf29c057a1 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -1599,6 +1599,7 @@ F:	include/linux/bcma/
 
 BROCADE BFA FC SCSI DRIVER
 M:      Jing Huang <huangj@brocade.com>
+M:      Krishna C Gudipati <kgudipat@brocade.com>
 L:      linux-scsi@vger.kernel.org
 S:      Supported
 F:      drivers/scsi/bfa/
@@ -6882,6 +6883,14 @@ F:	Documentation/cdrom/
 F:      drivers/cdrom/cdrom.c
 F:      include/linux/cdrom.h
 
+UNIVERSAL FLASH STORAGE HOST CONTROLLER DRIVER
+M:      Vinayak Holikatti <vinholikatti@gmail.com>
+M:      Santosh Y <santoshsy@gmail.com>
+L:      linux-scsi@vger.kernel.org
+S:      Supported
+F:      Documentation/scsi/ufs.txt
+F:      drivers/scsi/ufs/
+
 UNSORTED BLOCK IMAGES (UBI)
 M:      Artem Bityutskiy <dedekind1@gmail.com>
 W:      http://www.linux-mtd.infradead.org/
diff --git a/drivers/scsi/Kconfig b/drivers/scsi/Kconfig
index 29684c8142b0..bea04e5d3b51 100644
--- a/drivers/scsi/Kconfig
+++ b/drivers/scsi/Kconfig
@@ -408,6 +408,7 @@ config BLK_DEV_3W_XXXX_RAID
 config SCSI_HPSA
         tristate "HP Smart Array SCSI driver"
         depends on PCI && SCSI
+        select CHECK_SIGNATURE
         help
           This driver supports HP Smart Array Controllers (circa 2009).
           It is a SCSI alternative to the cciss driver, which is a block
diff --git a/drivers/scsi/aacraid/src.c b/drivers/scsi/aacraid/src.c
index 2bee51506a91..762820636304 100644
--- a/drivers/scsi/aacraid/src.c
+++ b/drivers/scsi/aacraid/src.c
@@ -424,6 +424,8 @@ static int aac_src_deliver_message(struct fib *fib)
 static int aac_src_ioremap(struct aac_dev *dev, u32 size)
 {
         if (!size) {
+                iounmap(dev->regs.src.bar1);
+                dev->regs.src.bar1 = NULL;
                 iounmap(dev->regs.src.bar0);
                 dev->base = dev->regs.src.bar0 = NULL;
                 return 0;
diff --git a/drivers/scsi/be2iscsi/be.h b/drivers/scsi/be2iscsi/be.h
index 1d7b976c850f..a50b6a9030e8 100644
--- a/drivers/scsi/be2iscsi/be.h
+++ b/drivers/scsi/be2iscsi/be.h
@@ -132,10 +132,6 @@ struct be_ctrl_info {
                 ((u32)((((size_t)(_address) & (PAGE_SIZE_4K - 1)) +     \
                         (size) + (PAGE_SIZE_4K - 1)) >> PAGE_SHIFT_4K))
 
-/* Byte offset into the page corresponding to given address */
-#define OFFSET_IN_PAGE(addr)                                            \
-                ((size_t)(addr) & (PAGE_SIZE_4K-1))
-
 /* Returns bit offset within a DWORD of a bitfield */
 #define AMAP_BIT_OFFSET(_struct, field)                                 \
                 (((size_t)&(((_struct *)0)->field))%32)
diff --git a/drivers/scsi/be2iscsi/be_cmds.c b/drivers/scsi/be2iscsi/be_cmds.c
index cdb15364bc69..d2e9e933f7a3 100644
--- a/drivers/scsi/be2iscsi/be_cmds.c
+++ b/drivers/scsi/be2iscsi/be_cmds.c
@@ -15,6 +15,8 @@
  * Costa Mesa, CA 92626
  */
 
+#include <scsi/iscsi_proto.h>
+
 #include "be.h"
 #include "be_mgmt.h"
 #include "be_main.h"
diff --git a/drivers/scsi/be2iscsi/be_cmds.h b/drivers/scsi/be2iscsi/be_cmds.h
index 8b40a5b4366c..b0b36c6a145f 100644
--- a/drivers/scsi/be2iscsi/be_cmds.h
+++ b/drivers/scsi/be2iscsi/be_cmds.h
@@ -23,7 +23,7 @@
  * firmware in the BE. These requests are communicated to the processor
  * using Work Request Blocks (WRBs) submitted to the MCC-WRB ring or via one
  * WRB inside a MAILBOX.
- * The commands are serviced by the ARM processor in the BladeEngine's MPU.
+ * The commands are serviced by the ARM processor in the OneConnect's MPU.
  */
 struct be_sge {
         u32 pa_lo;
@@ -163,7 +163,8 @@ struct be_mcc_mailbox {
 #define OPCODE_COMMON_ISCSI_CFG_REMOVE_SGL_PAGES        3
 #define OPCODE_COMMON_ISCSI_NTWK_GET_NIC_CONFIG         7
 #define OPCODE_COMMON_ISCSI_NTWK_SET_VLAN               14
-#define OPCODE_COMMON_ISCSI_NTWK_CONFIGURE_STATELESS_IP_ADDR    17
+#define OPCODE_COMMON_ISCSI_NTWK_CONFIG_STATELESS_IP_ADDR       17
+#define OPCODE_COMMON_ISCSI_NTWK_REL_STATELESS_IP_ADDR  18
 #define OPCODE_COMMON_ISCSI_NTWK_MODIFY_IP_ADDR         21
 #define OPCODE_COMMON_ISCSI_NTWK_GET_DEFAULT_GATEWAY    22
 #define OPCODE_COMMON_ISCSI_NTWK_MODIFY_DEFAULT_GATEWAY 23
@@ -274,15 +275,15 @@ struct mgmt_conn_login_options {
         struct  mgmt_auth_method_format auth_data;
 } __packed;
 
-struct ip_address_format {
+struct ip_addr_format {
         u16 size_of_structure;
         u8 reserved;
         u8 ip_type;
-        u8 ip_address[16];
+        u8 addr[16];
         u32 rsvd0;
 } __packed;
 
-struct  mgmt_conn_info {
+struct mgmt_conn_info {
         u32     connection_handle;
         u32     connection_status;
         u16     src_port;
@@ -290,9 +291,9 @@ struct	mgmt_conn_info {
         u16     dest_port_redirected;
         u16     cid;
         u32     estimated_throughput;
-        struct  ip_address_format       src_ipaddr;
-        struct  ip_address_format       dest_ipaddr;
-        struct  ip_address_format       dest_ipaddr_redirected;
+        struct  ip_addr_format  src_ipaddr;
+        struct  ip_addr_format  dest_ipaddr;
+        struct  ip_addr_format  dest_ipaddr_redirected;
         struct  mgmt_conn_login_options negotiated_login_options;
 } __packed;
 
@@ -322,43 +323,115 @@ struct mgmt_session_info {
         struct  mgmt_conn_info  conn_list[1];
 } __packed;
 
-struct  be_cmd_req_get_session {
+struct be_cmd_get_session_req {
         struct be_cmd_req_hdr hdr;
         u32 session_handle;
 } __packed;
 
-struct  be_cmd_resp_get_session {
+struct be_cmd_get_session_resp {
         struct be_cmd_resp_hdr hdr;
         struct mgmt_session_info session_info;
 } __packed;
 
 struct mac_addr {
-        u16 size_of_struct;
+        u16 size_of_structure;
         u8 addr[ETH_ALEN];
 } __packed;
 
-struct be_cmd_req_get_boot_target {
+struct be_cmd_get_boot_target_req {
         struct be_cmd_req_hdr hdr;
 } __packed;
 
-struct be_cmd_resp_get_boot_target {
+struct be_cmd_get_boot_target_resp {
         struct be_cmd_resp_hdr hdr;
         u32  boot_session_count;
         int  boot_session_handle;
 };
 
-struct be_cmd_req_mac_query {
+struct be_cmd_mac_query_req {
         struct be_cmd_req_hdr hdr;
         u8 type;
         u8 permanent;
         u16 if_id;
 } __packed;
 
-struct be_cmd_resp_mac_query {
+struct be_cmd_get_mac_resp {
         struct be_cmd_resp_hdr hdr;
         struct mac_addr mac;
 };
 
+struct be_ip_addr_subnet_format {
+        u16 size_of_structure;
+        u8 ip_type;
+        u8 ipv6_prefix_length;
+        u8 addr[16];
+        u8 subnet_mask[16];
+        u32 rsvd0;
+} __packed;
+
+struct be_cmd_get_if_info_req {
+        struct be_cmd_req_hdr hdr;
+        u32 interface_hndl;
+        u32 ip_type;
+} __packed;
+
+struct be_cmd_get_if_info_resp {
+        struct be_cmd_req_hdr hdr;
+        u32 interface_hndl;
+        u32 vlan_priority;
+        u32 ip_addr_count;
+        u32 dhcp_state;
+        struct be_ip_addr_subnet_format ip_addr;
+} __packed;
+
+struct be_ip_addr_record {
+        u32 action;
+        u32 interface_hndl;
+        struct be_ip_addr_subnet_format ip_addr;
+        u32 status;
+} __packed;
+
+struct be_ip_addr_record_params {
+        u32 record_entry_count;
+        struct be_ip_addr_record ip_record;
+} __packed;
+
+struct be_cmd_set_ip_addr_req {
+        struct be_cmd_req_hdr hdr;
+        struct be_ip_addr_record_params ip_params;
+} __packed;
+
+
+struct be_cmd_set_dhcp_req {
+        struct be_cmd_req_hdr hdr;
+        u32 interface_hndl;
+        u32 ip_type;
+        u32 flags;
+        u32 retry_count;
+} __packed;
+
+struct be_cmd_rel_dhcp_req {
+        struct be_cmd_req_hdr hdr;
+        u32 interface_hndl;
+        u32 ip_type;
+} __packed;
+
+struct be_cmd_set_def_gateway_req {
+        struct be_cmd_req_hdr hdr;
+        u32 action;
+        struct ip_addr_format ip_addr;
+} __packed;
+
+struct be_cmd_get_def_gateway_req {
+        struct be_cmd_req_hdr hdr;
+        u32 ip_type;
+} __packed;
+
+struct be_cmd_get_def_gateway_resp {
+        struct be_cmd_req_hdr hdr;
+        struct ip_addr_format ip_addr;
+} __packed;
+
 /******************** Create CQ ***************************/
 /**
  * Pseudo amap definition in which each bit of the actual structure is defined
@@ -489,7 +562,7 @@ struct be_cmd_req_modify_eq_delay {
 
 #define ETH_ALEN        6
 
-struct be_cmd_req_get_mac_addr {
+struct be_cmd_get_nic_conf_req {
         struct be_cmd_req_hdr hdr;
         u32 nic_port_count;
         u32 speed;
@@ -501,7 +574,7 @@ struct be_cmd_req_get_mac_addr {
         u32 rsvd[23];
 };
 
-struct be_cmd_resp_get_mac_addr {
+struct be_cmd_get_nic_conf_resp {
         struct be_cmd_resp_hdr hdr;
         u32 nic_port_count;
         u32 speed;
@@ -513,6 +586,39 @@ struct be_cmd_resp_get_mac_addr {
         u32 rsvd[23];
 };
 
+#define BEISCSI_ALIAS_LEN 32
+
+struct be_cmd_hba_name {
+        struct be_cmd_req_hdr hdr;
+        u16 flags;
+        u16 rsvd0;
+        u8 initiator_name[ISCSI_NAME_LEN];
+        u8 initiator_alias[BEISCSI_ALIAS_LEN];
+} __packed;
+
+struct be_cmd_ntwk_link_status_req {
+        struct be_cmd_req_hdr hdr;
+        u32 rsvd0;
+} __packed;
+
+/*** Port Speed Values ***/
+#define BE2ISCSI_LINK_SPEED_ZERO        0x00
+#define BE2ISCSI_LINK_SPEED_10MBPS      0x01
+#define BE2ISCSI_LINK_SPEED_100MBPS     0x02
+#define BE2ISCSI_LINK_SPEED_1GBPS       0x03
+#define BE2ISCSI_LINK_SPEED_10GBPS      0x04
+struct be_cmd_ntwk_link_status_resp {
+        struct be_cmd_resp_hdr hdr;
+        u8 phys_port;
+        u8 mac_duplex;
+        u8 mac_speed;
+        u8 mac_fault;
+        u8 mgmt_mac_duplex;
+        u8 mgmt_mac_speed;
+        u16 qos_link_speed;
+        u32 logical_link_speed;
+} __packed;
+
 int beiscsi_cmd_eq_create(struct be_ctrl_info *ctrl,
                           struct be_queue_info *eq, int eq_delay);
 
@@ -530,11 +636,8 @@ int beiscsi_cmd_mccq_create(struct beiscsi_hba *phba,
 int be_poll_mcc(struct be_ctrl_info *ctrl);
 int mgmt_check_supported_fw(struct be_ctrl_info *ctrl,
                                       struct beiscsi_hba *phba);
-unsigned int be_cmd_get_mac_addr(struct beiscsi_hba *phba);
-unsigned int beiscsi_get_boot_target(struct beiscsi_hba *phba);
-unsigned int beiscsi_get_session_info(struct beiscsi_hba *phba,
-                                  u32 boot_session_handle,
-                                  struct be_dma_mem *nonemb_cmd);
+unsigned int be_cmd_get_initname(struct beiscsi_hba *phba);
+unsigned int be_cmd_get_port_speed(struct beiscsi_hba *phba);
 
 void free_mcc_tag(struct be_ctrl_info *ctrl, unsigned int tag);
 /*ISCSI Functuions */
@@ -715,7 +818,7 @@ struct be_eq_delay_params_in {
 
 struct tcp_connect_and_offload_in {
         struct be_cmd_req_hdr hdr;
-        struct ip_address_format ip_address;
+        struct ip_addr_format ip_address;
         u16 tcp_port;
         u16 cid;
         u16 cq_id;
@@ -792,13 +895,14 @@ struct be_fw_cfg {
         u32 function_caps;
 } __packed;
 
-struct be_all_if_id {
+struct be_cmd_get_all_if_id_req {
         struct be_cmd_req_hdr hdr;
         u32 if_count;
         u32 if_hndl_list[1];
 } __packed;
 
 #define ISCSI_OPCODE_SCSI_DATA_OUT              5
+#define OPCODE_COMMON_NTWK_LINK_STATUS_QUERY 5
 #define OPCODE_COMMON_MODIFY_EQ_DELAY           41
 #define OPCODE_COMMON_ISCSI_CLEANUP             59
 #define OPCODE_COMMON_TCP_UPLOAD                56
@@ -810,6 +914,8 @@ struct be_all_if_id {
 #define OPCODE_ISCSI_INI_DRIVER_OFFLOAD_SESSION 41
 #define OPCODE_ISCSI_INI_DRIVER_INVALIDATE_CONNECTION 42
 #define OPCODE_ISCSI_INI_BOOT_GET_BOOT_TARGET   52
+#define OPCODE_COMMON_WRITE_FLASH               96
+#define OPCODE_COMMON_READ_FLASH                97
 
 /* --- CMD_ISCSI_INVALIDATE_CONNECTION_TYPE --- */
 #define CMD_ISCSI_COMMAND_INVALIDATE            1
diff --git a/drivers/scsi/be2iscsi/be_iscsi.c b/drivers/scsi/be2iscsi/be_iscsi.c
index 33c8f09c7ac1..43f35034585d 100644
--- a/drivers/scsi/be2iscsi/be_iscsi.c
+++ b/drivers/scsi/be2iscsi/be_iscsi.c
@@ -23,6 +23,8 @@
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_host.h>
+#include <scsi/scsi_netlink.h>
+#include <net/netlink.h>
 #include <scsi/scsi.h>
 
 #include "be_iscsi.h"
@@ -207,6 +209,301 @@ int beiscsi_conn_bind(struct iscsi_cls_session *cls_session,
         return beiscsi_bindconn_cid(phba, beiscsi_conn, beiscsi_ep->ep_cid);
 }
 
+static int beiscsi_create_ipv4_iface(struct beiscsi_hba *phba)
+{
+        if (phba->ipv4_iface)
+                return 0;
+
+        phba->ipv4_iface = iscsi_create_iface(phba->shost,
+                                              &beiscsi_iscsi_transport,
+                                              ISCSI_IFACE_TYPE_IPV4,
+                                              0, 0);
+        if (!phba->ipv4_iface) {
+                shost_printk(KERN_ERR, phba->shost, "Could not "
+                             "create default IPv4 address.\n");
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+static int beiscsi_create_ipv6_iface(struct beiscsi_hba *phba)
+{
+        if (phba->ipv6_iface)
+                return 0;
+
+        phba->ipv6_iface = iscsi_create_iface(phba->shost,
+                                              &beiscsi_iscsi_transport,
+                                              ISCSI_IFACE_TYPE_IPV6,
+                                              0, 0);
+        if (!phba->ipv6_iface) {
+                shost_printk(KERN_ERR, phba->shost, "Could not "
+                             "create default IPv6 address.\n");
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+void beiscsi_create_def_ifaces(struct beiscsi_hba *phba)
+{
+        struct be_cmd_get_if_info_resp if_info;
+
+        if (!mgmt_get_if_info(phba, BE2_IPV4, &if_info))
+                beiscsi_create_ipv4_iface(phba);
+
+        if (!mgmt_get_if_info(phba, BE2_IPV6, &if_info))
+                beiscsi_create_ipv6_iface(phba);
+}
+
+void beiscsi_destroy_def_ifaces(struct beiscsi_hba *phba)
+{
+        if (phba->ipv6_iface)
+                iscsi_destroy_iface(phba->ipv6_iface);
+        if (phba->ipv4_iface)
+                iscsi_destroy_iface(phba->ipv4_iface);
+}
+
+static int
+beiscsi_set_static_ip(struct Scsi_Host *shost,
+                struct iscsi_iface_param_info *iface_param,
+                void *data, uint32_t dt_len)
+{
+        struct beiscsi_hba *phba = iscsi_host_priv(shost);
+        struct iscsi_iface_param_info *iface_ip = NULL;
+        struct iscsi_iface_param_info *iface_subnet = NULL;
+        struct nlattr *nla;
+        int ret;
+
+
+        switch (iface_param->param) {
+        case ISCSI_NET_PARAM_IPV4_BOOTPROTO:
+                nla = nla_find(data, dt_len, ISCSI_NET_PARAM_IPV4_ADDR);
+                if (nla)
+                        iface_ip = nla_data(nla);
+
+                nla = nla_find(data, dt_len, ISCSI_NET_PARAM_IPV4_SUBNET);
+                if (nla)
+                        iface_subnet = nla_data(nla);
+                break;
+        case ISCSI_NET_PARAM_IPV4_ADDR:
+                iface_ip = iface_param;
+                nla = nla_find(data, dt_len, ISCSI_NET_PARAM_IPV4_SUBNET);
+                if (nla)
+                        iface_subnet = nla_data(nla);
+                break;
+        case ISCSI_NET_PARAM_IPV4_SUBNET:
+                iface_subnet = iface_param;
+                nla = nla_find(data, dt_len, ISCSI_NET_PARAM_IPV4_ADDR);
+                if (nla)
+                        iface_ip = nla_data(nla);
+                break;
+        default:
+                shost_printk(KERN_ERR, shost, "Unsupported param %d\n",
+                             iface_param->param);
+        }
+
+        if (!iface_ip || !iface_subnet) {
+                shost_printk(KERN_ERR, shost, "IP and Subnet Mask required\n");
+                return -EINVAL;
+        }
+
+        ret = mgmt_set_ip(phba, iface_ip, iface_subnet,
+                        ISCSI_BOOTPROTO_STATIC);
+
+        return ret;
+}
+
+static int
+beiscsi_set_ipv4(struct Scsi_Host *shost,
+                struct iscsi_iface_param_info *iface_param,
+                void *data, uint32_t dt_len)
+{
+        struct beiscsi_hba *phba = iscsi_host_priv(shost);
+        int ret = 0;
+
+        /* Check the param */
+        switch (iface_param->param) {
+        case ISCSI_NET_PARAM_IPV4_GW:
+                ret = mgmt_set_gateway(phba, iface_param);
+                break;
+        case ISCSI_NET_PARAM_IPV4_BOOTPROTO:
+                if (iface_param->value[0] == ISCSI_BOOTPROTO_DHCP)
+                        ret = mgmt_set_ip(phba, iface_param,
+                                        NULL, ISCSI_BOOTPROTO_DHCP);
+                else if (iface_param->value[0] == ISCSI_BOOTPROTO_STATIC)
+                        ret = beiscsi_set_static_ip(shost, iface_param,
+                                                    data, dt_len);
+                else
+                        shost_printk(KERN_ERR, shost, "Invalid BOOTPROTO: %d\n",
+                                        iface_param->value[0]);
+                break;
+        case ISCSI_NET_PARAM_IFACE_ENABLE:
+                if (iface_param->value[0] == ISCSI_IFACE_ENABLE)
+                        ret = beiscsi_create_ipv4_iface(phba);
+                else
+                        iscsi_destroy_iface(phba->ipv4_iface);
+                break;
+        case ISCSI_NET_PARAM_IPV4_SUBNET:
+        case ISCSI_NET_PARAM_IPV4_ADDR:
+                ret = beiscsi_set_static_ip(shost, iface_param,
+                                            data, dt_len);
+                break;
+        default:
+                shost_printk(KERN_ERR, shost, "Param %d not supported\n",
+                             iface_param->param);
+        }
+
+        return ret;
+}
+
+static int
+beiscsi_set_ipv6(struct Scsi_Host *shost,
+                struct iscsi_iface_param_info *iface_param,
+                void *data, uint32_t dt_len)
+{
+        struct beiscsi_hba *phba = iscsi_host_priv(shost);
+        int ret = 0;
+
+        switch (iface_param->param) {
+        case ISCSI_NET_PARAM_IFACE_ENABLE:
+                if (iface_param->value[0] == ISCSI_IFACE_ENABLE)
+                        ret = beiscsi_create_ipv6_iface(phba);
+                else {
+                        iscsi_destroy_iface(phba->ipv6_iface);
+                        ret = 0;
+                }
+                break;
+        case ISCSI_NET_PARAM_IPV6_ADDR:
+                ret = mgmt_set_ip(phba, iface_param, NULL,
+                                  ISCSI_BOOTPROTO_STATIC);
+                break;
+        default:
+                shost_printk(KERN_ERR, shost, "Param %d not supported\n",
+                             iface_param->param);
+        }
+
+        return ret;
+}
+
+int be2iscsi_iface_set_param(struct Scsi_Host *shost,
+                void *data, uint32_t dt_len)
+{
+        struct iscsi_iface_param_info *iface_param = NULL;
+        struct nlattr *attrib;
+        uint32_t rm_len = dt_len;
+        int ret = 0 ;
+
+        nla_for_each_attr(attrib, data, dt_len, rm_len) {
+                iface_param = nla_data(attrib);
+
+                if (iface_param->param_type != ISCSI_NET_PARAM)
+                        continue;
+
+                /*
+                 * BE2ISCSI only supports 1 interface
+                 */
+                if (iface_param->iface_num) {
+                        shost_printk(KERN_ERR, shost, "Invalid iface_num %d."
+                                     "Only iface_num 0 is supported.\n",
+                                     iface_param->iface_num);
+                        return -EINVAL;
+                }
+
+                switch (iface_param->iface_type) {
+                case ISCSI_IFACE_TYPE_IPV4:
+                        ret = beiscsi_set_ipv4(shost, iface_param,
+                                               data, dt_len);
+                        break;
+                case ISCSI_IFACE_TYPE_IPV6:
+                        ret = beiscsi_set_ipv6(shost, iface_param,
+                                               data, dt_len);
+                        break;
+                default:
+                        shost_printk(KERN_ERR, shost,
+                                     "Invalid iface type :%d passed\n",
+                                     iface_param->iface_type);
+                        break;
+                }
+
+                if (ret)
+                        return ret;
+        }
+
+        return ret;
+}
+
+static int be2iscsi_get_if_param(struct beiscsi_hba *phba,
+                struct iscsi_iface *iface, int param,
+                char *buf)
+{
+        struct be_cmd_get_if_info_resp if_info;
+        int len, ip_type = BE2_IPV4;
+
+        memset(&if_info, 0, sizeof(if_info));
+
+        if (iface->iface_type == ISCSI_IFACE_TYPE_IPV6)
+                ip_type = BE2_IPV6;
+
+        len = mgmt_get_if_info(phba, ip_type, &if_info);
+        if (len)
+                return len;
+
+        switch (param) {
+        case ISCSI_NET_PARAM_IPV4_ADDR:
+                len = sprintf(buf, "%pI4\n", &if_info.ip_addr.addr);
+                break;
+        case ISCSI_NET_PARAM_IPV6_ADDR:
+                len = sprintf(buf, "%pI6\n", &if_info.ip_addr.addr);
+                break;
+        case ISCSI_NET_PARAM_IPV4_BOOTPROTO:
+                if (!if_info.dhcp_state)
+                        len = sprintf(buf, "static");
+                else
+                        len = sprintf(buf, "dhcp");
+                break;
+        case ISCSI_NET_PARAM_IPV4_SUBNET:
+                len = sprintf(buf, "%pI4\n", &if_info.ip_addr.subnet_mask);
+                break;
+        default:
+                WARN_ON(1);
+        }
+
+        return len;
+}
+
+int be2iscsi_iface_get_param(struct iscsi_iface *iface,
+                enum iscsi_param_type param_type,
+                int param, char *buf)
+{
+        struct Scsi_Host *shost = iscsi_iface_to_shost(iface);
+        struct beiscsi_hba *phba = iscsi_host_priv(shost);
+        struct be_cmd_get_def_gateway_resp gateway;
+        int len = -ENOSYS;
+
+        switch (param) {
+        case ISCSI_NET_PARAM_IPV4_ADDR:
+        case ISCSI_NET_PARAM_IPV4_SUBNET:
+        case ISCSI_NET_PARAM_IPV4_BOOTPROTO:
+        case ISCSI_NET_PARAM_IPV6_ADDR:
+                len = be2iscsi_get_if_param(phba, iface, param, buf);
+                break;
+        case ISCSI_NET_PARAM_IFACE_ENABLE:
+                len = sprintf(buf, "enabled");
+                break;
+        case ISCSI_NET_PARAM_IPV4_GW:
+                memset(&gateway, 0, sizeof(gateway));
+                len = mgmt_get_gateway(phba, BE2_IPV4, &gateway);
+                if (!len)
+                        len = sprintf(buf, "%pI4\n", &gateway.ip_addr.addr);
+                break;
+        default:
+                len = -ENOSYS;
+        }
+
+        return len;
+}
+
 /**
  * beiscsi_ep_get_param - get the iscsi parameter
  * @ep: pointer to iscsi ep
@@ -221,7 +518,7 @@ int beiscsi_ep_get_param(struct iscsi_endpoint *ep,
         struct beiscsi_endpoint *beiscsi_ep = ep->dd_data;
         int len = 0;
 
-        SE_DEBUG(DBG_LVL_8, "In beiscsi_conn_get_param, param= %d\n", param);
+        SE_DEBUG(DBG_LVL_8, "In beiscsi_ep_get_param, param= %d\n", param);
 
         switch (param) {
         case ISCSI_PARAM_CONN_PORT:
@@ -279,6 +576,121 @@ int beiscsi_set_param(struct iscsi_cls_conn *cls_conn,
 }
 
 /**
+ * beiscsi_get_initname - Read Initiator Name from flash
+ * @buf: buffer bointer
+ * @phba: The device priv structure instance
+ *
+ * returns number of bytes
+ */
+static int beiscsi_get_initname(char *buf, struct beiscsi_hba *phba)
+{
+        int rc;
+        unsigned int tag, wrb_num;
+        unsigned short status, extd_status;
+        struct be_mcc_wrb *wrb;
+        struct be_cmd_hba_name *resp;
+        struct be_queue_info *mccq = &phba->ctrl.mcc_obj.q;
+
+        tag = be_cmd_get_initname(phba);
+        if (!tag) {
+                SE_DEBUG(DBG_LVL_1, "Getting Initiator Name Failed\n");
+                return -EBUSY;
+        } else
+                wait_event_interruptible(phba->ctrl.mcc_wait[tag],
+                                phba->ctrl.mcc_numtag[tag]);
+
+        wrb_num = (phba->ctrl.mcc_numtag[tag] & 0x00FF0000) >> 16;
+        extd_status = (phba->ctrl.mcc_numtag[tag] & 0x0000FF00) >> 8;
+        status = phba->ctrl.mcc_numtag[tag] & 0x000000FF;
+
+        if (status || extd_status) {
+                SE_DEBUG(DBG_LVL_1, "MailBox Command Failed with "
+                                "status = %d extd_status = %d\n",
+                                status, extd_status);
+                free_mcc_tag(&phba->ctrl, tag);
+                return -EAGAIN;
+        }
+        wrb = queue_get_wrb(mccq, wrb_num);
+        free_mcc_tag(&phba->ctrl, tag);
+        resp = embedded_payload(wrb);
+        rc = sprintf(buf, "%s\n", resp->initiator_name);
+        return rc;
+}
+
+/**
+ * beiscsi_get_port_state - Get the Port State
+ * @shost : pointer to scsi_host structure
+ *
+ * returns number of bytes
+ */
+static void beiscsi_get_port_state(struct Scsi_Host *shost)
+{
+        struct beiscsi_hba *phba = iscsi_host_priv(shost);
+        struct iscsi_cls_host *ihost = shost->shost_data;
+
+        ihost->port_state = (phba->state == BE_ADAPTER_UP) ?
+                ISCSI_PORT_STATE_UP : ISCSI_PORT_STATE_DOWN;
+}
+
+/**
+ * beiscsi_get_port_speed  - Get the Port Speed from Adapter
+ * @shost : pointer to scsi_host structure
+ *
+ * returns Success/Failure
+ */
+static int beiscsi_get_port_speed(struct Scsi_Host *shost)
+{
+        unsigned int tag, wrb_num;
+        unsigned short status, extd_status;
+        struct be_mcc_wrb *wrb;
+        struct be_cmd_ntwk_link_status_resp *resp;
+        struct beiscsi_hba *phba = iscsi_host_priv(shost);
+        struct iscsi_cls_host *ihost = shost->shost_data;
+        struct be_queue_info *mccq = &phba->ctrl.mcc_obj.q;
+
+        tag = be_cmd_get_port_speed(phba);
+        if (!tag) {
+                SE_DEBUG(DBG_LVL_1, "Getting Port Speed Failed\n");
+                 return -EBUSY;
+         } else
+                wait_event_interruptible(phba->ctrl.mcc_wait[tag],
+                                phba->ctrl.mcc_numtag[tag]);
+
+        wrb_num = (phba->ctrl.mcc_numtag[tag] & 0x00FF0000) >> 16;
+        extd_status = (phba->ctrl.mcc_numtag[tag] & 0x0000FF00) >> 8;
+        status = phba->ctrl.mcc_numtag[tag] & 0x000000FF;
+
+        if (status || extd_status) {
+                SE_DEBUG(DBG_LVL_1, "MailBox Command Failed with "
+                                "status = %d extd_status = %d\n",
+                                status, extd_status);
+                free_mcc_tag(&phba->ctrl, tag);
+                return -EAGAIN;
+        }
+        wrb = queue_get_wrb(mccq, wrb_num);
+        free_mcc_tag(&phba->ctrl, tag);
+        resp = embedded_payload(wrb);
+
+        switch (resp->mac_speed) {
+        case BE2ISCSI_LINK_SPEED_10MBPS:
+                ihost->port_speed = ISCSI_PORT_SPEED_10MBPS;
+                break;
+        case BE2ISCSI_LINK_SPEED_100MBPS:
+                ihost->port_speed = BE2ISCSI_LINK_SPEED_100MBPS;
+                break;
+        case BE2ISCSI_LINK_SPEED_1GBPS:
+                ihost->port_speed = ISCSI_PORT_SPEED_1GBPS;
+                break;
+        case BE2ISCSI_LINK_SPEED_10GBPS:
+                ihost->port_speed = ISCSI_PORT_SPEED_10GBPS;
+                break;
+        default:
+                ihost->port_speed = ISCSI_PORT_SPEED_UNKNOWN;
+        }
+        return 0;
+}
+
+/**
  * beiscsi_get_host_param - get the iscsi parameter
  * @shost: pointer to scsi_host structure
  * @param: parameter type identifier
@@ -301,6 +713,27 @@ int beiscsi_get_host_param(struct Scsi_Host *shost,
                         return status;
                 }
                 break;
+        case ISCSI_HOST_PARAM_INITIATOR_NAME:
+                status = beiscsi_get_initname(buf, phba);
+                if (status < 0) {
+                        SE_DEBUG(DBG_LVL_1,
+                                        "Retreiving Initiator Name Failed\n");
+                        return status;
+                }
+                break;
+        case ISCSI_HOST_PARAM_PORT_STATE:
+                beiscsi_get_port_state(shost);
+                status = sprintf(buf, "%s\n", iscsi_get_port_state_name(shost));
+                break;
+        case ISCSI_HOST_PARAM_PORT_SPEED:
+                status = beiscsi_get_port_speed(shost);
+                if (status) {
+                        SE_DEBUG(DBG_LVL_1,
+                                        "Retreiving Port Speed Failed\n");
+                        return status;
+                }
+                status = sprintf(buf, "%s\n", iscsi_get_port_speed_name(shost));
+                break;
         default:
                 return iscsi_host_get_param(shost, param, buf);
         }
@@ -309,46 +742,21 @@ int beiscsi_get_host_param(struct Scsi_Host *shost,
 
 int beiscsi_get_macaddr(char *buf, struct beiscsi_hba *phba)
 {
-        struct be_cmd_resp_get_mac_addr *resp;
-        struct be_mcc_wrb *wrb;
-        unsigned int tag, wrb_num;
-        unsigned short status, extd_status;
-        struct be_queue_info *mccq = &phba->ctrl.mcc_obj.q;
+        struct be_cmd_get_nic_conf_resp resp;
         int rc;
 
-        if (phba->read_mac_address)
-                return sysfs_format_mac(buf, phba->mac_address,
-                                        ETH_ALEN);
+        if (strlen(phba->mac_address))
+                return strlcpy(buf, phba->mac_address, PAGE_SIZE);
 
-        tag = be_cmd_get_mac_addr(phba);
-        if (!tag) {
-                SE_DEBUG(DBG_LVL_1, "be_cmd_get_mac_addr Failed\n");
-                return -EBUSY;
-        } else
-                wait_event_interruptible(phba->ctrl.mcc_wait[tag],
-                                         phba->ctrl.mcc_numtag[tag]);
+        memset(&resp, 0, sizeof(resp));
+        rc = mgmt_get_nic_conf(phba, &resp);
+        if (rc)
+                return rc;
 
-        wrb_num = (phba->ctrl.mcc_numtag[tag] & 0x00FF0000) >> 16;
-        extd_status = (phba->ctrl.mcc_numtag[tag] & 0x0000FF00) >> 8;
-        status = phba->ctrl.mcc_numtag[tag] & 0x000000FF;
-        if (status || extd_status) {
-                SE_DEBUG(DBG_LVL_1, "Failed to get be_cmd_get_mac_addr"
-                                    " status = %d extd_status = %d\n",
-                                    status, extd_status);
-                free_mcc_tag(&phba->ctrl, tag);
-                return -EAGAIN;
-        }
-        wrb = queue_get_wrb(mccq, wrb_num);
-        free_mcc_tag(&phba->ctrl, tag);
-        resp = embedded_payload(wrb);
-        memcpy(phba->mac_address, resp->mac_address, ETH_ALEN);
-        rc = sysfs_format_mac(buf, phba->mac_address,
-                               ETH_ALEN);
-        phba->read_mac_address = 1;
-        return rc;
+        memcpy(phba->mac_address, resp.mac_address, ETH_ALEN);
+        return sysfs_format_mac(buf, phba->mac_address, ETH_ALEN);
 }
 
-
 /**
  * beiscsi_conn_get_stats - get the iscsi stats
  * @cls_conn: pointer to iscsi cls conn
@@ -736,11 +1144,24 @@ void beiscsi_ep_disconnect(struct iscsi_endpoint *ep)
 umode_t be2iscsi_attr_is_visible(int param_type, int param)
 {
         switch (param_type) {
+        case ISCSI_NET_PARAM:
+                switch (param) {
+                case ISCSI_NET_PARAM_IFACE_ENABLE:
+                case ISCSI_NET_PARAM_IPV4_ADDR:
+                case ISCSI_NET_PARAM_IPV4_SUBNET:
+                case ISCSI_NET_PARAM_IPV4_BOOTPROTO:
+                case ISCSI_NET_PARAM_IPV4_GW:
+                case ISCSI_NET_PARAM_IPV6_ADDR:
+                        return S_IRUGO;
+                default:
+                        return 0;
+                }
         case ISCSI_HOST_PARAM:
                 switch (param) {
                 case ISCSI_HOST_PARAM_HWADDRESS:
-                case ISCSI_HOST_PARAM_IPADDRESS:
                 case ISCSI_HOST_PARAM_INITIATOR_NAME:
+                case ISCSI_HOST_PARAM_PORT_STATE:
+                case ISCSI_HOST_PARAM_PORT_SPEED:
                         return S_IRUGO;
                 default:
                         return 0;
diff --git a/drivers/scsi/be2iscsi/be_iscsi.h b/drivers/scsi/be2iscsi/be_iscsi.h
index 5c45be134501..8b826fc06bcc 100644
--- a/drivers/scsi/be2iscsi/be_iscsi.h
+++ b/drivers/scsi/be2iscsi/be_iscsi.h
@@ -25,6 +25,21 @@
 
 #define BE2_IPV4  0x1
 #define BE2_IPV6  0x10
+#define BE2_DHCP_V4 0x05
+
+#define NON_BLOCKING 0x0
+#define BLOCKING 0x1
+
+void beiscsi_create_def_ifaces(struct beiscsi_hba *phba);
+
+void beiscsi_destroy_def_ifaces(struct beiscsi_hba *phba);
+
+int be2iscsi_iface_get_param(struct iscsi_iface *iface,
+                             enum iscsi_param_type param_type,
+                             int param, char *buf);
+
+int be2iscsi_iface_set_param(struct Scsi_Host *shost,
+                             void *data, uint32_t count);
 
 umode_t be2iscsi_attr_is_visible(int param_type, int param);
 
diff --git a/drivers/scsi/be2iscsi/be_main.c b/drivers/scsi/be2iscsi/be_main.c
index 375756fa95cf..0b1d99c99fd2 100644
--- a/drivers/scsi/be2iscsi/be_main.c
+++ b/drivers/scsi/be2iscsi/be_main.c
@@ -28,8 +28,11 @@
 #include <linux/semaphore.h>
 #include <linux/iscsi_boot_sysfs.h>
 #include <linux/module.h>
+#include <linux/bsg-lib.h>
 
 #include <scsi/libiscsi.h>
+#include <scsi/scsi_bsg_iscsi.h>
+#include <scsi/scsi_netlink.h>
 #include <scsi/scsi_transport_iscsi.h>
 #include <scsi/scsi_transport.h>
 #include <scsi/scsi_cmnd.h>
@@ -48,7 +51,8 @@ static unsigned int num_hba = 0;
 
 MODULE_DEVICE_TABLE(pci, beiscsi_pci_id_table);
 MODULE_DESCRIPTION(DRV_DESC " " BUILD_STR);
-MODULE_AUTHOR("ServerEngines Corporation");
+MODULE_VERSION(BUILD_STR);
+MODULE_AUTHOR("Emulex Corporation");
 MODULE_LICENSE("GPL");
 module_param(be_iopoll_budget, int, 0);
 module_param(enable_msix, int, 0);
@@ -147,15 +151,15 @@ static int beiscsi_eh_device_reset(struct scsi_cmnd *sc)
         struct invalidate_command_table *inv_tbl;
         struct be_dma_mem nonemb_cmd;
         unsigned int cid, tag, i, num_invalidate;
-        int rc = FAILED;
 
         /* invalidate iocbs */
         cls_session = starget_to_session(scsi_target(sc->device));
         session = cls_session->dd_data;
         spin_lock_bh(&session->lock);
-        if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN)
-                goto unlock;
-
+        if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN) {
+                spin_unlock_bh(&session->lock);
+                return FAILED;
+        }
         conn = session->leadconn;
         beiscsi_conn = conn->dd_data;
         phba = beiscsi_conn->phba;
@@ -208,9 +212,6 @@ static int beiscsi_eh_device_reset(struct scsi_cmnd *sc)
         pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
                             nonemb_cmd.va, nonemb_cmd.dma);
         return iscsi_eh_device_reset(sc);
-unlock:
-        spin_unlock_bh(&session->lock);
-        return rc;
 }
 
 static ssize_t beiscsi_show_boot_tgt_info(void *data, int type, char *buf)
@@ -230,10 +231,10 @@ static ssize_t beiscsi_show_boot_tgt_info(void *data, int type, char *buf)
         case ISCSI_BOOT_TGT_IP_ADDR:
                 if (boot_conn->dest_ipaddr.ip_type == 0x1)
                         rc = sprintf(buf, "%pI4\n",
-                                (char *)&boot_conn->dest_ipaddr.ip_address);
+                                (char *)&boot_conn->dest_ipaddr.addr);
                 else
                         rc = sprintf(str, "%pI6\n",
-                                (char *)&boot_conn->dest_ipaddr.ip_address);
+                                (char *)&boot_conn->dest_ipaddr.addr);
                 break;
         case ISCSI_BOOT_TGT_PORT:
                 rc = sprintf(str, "%d\n", boot_conn->dest_port);
@@ -311,12 +312,8 @@ static ssize_t beiscsi_show_boot_eth_info(void *data, int type, char *buf)
                 rc = sprintf(str, "0\n");
                 break;
         case ISCSI_BOOT_ETH_MAC:
-                rc  = beiscsi_get_macaddr(buf, phba);
-                if (rc < 0) {
-                        SE_DEBUG(DBG_LVL_1, "beiscsi_get_macaddr Failed\n");
-                        return rc;
-                }
-        break;
+                rc  = beiscsi_get_macaddr(str, phba);
+                break;
         default:
                 rc = -ENOSYS;
                 break;
@@ -394,7 +391,7 @@ MODULE_DEVICE_TABLE(pci, beiscsi_pci_id_table);
 
 static struct scsi_host_template beiscsi_sht = {
         .module = THIS_MODULE,
-        .name = "ServerEngines 10Gbe open-iscsi Initiator Driver",
+        .name = "Emulex 10Gbe open-iscsi Initiator Driver",
         .proc_name = DRV_NAME,
         .queuecommand = iscsi_queuecommand,
         .change_queue_depth = iscsi_change_queue_depth,
@@ -409,6 +406,8 @@ static struct scsi_host_template beiscsi_sht = {
         .max_sectors = BEISCSI_MAX_SECTORS,
         .cmd_per_lun = BEISCSI_CMD_PER_LUN,
         .use_clustering = ENABLE_CLUSTERING,
+        .vendor_id = SCSI_NL_VID_TYPE_PCI | BE_VENDOR_ID,
+
 };
 
 static struct scsi_transport_template *beiscsi_scsi_transport;
@@ -435,6 +434,7 @@ static struct beiscsi_hba *beiscsi_hba_alloc(struct pci_dev *pcidev)
         phba->shost = shost;
         phba->pcidev = pci_dev_get(pcidev);
         pci_set_drvdata(pcidev, phba);
+        phba->interface_handle = 0xFFFFFFFF;
 
         if (iscsi_host_add(shost, &phba->pcidev->dev))
                 goto free_devices;
@@ -544,8 +544,7 @@ static int be_ctrl_init(struct beiscsi_hba *phba, struct pci_dev *pdev)
                                                   &mbox_mem_alloc->dma);
         if (!mbox_mem_alloc->va) {
                 beiscsi_unmap_pci_function(phba);
-                status = -ENOMEM;
-                return status;
+                return -ENOMEM;
         }
 
         mbox_mem_align->size = sizeof(struct be_mcc_mailbox);
@@ -1252,9 +1251,9 @@ hwi_complete_drvr_msgs(struct beiscsi_conn *beiscsi_conn,
         task = pwrb_handle->pio_handle;
 
         io_task = task->dd_data;
-        spin_lock(&phba->mgmt_sgl_lock);
+        spin_lock_bh(&phba->mgmt_sgl_lock);
         free_mgmt_sgl_handle(phba, io_task->psgl_handle);
-        spin_unlock(&phba->mgmt_sgl_lock);
+        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);
@@ -1370,8 +1369,6 @@ hwi_get_async_handle(struct beiscsi_hba *phba,
         struct be_bus_address phys_addr;
         struct list_head *pbusy_list;
         struct async_pdu_handle *pasync_handle = NULL;
-        int buffer_len = 0;
-        unsigned char buffer_index = -1;
         unsigned char is_header = 0;
 
         phys_addr.u.a32.address_lo =
@@ -1392,22 +1389,11 @@ hwi_get_async_handle(struct beiscsi_hba *phba,
                 pbusy_list = hwi_get_async_busy_list(pasync_ctx, 1,
                         (pdpdu_cqe->dw[offsetof(struct amap_i_t_dpdu_cqe,
                         index) / 32] & PDUCQE_INDEX_MASK));
-
-                buffer_len = (unsigned int)(phys_addr.u.a64.address -
-                                pasync_ctx->async_header.pa_base.u.a64.address);
-
-                buffer_index = buffer_len /
-                                pasync_ctx->async_header.buffer_size;
-
                 break;
         case UNSOL_DATA_NOTIFY:
                 pbusy_list = hwi_get_async_busy_list(pasync_ctx, 0, (pdpdu_cqe->
                                         dw[offsetof(struct amap_i_t_dpdu_cqe,
                                         index) / 32] & PDUCQE_INDEX_MASK));
-                buffer_len = (unsigned long)(phys_addr.u.a64.address -
-                                        pasync_ctx->async_data.pa_base.u.
-                                        a64.address);
-                buffer_index = buffer_len / pasync_ctx->async_data.buffer_size;
                 break;
         default:
                 pbusy_list = NULL;
@@ -1418,11 +1404,9 @@ hwi_get_async_handle(struct beiscsi_hba *phba,
                 return NULL;
         }
 
-        WARN_ON(!(buffer_index <= pasync_ctx->async_data.num_entries));
         WARN_ON(list_empty(pbusy_list));
         list_for_each_entry(pasync_handle, pbusy_list, link) {
-                WARN_ON(pasync_handle->consumed);
-                if (pasync_handle->index == buffer_index)
+                if (pasync_handle->pa.u.a64.address == phys_addr.u.a64.address)
                         break;
         }
 
@@ -1449,15 +1433,13 @@ hwi_update_async_writables(struct hwi_async_pdu_context *pasync_ctx,
         unsigned int num_entries, writables = 0;
         unsigned int *pep_read_ptr, *pwritables;
 
-
+        num_entries = pasync_ctx->num_entries;
         if (is_header) {
                 pep_read_ptr = &pasync_ctx->async_header.ep_read_ptr;
                 pwritables = &pasync_ctx->async_header.writables;
-                num_entries = pasync_ctx->async_header.num_entries;
         } else {
                 pep_read_ptr = &pasync_ctx->async_data.ep_read_ptr;
                 pwritables = &pasync_ctx->async_data.writables;
-                num_entries = pasync_ctx->async_data.num_entries;
         }
 
         while ((*pep_read_ptr) != cq_index) {
@@ -1491,14 +1473,13 @@ hwi_update_async_writables(struct hwi_async_pdu_context *pasync_ctx,
         return 0;
 }
 
-static unsigned int hwi_free_async_msg(struct beiscsi_hba *phba,
+static void hwi_free_async_msg(struct beiscsi_hba *phba,
                                        unsigned int cri)
 {
         struct hwi_controller *phwi_ctrlr;
         struct hwi_async_pdu_context *pasync_ctx;
         struct async_pdu_handle *pasync_handle, *tmp_handle;
         struct list_head *plist;
-        unsigned int i = 0;
 
         phwi_ctrlr = phba->phwi_ctrlr;
         pasync_ctx = HWI_GET_ASYNC_PDU_CTX(phwi_ctrlr);
@@ -1508,23 +1489,20 @@ static unsigned int hwi_free_async_msg(struct beiscsi_hba *phba,
         list_for_each_entry_safe(pasync_handle, tmp_handle, plist, link) {
                 list_del(&pasync_handle->link);
 
-                if (i == 0) {
+                if (pasync_handle->is_header) {
                         list_add_tail(&pasync_handle->link,
                                       &pasync_ctx->async_header.free_list);
                         pasync_ctx->async_header.free_entries++;
-                        i++;
                 } else {
                         list_add_tail(&pasync_handle->link,
                                       &pasync_ctx->async_data.free_list);
                         pasync_ctx->async_data.free_entries++;
-                        i++;
                 }
         }
 
         INIT_LIST_HEAD(&pasync_ctx->async_entry[cri].wait_queue.list);
         pasync_ctx->async_entry[cri].wait_queue.hdr_received = 0;
         pasync_ctx->async_entry[cri].wait_queue.bytes_received = 0;
-        return 0;
 }
 
 static struct phys_addr *
@@ -1557,16 +1535,15 @@ static void hwi_post_async_buffers(struct beiscsi_hba *phba,
 
         phwi_ctrlr = phba->phwi_ctrlr;
         pasync_ctx = HWI_GET_ASYNC_PDU_CTX(phwi_ctrlr);
+        num_entries = pasync_ctx->num_entries;
 
         if (is_header) {
-                num_entries = pasync_ctx->async_header.num_entries;
                 writables = min(pasync_ctx->async_header.writables,
                                 pasync_ctx->async_header.free_entries);
                 pfree_link = pasync_ctx->async_header.free_list.next;
                 host_write_num = pasync_ctx->async_header.host_write_ptr;
                 ring_id = phwi_ctrlr->default_pdu_hdr.id;
         } else {
-                num_entries = pasync_ctx->async_data.num_entries;
                 writables = min(pasync_ctx->async_data.writables,
                                 pasync_ctx->async_data.free_entries);
                 pfree_link = pasync_ctx->async_data.free_list.next;
@@ -1673,7 +1650,7 @@ hwi_fwd_async_msg(struct beiscsi_conn *beiscsi_conn,
                         }
                         memcpy(pfirst_buffer + offset,
                                pasync_handle->pbuffer, buf_len);
-                        offset = buf_len;
+                        offset += buf_len;
                 }
                 index++;
         }
@@ -1682,10 +1659,9 @@ hwi_fwd_async_msg(struct beiscsi_conn *beiscsi_conn,
                                            (beiscsi_conn->beiscsi_conn_cid -
                                             phba->fw_config.iscsi_cid_start),
                                             phdr, hdr_len, pfirst_buffer,
-                                            buf_len);
+                                            offset);
 
-        if (status == 0)
-                hwi_free_async_msg(phba, cri);
+        hwi_free_async_msg(phba, cri);
         return 0;
 }
 
@@ -2229,7 +2205,7 @@ static int beiscsi_alloc_mem(struct beiscsi_hba *phba)
         struct mem_array *mem_arr, *mem_arr_orig;
         unsigned int i, j, alloc_size, curr_alloc_size;
 
-        phba->phwi_ctrlr = kmalloc(phba->params.hwi_ws_sz, GFP_KERNEL);
+        phba->phwi_ctrlr = kzalloc(phba->params.hwi_ws_sz, GFP_KERNEL);
         if (!phba->phwi_ctrlr)
                 return -ENOMEM;
 
@@ -2349,27 +2325,21 @@ static void iscsi_init_global_templates(struct beiscsi_hba *phba)
         AMAP_SET_BITS(struct amap_pdu_nop_out, i_bit, pnop_out, 0);
 }
 
-static void beiscsi_init_wrb_handle(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 wrb_handle *pwrb_handle;
+        struct wrb_handle *pwrb_handle = NULL;
         struct hwi_controller *phwi_ctrlr;
         struct hwi_wrb_context *pwrb_context;
-        struct iscsi_wrb *pwrb;
-        unsigned int num_cxn_wrbh;
-        unsigned int num_cxn_wrb, j, idx, index;
+        struct iscsi_wrb *pwrb = NULL;
+        unsigned int num_cxn_wrbh = 0;
+        unsigned int num_cxn_wrb = 0, j, idx = 0, index;
 
         mem_descr_wrbh = phba->init_mem;
         mem_descr_wrbh += HWI_MEM_WRBH;
 
         mem_descr_wrb = phba->init_mem;
         mem_descr_wrb += HWI_MEM_WRB;
-
-        idx = 0;
-        pwrb_handle = mem_descr_wrbh->mem_array[idx].virtual_address;
-        num_cxn_wrbh = ((mem_descr_wrbh->mem_array[idx].size) /
-                        ((sizeof(struct wrb_handle)) *
-                         phba->params.wrbs_per_cxn));
         phwi_ctrlr = phba->phwi_ctrlr;
 
         for (index = 0; index < phba->params.cxns_per_ctrl * 2; index += 2) {
@@ -2377,12 +2347,32 @@ static void beiscsi_init_wrb_handle(struct beiscsi_hba *phba)
                 pwrb_context->pwrb_handle_base =
                                 kzalloc(sizeof(struct wrb_handle *) *
                                         phba->params.wrbs_per_cxn, GFP_KERNEL);
+                if (!pwrb_context->pwrb_handle_base) {
+                        shost_printk(KERN_ERR, phba->shost,
+                                        "Mem Alloc Failed. Failing to load\n");
+                        goto init_wrb_hndl_failed;
+                }
                 pwrb_context->pwrb_handle_basestd =
                                 kzalloc(sizeof(struct wrb_handle *) *
                                         phba->params.wrbs_per_cxn, GFP_KERNEL);
+                if (!pwrb_context->pwrb_handle_basestd) {
+                        shost_printk(KERN_ERR, phba->shost,
+                                        "Mem Alloc Failed. Failing to load\n");
+                        goto init_wrb_hndl_failed;
+                }
+                if (!num_cxn_wrbh) {
+                        pwrb_handle =
+                                mem_descr_wrbh->mem_array[idx].virtual_address;
+                        num_cxn_wrbh = ((mem_descr_wrbh->mem_array[idx].size) /
+                                        ((sizeof(struct wrb_handle)) *
+                                         phba->params.wrbs_per_cxn));
+                        idx++;
+                }
+                pwrb_context->alloc_index = 0;
+                pwrb_context->wrb_handles_available = 0;
+                pwrb_context->free_index = 0;
+
                 if (num_cxn_wrbh) {
-                        pwrb_context->alloc_index = 0;
-                        pwrb_context->wrb_handles_available = 0;
                         for (j = 0; j < phba->params.wrbs_per_cxn; j++) {
                                 pwrb_context->pwrb_handle_base[j] = pwrb_handle;
                                 pwrb_context->pwrb_handle_basestd[j] =
@@ -2391,49 +2381,21 @@ static void beiscsi_init_wrb_handle(struct beiscsi_hba *phba)
                                 pwrb_handle->wrb_index = j;
                                 pwrb_handle++;
                         }
-                        pwrb_context->free_index = 0;
-                        num_cxn_wrbh--;
-                } else {
-                        idx++;
-                        pwrb_handle =
-                            mem_descr_wrbh->mem_array[idx].virtual_address;
-                        num_cxn_wrbh =
-                            ((mem_descr_wrbh->mem_array[idx].size) /
-                             ((sizeof(struct wrb_handle)) *
-                              phba->params.wrbs_per_cxn));
-                        pwrb_context->alloc_index = 0;
-                        for (j = 0; j < phba->params.wrbs_per_cxn; j++) {
-                                pwrb_context->pwrb_handle_base[j] = pwrb_handle;
-                                pwrb_context->pwrb_handle_basestd[j] =
-                                    pwrb_handle;
-                                pwrb_context->wrb_handles_available++;
-                                pwrb_handle->wrb_index = j;
-                                pwrb_handle++;
-                        }
-                        pwrb_context->free_index = 0;
                         num_cxn_wrbh--;
                 }
         }
         idx = 0;
-        pwrb = mem_descr_wrb->mem_array[idx].virtual_address;
-        num_cxn_wrb = (mem_descr_wrb->mem_array[idx].size) /
-                      ((sizeof(struct iscsi_wrb) *
-                        phba->params.wrbs_per_cxn));
         for (index = 0; index < phba->params.cxns_per_ctrl * 2; index += 2) {
                 pwrb_context = &phwi_ctrlr->wrb_context[index];
-                if (num_cxn_wrb) {
-                        for (j = 0; j < phba->params.wrbs_per_cxn; j++) {
-                                pwrb_handle = pwrb_context->pwrb_handle_base[j];
-                                pwrb_handle->pwrb = pwrb;
-                                pwrb++;
-                        }
-                        num_cxn_wrb--;
-                } else {
-                        idx++;
+                if (!num_cxn_wrb) {
                         pwrb = mem_descr_wrb->mem_array[idx].virtual_address;
                         num_cxn_wrb = (mem_descr_wrb->mem_array[idx].size) /
-                                      ((sizeof(struct iscsi_wrb) *
-                                        phba->params.wrbs_per_cxn));
+                                ((sizeof(struct iscsi_wrb) *
+                                  phba->params.wrbs_per_cxn));
+                        idx++;
+                }
+
+                if (num_cxn_wrb) {
                         for (j = 0; j < phba->params.wrbs_per_cxn; j++) {
                                 pwrb_handle = pwrb_context->pwrb_handle_base[j];
                                 pwrb_handle->pwrb = pwrb;
@@ -2442,6 +2404,14 @@ static void beiscsi_init_wrb_handle(struct beiscsi_hba *phba)
                         num_cxn_wrb--;
                 }
         }
+        return 0;
+init_wrb_hndl_failed:
+        for (j = index; j > 0; j--) {
+                pwrb_context = &phwi_ctrlr->wrb_context[j];
+                kfree(pwrb_context->pwrb_handle_base);
+                kfree(pwrb_context->pwrb_handle_basestd);
+        }
+        return -ENOMEM;
 }
 
 static void hwi_init_async_pdu_ctx(struct beiscsi_hba *phba)
@@ -2450,7 +2420,7 @@ static void hwi_init_async_pdu_ctx(struct beiscsi_hba *phba)
         struct hba_parameters *p = &phba->params;
         struct hwi_async_pdu_context *pasync_ctx;
         struct async_pdu_handle *pasync_header_h, *pasync_data_h;
-        unsigned int index;
+        unsigned int index, idx, num_per_mem, num_async_data;
         struct be_mem_descriptor *mem_descr;
 
         mem_descr = (struct be_mem_descriptor *)phba->init_mem;
@@ -2462,10 +2432,8 @@ 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_header.num_entries = p->asyncpdus_per_ctrl;
-        pasync_ctx->async_header.buffer_size = p->defpdu_hdr_sz;
-        pasync_ctx->async_data.buffer_size = p->defpdu_data_sz;
-        pasync_ctx->async_data.num_entries = p->asyncpdus_per_ctrl;
+        pasync_ctx->num_entries = p->asyncpdus_per_ctrl;
+        pasync_ctx->buffer_size = p->defpdu_hdr_sz;
 
         mem_descr = (struct be_mem_descriptor *)phba->init_mem;
         mem_descr += HWI_MEM_ASYNC_HEADER_BUF;
@@ -2510,19 +2478,6 @@ static void hwi_init_async_pdu_ctx(struct beiscsi_hba *phba)
         pasync_ctx->async_header.writables = 0;
         INIT_LIST_HEAD(&pasync_ctx->async_header.free_list);
 
-        mem_descr = (struct be_mem_descriptor *)phba->init_mem;
-        mem_descr += HWI_MEM_ASYNC_DATA_BUF;
-        if (mem_descr->mem_array[0].virtual_address) {
-                SE_DEBUG(DBG_LVL_8,
-                         "hwi_init_async_pdu_ctx HWI_MEM_ASYNC_DATA_BUF"
-                         "va=%p\n", mem_descr->mem_array[0].virtual_address);
-        } else
-                shost_printk(KERN_WARNING, phba->shost,
-                            "No Virtual address\n");
-        pasync_ctx->async_data.va_base =
-                        mem_descr->mem_array[0].virtual_address;
-        pasync_ctx->async_data.pa_base.u.a64.address =
-                        mem_descr->mem_array[0].bus_address.u.a64.address;
 
         mem_descr = (struct be_mem_descriptor *)phba->init_mem;
         mem_descr += HWI_MEM_ASYNC_DATA_RING;
@@ -2553,6 +2508,25 @@ static void hwi_init_async_pdu_ctx(struct beiscsi_hba *phba)
         pasync_data_h =
                 (struct async_pdu_handle *)pasync_ctx->async_data.handle_base;
 
+        mem_descr = (struct be_mem_descriptor *)phba->init_mem;
+        mem_descr += HWI_MEM_ASYNC_DATA_BUF;
+        if (mem_descr->mem_array[0].virtual_address) {
+                SE_DEBUG(DBG_LVL_8,
+                         "hwi_init_async_pdu_ctx HWI_MEM_ASYNC_DATA_BUF"
+                         "va=%p\n", mem_descr->mem_array[0].virtual_address);
+        } else
+                shost_printk(KERN_WARNING, phba->shost,
+                            "No Virtual address\n");
+        idx = 0;
+        pasync_ctx->async_data.va_base =
+                        mem_descr->mem_array[idx].virtual_address;
+        pasync_ctx->async_data.pa_base.u.a64.address =
+                        mem_descr->mem_array[idx].bus_address.u.a64.address;
+
+        num_async_data = ((mem_descr->mem_array[idx].size) /
+                                phba->params.defpdu_data_sz);
+        num_per_mem = 0;
+
         for (index = 0; index < p->asyncpdus_per_ctrl; index++) {
                 pasync_header_h->cri = -1;
                 pasync_header_h->index = (char)index;
@@ -2578,14 +2552,29 @@ static void hwi_init_async_pdu_ctx(struct beiscsi_hba *phba)
                 pasync_data_h->cri = -1;
                 pasync_data_h->index = (char)index;
                 INIT_LIST_HEAD(&pasync_data_h->link);
+
+                if (!num_async_data) {
+                        num_per_mem = 0;
+                        idx++;
+                        pasync_ctx->async_data.va_base =
+                                mem_descr->mem_array[idx].virtual_address;
+                        pasync_ctx->async_data.pa_base.u.a64.address =
+                                mem_descr->mem_array[idx].
+                                bus_address.u.a64.address;
+
+                        num_async_data = ((mem_descr->mem_array[idx].size) /
+                                        phba->params.defpdu_data_sz);
+                }
                 pasync_data_h->pbuffer =
                         (void *)((unsigned long)
                         (pasync_ctx->async_data.va_base) +
-                        (p->defpdu_data_sz * index));
+                        (p->defpdu_data_sz * num_per_mem));
 
                 pasync_data_h->pa.u.a64.address =
                     pasync_ctx->async_data.pa_base.u.a64.address +
-                    (p->defpdu_data_sz * index);
+                    (p->defpdu_data_sz * num_per_mem);
+                num_per_mem++;
+                num_async_data--;
 
                 list_add_tail(&pasync_data_h->link,
                               &pasync_ctx->async_data.free_list);
@@ -2913,9 +2902,11 @@ beiscsi_post_pages(struct beiscsi_hba *phba)
 static void be_queue_free(struct beiscsi_hba *phba, struct be_queue_info *q)
 {
         struct be_dma_mem *mem = &q->dma_mem;
-        if (mem->va)
+        if (mem->va) {
                 pci_free_consistent(phba->pcidev, mem->size,
                         mem->va, mem->dma);
+                mem->va = NULL;
+        }
 }
 
 static int be_queue_alloc(struct beiscsi_hba *phba, struct be_queue_info *q,
@@ -3215,7 +3206,7 @@ static int hwi_init_port(struct beiscsi_hba *phba)
 error:
         shost_printk(KERN_ERR, phba->shost, "hwi_init_port failed");
         hwi_cleanup(phba);
-        return -ENOMEM;
+        return status;
 }
 
 static int hwi_init_controller(struct beiscsi_hba *phba)
@@ -3236,7 +3227,9 @@ static int hwi_init_controller(struct beiscsi_hba *phba)
         }
 
         iscsi_init_global_templates(phba);
-        beiscsi_init_wrb_handle(phba);
+        if (beiscsi_init_wrb_handle(phba))
+                return -ENOMEM;
+
         hwi_init_async_pdu_ctx(phba);
         if (hwi_init_port(phba) != 0) {
                 shost_printk(KERN_ERR, phba->shost,
@@ -3288,7 +3281,7 @@ static int beiscsi_init_controller(struct beiscsi_hba *phba)
 
 free_init:
         beiscsi_free_mem(phba);
-        return -ENOMEM;
+        return ret;
 }
 
 static int beiscsi_init_sgl_handle(struct beiscsi_hba *phba)
@@ -3475,8 +3468,8 @@ static void hwi_disable_intr(struct beiscsi_hba *phba)
 
 static int beiscsi_get_boot_info(struct beiscsi_hba *phba)
 {
-        struct be_cmd_resp_get_boot_target *boot_resp;
-        struct be_cmd_resp_get_session *session_resp;
+        struct be_cmd_get_boot_target_resp *boot_resp;
+        struct be_cmd_get_session_resp *session_resp;
         struct be_mcc_wrb *wrb;
         struct be_dma_mem nonemb_cmd;
         unsigned int tag, wrb_num;
@@ -3484,9 +3477,9 @@ static int beiscsi_get_boot_info(struct beiscsi_hba *phba)
         struct be_queue_info *mccq = &phba->ctrl.mcc_obj.q;
         int ret = -ENOMEM;
 
-        tag = beiscsi_get_boot_target(phba);
+        tag = mgmt_get_boot_target(phba);
         if (!tag) {
-                SE_DEBUG(DBG_LVL_1, "be_cmd_get_mac_addr Failed\n");
+                SE_DEBUG(DBG_LVL_1, "beiscsi_get_boot_info Failed\n");
                 return -EAGAIN;
         } else
                 wait_event_interruptible(phba->ctrl.mcc_wait[tag],
@@ -3496,7 +3489,7 @@ static int beiscsi_get_boot_info(struct beiscsi_hba *phba)
         extd_status = (phba->ctrl.mcc_numtag[tag] & 0x0000FF00) >> 8;
         status = phba->ctrl.mcc_numtag[tag] & 0x000000FF;
         if (status || extd_status) {
-                SE_DEBUG(DBG_LVL_1, "be_cmd_get_mac_addr Failed"
+                SE_DEBUG(DBG_LVL_1, "beiscsi_get_boot_info Failed"
                                     " status = %d extd_status = %d\n",
                                     status, extd_status);
                 free_mcc_tag(&phba->ctrl, tag);
@@ -3522,8 +3515,8 @@ static int beiscsi_get_boot_info(struct beiscsi_hba *phba)
         }
 
         memset(nonemb_cmd.va, 0, sizeof(*session_resp));
-        tag = beiscsi_get_session_info(phba,
-                boot_resp->boot_session_handle, &nonemb_cmd);
+        tag = mgmt_get_session_info(phba, boot_resp->boot_session_handle,
+                                    &nonemb_cmd);
         if (!tag) {
                 SE_DEBUG(DBG_LVL_1, "beiscsi_get_session_info"
                         " Failed\n");
@@ -3696,6 +3689,57 @@ static void beiscsi_clean_port(struct beiscsi_hba *phba)
         kfree(phba->ep_array);
 }
 
+static void beiscsi_cleanup_task(struct iscsi_task *task)
+{
+        struct beiscsi_io_task *io_task = task->dd_data;
+        struct iscsi_conn *conn = task->conn;
+        struct beiscsi_conn *beiscsi_conn = conn->dd_data;
+        struct beiscsi_hba *phba = beiscsi_conn->phba;
+        struct beiscsi_session *beiscsi_sess = beiscsi_conn->beiscsi_sess;
+        struct hwi_wrb_context *pwrb_context;
+        struct hwi_controller *phwi_ctrlr;
+
+        phwi_ctrlr = phba->phwi_ctrlr;
+        pwrb_context = &phwi_ctrlr->wrb_context[beiscsi_conn->beiscsi_conn_cid
+                        - phba->fw_config.iscsi_cid_start];
+
+        if (io_task->cmd_bhs) {
+                pci_pool_free(beiscsi_sess->bhs_pool, io_task->cmd_bhs,
+                              io_task->bhs_pa.u.a64.address);
+                io_task->cmd_bhs = NULL;
+        }
+
+        if (task->sc) {
+                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->io_sgl_lock);
+                        free_io_sgl_handle(phba, io_task->psgl_handle);
+                        spin_unlock(&phba->io_sgl_lock);
+                        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;
+                        }
+                }
+        }
+}
+
 void
 beiscsi_offload_connection(struct beiscsi_conn *beiscsi_conn,
                            struct beiscsi_offload_params *params)
@@ -3704,12 +3748,19 @@ beiscsi_offload_connection(struct beiscsi_conn *beiscsi_conn,
         struct iscsi_target_context_update_wrb *pwrb = NULL;
         struct be_mem_descriptor *mem_descr;
         struct beiscsi_hba *phba = beiscsi_conn->phba;
+        struct iscsi_task *task = beiscsi_conn->task;
+        struct iscsi_session *session = task->conn->session;
         u32 doorbell = 0;
 
         /*
          * We can always use 0 here because it is reserved by libiscsi for
          * login/startup related tasks.
          */
+        beiscsi_conn->login_in_progress = 0;
+        spin_lock_bh(&session->lock);
+        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 = (struct iscsi_target_context_update_wrb *)pwrb_handle->pwrb;
@@ -3823,7 +3874,7 @@ static int beiscsi_alloc_pdu(struct iscsi_task *task, uint8_t opcode)
         task->hdr = (struct iscsi_hdr *)&io_task->cmd_bhs->iscsi_hdr;
         task->hdr_max = sizeof(struct be_cmd_bhs);
         io_task->psgl_handle = NULL;
-        io_task->psgl_handle = NULL;
+        io_task->pwrb_handle = NULL;
 
         if (task->sc) {
                 spin_lock(&phba->io_sgl_lock);
@@ -3865,6 +3916,7 @@ 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);
@@ -3907,53 +3959,11 @@ free_hndls:
         io_task->pwrb_handle = NULL;
         pci_pool_free(beiscsi_sess->bhs_pool, io_task->cmd_bhs,
                       io_task->bhs_pa.u.a64.address);
+        io_task->cmd_bhs = NULL;
         SE_DEBUG(DBG_LVL_1, "Alloc of SGL_ICD Failed\n");
         return -ENOMEM;
 }
 
-static void beiscsi_cleanup_task(struct iscsi_task *task)
-{
-        struct beiscsi_io_task *io_task = task->dd_data;
-        struct iscsi_conn *conn = task->conn;
-        struct beiscsi_conn *beiscsi_conn = conn->dd_data;
-        struct beiscsi_hba *phba = beiscsi_conn->phba;
-        struct beiscsi_session *beiscsi_sess = beiscsi_conn->beiscsi_sess;
-        struct hwi_wrb_context *pwrb_context;
-        struct hwi_controller *phwi_ctrlr;
-
-        phwi_ctrlr = phba->phwi_ctrlr;
-        pwrb_context = &phwi_ctrlr->wrb_context[beiscsi_conn->beiscsi_conn_cid
-                        - phba->fw_config.iscsi_cid_start];
-        if (io_task->pwrb_handle) {
-                free_wrb_handle(phba, pwrb_context, io_task->pwrb_handle);
-                io_task->pwrb_handle = NULL;
-        }
-
-        if (io_task->cmd_bhs) {
-                pci_pool_free(beiscsi_sess->bhs_pool, io_task->cmd_bhs,
-                              io_task->bhs_pa.u.a64.address);
-        }
-
-        if (task->sc) {
-                if (io_task->psgl_handle) {
-                        spin_lock(&phba->io_sgl_lock);
-                        free_io_sgl_handle(phba, io_task->psgl_handle);
-                        spin_unlock(&phba->io_sgl_lock);
-                        io_task->psgl_handle = NULL;
-                }
-        } else {
-                if (task->hdr &&
-                   ((task->hdr->opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGIN))
-                        return;
-                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;
-                }
-        }
-}
-
 static int beiscsi_iotask(struct iscsi_task *task, struct scatterlist *sg,
                           unsigned int num_sg, unsigned int xferlen,
                           unsigned int writedir)
@@ -3993,7 +4003,8 @@ static int beiscsi_iotask(struct iscsi_task *task, struct scatterlist *sg,
                &io_task->cmd_bhs->iscsi_hdr.lun, sizeof(struct scsi_lun));
 
         AMAP_SET_BITS(struct amap_iscsi_wrb, lun, pwrb,
-                      cpu_to_be16(*(unsigned short *)&io_task->cmd_bhs->iscsi_hdr.lun));
+                      cpu_to_be16(*(unsigned short *)
+                                  &io_task->cmd_bhs->iscsi_hdr.lun));
         AMAP_SET_BITS(struct amap_iscsi_wrb, r2t_exp_dtl, pwrb, xferlen);
         AMAP_SET_BITS(struct amap_iscsi_wrb, wrb_idx, pwrb,
                       io_task->pwrb_handle->wrb_index);
@@ -4126,6 +4137,76 @@ static int beiscsi_task_xmit(struct iscsi_task *task)
         return beiscsi_iotask(task, sg, num_sg, xferlen, writedir);
 }
 
+/**
+ * beiscsi_bsg_request - handle bsg request from ISCSI transport
+ * @job: job to handle
+ */
+static int beiscsi_bsg_request(struct bsg_job *job)
+{
+        struct Scsi_Host *shost;
+        struct beiscsi_hba *phba;
+        struct iscsi_bsg_request *bsg_req = job->request;
+        int rc = -EINVAL;
+        unsigned int tag;
+        struct be_dma_mem nonemb_cmd;
+        struct be_cmd_resp_hdr *resp;
+        struct iscsi_bsg_reply *bsg_reply = job->reply;
+        unsigned short status, extd_status;
+
+        shost = iscsi_job_to_shost(job);
+        phba = iscsi_host_priv(shost);
+
+        switch (bsg_req->msgcode) {
+        case ISCSI_BSG_HST_VENDOR:
+                nonemb_cmd.va = pci_alloc_consistent(phba->ctrl.pdev,
+                                        job->request_payload.payload_len,
+                                        &nonemb_cmd.dma);
+                if (nonemb_cmd.va == NULL) {
+                        SE_DEBUG(DBG_LVL_1, "Failed to allocate memory for "
+                                 "beiscsi_bsg_request\n");
+                        return -EIO;
+                }
+                tag = mgmt_vendor_specific_fw_cmd(&phba->ctrl, phba, job,
+                                                  &nonemb_cmd);
+                if (!tag) {
+                        SE_DEBUG(DBG_LVL_1, "be_cmd_get_mac_addr Failed\n");
+                        pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
+                                            nonemb_cmd.va, nonemb_cmd.dma);
+                        return -EAGAIN;
+                } else
+                        wait_event_interruptible(phba->ctrl.mcc_wait[tag],
+                                                 phba->ctrl.mcc_numtag[tag]);
+                extd_status = (phba->ctrl.mcc_numtag[tag] & 0x0000FF00) >> 8;
+                status = phba->ctrl.mcc_numtag[tag] & 0x000000FF;
+                free_mcc_tag(&phba->ctrl, tag);
+                resp = (struct be_cmd_resp_hdr *)nonemb_cmd.va;
+                sg_copy_from_buffer(job->reply_payload.sg_list,
+                                    job->reply_payload.sg_cnt,
+                                    nonemb_cmd.va, (resp->response_length
+                                    + sizeof(*resp)));
+                bsg_reply->reply_payload_rcv_len = resp->response_length;
+                bsg_reply->result = status;
+                bsg_job_done(job, bsg_reply->result,
+                             bsg_reply->reply_payload_rcv_len);
+                pci_free_consistent(phba->ctrl.pdev, nonemb_cmd.size,
+                                    nonemb_cmd.va, nonemb_cmd.dma);
+                if (status || extd_status) {
+                        SE_DEBUG(DBG_LVL_1, "be_cmd_get_mac_addr Failed"
+                                 " status = %d extd_status = %d\n",
+                                 status, extd_status);
+                        return -EIO;
+                }
+                break;
+
+        default:
+                SE_DEBUG(DBG_LVL_1, "Unsupported bsg command: 0x%x\n",
+                         bsg_req->msgcode);
+                break;
+        }
+
+        return rc;
+}
+
 static void beiscsi_quiesce(struct beiscsi_hba *phba)
 {
         struct hwi_controller *phwi_ctrlr;
@@ -4183,6 +4264,7 @@ static void beiscsi_remove(struct pci_dev *pcidev)
                 return;
         }
 
+        beiscsi_destroy_def_ifaces(phba);
         beiscsi_quiesce(phba);
         iscsi_boot_destroy_kset(phba->boot_kset);
         iscsi_host_remove(phba->shost);
@@ -4267,8 +4349,11 @@ static int __devinit beiscsi_dev_probe(struct pci_dev *pcidev,
         phba->num_cpus = num_cpus;
         SE_DEBUG(DBG_LVL_8, "num_cpus = %d\n", phba->num_cpus);
 
-        if (enable_msix)
+        if (enable_msix) {
                 beiscsi_msix_enable(phba);
+                if (!phba->msix_enabled)
+                        phba->num_cpus = 1;
+        }
         ret = be_ctrl_init(phba, pcidev);
         if (ret) {
                 shost_printk(KERN_ERR, phba->shost, "beiscsi_dev_probe-"
@@ -4366,8 +4451,9 @@ static int __devinit beiscsi_dev_probe(struct pci_dev *pcidev,
                  * iscsi boot.
                  */
                 shost_printk(KERN_ERR, phba->shost, "Could not set up "
-                             "iSCSI boot info.");
+                             "iSCSI boot info.\n");
 
+        beiscsi_create_def_ifaces(phba);
         SE_DEBUG(DBG_LVL_8, "\n\n\n SUCCESS - DRIVER LOADED\n\n\n");
         return 0;
 
@@ -4418,6 +4504,8 @@ struct iscsi_transport beiscsi_iscsi_transport = {
         .bind_conn = beiscsi_conn_bind,
         .destroy_conn = iscsi_conn_teardown,
         .attr_is_visible = be2iscsi_attr_is_visible,
+        .set_iface_param = be2iscsi_iface_set_param,
+        .get_iface_param = be2iscsi_iface_get_param,
         .set_param = beiscsi_set_param,
         .get_conn_param = iscsi_conn_get_param,
         .get_session_param = iscsi_session_get_param,
@@ -4435,6 +4523,7 @@ struct iscsi_transport beiscsi_iscsi_transport = {
         .ep_poll = beiscsi_ep_poll,
         .ep_disconnect = beiscsi_ep_disconnect,
         .session_recovery_timedout = iscsi_session_recovery_timedout,
+        .bsg_request = beiscsi_bsg_request,
 };
 
 static struct pci_driver beiscsi_pci_driver = {
diff --git a/drivers/scsi/be2iscsi/be_main.h b/drivers/scsi/be2iscsi/be_main.h
index b4a06d5e5f9e..40fea6ec879c 100644
--- a/drivers/scsi/be2iscsi/be_main.h
+++ b/drivers/scsi/be2iscsi/be_main.h
@@ -34,9 +34,9 @@
 
 #include "be.h"
 #define DRV_NAME                "be2iscsi"
-#define BUILD_STR               "4.1.239.0"
-#define BE_NAME                 "ServerEngines BladeEngine2" \
-                                "Linux iSCSI Driver version" BUILD_STR
+#define BUILD_STR               "4.2.162.0"
+#define BE_NAME                 "Emulex OneConnect" \
+                                "Open-iSCSI Driver version" BUILD_STR
 #define DRV_DESC                BE_NAME " " "Driver"
 
 #define BE_VENDOR_ID            0x19A2
@@ -316,6 +316,8 @@ struct beiscsi_hba {
         struct iscsi_endpoint **ep_array;
         struct iscsi_boot_kset *boot_kset;
         struct Scsi_Host *shost;
+        struct iscsi_iface *ipv4_iface;
+        struct iscsi_iface *ipv6_iface;
         struct {
                 /**
                  * group together since they are used most frequently
@@ -345,7 +347,7 @@ struct beiscsi_hba {
         struct work_struct work_cqs;    /* The work being queued */
         struct be_ctrl_info ctrl;
         unsigned int generation;
-        unsigned int read_mac_address;
+        unsigned int interface_handle;
         struct mgmt_session_info boot_sess;
         struct invalidate_command_table inv_tbl[128];
 
@@ -525,8 +527,6 @@ struct hwi_async_pdu_context {
 
                 unsigned int free_entries;
                 unsigned int busy_entries;
-                unsigned int buffer_size;
-                unsigned int num_entries;
 
                 struct list_head free_list;
         } async_header;
@@ -543,11 +543,12 @@ struct hwi_async_pdu_context {
 
                 unsigned int free_entries;
                 unsigned int busy_entries;
-                unsigned int buffer_size;
                 struct list_head free_list;
-                unsigned int num_entries;
         } async_data;
 
+        unsigned int buffer_size;
+        unsigned int num_entries;
+
         /**
          * This is a varying size list! Do not add anything
          * after this entry!!
diff --git a/drivers/scsi/be2iscsi/be_mgmt.c b/drivers/scsi/be2iscsi/be_mgmt.c
index 44762cfa3e12..01bb04cd9e75 100644
--- a/drivers/scsi/be2iscsi/be_mgmt.c
+++ b/drivers/scsi/be2iscsi/be_mgmt.c
@@ -17,15 +17,17 @@
  * Costa Mesa, CA 92626
  */
 
+#include <linux/bsg-lib.h>
+#include <scsi/scsi_transport_iscsi.h>
+#include <scsi/scsi_bsg_iscsi.h>
 #include "be_mgmt.h"
 #include "be_iscsi.h"
-#include <scsi/scsi_transport_iscsi.h>
 
-unsigned int beiscsi_get_boot_target(struct beiscsi_hba *phba)
+unsigned int mgmt_get_boot_target(struct beiscsi_hba *phba)
 {
         struct be_ctrl_info *ctrl = &phba->ctrl;
         struct be_mcc_wrb *wrb;
-        struct be_cmd_req_get_mac_addr *req;
+        struct be_cmd_get_boot_target_req *req;
         unsigned int tag = 0;
 
         SE_DEBUG(DBG_LVL_8, "In bescsi_get_boot_target\n");
@@ -42,22 +44,22 @@ unsigned int beiscsi_get_boot_target(struct beiscsi_hba *phba)
         be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
         be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI,
                            OPCODE_ISCSI_INI_BOOT_GET_BOOT_TARGET,
-                           sizeof(*req));
+                           sizeof(struct be_cmd_get_boot_target_resp));
 
         be_mcc_notify(phba);
         spin_unlock(&ctrl->mbox_lock);
         return tag;
 }
 
-unsigned int beiscsi_get_session_info(struct beiscsi_hba *phba,
-                                  u32 boot_session_handle,
-                                  struct be_dma_mem *nonemb_cmd)
+unsigned int mgmt_get_session_info(struct beiscsi_hba *phba,
+                                   u32 boot_session_handle,
+                                   struct be_dma_mem *nonemb_cmd)
 {
         struct be_ctrl_info *ctrl = &phba->ctrl;
         struct be_mcc_wrb *wrb;
         unsigned int tag = 0;
-        struct  be_cmd_req_get_session *req;
-        struct be_cmd_resp_get_session *resp;
+        struct  be_cmd_get_session_req *req;
+        struct be_cmd_get_session_resp *resp;
         struct be_sge *sge;
 
         SE_DEBUG(DBG_LVL_8, "In beiscsi_get_session_info\n");
@@ -187,6 +189,72 @@ int mgmt_check_supported_fw(struct be_ctrl_info *ctrl,
         return status;
 }
 
+unsigned int mgmt_vendor_specific_fw_cmd(struct be_ctrl_info *ctrl,
+                                         struct beiscsi_hba *phba,
+                                         struct bsg_job *job,
+                                         struct be_dma_mem *nonemb_cmd)
+{
+        struct be_cmd_resp_hdr *resp;
+        struct be_mcc_wrb *wrb = wrb_from_mccq(phba);
+        struct be_sge *mcc_sge = nonembedded_sgl(wrb);
+        unsigned int tag = 0;
+        struct iscsi_bsg_request *bsg_req = job->request;
+        struct be_bsg_vendor_cmd *req = nonemb_cmd->va;
+        unsigned short region, sector_size, sector, offset;
+
+        nonemb_cmd->size = job->request_payload.payload_len;
+        memset(nonemb_cmd->va, 0, nonemb_cmd->size);
+        resp = nonemb_cmd->va;
+        region =  bsg_req->rqst_data.h_vendor.vendor_cmd[1];
+        sector_size =  bsg_req->rqst_data.h_vendor.vendor_cmd[2];
+        sector =  bsg_req->rqst_data.h_vendor.vendor_cmd[3];
+        offset =  bsg_req->rqst_data.h_vendor.vendor_cmd[4];
+        req->region = region;
+        req->sector = sector;
+        req->offset = offset;
+        spin_lock(&ctrl->mbox_lock);
+        memset(wrb, 0, sizeof(*wrb));
+
+        switch (bsg_req->rqst_data.h_vendor.vendor_cmd[0]) {
+        case BEISCSI_WRITE_FLASH:
+                offset = sector * sector_size + offset;
+                be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
+                                   OPCODE_COMMON_WRITE_FLASH, sizeof(*req));
+                sg_copy_to_buffer(job->request_payload.sg_list,
+                                  job->request_payload.sg_cnt,
+                                  nonemb_cmd->va + offset, job->request_len);
+                break;
+        case BEISCSI_READ_FLASH:
+                be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
+                           OPCODE_COMMON_READ_FLASH, sizeof(*req));
+                break;
+        default:
+                shost_printk(KERN_WARNING, phba->shost,
+                             "Unsupported cmd = 0x%x\n\n", bsg_req->rqst_data.
+                             h_vendor.vendor_cmd[0]);
+                spin_unlock(&ctrl->mbox_lock);
+                return -ENOSYS;
+        }
+
+        tag = alloc_mcc_tag(phba);
+        if (!tag) {
+                spin_unlock(&ctrl->mbox_lock);
+                return tag;
+        }
+
+        be_wrb_hdr_prepare(wrb, nonemb_cmd->size, false,
+                           job->request_payload.sg_cnt);
+        mcc_sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma));
+        mcc_sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF);
+        mcc_sge->len = cpu_to_le32(nonemb_cmd->size);
+        wrb->tag0 |= tag;
+
+        be_mcc_notify(phba);
+
+        spin_unlock(&ctrl->mbox_lock);
+        return tag;
+}
+
 int mgmt_epfw_cleanup(struct beiscsi_hba *phba, unsigned short chute)
 {
         struct be_ctrl_info *ctrl = &phba->ctrl;
@@ -328,7 +396,6 @@ int mgmt_open_connection(struct beiscsi_hba *phba,
                          struct sockaddr *dst_addr,
                          struct beiscsi_endpoint *beiscsi_ep,
                          struct be_dma_mem *nonemb_cmd)
-
 {
         struct hwi_controller *phwi_ctrlr;
         struct hwi_context_memory *phwi_context;
@@ -374,17 +441,17 @@ int mgmt_open_connection(struct beiscsi_hba *phba,
         if (dst_addr->sa_family == PF_INET) {
                 __be32 s_addr = daddr_in->sin_addr.s_addr;
                 req->ip_address.ip_type = BE2_IPV4;
-                req->ip_address.ip_address[0] = s_addr & 0x000000ff;
-                req->ip_address.ip_address[1] = (s_addr & 0x0000ff00) >> 8;
-                req->ip_address.ip_address[2] = (s_addr & 0x00ff0000) >> 16;
-                req->ip_address.ip_address[3] = (s_addr & 0xff000000) >> 24;
+                req->ip_address.addr[0] = s_addr & 0x000000ff;
+                req->ip_address.addr[1] = (s_addr & 0x0000ff00) >> 8;
+                req->ip_address.addr[2] = (s_addr & 0x00ff0000) >> 16;
+                req->ip_address.addr[3] = (s_addr & 0xff000000) >> 24;
                 req->tcp_port = ntohs(daddr_in->sin_port);
                 beiscsi_ep->dst_addr = daddr_in->sin_addr.s_addr;
                 beiscsi_ep->dst_tcpport = ntohs(daddr_in->sin_port);
                 beiscsi_ep->ip_type = BE2_IPV4;
         } else if (dst_addr->sa_family == PF_INET6) {
                 req->ip_address.ip_type = BE2_IPV6;
-                memcpy(&req->ip_address.ip_address,
+                memcpy(&req->ip_address.addr,
                        &daddr_in6->sin6_addr.in6_u.u6_addr8, 16);
                 req->tcp_port = ntohs(daddr_in6->sin6_port);
                 beiscsi_ep->dst_tcpport = ntohs(daddr_in6->sin6_port);
@@ -419,14 +486,399 @@ int mgmt_open_connection(struct beiscsi_hba *phba,
         return tag;
 }
 
-unsigned int be_cmd_get_mac_addr(struct beiscsi_hba *phba)
+unsigned int mgmt_get_all_if_id(struct beiscsi_hba *phba)
 {
         struct be_ctrl_info *ctrl = &phba->ctrl;
-        struct be_mcc_wrb *wrb;
-        struct be_cmd_req_get_mac_addr *req;
+        struct be_mcc_wrb *wrb = wrb_from_mbox(&ctrl->mbox_mem);
+        struct be_cmd_get_all_if_id_req *req = embedded_payload(wrb);
+        struct be_cmd_get_all_if_id_req *pbe_allid = req;
+        int status = 0;
+
+        memset(wrb, 0, sizeof(*wrb));
+
+        spin_lock(&ctrl->mbox_lock);
+
+        be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
+        be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
+                           OPCODE_COMMON_ISCSI_NTWK_GET_ALL_IF_ID,
+                           sizeof(*req));
+        status = be_mbox_notify(ctrl);
+        if (!status)
+                phba->interface_handle = pbe_allid->if_hndl_list[0];
+        else {
+                shost_printk(KERN_WARNING, phba->shost,
+                             "Failed in mgmt_get_all_if_id\n");
+        }
+        spin_unlock(&ctrl->mbox_lock);
+
+        return status;
+}
+
+static int mgmt_exec_nonemb_cmd(struct beiscsi_hba *phba,
+                                struct be_dma_mem *nonemb_cmd, void *resp_buf,
+                                int resp_buf_len)
+{
+        struct be_ctrl_info *ctrl = &phba->ctrl;
+        struct be_mcc_wrb *wrb = wrb_from_mccq(phba);
+        unsigned short status, extd_status;
+        struct be_sge *sge;
+        unsigned int tag;
+        int rc = 0;
+
+        spin_lock(&ctrl->mbox_lock);
+        tag = alloc_mcc_tag(phba);
+        if (!tag) {
+                spin_unlock(&ctrl->mbox_lock);
+                rc = -ENOMEM;
+                goto free_cmd;
+        }
+        memset(wrb, 0, sizeof(*wrb));
+        wrb->tag0 |= tag;
+        sge = nonembedded_sgl(wrb);
+
+        be_wrb_hdr_prepare(wrb, nonemb_cmd->size, false, 1);
+        sge->pa_hi = cpu_to_le32(upper_32_bits(nonemb_cmd->dma));
+        sge->pa_lo = cpu_to_le32(nonemb_cmd->dma & 0xFFFFFFFF);
+        sge->len = cpu_to_le32(nonemb_cmd->size);
+
+        be_mcc_notify(phba);
+        spin_unlock(&ctrl->mbox_lock);
+
+        wait_event_interruptible(phba->ctrl.mcc_wait[tag],
+                                 phba->ctrl.mcc_numtag[tag]);
+
+        extd_status = (phba->ctrl.mcc_numtag[tag] & 0x0000FF00) >> 8;
+        status = phba->ctrl.mcc_numtag[tag] & 0x000000FF;
+        if (status || extd_status) {
+                SE_DEBUG(DBG_LVL_1,
+                         "mgmt_exec_nonemb_cmd Failed status = %d"
+                         "extd_status = %d\n", status, extd_status);
+                rc = -EIO;
+                goto free_tag;
+        }
+
+        if (resp_buf)
+                memcpy(resp_buf, nonemb_cmd->va, resp_buf_len);
+
+free_tag:
+        free_mcc_tag(&phba->ctrl, tag);
+free_cmd:
+        pci_free_consistent(ctrl->pdev, nonemb_cmd->size,
+                            nonemb_cmd->va, nonemb_cmd->dma);
+        return rc;
+}
+
+static int mgmt_alloc_cmd_data(struct beiscsi_hba *phba, struct be_dma_mem *cmd,
+                               int iscsi_cmd, int size)
+{
+        cmd->va = pci_alloc_consistent(phba->ctrl.pdev, sizeof(size),
+                                       &cmd->dma);
+        if (!cmd->va) {
+                SE_DEBUG(DBG_LVL_1, "Failed to allocate memory for if info\n");
+                return -ENOMEM;
+        }
+        memset(cmd->va, 0, sizeof(size));
+        cmd->size = size;
+        be_cmd_hdr_prepare(cmd->va, CMD_SUBSYSTEM_ISCSI, iscsi_cmd, size);
+        return 0;
+}
+
+static int
+mgmt_static_ip_modify(struct beiscsi_hba *phba,
+                      struct be_cmd_get_if_info_resp *if_info,
+                      struct iscsi_iface_param_info *ip_param,
+                      struct iscsi_iface_param_info *subnet_param,
+                      uint32_t ip_action)
+{
+        struct be_cmd_set_ip_addr_req *req;
+        struct be_dma_mem nonemb_cmd;
+        uint32_t ip_type;
+        int rc;
+
+        rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
+                                 OPCODE_COMMON_ISCSI_NTWK_MODIFY_IP_ADDR,
+                                 sizeof(*req));
+        if (rc)
+                return rc;
+
+        ip_type = (ip_param->param == ISCSI_NET_PARAM_IPV6_ADDR) ?
+                BE2_IPV6 : BE2_IPV4 ;
+
+        req = nonemb_cmd.va;
+        req->ip_params.record_entry_count = 1;
+        req->ip_params.ip_record.action = ip_action;
+        req->ip_params.ip_record.interface_hndl =
+                phba->interface_handle;
+        req->ip_params.ip_record.ip_addr.size_of_structure =
+                sizeof(struct be_ip_addr_subnet_format);
+        req->ip_params.ip_record.ip_addr.ip_type = ip_type;
+
+        if (ip_action == IP_ACTION_ADD) {
+                memcpy(req->ip_params.ip_record.ip_addr.addr, ip_param->value,
+                       ip_param->len);
+
+                if (subnet_param)
+                        memcpy(req->ip_params.ip_record.ip_addr.subnet_mask,
+                               subnet_param->value, subnet_param->len);
+        } else {
+                memcpy(req->ip_params.ip_record.ip_addr.addr,
+                       if_info->ip_addr.addr, ip_param->len);
+
+                memcpy(req->ip_params.ip_record.ip_addr.subnet_mask,
+                       if_info->ip_addr.subnet_mask, ip_param->len);
+        }
+
+        rc = mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0);
+        if (rc < 0)
+                shost_printk(KERN_WARNING, phba->shost,
+                             "Failed to Modify existing IP Address\n");
+        return rc;
+}
+
+static int mgmt_modify_gateway(struct beiscsi_hba *phba, uint8_t *gt_addr,
+                               uint32_t gtway_action, uint32_t param_len)
+{
+        struct be_cmd_set_def_gateway_req *req;
+        struct be_dma_mem nonemb_cmd;
+        int rt_val;
+
+
+        rt_val = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
+                                OPCODE_COMMON_ISCSI_NTWK_MODIFY_DEFAULT_GATEWAY,
+                                sizeof(*req));
+        if (rt_val)
+                return rt_val;
+
+        req = nonemb_cmd.va;
+        req->action = gtway_action;
+        req->ip_addr.ip_type = BE2_IPV4;
+
+        memcpy(req->ip_addr.addr, gt_addr, param_len);
+
+        return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0);
+}
+
+int mgmt_set_ip(struct beiscsi_hba *phba,
+                struct iscsi_iface_param_info *ip_param,
+                struct iscsi_iface_param_info *subnet_param,
+                uint32_t boot_proto)
+{
+        struct be_cmd_get_def_gateway_resp gtway_addr_set;
+        struct be_cmd_get_if_info_resp if_info;
+        struct be_cmd_set_dhcp_req *dhcpreq;
+        struct be_cmd_rel_dhcp_req *reldhcp;
+        struct be_dma_mem nonemb_cmd;
+        uint8_t *gtway_addr;
+        uint32_t ip_type;
+        int rc;
+
+        if (mgmt_get_all_if_id(phba))
+                return -EIO;
+
+        memset(&if_info, 0, sizeof(if_info));
+        ip_type = (ip_param->param == ISCSI_NET_PARAM_IPV6_ADDR) ?
+                BE2_IPV6 : BE2_IPV4 ;
+
+        rc = mgmt_get_if_info(phba, ip_type, &if_info);
+        if (rc)
+                return rc;
+
+        if (boot_proto == ISCSI_BOOTPROTO_DHCP) {
+                if (if_info.dhcp_state) {
+                        shost_printk(KERN_WARNING, phba->shost,
+                                     "DHCP Already Enabled\n");
+                        return 0;
+                }
+                /* The ip_param->len is 1 in DHCP case. Setting
+                   proper IP len as this it is used while
+                   freeing the Static IP.
+                 */
+                ip_param->len = (ip_param->param == ISCSI_NET_PARAM_IPV6_ADDR) ?
+                                IP_V6_LEN : IP_V4_LEN;
+
+        } else {
+                if (if_info.dhcp_state) {
+
+                        memset(&if_info, 0, sizeof(if_info));
+                        rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
+                                OPCODE_COMMON_ISCSI_NTWK_REL_STATELESS_IP_ADDR,
+                                sizeof(*reldhcp));
+
+                        if (rc)
+                                return rc;
+
+                        reldhcp = nonemb_cmd.va;
+                        reldhcp->interface_hndl = phba->interface_handle;
+                        reldhcp->ip_type = ip_type;
+
+                        rc = mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0);
+                        if (rc < 0) {
+                                shost_printk(KERN_WARNING, phba->shost,
+                                             "Failed to Delete existing dhcp\n");
+                                return rc;
+                        }
+                }
+        }
+
+        /* Delete the Static IP Set */
+        if (if_info.ip_addr.addr[0]) {
+                rc = mgmt_static_ip_modify(phba, &if_info, ip_param, NULL,
+                                           IP_ACTION_DEL);
+                if (rc)
+                        return rc;
+        }
+
+        /* Delete the Gateway settings if mode change is to DHCP */
+        if (boot_proto == ISCSI_BOOTPROTO_DHCP) {
+                memset(&gtway_addr_set, 0, sizeof(gtway_addr_set));
+                rc = mgmt_get_gateway(phba, BE2_IPV4, &gtway_addr_set);
+                if (rc) {
+                        shost_printk(KERN_WARNING, phba->shost,
+                                     "Failed to Get Gateway Addr\n");
+                        return rc;
+                }
+
+                if (gtway_addr_set.ip_addr.addr[0]) {
+                        gtway_addr = (uint8_t *)&gtway_addr_set.ip_addr.addr;
+                        rc = mgmt_modify_gateway(phba, gtway_addr,
+                                                 IP_ACTION_DEL, IP_V4_LEN);
+
+                        if (rc) {
+                                shost_printk(KERN_WARNING, phba->shost,
+                                             "Failed to clear Gateway Addr Set\n");
+                                return rc;
+                        }
+                }
+        }
+
+        /* Set Adapter to DHCP/Static Mode */
+        if (boot_proto == ISCSI_BOOTPROTO_DHCP) {
+                rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
+                        OPCODE_COMMON_ISCSI_NTWK_CONFIG_STATELESS_IP_ADDR,
+                        sizeof(*dhcpreq));
+                if (rc)
+                        return rc;
+
+                dhcpreq = nonemb_cmd.va;
+                dhcpreq->flags = BLOCKING;
+                dhcpreq->retry_count = 1;
+                dhcpreq->interface_hndl = phba->interface_handle;
+                dhcpreq->ip_type = BE2_DHCP_V4;
+
+                return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, NULL, 0);
+        } else {
+                return mgmt_static_ip_modify(phba, &if_info, ip_param,
+                                             subnet_param, IP_ACTION_ADD);
+        }
+
+        return rc;
+}
+
+int mgmt_set_gateway(struct beiscsi_hba *phba,
+                     struct iscsi_iface_param_info *gateway_param)
+{
+        struct be_cmd_get_def_gateway_resp gtway_addr_set;
+        uint8_t *gtway_addr;
+        int rt_val;
+
+        memset(&gtway_addr_set, 0, sizeof(gtway_addr_set));
+        rt_val = mgmt_get_gateway(phba, BE2_IPV4, &gtway_addr_set);
+        if (rt_val) {
+                shost_printk(KERN_WARNING, phba->shost,
+                             "Failed to Get Gateway Addr\n");
+                return rt_val;
+        }
+
+        if (gtway_addr_set.ip_addr.addr[0]) {
+                gtway_addr = (uint8_t *)&gtway_addr_set.ip_addr.addr;
+                rt_val = mgmt_modify_gateway(phba, gtway_addr, IP_ACTION_DEL,
+                                             gateway_param->len);
+                if (rt_val) {
+                        shost_printk(KERN_WARNING, phba->shost,
+                                     "Failed to clear Gateway Addr Set\n");
+                        return rt_val;
+                }
+        }
+
+        gtway_addr = (uint8_t *)&gateway_param->value;
+        rt_val = mgmt_modify_gateway(phba, gtway_addr, IP_ACTION_ADD,
+                                     gateway_param->len);
+
+        if (rt_val)
+                shost_printk(KERN_WARNING, phba->shost,
+                             "Failed to Set Gateway Addr\n");
+
+        return rt_val;
+}
+
+int mgmt_get_gateway(struct beiscsi_hba *phba, int ip_type,
+                     struct be_cmd_get_def_gateway_resp *gateway)
+{
+        struct be_cmd_get_def_gateway_req *req;
+        struct be_dma_mem nonemb_cmd;
+        int rc;
+
+        rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
+                                 OPCODE_COMMON_ISCSI_NTWK_GET_DEFAULT_GATEWAY,
+                                 sizeof(*gateway));
+        if (rc)
+                return rc;
+
+        req = nonemb_cmd.va;
+        req->ip_type = ip_type;
+
+        return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, gateway,
+                                    sizeof(*gateway));
+}
+
+int mgmt_get_if_info(struct beiscsi_hba *phba, int ip_type,
+                     struct be_cmd_get_if_info_resp *if_info)
+{
+        struct be_cmd_get_if_info_req *req;
+        struct be_dma_mem nonemb_cmd;
+        int rc;
+
+        if (mgmt_get_all_if_id(phba))
+                return -EIO;
+
+        rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
+                                 OPCODE_COMMON_ISCSI_NTWK_GET_IF_INFO,
+                                 sizeof(*if_info));
+        if (rc)
+                return rc;
+
+        req = nonemb_cmd.va;
+        req->interface_hndl = phba->interface_handle;
+        req->ip_type = ip_type;
+
+        return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, if_info,
+                                    sizeof(*if_info));
+}
+
+int mgmt_get_nic_conf(struct beiscsi_hba *phba,
+                      struct be_cmd_get_nic_conf_resp *nic)
+{
+        struct be_dma_mem nonemb_cmd;
+        int rc;
+
+        rc = mgmt_alloc_cmd_data(phba, &nonemb_cmd,
+                                 OPCODE_COMMON_ISCSI_NTWK_GET_NIC_CONFIG,
+                                 sizeof(*nic));
+        if (rc)
+                return rc;
+
+        return mgmt_exec_nonemb_cmd(phba, &nonemb_cmd, nic, sizeof(*nic));
+}
+
+
+
+unsigned int be_cmd_get_initname(struct beiscsi_hba *phba)
+{
         unsigned int tag = 0;
+        struct be_mcc_wrb *wrb;
+        struct be_cmd_hba_name *req;
+        struct be_ctrl_info *ctrl = &phba->ctrl;
 
-        SE_DEBUG(DBG_LVL_8, "In be_cmd_get_mac_addr\n");
         spin_lock(&ctrl->mbox_lock);
         tag = alloc_mcc_tag(phba);
         if (!tag) {
@@ -438,12 +890,38 @@ unsigned int be_cmd_get_mac_addr(struct beiscsi_hba *phba)
         req = embedded_payload(wrb);
         wrb->tag0 |= tag;
         be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
-        be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
-                           OPCODE_COMMON_ISCSI_NTWK_GET_NIC_CONFIG,
-                           sizeof(*req));
+        be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI,
+                        OPCODE_ISCSI_INI_CFG_GET_HBA_NAME,
+                        sizeof(*req));
 
         be_mcc_notify(phba);
         spin_unlock(&ctrl->mbox_lock);
         return tag;
 }
 
+unsigned int be_cmd_get_port_speed(struct beiscsi_hba *phba)
+{
+        unsigned int tag = 0;
+        struct be_mcc_wrb *wrb;
+        struct be_cmd_ntwk_link_status_req *req;
+        struct be_ctrl_info *ctrl = &phba->ctrl;
+
+        spin_lock(&ctrl->mbox_lock);
+        tag = alloc_mcc_tag(phba);
+        if (!tag) {
+                spin_unlock(&ctrl->mbox_lock);
+                return tag;
+        }
+
+        wrb = wrb_from_mccq(phba);
+        req = embedded_payload(wrb);
+        wrb->tag0 |= tag;
+        be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
+        be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,
+                        OPCODE_COMMON_NTWK_LINK_STATUS_QUERY,
+                        sizeof(*req));
+
+        be_mcc_notify(phba);
+        spin_unlock(&ctrl->mbox_lock);
+        return tag;
+}
diff --git a/drivers/scsi/be2iscsi/be_mgmt.h b/drivers/scsi/be2iscsi/be_mgmt.h
index 08428824ace2..5c2e37693ca8 100644
--- a/drivers/scsi/be2iscsi/be_mgmt.h
+++ b/drivers/scsi/be2iscsi/be_mgmt.h
@@ -20,11 +20,16 @@
 #ifndef _BEISCSI_MGMT_
 #define _BEISCSI_MGMT_
 
-#include <linux/types.h>
-#include <linux/list.h>
+#include <scsi/scsi_bsg_iscsi.h>
 #include "be_iscsi.h"
 #include "be_main.h"
 
+#define IP_ACTION_ADD   0x01
+#define IP_ACTION_DEL   0x02
+
+#define IP_V6_LEN       16
+#define IP_V4_LEN       4
+
 /**
  * Pseudo amap definition in which each bit of the actual structure is defined
  * as a byte: used to calculate offset/shift/mask of each field
@@ -98,6 +103,10 @@ unsigned int mgmt_invalidate_icds(struct beiscsi_hba *phba,
                                 struct invalidate_command_table *inv_tbl,
                                 unsigned int num_invalidate, unsigned int cid,
                                 struct be_dma_mem *nonemb_cmd);
+unsigned int mgmt_vendor_specific_fw_cmd(struct be_ctrl_info *ctrl,
+                                         struct beiscsi_hba *phba,
+                                         struct bsg_job *job,
+                                         struct be_dma_mem *nonemb_cmd);
 
 struct iscsi_invalidate_connection_params_in {
         struct be_cmd_req_hdr hdr;
@@ -204,6 +213,13 @@ struct be_mgmt_controller_attributes_resp {
         struct mgmt_controller_attributes params;
 } __packed;
 
+struct be_bsg_vendor_cmd {
+        struct be_cmd_req_hdr hdr;
+        unsigned short region;
+        unsigned short offset;
+        unsigned short sector;
+} __packed;
+
 /* configuration management */
 
 #define GET_MGMT_CONTROLLER_WS(phba)    (phba->pmgmt_ws)
@@ -219,12 +235,15 @@ struct be_mgmt_controller_attributes_resp {
                                 /* the CMD_RESPONSE_HEADER  */
 
 #define ISCSI_GET_PDU_TEMPLATE_ADDRESS(pc, pa) {\
-    pa->lo = phba->init_mem[ISCSI_MEM_GLOBAL_HEADER].mem_array[0].\
+        pa->lo = phba->init_mem[ISCSI_MEM_GLOBAL_HEADER].mem_array[0].\
                                         bus_address.u.a32.address_lo;  \
-    pa->hi = phba->init_mem[ISCSI_MEM_GLOBAL_HEADER].mem_array[0].\
+        pa->hi = phba->init_mem[ISCSI_MEM_GLOBAL_HEADER].mem_array[0].\
                                         bus_address.u.a32.address_hi;  \
 }
 
+#define BEISCSI_WRITE_FLASH 0
+#define BEISCSI_READ_FLASH 1
+
 struct beiscsi_endpoint {
         struct beiscsi_hba *phba;
         struct beiscsi_sess *sess;
@@ -248,4 +267,27 @@ unsigned int mgmt_invalidate_connection(struct beiscsi_hba *phba,
                                          unsigned short issue_reset,
                                          unsigned short savecfg_flag);
 
+int mgmt_set_ip(struct beiscsi_hba *phba,
+                struct iscsi_iface_param_info *ip_param,
+                struct iscsi_iface_param_info *subnet_param,
+                uint32_t boot_proto);
+
+unsigned int mgmt_get_boot_target(struct beiscsi_hba *phba);
+
+unsigned int mgmt_get_session_info(struct beiscsi_hba *phba,
+                                   u32 boot_session_handle,
+                                   struct be_dma_mem *nonemb_cmd);
+
+int mgmt_get_nic_conf(struct beiscsi_hba *phba,
+                      struct be_cmd_get_nic_conf_resp *mac);
+
+int mgmt_get_if_info(struct beiscsi_hba *phba, int ip_type,
+                     struct be_cmd_get_if_info_resp *if_info);
+
+int mgmt_get_gateway(struct beiscsi_hba *phba, int ip_type,
+                     struct be_cmd_get_def_gateway_resp *gateway);
+
+int mgmt_set_gateway(struct beiscsi_hba *phba,
+                     struct iscsi_iface_param_info *gateway_param);
+
 #endif
diff --git a/drivers/scsi/bfa/bfa_fcs.h b/drivers/scsi/bfa/bfa_fcs.h
index e75e07d25915..51c9e1345719 100644
--- a/drivers/scsi/bfa/bfa_fcs.h
+++ b/drivers/scsi/bfa/bfa_fcs.h
@@ -799,9 +799,6 @@ struct bfad_port_s *bfa_fcb_lport_new(struct bfad_s *bfad,
                                       enum bfa_lport_role roles,
                                       struct bfad_vf_s *vf_drv,
                                       struct bfad_vport_s *vp_drv);
-void bfa_fcb_lport_delete(struct bfad_s *bfad, enum bfa_lport_role roles,
-                          struct bfad_vf_s *vf_drv,
-                          struct bfad_vport_s *vp_drv);
 
 /*
  * vport callbacks
diff --git a/drivers/scsi/bfa/bfa_fcs_lport.c b/drivers/scsi/bfa/bfa_fcs_lport.c
index 5d2a1307e5ce..937000db62a8 100644
--- a/drivers/scsi/bfa/bfa_fcs_lport.c
+++ b/drivers/scsi/bfa/bfa_fcs_lport.c
@@ -616,7 +616,7 @@ bfa_fcs_lport_online_actions(struct bfa_fcs_lport_s *port)
         __port_action[port->fabric->fab_type].online(port);
 
         wwn2str(lpwwn_buf, bfa_fcs_lport_get_pwwn(port));
-        BFA_LOG(KERN_INFO, bfad, bfa_log_level,
+        BFA_LOG(KERN_WARNING, bfad, bfa_log_level,
                 "Logical port online: WWN = %s Role = %s\n",
                 lpwwn_buf, "Initiator");
         bfa_fcs_lport_aen_post(port, BFA_LPORT_AEN_ONLINE);
@@ -639,12 +639,12 @@ bfa_fcs_lport_offline_actions(struct bfa_fcs_lport_s *port)
         wwn2str(lpwwn_buf, bfa_fcs_lport_get_pwwn(port));
         if (bfa_sm_cmp_state(port->fabric,
                         bfa_fcs_fabric_sm_online) == BFA_TRUE) {
-                BFA_LOG(KERN_ERR, bfad, bfa_log_level,
+                BFA_LOG(KERN_WARNING, bfad, bfa_log_level,
                 "Logical port lost fabric connectivity: WWN = %s Role = %s\n",
                 lpwwn_buf, "Initiator");
                 bfa_fcs_lport_aen_post(port, BFA_LPORT_AEN_DISCONNECT);
         } else {
-                BFA_LOG(KERN_INFO, bfad, bfa_log_level,
+                BFA_LOG(KERN_WARNING, bfad, bfa_log_level,
                 "Logical port taken offline: WWN = %s Role = %s\n",
                 lpwwn_buf, "Initiator");
                 bfa_fcs_lport_aen_post(port, BFA_LPORT_AEN_OFFLINE);
@@ -709,14 +709,10 @@ bfa_fcs_lport_deleted(struct bfa_fcs_lport_s *port)
         bfa_fcs_lport_aen_post(port, BFA_LPORT_AEN_DELETE);
 
         /* Base port will be deleted by the OS driver */
-        if (port->vport) {
-                bfa_fcb_lport_delete(port->fcs->bfad, port->port_cfg.roles,
-                                port->fabric->vf_drv,
-                                port->vport ? port->vport->vport_drv : NULL);
+        if (port->vport)
                 bfa_fcs_vport_delete_comp(port->vport);
-        } else {
+        else
                 bfa_wc_down(&port->fabric->wc);
-        }
 }
 
 
@@ -5714,17 +5710,23 @@ bfa_fcs_vport_free(struct bfa_fcs_vport_s *vport)
                         (struct bfad_vport_s *)vport->vport_drv;
 
         bfa_fcs_fabric_delvport(__vport_fabric(vport), vport);
+        bfa_lps_delete(vport->lps);
 
-        if (vport_drv->comp_del)
+        if (vport_drv->comp_del) {
                 complete(vport_drv->comp_del);
-        else
-                kfree(vport_drv);
+                return;
+        }
 
-        bfa_lps_delete(vport->lps);
+        /*
+         * We queue the vport delete work to the IM work_q from here.
+         * The memory for the bfad_vport_s is freed from the FC function
+         * template vport_delete entry point.
+         */
+        if (vport_drv)
+                bfad_im_port_delete(vport_drv->drv_port.bfad,
+                                &vport_drv->drv_port);
 }
 
-
-
 /*
  *  fcs_vport_public FCS virtual port public interfaces
  */
diff --git a/drivers/scsi/bfa/bfad.c b/drivers/scsi/bfa/bfad.c
index 404fd10ddb21..2e4b0be14a20 100644
--- a/drivers/scsi/bfa/bfad.c
+++ b/drivers/scsi/bfa/bfad.c
@@ -456,23 +456,6 @@ bfa_fcb_lport_new(struct bfad_s *bfad, struct bfa_fcs_lport_s *port,
         return port_drv;
 }
 
-void
-bfa_fcb_lport_delete(struct bfad_s *bfad, enum bfa_lport_role roles,
-                    struct bfad_vf_s *vf_drv, struct bfad_vport_s *vp_drv)
-{
-        struct bfad_port_s    *port_drv;
-
-        /* this will be only called from rmmod context */
-        if (vp_drv && !vp_drv->comp_del) {
-                port_drv = (vp_drv) ? (&(vp_drv)->drv_port) :
-                                ((vf_drv) ? (&(vf_drv)->base_port) :
-                                (&(bfad)->pport));
-                bfa_trc(bfad, roles);
-                if (roles & BFA_LPORT_ROLE_FCP_IM)
-                        bfad_im_port_delete(bfad, port_drv);
-        }
-}
-
 /*
  * FCS RPORT alloc callback, after successful PLOGI by FCS
  */
diff --git a/drivers/scsi/bfa/bfad_attr.c b/drivers/scsi/bfa/bfad_attr.c
index 7b1ecd2b3ffe..8b6c6bf7837e 100644
--- a/drivers/scsi/bfa/bfad_attr.c
+++ b/drivers/scsi/bfa/bfad_attr.c
@@ -497,6 +497,7 @@ bfad_im_vport_delete(struct fc_vport *fc_vport)
         if (im_port->flags & BFAD_PORT_DELETE) {
                 bfad_scsi_host_free(bfad, im_port);
                 list_del(&vport->list_entry);
+                kfree(vport);
                 return 0;
         }
 
@@ -758,25 +759,10 @@ bfad_im_model_desc_show(struct device *dev, struct device_attribute *attr,
         else if (!strcmp(model, "Brocade-804"))
                 snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
                         "Brocade 8Gbps FC HBA for HP Bladesystem C-class");
-        else if (!strcmp(model, "Brocade-902") ||
-                 !strcmp(model, "Brocade-1741"))
+        else if (!strcmp(model, "Brocade-1741"))
                 snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
                         "Brocade 10Gbps CNA for Dell M-Series Blade Servers");
-        else if (strstr(model, "Brocade-1560")) {
-                if (nports == 1)
-                        snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
-                                "Brocade 16Gbps PCIe single port FC HBA");
-                else
-                        snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
-                                "Brocade 16Gbps PCIe dual port FC HBA");
-        } else if (strstr(model, "Brocade-1710")) {
-                if (nports == 1)
-                        snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
-                                "Brocade 10Gbps single port CNA");
-                else
-                        snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
-                                "Brocade 10Gbps dual port CNA");
-        } else if (strstr(model, "Brocade-1860")) {
+        else if (strstr(model, "Brocade-1860")) {
                 if (nports == 1 && bfa_ioc_is_cna(&bfad->bfa.ioc))
                         snprintf(model_descr, BFA_ADAPTER_MODEL_DESCR_LEN,
                                 "Brocade 10Gbps single port CNA");
diff --git a/drivers/scsi/bnx2i/57xx_iscsi_constants.h b/drivers/scsi/bnx2i/57xx_iscsi_constants.h
index 495a841645f9..25093a04123b 100644
--- a/drivers/scsi/bnx2i/57xx_iscsi_constants.h
+++ b/drivers/scsi/bnx2i/57xx_iscsi_constants.h
@@ -1,6 +1,6 @@
 /* 57xx_iscsi_constants.h: Broadcom NetXtreme II iSCSI HSI
  *
- * Copyright (c) 2006 - 2011 Broadcom Corporation
+ * Copyright (c) 2006 - 2012 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/bnx2i/57xx_iscsi_hsi.h b/drivers/scsi/bnx2i/57xx_iscsi_hsi.h
index 72118db89a20..dc0a08e69c82 100644
--- a/drivers/scsi/bnx2i/57xx_iscsi_hsi.h
+++ b/drivers/scsi/bnx2i/57xx_iscsi_hsi.h
@@ -1,6 +1,6 @@
 /* 57xx_iscsi_hsi.h: Broadcom NetXtreme II iSCSI HSI.
  *
- * Copyright (c) 2006 - 2011 Broadcom Corporation
+ * Copyright (c) 2006 - 2012 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/bnx2i/bnx2i.h b/drivers/scsi/bnx2i/bnx2i.h
index 0bd70e80efe4..0c53c28dc3d3 100644
--- a/drivers/scsi/bnx2i/bnx2i.h
+++ b/drivers/scsi/bnx2i/bnx2i.h
@@ -1,6 +1,6 @@
 /* bnx2i.h: Broadcom NetXtreme II iSCSI driver.
  *
- * Copyright (c) 2006 - 2011 Broadcom Corporation
+ * Copyright (c) 2006 - 2012 Broadcom Corporation
  * Copyright (c) 2007, 2008 Red Hat, Inc.  All rights reserved.
  * Copyright (c) 2007, 2008 Mike Christie
  *
diff --git a/drivers/scsi/bnx2i/bnx2i_hwi.c b/drivers/scsi/bnx2i/bnx2i_hwi.c
index f9d6f4129093..ece47e502282 100644
--- a/drivers/scsi/bnx2i/bnx2i_hwi.c
+++ b/drivers/scsi/bnx2i/bnx2i_hwi.c
@@ -1,6 +1,6 @@
 /* bnx2i_hwi.c: Broadcom NetXtreme II iSCSI driver.
  *
- * Copyright (c) 2006 - 2011 Broadcom Corporation
+ * Copyright (c) 2006 - 2012 Broadcom Corporation
  * Copyright (c) 2007, 2008 Red Hat, Inc.  All rights reserved.
  * Copyright (c) 2007, 2008 Mike Christie
  *
diff --git a/drivers/scsi/bnx2i/bnx2i_init.c b/drivers/scsi/bnx2i/bnx2i_init.c
index 4927cca733d3..8b6816706ee5 100644
--- a/drivers/scsi/bnx2i/bnx2i_init.c
+++ b/drivers/scsi/bnx2i/bnx2i_init.c
@@ -1,6 +1,6 @@
 /* bnx2i.c: Broadcom NetXtreme II iSCSI driver.
  *
- * Copyright (c) 2006 - 2011 Broadcom Corporation
+ * Copyright (c) 2006 - 2012 Broadcom Corporation
  * Copyright (c) 2007, 2008 Red Hat, Inc.  All rights reserved.
  * Copyright (c) 2007, 2008 Mike Christie
  *
@@ -18,8 +18,8 @@ static struct list_head adapter_list = LIST_HEAD_INIT(adapter_list);
 static u32 adapter_count;
 
 #define DRV_MODULE_NAME         "bnx2i"
-#define DRV_MODULE_VERSION      "2.7.0.3"
-#define DRV_MODULE_RELDATE      "Jun 15, 2011"
+#define DRV_MODULE_VERSION      "2.7.2.2"
+#define DRV_MODULE_RELDATE      "Apr 25, 2012"
 
 static char version[] __devinitdata =
                 "Broadcom NetXtreme II iSCSI Driver " DRV_MODULE_NAME \
diff --git a/drivers/scsi/bnx2i/bnx2i_iscsi.c b/drivers/scsi/bnx2i/bnx2i_iscsi.c
index 1a44b45e7bef..f8d516b53161 100644
--- a/drivers/scsi/bnx2i/bnx2i_iscsi.c
+++ b/drivers/scsi/bnx2i/bnx2i_iscsi.c
@@ -1,7 +1,7 @@
 /*
  * bnx2i_iscsi.c: Broadcom NetXtreme II iSCSI driver.
  *
- * Copyright (c) 2006 - 2011 Broadcom Corporation
+ * Copyright (c) 2006 - 2012 Broadcom Corporation
  * Copyright (c) 2007, 2008 Red Hat, Inc.  All rights reserved.
  * Copyright (c) 2007, 2008 Mike Christie
  *
@@ -2244,6 +2244,7 @@ static struct scsi_host_template bnx2i_host_template = {
         .eh_device_reset_handler = iscsi_eh_device_reset,
         .eh_target_reset_handler = iscsi_eh_recover_target,
         .change_queue_depth     = iscsi_change_queue_depth,
+        .target_alloc           = iscsi_target_alloc,
         .can_queue              = 2048,
         .max_sectors            = 127,
         .cmd_per_lun            = 128,
diff --git a/drivers/scsi/bnx2i/bnx2i_sysfs.c b/drivers/scsi/bnx2i/bnx2i_sysfs.c
index 83a77f7244d2..c61cf7a43658 100644
--- a/drivers/scsi/bnx2i/bnx2i_sysfs.c
+++ b/drivers/scsi/bnx2i/bnx2i_sysfs.c
@@ -1,6 +1,6 @@
 /* bnx2i_sysfs.c: Broadcom NetXtreme II iSCSI driver.
  *
- * Copyright (c) 2004 - 2011 Broadcom Corporation
+ * Copyright (c) 2004 - 2012 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/device_handler/scsi_dh_alua.c b/drivers/scsi/device_handler/scsi_dh_alua.c
index 04c5cea47a22..fda9cdea0e60 100644
--- a/drivers/scsi/device_handler/scsi_dh_alua.c
+++ b/drivers/scsi/device_handler/scsi_dh_alua.c
@@ -55,11 +55,16 @@
 #define ALUA_FAILOVER_TIMEOUT           (60 * HZ)
 #define ALUA_FAILOVER_RETRIES           5
 
+/* flags passed from user level */
+#define ALUA_OPTIMIZE_STPG              1
+
 struct alua_dh_data {
         int                     group_id;
         int                     rel_port;
         int                     tpgs;
         int                     state;
+        int                     pref;
+        unsigned                flags; /* used for optimizing STPG */
         unsigned char           inq[ALUA_INQUIRY_SIZE];
         unsigned char           *buff;
         int                     bufflen;
@@ -554,14 +559,16 @@ static int alua_rtpg(struct scsi_device *sdev, struct alua_dh_data *h)
         for (k = 4, ucp = h->buff + 4; k < len; k += off, ucp += off) {
                 if (h->group_id == (ucp[2] << 8) + ucp[3]) {
                         h->state = ucp[0] & 0x0f;
+                        h->pref = ucp[0] >> 7;
                         valid_states = ucp[1];
                 }
                 off = 8 + (ucp[7] * 4);
         }
 
         sdev_printk(KERN_INFO, sdev,
-                    "%s: port group %02x state %c supports %c%c%c%c%c%c%c\n",
+                    "%s: port group %02x state %c %s supports %c%c%c%c%c%c%c\n",
                     ALUA_DH_NAME, h->group_id, print_alua_state(h->state),
+                    h->pref ? "preferred" : "non-preferred",
                     valid_states&TPGS_SUPPORT_TRANSITION?'T':'t',
                     valid_states&TPGS_SUPPORT_OFFLINE?'O':'o',
                     valid_states&TPGS_SUPPORT_LBA_DEPENDENT?'L':'l',
@@ -621,6 +628,37 @@ static int alua_initialize(struct scsi_device *sdev, struct alua_dh_data *h)
 out:
         return err;
 }
+/*
+ * alua_set_params - set/unset the optimize flag
+ * @sdev: device on the path to be activated
+ * params - parameters in the following format
+ *      "no_of_params\0param1\0param2\0param3\0...\0"
+ * For example, to set the flag pass the following parameters
+ * from multipath.conf
+ *     hardware_handler        "2 alua 1"
+ */
+static int alua_set_params(struct scsi_device *sdev, const char *params)
+{
+        struct alua_dh_data *h = get_alua_data(sdev);
+        unsigned int optimize = 0, argc;
+        const char *p = params;
+        int result = SCSI_DH_OK;
+
+        if ((sscanf(params, "%u", &argc) != 1) || (argc != 1))
+                return -EINVAL;
+
+        while (*p++)
+                ;
+        if ((sscanf(p, "%u", &optimize) != 1) || (optimize > 1))
+                return -EINVAL;
+
+        if (optimize)
+                h->flags |= ALUA_OPTIMIZE_STPG;
+        else
+                h->flags &= ~ALUA_OPTIMIZE_STPG;
+
+        return result;
+}
 
 /*
  * alua_activate - activate a path
@@ -637,14 +675,37 @@ static int alua_activate(struct scsi_device *sdev,
 {
         struct alua_dh_data *h = get_alua_data(sdev);
         int err = SCSI_DH_OK;
+        int stpg = 0;
 
         err = alua_rtpg(sdev, h);
         if (err != SCSI_DH_OK)
                 goto out;
 
-        if (h->tpgs & TPGS_MODE_EXPLICIT &&
-            h->state != TPGS_STATE_OPTIMIZED &&
-            h->state != TPGS_STATE_LBA_DEPENDENT) {
+        if (h->tpgs & TPGS_MODE_EXPLICIT) {
+                switch (h->state) {
+                case TPGS_STATE_NONOPTIMIZED:
+                        stpg = 1;
+                        if ((h->flags & ALUA_OPTIMIZE_STPG) &&
+                            (!h->pref) &&
+                            (h->tpgs & TPGS_MODE_IMPLICIT))
+                                stpg = 0;
+                        break;
+                case TPGS_STATE_STANDBY:
+                        stpg = 1;
+                        break;
+                case TPGS_STATE_UNAVAILABLE:
+                case TPGS_STATE_OFFLINE:
+                        err = SCSI_DH_IO;
+                        break;
+                case TPGS_STATE_TRANSITIONING:
+                        err = SCSI_DH_RETRY;
+                        break;
+                default:
+                        break;
+                }
+        }
+
+        if (stpg) {
                 h->callback_fn = fn;
                 h->callback_data = data;
                 err = submit_stpg(h);
@@ -698,6 +759,7 @@ static struct scsi_device_handler alua_dh = {
         .prep_fn = alua_prep_fn,
         .check_sense = alua_check_sense,
         .activate = alua_activate,
+        .set_params = alua_set_params,
         .match = alua_match,
 };
 
diff --git a/drivers/scsi/fcoe/fcoe.c b/drivers/scsi/fcoe/fcoe.c
index 335e85192807..76e3d0b5bfa6 100644
--- a/drivers/scsi/fcoe/fcoe.c
+++ b/drivers/scsi/fcoe/fcoe.c
@@ -411,20 +411,18 @@ out:
 }
 
 /**
- * fcoe_interface_cleanup() - Clean up a FCoE interface
+ * fcoe_interface_remove() - remove FCoE interface from netdev
  * @fcoe: The FCoE interface to be cleaned up
  *
  * Caller must be holding the RTNL mutex
  */
-static void fcoe_interface_cleanup(struct fcoe_interface *fcoe)
+static void fcoe_interface_remove(struct fcoe_interface *fcoe)
 {
         struct net_device *netdev = fcoe->netdev;
         struct fcoe_ctlr *fip = &fcoe->ctlr;
         u8 flogi_maddr[ETH_ALEN];
         const struct net_device_ops *ops;
 
-        rtnl_lock();
-
         /*
          * Don't listen for Ethernet packets anymore.
          * synchronize_net() ensures that the packet handlers are not running
@@ -453,12 +451,28 @@ static void fcoe_interface_cleanup(struct fcoe_interface *fcoe)
                         FCOE_NETDEV_DBG(netdev, "Failed to disable FCoE"
                                         " specific feature for LLD.\n");
         }
+        fcoe->removed = 1;
+}
+
+
+/**
+ * fcoe_interface_cleanup() - Clean up a FCoE interface
+ * @fcoe: The FCoE interface to be cleaned up
+ */
+static void fcoe_interface_cleanup(struct fcoe_interface *fcoe)
+{
+        struct net_device *netdev = fcoe->netdev;
+        struct fcoe_ctlr *fip = &fcoe->ctlr;
 
+        rtnl_lock();
+        if (!fcoe->removed)
+                fcoe_interface_remove(fcoe);
         rtnl_unlock();
 
         /* Release the self-reference taken during fcoe_interface_create() */
         /* tear-down the FCoE controller */
         fcoe_ctlr_destroy(fip);
+        scsi_host_put(fcoe->ctlr.lp->host);
         kfree(fcoe);
         dev_put(netdev);
         module_put(THIS_MODULE);
@@ -522,13 +536,11 @@ static void fcoe_update_src_mac(struct fc_lport *lport, u8 *addr)
         struct fcoe_port *port = lport_priv(lport);
         struct fcoe_interface *fcoe = port->priv;
 
-        rtnl_lock();
         if (!is_zero_ether_addr(port->data_src_addr))
                 dev_uc_del(fcoe->netdev, port->data_src_addr);
         if (!is_zero_ether_addr(addr))
                 dev_uc_add(fcoe->netdev, addr);
         memcpy(port->data_src_addr, addr, ETH_ALEN);
-        rtnl_unlock();
 }
 
 /**
@@ -941,6 +953,10 @@ static void fcoe_if_destroy(struct fc_lport *lport)
         rtnl_lock();
         if (!is_zero_ether_addr(port->data_src_addr))
                 dev_uc_del(netdev, port->data_src_addr);
+        if (lport->vport)
+                synchronize_net();
+        else
+                fcoe_interface_remove(fcoe);
         rtnl_unlock();
 
         /* Free queued packets for the per-CPU receive threads */
@@ -959,8 +975,12 @@ static void fcoe_if_destroy(struct fc_lport *lport)
         /* Free memory used by statistical counters */
         fc_lport_free_stats(lport);
 
-        /* Release the Scsi_Host */
-        scsi_host_put(lport->host);
+        /*
+         * Release the Scsi_Host for vport but hold on to
+         * master lport until it fcoe interface fully cleaned-up.
+         */
+        if (lport->vport)
+                scsi_host_put(lport->host);
 }
 
 /**
@@ -2274,10 +2294,9 @@ static void fcoe_percpu_clean(struct fc_lport *lport)
                         continue;
 
                 skb = dev_alloc_skb(0);
-                if (!skb) {
-                        spin_unlock_bh(&pp->fcoe_rx_list.lock);
+                if (!skb)
                         continue;
-                }
+
                 skb->destructor = fcoe_percpu_flush_done;
 
                 spin_lock_bh(&pp->fcoe_rx_list.lock);
diff --git a/drivers/scsi/fcoe/fcoe.h b/drivers/scsi/fcoe/fcoe.h
index 3c2733a12aa1..96ac938d39cc 100644
--- a/drivers/scsi/fcoe/fcoe.h
+++ b/drivers/scsi/fcoe/fcoe.h
@@ -71,7 +71,8 @@ do {                                                            	\
  * @ctlr:             The FCoE controller (for FIP)
  * @oem:              The offload exchange manager for all local port
  *                    instances associated with this port
- * This structure is 1:1 with a net devive.
+ * @removed:          Indicates fcoe interface removed from net device
+ * This structure is 1:1 with a net device.
  */
 struct fcoe_interface {
         struct list_head   list;
@@ -81,6 +82,7 @@ struct fcoe_interface {
         struct packet_type fip_packet_type;
         struct fcoe_ctlr   ctlr;
         struct fc_exch_mgr *oem;
+        u8      removed;
 };
 
 #define fcoe_from_ctlr(fip) container_of(fip, struct fcoe_interface, ctlr)
diff --git a/drivers/scsi/fcoe/fcoe_ctlr.c b/drivers/scsi/fcoe/fcoe_ctlr.c
index 249a106888d9..5a4c7250aa77 100644
--- a/drivers/scsi/fcoe/fcoe_ctlr.c
+++ b/drivers/scsi/fcoe/fcoe_ctlr.c
@@ -1883,7 +1883,13 @@ static void fcoe_ctlr_vn_send(struct fcoe_ctlr *fip,
         frame = (struct fip_frame *)skb->data;
         memset(frame, 0, len);
         memcpy(frame->eth.h_dest, dest, ETH_ALEN);
-        memcpy(frame->eth.h_source, fip->ctl_src_addr, ETH_ALEN);
+
+        if (sub == FIP_SC_VN_BEACON) {
+                hton24(frame->eth.h_source, FIP_VN_FC_MAP);
+                hton24(frame->eth.h_source + 3, fip->port_id);
+        } else {
+                memcpy(frame->eth.h_source, fip->ctl_src_addr, ETH_ALEN);
+        }
         frame->eth.h_proto = htons(ETH_P_FIP);
 
         frame->fip.fip_ver = FIP_VER_ENCAPS(FIP_VER);
diff --git a/drivers/scsi/hpsa.c b/drivers/scsi/hpsa.c
index 500e20dd56ec..796482badf13 100644
--- a/drivers/scsi/hpsa.c
+++ b/drivers/scsi/hpsa.c
@@ -159,6 +159,7 @@ static int hpsa_change_queue_depth(struct scsi_device *sdev,
         int qdepth, int reason);
 
 static int hpsa_eh_device_reset_handler(struct scsi_cmnd *scsicmd);
+static int hpsa_eh_abort_handler(struct scsi_cmnd *scsicmd);
 static int hpsa_slave_alloc(struct scsi_device *sdev);
 static void hpsa_slave_destroy(struct scsi_device *sdev);
 
@@ -171,7 +172,7 @@ static void check_ioctl_unit_attention(struct ctlr_info *h,
 static void calc_bucket_map(int *bucket, int num_buckets,
         int nsgs, int *bucket_map);
 static __devinit void hpsa_put_ctlr_into_performant_mode(struct ctlr_info *h);
-static inline u32 next_command(struct ctlr_info *h);
+static inline u32 next_command(struct ctlr_info *h, u8 q);
 static int __devinit hpsa_find_cfg_addrs(struct pci_dev *pdev,
         void __iomem *vaddr, u32 *cfg_base_addr, u64 *cfg_base_addr_index,
         u64 *cfg_offset);
@@ -180,6 +181,7 @@ static int __devinit hpsa_pci_find_memory_BAR(struct pci_dev *pdev,
 static int __devinit hpsa_lookup_board_id(struct pci_dev *pdev, u32 *board_id);
 static int __devinit hpsa_wait_for_board_state(struct pci_dev *pdev,
         void __iomem *vaddr, int wait_for_ready);
+static inline void finish_cmd(struct CommandList *c);
 #define BOARD_NOT_READY 0
 #define BOARD_READY 1
 
@@ -234,6 +236,16 @@ static int check_for_unit_attention(struct ctlr_info *h,
         return 1;
 }
 
+static int check_for_busy(struct ctlr_info *h, struct CommandList *c)
+{
+        if (c->err_info->CommandStatus != CMD_TARGET_STATUS ||
+                (c->err_info->ScsiStatus != SAM_STAT_BUSY &&
+                 c->err_info->ScsiStatus != SAM_STAT_TASK_SET_FULL))
+                return 0;
+        dev_warn(&h->pdev->dev, HPSA "device busy");
+        return 1;
+}
+
 static ssize_t host_store_rescan(struct device *dev,
                                  struct device_attribute *attr,
                                  const char *buf, size_t count)
@@ -368,7 +380,7 @@ static inline int is_logical_dev_addr_mode(unsigned char scsi3addr[])
 }
 
 static const char *raid_label[] = { "0", "4", "1(1+0)", "5", "5+1", "ADG",
-        "UNKNOWN"
+        "1(ADM)", "UNKNOWN"
 };
 #define RAID_UNKNOWN (ARRAY_SIZE(raid_label) - 1)
 
@@ -497,6 +509,7 @@ static struct scsi_host_template hpsa_driver_template = {
         .change_queue_depth     = hpsa_change_queue_depth,
         .this_id                = -1,
         .use_clustering         = ENABLE_CLUSTERING,
+        .eh_abort_handler       = hpsa_eh_abort_handler,
         .eh_device_reset_handler = hpsa_eh_device_reset_handler,
         .ioctl                  = hpsa_ioctl,
         .slave_alloc            = hpsa_slave_alloc,
@@ -516,24 +529,28 @@ static inline void addQ(struct list_head *list, struct CommandList *c)
         list_add_tail(&c->list, list);
 }
 
-static inline u32 next_command(struct ctlr_info *h)
+static inline u32 next_command(struct ctlr_info *h, u8 q)
 {
         u32 a;
+        struct reply_pool *rq = &h->reply_queue[q];
+        unsigned long flags;
 
         if (unlikely(!(h->transMethod & CFGTBL_Trans_Performant)))
-                return h->access.command_completed(h);
+                return h->access.command_completed(h, q);
 
-        if ((*(h->reply_pool_head) & 1) == (h->reply_pool_wraparound)) {
-                a = *(h->reply_pool_head); /* Next cmd in ring buffer */
-                (h->reply_pool_head)++;
+        if ((rq->head[rq->current_entry] & 1) == rq->wraparound) {
+                a = rq->head[rq->current_entry];
+                rq->current_entry++;
+                spin_lock_irqsave(&h->lock, flags);
                 h->commands_outstanding--;
+                spin_unlock_irqrestore(&h->lock, flags);
         } else {
                 a = FIFO_EMPTY;
         }
         /* Check for wraparound */
-        if (h->reply_pool_head == (h->reply_pool + h->max_commands)) {
-                h->reply_pool_head = h->reply_pool;
-                h->reply_pool_wraparound ^= 1;
+        if (rq->current_entry == h->max_commands) {
+                rq->current_entry = 0;
+                rq->wraparound ^= 1;
         }
         return a;
 }
@@ -544,8 +561,41 @@ static inline u32 next_command(struct ctlr_info *h)
  */
 static void set_performant_mode(struct ctlr_info *h, struct CommandList *c)
 {
-        if (likely(h->transMethod & CFGTBL_Trans_Performant))
+        if (likely(h->transMethod & CFGTBL_Trans_Performant)) {
                 c->busaddr |= 1 | (h->blockFetchTable[c->Header.SGList] << 1);
+                if (likely(h->msix_vector))
+                        c->Header.ReplyQueue =
+                                smp_processor_id() % h->nreply_queues;
+        }
+}
+
+static int is_firmware_flash_cmd(u8 *cdb)
+{
+        return cdb[0] == BMIC_WRITE && cdb[6] == BMIC_FLASH_FIRMWARE;
+}
+
+/*
+ * During firmware flash, the heartbeat register may not update as frequently
+ * as it should.  So we dial down lockup detection during firmware flash. and
+ * dial it back up when firmware flash completes.
+ */
+#define HEARTBEAT_SAMPLE_INTERVAL_DURING_FLASH (240 * HZ)
+#define HEARTBEAT_SAMPLE_INTERVAL (30 * HZ)
+static void dial_down_lockup_detection_during_fw_flash(struct ctlr_info *h,
+                struct CommandList *c)
+{
+        if (!is_firmware_flash_cmd(c->Request.CDB))
+                return;
+        atomic_inc(&h->firmware_flash_in_progress);
+        h->heartbeat_sample_interval = HEARTBEAT_SAMPLE_INTERVAL_DURING_FLASH;
+}
+
+static void dial_up_lockup_detection_on_fw_flash_complete(struct ctlr_info *h,
+                struct CommandList *c)
+{
+        if (is_firmware_flash_cmd(c->Request.CDB) &&
+                atomic_dec_and_test(&h->firmware_flash_in_progress))
+                h->heartbeat_sample_interval = HEARTBEAT_SAMPLE_INTERVAL;
 }
 
 static void enqueue_cmd_and_start_io(struct ctlr_info *h,
@@ -554,11 +604,12 @@ static void enqueue_cmd_and_start_io(struct ctlr_info *h,
         unsigned long flags;
 
         set_performant_mode(h, c);
+        dial_down_lockup_detection_during_fw_flash(h, c);
         spin_lock_irqsave(&h->lock, flags);
         addQ(&h->reqQ, c);
         h->Qdepth++;
-        start_io(h);
         spin_unlock_irqrestore(&h->lock, flags);
+        start_io(h);
 }
 
 static inline void removeQ(struct CommandList *c)
@@ -1193,7 +1244,7 @@ static void complete_scsi_command(struct CommandList *cp)
                                 break;
                         }
                         /* Must be some other type of check condition */
-                        dev_warn(&h->pdev->dev, "cp %p has check condition: "
+                        dev_dbg(&h->pdev->dev, "cp %p has check condition: "
                                         "unknown type: "
                                         "Sense: 0x%x, ASC: 0x%x, ASCQ: 0x%x, "
                                         "Returning result: 0x%x, "
@@ -1370,16 +1421,24 @@ static void hpsa_scsi_do_simple_cmd_core_if_no_lockup(struct ctlr_info *h,
         }
 }
 
+#define MAX_DRIVER_CMD_RETRIES 25
 static void hpsa_scsi_do_simple_cmd_with_retry(struct ctlr_info *h,
         struct CommandList *c, int data_direction)
 {
-        int retry_count = 0;
+        int backoff_time = 10, retry_count = 0;
 
         do {
                 memset(c->err_info, 0, sizeof(*c->err_info));
                 hpsa_scsi_do_simple_cmd_core(h, c);
                 retry_count++;
-        } while (check_for_unit_attention(h, c) && retry_count <= 3);
+                if (retry_count > 3) {
+                        msleep(backoff_time);
+                        if (backoff_time < 1000)
+                                backoff_time *= 2;
+                }
+        } while ((check_for_unit_attention(h, c) ||
+                        check_for_busy(h, c)) &&
+                        retry_count <= MAX_DRIVER_CMD_RETRIES);
         hpsa_pci_unmap(h->pdev, c, 1, data_direction);
 }
 
@@ -2065,9 +2124,8 @@ static int hpsa_scsi_queue_command_lck(struct scsi_cmnd *cmd,
                 done(cmd);
                 return 0;
         }
-        /* Need a lock as this is being allocated from the pool */
-        c = cmd_alloc(h);
         spin_unlock_irqrestore(&h->lock, flags);
+        c = cmd_alloc(h);
         if (c == NULL) {                        /* trouble... */
                 dev_err(&h->pdev->dev, "cmd_alloc returned NULL!\n");
                 return SCSI_MLQUEUE_HOST_BUSY;
@@ -2334,6 +2392,261 @@ static int hpsa_eh_device_reset_handler(struct scsi_cmnd *scsicmd)
         return FAILED;
 }
 
+static void swizzle_abort_tag(u8 *tag)
+{
+        u8 original_tag[8];
+
+        memcpy(original_tag, tag, 8);
+        tag[0] = original_tag[3];
+        tag[1] = original_tag[2];
+        tag[2] = original_tag[1];
+        tag[3] = original_tag[0];
+        tag[4] = original_tag[7];
+        tag[5] = original_tag[6];
+        tag[6] = original_tag[5];
+        tag[7] = original_tag[4];
+}
+
+static int hpsa_send_abort(struct ctlr_info *h, unsigned char *scsi3addr,
+        struct CommandList *abort, int swizzle)
+{
+        int rc = IO_OK;
+        struct CommandList *c;
+        struct ErrorInfo *ei;
+
+        c = cmd_special_alloc(h);
+        if (c == NULL) {        /* trouble... */
+                dev_warn(&h->pdev->dev, "cmd_special_alloc returned NULL!\n");
+                return -ENOMEM;
+        }
+
+        fill_cmd(c, HPSA_ABORT_MSG, h, abort, 0, 0, scsi3addr, TYPE_MSG);
+        if (swizzle)
+                swizzle_abort_tag(&c->Request.CDB[4]);
+        hpsa_scsi_do_simple_cmd_core(h, c);
+        dev_dbg(&h->pdev->dev, "%s: Tag:0x%08x:%08x: do_simple_cmd_core completed.\n",
+                __func__, abort->Header.Tag.upper, abort->Header.Tag.lower);
+        /* no unmap needed here because no data xfer. */
+
+        ei = c->err_info;
+        switch (ei->CommandStatus) {
+        case CMD_SUCCESS:
+                break;
+        case CMD_UNABORTABLE: /* Very common, don't make noise. */
+                rc = -1;
+                break;
+        default:
+                dev_dbg(&h->pdev->dev, "%s: Tag:0x%08x:%08x: interpreting error.\n",
+                        __func__, abort->Header.Tag.upper,
+                        abort->Header.Tag.lower);
+                hpsa_scsi_interpret_error(c);
+                rc = -1;
+                break;
+        }
+        cmd_special_free(h, c);
+        dev_dbg(&h->pdev->dev, "%s: Tag:0x%08x:%08x: Finished.\n", __func__,
+                abort->Header.Tag.upper, abort->Header.Tag.lower);
+        return rc;
+}
+
+/*
+ * hpsa_find_cmd_in_queue
+ *
+ * Used to determine whether a command (find) is still present
+ * in queue_head.   Optionally excludes the last element of queue_head.
+ *
+ * This is used to avoid unnecessary aborts.  Commands in h->reqQ have
+ * not yet been submitted, and so can be aborted by the driver without
+ * sending an abort to the hardware.
+ *
+ * Returns pointer to command if found in queue, NULL otherwise.
+ */
+static struct CommandList *hpsa_find_cmd_in_queue(struct ctlr_info *h,
+                        struct scsi_cmnd *find, struct list_head *queue_head)
+{
+        unsigned long flags;
+        struct CommandList *c = NULL;   /* ptr into cmpQ */
+
+        if (!find)
+                return 0;
+        spin_lock_irqsave(&h->lock, flags);
+        list_for_each_entry(c, queue_head, list) {
+                if (c->scsi_cmd == NULL) /* e.g.: passthru ioctl */
+                        continue;
+                if (c->scsi_cmd == find) {
+                        spin_unlock_irqrestore(&h->lock, flags);
+                        return c;
+                }
+        }
+        spin_unlock_irqrestore(&h->lock, flags);
+        return NULL;
+}
+
+static struct CommandList *hpsa_find_cmd_in_queue_by_tag(struct ctlr_info *h,
+                                        u8 *tag, struct list_head *queue_head)
+{
+        unsigned long flags;
+        struct CommandList *c;
+
+        spin_lock_irqsave(&h->lock, flags);
+        list_for_each_entry(c, queue_head, list) {
+                if (memcmp(&c->Header.Tag, tag, 8) != 0)
+                        continue;
+                spin_unlock_irqrestore(&h->lock, flags);
+                return c;
+        }
+        spin_unlock_irqrestore(&h->lock, flags);
+        return NULL;
+}
+
+/* Some Smart Arrays need the abort tag swizzled, and some don't.  It's hard to
+ * tell which kind we're dealing with, so we send the abort both ways.  There
+ * shouldn't be any collisions between swizzled and unswizzled tags due to the
+ * way we construct our tags but we check anyway in case the assumptions which
+ * make this true someday become false.
+ */
+static int hpsa_send_abort_both_ways(struct ctlr_info *h,
+        unsigned char *scsi3addr, struct CommandList *abort)
+{
+        u8 swizzled_tag[8];
+        struct CommandList *c;
+        int rc = 0, rc2 = 0;
+
+        /* we do not expect to find the swizzled tag in our queue, but
+         * check anyway just to be sure the assumptions which make this
+         * the case haven't become wrong.
+         */
+        memcpy(swizzled_tag, &abort->Request.CDB[4], 8);
+        swizzle_abort_tag(swizzled_tag);
+        c = hpsa_find_cmd_in_queue_by_tag(h, swizzled_tag, &h->cmpQ);
+        if (c != NULL) {
+                dev_warn(&h->pdev->dev, "Unexpectedly found byte-swapped tag in completion queue.\n");
+                return hpsa_send_abort(h, scsi3addr, abort, 0);
+        }
+        rc = hpsa_send_abort(h, scsi3addr, abort, 0);
+
+        /* if the command is still in our queue, we can't conclude that it was
+         * aborted (it might have just completed normally) but in any case
+         * we don't need to try to abort it another way.
+         */
+        c = hpsa_find_cmd_in_queue(h, abort->scsi_cmd, &h->cmpQ);
+        if (c)
+                rc2 = hpsa_send_abort(h, scsi3addr, abort, 1);
+        return rc && rc2;
+}
+
+/* Send an abort for the specified command.
+ *      If the device and controller support it,
+ *              send a task abort request.
+ */
+static int hpsa_eh_abort_handler(struct scsi_cmnd *sc)
+{
+
+        int i, rc;
+        struct ctlr_info *h;
+        struct hpsa_scsi_dev_t *dev;
+        struct CommandList *abort; /* pointer to command to be aborted */
+        struct CommandList *found;
+        struct scsi_cmnd *as;   /* ptr to scsi cmd inside aborted command. */
+        char msg[256];          /* For debug messaging. */
+        int ml = 0;
+
+        /* Find the controller of the command to be aborted */
+        h = sdev_to_hba(sc->device);
+        if (WARN(h == NULL,
+                        "ABORT REQUEST FAILED, Controller lookup failed.\n"))
+                return FAILED;
+
+        /* Check that controller supports some kind of task abort */
+        if (!(HPSATMF_PHYS_TASK_ABORT & h->TMFSupportFlags) &&
+                !(HPSATMF_LOG_TASK_ABORT & h->TMFSupportFlags))
+                return FAILED;
+
+        memset(msg, 0, sizeof(msg));
+        ml += sprintf(msg+ml, "ABORT REQUEST on C%d:B%d:T%d:L%d ",
+                h->scsi_host->host_no, sc->device->channel,
+                sc->device->id, sc->device->lun);
+
+        /* Find the device of the command to be aborted */
+        dev = sc->device->hostdata;
+        if (!dev) {
+                dev_err(&h->pdev->dev, "%s FAILED, Device lookup failed.\n",
+                                msg);
+                return FAILED;
+        }
+
+        /* Get SCSI command to be aborted */
+        abort = (struct CommandList *) sc->host_scribble;
+        if (abort == NULL) {
+                dev_err(&h->pdev->dev, "%s FAILED, Command to abort is NULL.\n",
+                                msg);
+                return FAILED;
+        }
+
+        ml += sprintf(msg+ml, "Tag:0x%08x:%08x ",
+                abort->Header.Tag.upper, abort->Header.Tag.lower);
+        as  = (struct scsi_cmnd *) abort->scsi_cmd;
+        if (as != NULL)
+                ml += sprintf(msg+ml, "Command:0x%x SN:0x%lx ",
+                        as->cmnd[0], as->serial_number);
+        dev_dbg(&h->pdev->dev, "%s\n", msg);
+        dev_warn(&h->pdev->dev, "Abort request on C%d:B%d:T%d:L%d\n",
+                h->scsi_host->host_no, dev->bus, dev->target, dev->lun);
+
+        /* Search reqQ to See if command is queued but not submitted,
+         * if so, complete the command with aborted status and remove
+         * it from the reqQ.
+         */
+        found = hpsa_find_cmd_in_queue(h, sc, &h->reqQ);
+        if (found) {
+                found->err_info->CommandStatus = CMD_ABORTED;
+                finish_cmd(found);
+                dev_info(&h->pdev->dev, "%s Request SUCCEEDED (driver queue).\n",
+                                msg);
+                return SUCCESS;
+        }
+
+        /* not in reqQ, if also not in cmpQ, must have already completed */
+        found = hpsa_find_cmd_in_queue(h, sc, &h->cmpQ);
+        if (!found)  {
+                dev_dbg(&h->pdev->dev, "%s Request FAILED (not known to driver).\n",
+                                msg);
+                return SUCCESS;
+        }
+
+        /*
+         * Command is in flight, or possibly already completed
+         * by the firmware (but not to the scsi mid layer) but we can't
+         * distinguish which.  Send the abort down.
+         */
+        rc = hpsa_send_abort_both_ways(h, dev->scsi3addr, abort);
+        if (rc != 0) {
+                dev_dbg(&h->pdev->dev, "%s Request FAILED.\n", msg);
+                dev_warn(&h->pdev->dev, "FAILED abort on device C%d:B%d:T%d:L%d\n",
+                        h->scsi_host->host_no,
+                        dev->bus, dev->target, dev->lun);
+                return FAILED;
+        }
+        dev_info(&h->pdev->dev, "%s REQUEST SUCCEEDED.\n", msg);
+
+        /* If the abort(s) above completed and actually aborted the
+         * command, then the command to be aborted should already be
+         * completed.  If not, wait around a bit more to see if they
+         * manage to complete normally.
+         */
+#define ABORT_COMPLETE_WAIT_SECS 30
+        for (i = 0; i < ABORT_COMPLETE_WAIT_SECS * 10; i++) {
+                found = hpsa_find_cmd_in_queue(h, sc, &h->cmpQ);
+                if (!found)
+                        return SUCCESS;
+                msleep(100);
+        }
+        dev_warn(&h->pdev->dev, "%s FAILED. Aborted command has not completed after %d seconds.\n",
+                msg, ABORT_COMPLETE_WAIT_SECS);
+        return FAILED;
+}
+
+
 /*
  * For operations that cannot sleep, a command block is allocated at init,
  * and managed by cmd_alloc() and cmd_free() using a simple bitmap to track
@@ -2346,14 +2659,21 @@ static struct CommandList *cmd_alloc(struct ctlr_info *h)
         int i;
         union u64bit temp64;
         dma_addr_t cmd_dma_handle, err_dma_handle;
+        unsigned long flags;
 
+        spin_lock_irqsave(&h->lock, flags);
         do {
                 i = find_first_zero_bit(h->cmd_pool_bits, h->nr_cmds);
-                if (i == h->nr_cmds)
+                if (i == h->nr_cmds) {
+                        spin_unlock_irqrestore(&h->lock, flags);
                         return NULL;
+                }
         } while (test_and_set_bit
                  (i & (BITS_PER_LONG - 1),
                   h->cmd_pool_bits + (i / BITS_PER_LONG)) != 0);
+        h->nr_allocs++;
+        spin_unlock_irqrestore(&h->lock, flags);
+
         c = h->cmd_pool + i;
         memset(c, 0, sizeof(*c));
         cmd_dma_handle = h->cmd_pool_dhandle
@@ -2362,7 +2682,6 @@ static struct CommandList *cmd_alloc(struct ctlr_info *h)
         memset(c->err_info, 0, sizeof(*c->err_info));
         err_dma_handle = h->errinfo_pool_dhandle
             + i * sizeof(*c->err_info);
-        h->nr_allocs++;
 
         c->cmdindex = i;
 
@@ -2418,11 +2737,14 @@ static struct CommandList *cmd_special_alloc(struct ctlr_info *h)
 static void cmd_free(struct ctlr_info *h, struct CommandList *c)
 {
         int i;
+        unsigned long flags;
 
         i = c - h->cmd_pool;
+        spin_lock_irqsave(&h->lock, flags);
         clear_bit(i & (BITS_PER_LONG - 1),
                   h->cmd_pool_bits + (i / BITS_PER_LONG));
         h->nr_frees++;
+        spin_unlock_irqrestore(&h->lock, flags);
 }
 
 static void cmd_special_free(struct ctlr_info *h, struct CommandList *c)
@@ -2866,6 +3188,7 @@ static void fill_cmd(struct CommandList *c, u8 cmd, struct ctlr_info *h,
         int cmd_type)
 {
         int pci_dir = XFER_NONE;
+        struct CommandList *a; /* for commands to be aborted */
 
         c->cmd_type = CMD_IOCTL_PEND;
         c->Header.ReplyQueue = 0;
@@ -2949,8 +3272,35 @@ static void fill_cmd(struct CommandList *c, u8 cmd, struct ctlr_info *h,
                         c->Request.CDB[5] = 0x00;
                         c->Request.CDB[6] = 0x00;
                         c->Request.CDB[7] = 0x00;
+                        break;
+                case  HPSA_ABORT_MSG:
+                        a = buff;       /* point to command to be aborted */
+                        dev_dbg(&h->pdev->dev, "Abort Tag:0x%08x:%08x using request Tag:0x%08x:%08x\n",
+                                a->Header.Tag.upper, a->Header.Tag.lower,
+                                c->Header.Tag.upper, c->Header.Tag.lower);
+                        c->Request.CDBLen = 16;
+                        c->Request.Type.Type = TYPE_MSG;
+                        c->Request.Type.Attribute = ATTR_SIMPLE;
+                        c->Request.Type.Direction = XFER_WRITE;
+                        c->Request.Timeout = 0; /* Don't time out */
+                        c->Request.CDB[0] = HPSA_TASK_MANAGEMENT;
+                        c->Request.CDB[1] = HPSA_TMF_ABORT_TASK;
+                        c->Request.CDB[2] = 0x00; /* reserved */
+                        c->Request.CDB[3] = 0x00; /* reserved */
+                        /* Tag to abort goes in CDB[4]-CDB[11] */
+                        c->Request.CDB[4] = a->Header.Tag.lower & 0xFF;
+                        c->Request.CDB[5] = (a->Header.Tag.lower >> 8) & 0xFF;
+                        c->Request.CDB[6] = (a->Header.Tag.lower >> 16) & 0xFF;
+                        c->Request.CDB[7] = (a->Header.Tag.lower >> 24) & 0xFF;
+                        c->Request.CDB[8] = a->Header.Tag.upper & 0xFF;
+                        c->Request.CDB[9] = (a->Header.Tag.upper >> 8) & 0xFF;
+                        c->Request.CDB[10] = (a->Header.Tag.upper >> 16) & 0xFF;
+                        c->Request.CDB[11] = (a->Header.Tag.upper >> 24) & 0xFF;
+                        c->Request.CDB[12] = 0x00; /* reserved */
+                        c->Request.CDB[13] = 0x00; /* reserved */
+                        c->Request.CDB[14] = 0x00; /* reserved */
+                        c->Request.CDB[15] = 0x00; /* reserved */
                 break;
-
                 default:
                         dev_warn(&h->pdev->dev, "unknown message type %d\n",
                                 cmd);
@@ -2998,7 +3348,9 @@ static void __iomem *remap_pci_mem(ulong base, ulong size)
 static void start_io(struct ctlr_info *h)
 {
         struct CommandList *c;
+        unsigned long flags;
 
+        spin_lock_irqsave(&h->lock, flags);
         while (!list_empty(&h->reqQ)) {
                 c = list_entry(h->reqQ.next, struct CommandList, list);
                 /* can't do anything if fifo is full */
@@ -3011,17 +3363,28 @@ static void start_io(struct ctlr_info *h)
                 removeQ(c);
                 h->Qdepth--;
 
-                /* Tell the controller execute command */
-                h->access.submit_command(h, c);
-
                 /* Put job onto the completed Q */
                 addQ(&h->cmpQ, c);
+
+                /* Must increment commands_outstanding before unlocking
+                 * and submitting to avoid race checking for fifo full
+                 * condition.
+                 */
+                h->commands_outstanding++;
+                if (h->commands_outstanding > h->max_outstanding)
+                        h->max_outstanding = h->commands_outstanding;
+
+                /* Tell the controller execute command */
+                spin_unlock_irqrestore(&h->lock, flags);
+                h->access.submit_command(h, c);
+                spin_lock_irqsave(&h->lock, flags);
         }
+        spin_unlock_irqrestore(&h->lock, flags);
 }
 
-static inline unsigned long get_next_completion(struct ctlr_info *h)
+static inline unsigned long get_next_completion(struct ctlr_info *h, u8 q)
 {
-        return h->access.command_completed(h);
+        return h->access.command_completed(h, q);
 }
 
 static inline bool interrupt_pending(struct ctlr_info *h)
@@ -3045,9 +3408,14 @@ static inline int bad_tag(struct ctlr_info *h, u32 tag_index,
         return 0;
 }
 
-static inline void finish_cmd(struct CommandList *c, u32 raw_tag)
+static inline void finish_cmd(struct CommandList *c)
 {
+        unsigned long flags;
+
+        spin_lock_irqsave(&c->h->lock, flags);
         removeQ(c);
+        spin_unlock_irqrestore(&c->h->lock, flags);
+        dial_up_lockup_detection_on_fw_flash_complete(c->h, c);
         if (likely(c->cmd_type == CMD_SCSI))
                 complete_scsi_command(c);
         else if (c->cmd_type == CMD_IOCTL_PEND)
@@ -3075,36 +3443,38 @@ static inline u32 hpsa_tag_discard_error_bits(struct ctlr_info *h, u32 tag)
 }
 
 /* process completion of an indexed ("direct lookup") command */
-static inline u32 process_indexed_cmd(struct ctlr_info *h,
+static inline void process_indexed_cmd(struct ctlr_info *h,
         u32 raw_tag)
 {
         u32 tag_index;
         struct CommandList *c;
 
         tag_index = hpsa_tag_to_index(raw_tag);
-        if (bad_tag(h, tag_index, raw_tag))
-                return next_command(h);
-        c = h->cmd_pool + tag_index;
-        finish_cmd(c, raw_tag);
-        return next_command(h);
+        if (!bad_tag(h, tag_index, raw_tag)) {
+                c = h->cmd_pool + tag_index;
+                finish_cmd(c);
+        }
 }
 
 /* process completion of a non-indexed command */
-static inline u32 process_nonindexed_cmd(struct ctlr_info *h,
+static inline void process_nonindexed_cmd(struct ctlr_info *h,
         u32 raw_tag)
 {
         u32 tag;
         struct CommandList *c = NULL;
+        unsigned long flags;
 
         tag = hpsa_tag_discard_error_bits(h, raw_tag);
+        spin_lock_irqsave(&h->lock, flags);
         list_for_each_entry(c, &h->cmpQ, list) {
                 if ((c->busaddr & 0xFFFFFFE0) == (tag & 0xFFFFFFE0)) {
-                        finish_cmd(c, raw_tag);
-                        return next_command(h);
+                        spin_unlock_irqrestore(&h->lock, flags);
+                        finish_cmd(c);
+                        return;
                 }
         }
+        spin_unlock_irqrestore(&h->lock, flags);
         bad_tag(h, h->nr_cmds + 1, raw_tag);
-        return next_command(h);
 }
 
 /* Some controllers, like p400, will give us one interrupt
@@ -3126,10 +3496,20 @@ static int ignore_bogus_interrupt(struct ctlr_info *h)
         return 1;
 }
 
-static irqreturn_t hpsa_intx_discard_completions(int irq, void *dev_id)
+/*
+ * Convert &h->q[x] (passed to interrupt handlers) back to h.
+ * Relies on (h-q[x] == x) being true for x such that
+ * 0 <= x < MAX_REPLY_QUEUES.
+ */
+static struct ctlr_info *queue_to_hba(u8 *queue)
 {
-        struct ctlr_info *h = dev_id;
-        unsigned long flags;
+        return container_of((queue - *queue), struct ctlr_info, q[0]);
+}
+
+static irqreturn_t hpsa_intx_discard_completions(int irq, void *queue)
+{
+        struct ctlr_info *h = queue_to_hba(queue);
+        u8 q = *(u8 *) queue;
         u32 raw_tag;
 
         if (ignore_bogus_interrupt(h))
@@ -3137,74 +3517,68 @@ static irqreturn_t hpsa_intx_discard_completions(int irq, void *dev_id)
 
         if (interrupt_not_for_us(h))
                 return IRQ_NONE;
-        spin_lock_irqsave(&h->lock, flags);
         h->last_intr_timestamp = get_jiffies_64();
         while (interrupt_pending(h)) {
-                raw_tag = get_next_completion(h);
+                raw_tag = get_next_completion(h, q);
                 while (raw_tag != FIFO_EMPTY)
-                        raw_tag = next_command(h);
+                        raw_tag = next_command(h, q);
         }
-        spin_unlock_irqrestore(&h->lock, flags);
         return IRQ_HANDLED;
 }
 
-static irqreturn_t hpsa_msix_discard_completions(int irq, void *dev_id)
+static irqreturn_t hpsa_msix_discard_completions(int irq, void *queue)
 {
-        struct ctlr_info *h = dev_id;
-        unsigned long flags;
+        struct ctlr_info *h = queue_to_hba(queue);
         u32 raw_tag;
+        u8 q = *(u8 *) queue;
 
         if (ignore_bogus_interrupt(h))
                 return IRQ_NONE;
 
-        spin_lock_irqsave(&h->lock, flags);
         h->last_intr_timestamp = get_jiffies_64();
-        raw_tag = get_next_completion(h);
+        raw_tag = get_next_completion(h, q);
         while (raw_tag != FIFO_EMPTY)
-                raw_tag = next_command(h);
-        spin_unlock_irqrestore(&h->lock, flags);
+                raw_tag = next_command(h, q);
         return IRQ_HANDLED;
 }
 
-static irqreturn_t do_hpsa_intr_intx(int irq, void *dev_id)
+static irqreturn_t do_hpsa_intr_intx(int irq, void *queue)
 {
-        struct ctlr_info *h = dev_id;
-        unsigned long flags;
+        struct ctlr_info *h = queue_to_hba((u8 *) queue);
         u32 raw_tag;
+        u8 q = *(u8 *) queue;
 
         if (interrupt_not_for_us(h))
                 return IRQ_NONE;
-        spin_lock_irqsave(&h->lock, flags);
         h->last_intr_timestamp = get_jiffies_64();
         while (interrupt_pending(h)) {
-                raw_tag = get_next_completion(h);
+                raw_tag = get_next_completion(h, q);
                 while (raw_tag != FIFO_EMPTY) {
-                        if (hpsa_tag_contains_index(raw_tag))
-                                raw_tag = process_indexed_cmd(h, raw_tag);
+                        if (likely(hpsa_tag_contains_index(raw_tag)))
+                                process_indexed_cmd(h, raw_tag);
                         else
-                                raw_tag = process_nonindexed_cmd(h, raw_tag);
+                                process_nonindexed_cmd(h, raw_tag);
+                        raw_tag = next_command(h, q);
                 }
         }
-        spin_unlock_irqrestore(&h->lock, flags);
         return IRQ_HANDLED;
 }
 
-static irqreturn_t do_hpsa_intr_msi(int irq, void *dev_id)
+static irqreturn_t do_hpsa_intr_msi(int irq, void *queue)
 {
-        struct ctlr_info *h = dev_id;
-        unsigned long flags;
+        struct ctlr_info *h = queue_to_hba(queue);
         u32 raw_tag;
+        u8 q = *(u8 *) queue;
 
-        spin_lock_irqsave(&h->lock, flags);
         h->last_intr_timestamp = get_jiffies_64();
-        raw_tag = get_next_completion(h);
+        raw_tag = get_next_completion(h, q);
         while (raw_tag != FIFO_EMPTY) {
-                if (hpsa_tag_contains_index(raw_tag))
-                        raw_tag = process_indexed_cmd(h, raw_tag);
+                if (likely(hpsa_tag_contains_index(raw_tag)))
+                        process_indexed_cmd(h, raw_tag);
                 else
-                        raw_tag = process_nonindexed_cmd(h, raw_tag);
+                        process_nonindexed_cmd(h, raw_tag);
+                raw_tag = next_command(h, q);
         }
-        spin_unlock_irqrestore(&h->lock, flags);
         return IRQ_HANDLED;
 }
 
@@ -3638,10 +4012,13 @@ static int find_PCI_BAR_index(struct pci_dev *pdev, unsigned long pci_bar_addr)
 static void __devinit hpsa_interrupt_mode(struct ctlr_info *h)
 {
 #ifdef CONFIG_PCI_MSI
-        int err;
-        struct msix_entry hpsa_msix_entries[4] = { {0, 0}, {0, 1},
-        {0, 2}, {0, 3}
-        };
+        int err, i;
+        struct msix_entry hpsa_msix_entries[MAX_REPLY_QUEUES];
+
+        for (i = 0; i < MAX_REPLY_QUEUES; i++) {
+                hpsa_msix_entries[i].vector = 0;
+                hpsa_msix_entries[i].entry = i;
+        }
 
         /* Some boards advertise MSI but don't really support it */
         if ((h->board_id == 0x40700E11) || (h->board_id == 0x40800E11) ||
@@ -3649,12 +4026,11 @@ static void __devinit hpsa_interrupt_mode(struct ctlr_info *h)
                 goto default_int_mode;
         if (pci_find_capability(h->pdev, PCI_CAP_ID_MSIX)) {
                 dev_info(&h->pdev->dev, "MSIX\n");
-                err = pci_enable_msix(h->pdev, hpsa_msix_entries, 4);
+                err = pci_enable_msix(h->pdev, hpsa_msix_entries,
+                                                MAX_REPLY_QUEUES);
                 if (!err) {
-                        h->intr[0] = hpsa_msix_entries[0].vector;
-                        h->intr[1] = hpsa_msix_entries[1].vector;
-                        h->intr[2] = hpsa_msix_entries[2].vector;
-                        h->intr[3] = hpsa_msix_entries[3].vector;
+                        for (i = 0; i < MAX_REPLY_QUEUES; i++)
+                                h->intr[i] = hpsa_msix_entries[i].vector;
                         h->msix_vector = 1;
                         return;
                 }
@@ -3705,14 +4081,6 @@ static int __devinit hpsa_lookup_board_id(struct pci_dev *pdev, u32 *board_id)
         return ARRAY_SIZE(products) - 1; /* generic unknown smart array */
 }
 
-static inline bool hpsa_board_disabled(struct pci_dev *pdev)
-{
-        u16 command;
-
-        (void) pci_read_config_word(pdev, PCI_COMMAND, &command);
-        return ((command & PCI_COMMAND_MEMORY) == 0);
-}
-
 static int __devinit hpsa_pci_find_memory_BAR(struct pci_dev *pdev,
         unsigned long *memory_bar)
 {
@@ -3838,14 +4206,14 @@ static void __devinit hpsa_find_board_params(struct ctlr_info *h)
                 h->maxsgentries = 31; /* default to traditional values */
                 h->chainsize = 0;
         }
+
+        /* Find out what task management functions are supported and cache */
+        h->TMFSupportFlags = readl(&(h->cfgtable->TMFSupportFlags));
 }
 
 static inline bool hpsa_CISS_signature_present(struct ctlr_info *h)
 {
-        if ((readb(&h->cfgtable->Signature[0]) != 'C') ||
-            (readb(&h->cfgtable->Signature[1]) != 'I') ||
-            (readb(&h->cfgtable->Signature[2]) != 'S') ||
-            (readb(&h->cfgtable->Signature[3]) != 'S')) {
+        if (!check_signature(h->cfgtable->Signature, "CISS", 4)) {
                 dev_warn(&h->pdev->dev, "not a valid CISS config table\n");
                 return false;
         }
@@ -3932,11 +4300,6 @@ static int __devinit hpsa_pci_init(struct ctlr_info *h)
         h->product_name = products[prod_index].product_name;
         h->access = *(products[prod_index].access);
 
-        if (hpsa_board_disabled(h->pdev)) {
-                dev_warn(&h->pdev->dev, "controller appears to be disabled\n");
-                return -ENODEV;
-        }
-
         pci_disable_link_state(h->pdev, PCIE_LINK_STATE_L0S |
                                PCIE_LINK_STATE_L1 | PCIE_LINK_STATE_CLKPM);
 
@@ -3946,6 +4309,9 @@ static int __devinit hpsa_pci_init(struct ctlr_info *h)
                 return err;
         }
 
+        /* Enable bus mastering (pci_disable_device may disable this) */
+        pci_set_master(h->pdev);
+
         err = pci_request_regions(h->pdev, HPSA);
         if (err) {
                 dev_err(&h->pdev->dev,
@@ -3987,10 +4353,7 @@ err_out_free_res:
                 iounmap(h->cfgtable);
         if (h->vaddr)
                 iounmap(h->vaddr);
-        /*
-         * Deliberately omit pci_disable_device(): it does something nasty to
-         * Smart Array controllers that pci_enable_device does not undo
-         */
+        pci_disable_device(h->pdev);
         pci_release_regions(h->pdev);
         return err;
 }
@@ -4081,14 +4444,33 @@ static int hpsa_request_irq(struct ctlr_info *h,
         irqreturn_t (*msixhandler)(int, void *),
         irqreturn_t (*intxhandler)(int, void *))
 {
-        int rc;
+        int rc, i;
 
-        if (h->msix_vector || h->msi_vector)
-                rc = request_irq(h->intr[h->intr_mode], msixhandler,
-                                0, h->devname, h);
-        else
-                rc = request_irq(h->intr[h->intr_mode], intxhandler,
-                                IRQF_SHARED, h->devname, h);
+        /*
+         * initialize h->q[x] = x so that interrupt handlers know which
+         * queue to process.
+         */
+        for (i = 0; i < MAX_REPLY_QUEUES; i++)
+                h->q[i] = (u8) i;
+
+        if (h->intr_mode == PERF_MODE_INT && h->msix_vector) {
+                /* If performant mode and MSI-X, use multiple reply queues */
+                for (i = 0; i < MAX_REPLY_QUEUES; i++)
+                        rc = request_irq(h->intr[i], msixhandler,
+                                        0, h->devname,
+                                        &h->q[i]);
+        } else {
+                /* Use single reply pool */
+                if (h->msix_vector || h->msi_vector) {
+                        rc = request_irq(h->intr[h->intr_mode],
+                                msixhandler, 0, h->devname,
+                                &h->q[h->intr_mode]);
+                } else {
+                        rc = request_irq(h->intr[h->intr_mode],
+                                intxhandler, IRQF_SHARED, h->devname,
+                                &h->q[h->intr_mode]);
+                }
+        }
         if (rc) {
                 dev_err(&h->pdev->dev, "unable to get irq %d for %s\n",
                        h->intr[h->intr_mode], h->devname);
@@ -4121,15 +4503,38 @@ static int __devinit hpsa_kdump_soft_reset(struct ctlr_info *h)
         return 0;
 }
 
-static void hpsa_undo_allocations_after_kdump_soft_reset(struct ctlr_info *h)
+static void free_irqs(struct ctlr_info *h)
 {
-        free_irq(h->intr[h->intr_mode], h);
+        int i;
+
+        if (!h->msix_vector || h->intr_mode != PERF_MODE_INT) {
+                /* Single reply queue, only one irq to free */
+                i = h->intr_mode;
+                free_irq(h->intr[i], &h->q[i]);
+                return;
+        }
+
+        for (i = 0; i < MAX_REPLY_QUEUES; i++)
+                free_irq(h->intr[i], &h->q[i]);
+}
+
+static void hpsa_free_irqs_and_disable_msix(struct ctlr_info *h)
+{
+        free_irqs(h);
 #ifdef CONFIG_PCI_MSI
-        if (h->msix_vector)
-                pci_disable_msix(h->pdev);
-        else if (h->msi_vector)
-                pci_disable_msi(h->pdev);
+        if (h->msix_vector) {
+                if (h->pdev->msix_enabled)
+                        pci_disable_msix(h->pdev);
+        } else if (h->msi_vector) {
+                if (h->pdev->msi_enabled)
+                        pci_disable_msi(h->pdev);
+        }
 #endif /* CONFIG_PCI_MSI */
+}
+
+static void hpsa_undo_allocations_after_kdump_soft_reset(struct ctlr_info *h)
+{
+        hpsa_free_irqs_and_disable_msix(h);
         hpsa_free_sg_chain_blocks(h);
         hpsa_free_cmd_pool(h);
         kfree(h->blockFetchTable);
@@ -4165,7 +4570,7 @@ static void fail_all_cmds_on_list(struct ctlr_info *h, struct list_head *list)
         while (!list_empty(list)) {
                 c = list_entry(list->next, struct CommandList, list);
                 c->err_info->CommandStatus = CMD_HARDWARE_ERR;
-                finish_cmd(c, c->Header.Tag.lower);
+                finish_cmd(c);
         }
 }
 
@@ -4188,9 +4593,6 @@ static void controller_lockup_detected(struct ctlr_info *h)
         spin_unlock_irqrestore(&h->lock, flags);
 }
 
-#define HEARTBEAT_SAMPLE_INTERVAL (10 * HZ)
-#define HEARTBEAT_CHECK_MINIMUM_INTERVAL (HEARTBEAT_SAMPLE_INTERVAL / 2)
-
 static void detect_controller_lockup(struct ctlr_info *h)
 {
         u64 now;
@@ -4201,7 +4603,7 @@ static void detect_controller_lockup(struct ctlr_info *h)
         now = get_jiffies_64();
         /* If we've received an interrupt recently, we're ok. */
         if (time_after64(h->last_intr_timestamp +
-                                (HEARTBEAT_CHECK_MINIMUM_INTERVAL), now))
+                                (h->heartbeat_sample_interval), now))
                 return;
 
         /*
@@ -4210,7 +4612,7 @@ static void detect_controller_lockup(struct ctlr_info *h)
          * otherwise don't care about signals in this thread.
          */
         if (time_after64(h->last_heartbeat_timestamp +
-                                (HEARTBEAT_CHECK_MINIMUM_INTERVAL), now))
+                                (h->heartbeat_sample_interval), now))
                 return;
 
         /* If heartbeat has not changed since we last looked, we're not ok. */
@@ -4252,6 +4654,7 @@ static void add_ctlr_to_lockup_detector_list(struct ctlr_info *h)
 {
         unsigned long flags;
 
+        h->heartbeat_sample_interval = HEARTBEAT_SAMPLE_INTERVAL;
         spin_lock_irqsave(&lockup_detector_lock, flags);
         list_add_tail(&h->lockup_list, &hpsa_ctlr_list);
         spin_unlock_irqrestore(&lockup_detector_lock, flags);
@@ -4391,7 +4794,7 @@ reinit_after_soft_reset:
                 spin_lock_irqsave(&h->lock, flags);
                 h->access.set_intr_mask(h, HPSA_INTR_OFF);
                 spin_unlock_irqrestore(&h->lock, flags);
-                free_irq(h->intr[h->intr_mode], h);
+                free_irqs(h);
                 rc = hpsa_request_irq(h, hpsa_msix_discard_completions,
                                         hpsa_intx_discard_completions);
                 if (rc) {
@@ -4441,7 +4844,7 @@ reinit_after_soft_reset:
 clean4:
         hpsa_free_sg_chain_blocks(h);
         hpsa_free_cmd_pool(h);
-        free_irq(h->intr[h->intr_mode], h);
+        free_irqs(h);
 clean2:
 clean1:
         kfree(h);
@@ -4484,13 +4887,7 @@ static void hpsa_shutdown(struct pci_dev *pdev)
          */
         hpsa_flush_cache(h);
         h->access.set_intr_mask(h, HPSA_INTR_OFF);
-        free_irq(h->intr[h->intr_mode], h);
-#ifdef CONFIG_PCI_MSI
-        if (h->msix_vector)
-                pci_disable_msix(h->pdev);
-        else if (h->msi_vector)
-                pci_disable_msi(h->pdev);
-#endif                          /* CONFIG_PCI_MSI */
+        hpsa_free_irqs_and_disable_msix(h);
 }
 
 static void __devexit hpsa_free_device_info(struct ctlr_info *h)
@@ -4529,10 +4926,7 @@ static void __devexit hpsa_remove_one(struct pci_dev *pdev)
         kfree(h->cmd_pool_bits);
         kfree(h->blockFetchTable);
         kfree(h->hba_inquiry_data);
-        /*
-         * Deliberately omit pci_disable_device(): it does something nasty to
-         * Smart Array controllers that pci_enable_device does not undo
-         */
+        pci_disable_device(pdev);
         pci_release_regions(pdev);
         pci_set_drvdata(pdev, NULL);
         kfree(h);
@@ -4627,11 +5021,8 @@ static __devinit void hpsa_enter_performant_mode(struct ctlr_info *h,
          * 10 = 6 s/g entry or 24k
          */
 
-        h->reply_pool_wraparound = 1; /* spec: init to 1 */
-
         /* Controller spec: zero out this buffer. */
         memset(h->reply_pool, 0, h->reply_pool_size);
-        h->reply_pool_head = h->reply_pool;
 
         bft[7] = SG_ENTRIES_IN_CMD + 4;
         calc_bucket_map(bft, ARRAY_SIZE(bft),
@@ -4641,12 +5032,19 @@ static __devinit void hpsa_enter_performant_mode(struct ctlr_info *h,
 
         /* size of controller ring buffer */
         writel(h->max_commands, &h->transtable->RepQSize);
-        writel(1, &h->transtable->RepQCount);
+        writel(h->nreply_queues, &h->transtable->RepQCount);
         writel(0, &h->transtable->RepQCtrAddrLow32);
         writel(0, &h->transtable->RepQCtrAddrHigh32);
-        writel(h->reply_pool_dhandle, &h->transtable->RepQAddr0Low32);
-        writel(0, &h->transtable->RepQAddr0High32);
-        writel(CFGTBL_Trans_Performant | use_short_tags,
+
+        for (i = 0; i < h->nreply_queues; i++) {
+                writel(0, &h->transtable->RepQAddr[i].upper);
+                writel(h->reply_pool_dhandle +
+                        (h->max_commands * sizeof(u64) * i),
+                        &h->transtable->RepQAddr[i].lower);
+        }
+
+        writel(CFGTBL_Trans_Performant | use_short_tags |
+                CFGTBL_Trans_enable_directed_msix,
                 &(h->cfgtable->HostWrite.TransportRequest));
         writel(CFGTBL_ChangeReq, h->vaddr + SA5_DOORBELL);
         hpsa_wait_for_mode_change_ack(h);
@@ -4664,6 +5062,7 @@ static __devinit void hpsa_enter_performant_mode(struct ctlr_info *h,
 static __devinit void hpsa_put_ctlr_into_performant_mode(struct ctlr_info *h)
 {
         u32 trans_support;
+        int i;
 
         if (hpsa_simple_mode)
                 return;
@@ -4672,12 +5071,20 @@ static __devinit void hpsa_put_ctlr_into_performant_mode(struct ctlr_info *h)
         if (!(trans_support & PERFORMANT_MODE))
                 return;
 
+        h->nreply_queues = h->msix_vector ? MAX_REPLY_QUEUES : 1;
         hpsa_get_max_perf_mode_cmds(h);
         /* Performant mode ring buffer and supporting data structures */
-        h->reply_pool_size = h->max_commands * sizeof(u64);
+        h->reply_pool_size = h->max_commands * sizeof(u64) * h->nreply_queues;
         h->reply_pool = pci_alloc_consistent(h->pdev, h->reply_pool_size,
                                 &(h->reply_pool_dhandle));
 
+        for (i = 0; i < h->nreply_queues; i++) {
+                h->reply_queue[i].head = &h->reply_pool[h->max_commands * i];
+                h->reply_queue[i].size = h->max_commands;
+                h->reply_queue[i].wraparound = 1;  /* spec: init to 1 */
+                h->reply_queue[i].current_entry = 0;
+        }
+
         /* Need a block fetch table for performant mode */
         h->blockFetchTable = kmalloc(((SG_ENTRIES_IN_CMD + 1) *
                                 sizeof(u32)), GFP_KERNEL);
diff --git a/drivers/scsi/hpsa.h b/drivers/scsi/hpsa.h
index 7b28d54fa878..981647989bfd 100644
--- a/drivers/scsi/hpsa.h
+++ b/drivers/scsi/hpsa.h
@@ -34,7 +34,7 @@ struct access_method {
         void (*set_intr_mask)(struct ctlr_info *h, unsigned long val);
         unsigned long (*fifo_full)(struct ctlr_info *h);
         bool (*intr_pending)(struct ctlr_info *h);
-        unsigned long (*command_completed)(struct ctlr_info *h);
+        unsigned long (*command_completed)(struct ctlr_info *h, u8 q);
 };
 
 struct hpsa_scsi_dev_t {
@@ -48,6 +48,13 @@ struct hpsa_scsi_dev_t {
         unsigned char raid_level;       /* from inquiry page 0xC1 */
 };
 
+struct reply_pool {
+        u64 *head;
+        size_t size;
+        u8 wraparound;
+        u32 current_entry;
+};
+
 struct ctlr_info {
         int     ctlr;
         char    devname[8];
@@ -68,7 +75,7 @@ struct ctlr_info {
 #       define DOORBELL_INT     1
 #       define SIMPLE_MODE_INT  2
 #       define MEMQ_MODE_INT    3
-        unsigned int intr[4];
+        unsigned int intr[MAX_REPLY_QUEUES];
         unsigned int msix_vector;
         unsigned int msi_vector;
         int intr_mode; /* either PERF_MODE_INT or SIMPLE_MODE_INT */
@@ -78,7 +85,6 @@ struct ctlr_info {
         struct list_head reqQ;
         struct list_head cmpQ;
         unsigned int Qdepth;
-        unsigned int maxQsinceinit;
         unsigned int maxSG;
         spinlock_t lock;
         int maxsgentries;
@@ -111,20 +117,45 @@ struct ctlr_info {
         unsigned long transMethod;
 
         /*
-         * Performant mode completion buffer
+         * Performant mode completion buffers
          */
         u64 *reply_pool;
-        dma_addr_t reply_pool_dhandle;
-        u64 *reply_pool_head;
         size_t reply_pool_size;
-        unsigned char reply_pool_wraparound;
+        struct reply_pool reply_queue[MAX_REPLY_QUEUES];
+        u8 nreply_queues;
+        dma_addr_t reply_pool_dhandle;
         u32 *blockFetchTable;
         unsigned char *hba_inquiry_data;
         u64 last_intr_timestamp;
         u32 last_heartbeat;
         u64 last_heartbeat_timestamp;
+        u32 heartbeat_sample_interval;
+        atomic_t firmware_flash_in_progress;
         u32 lockup_detected;
         struct list_head lockup_list;
+        /* Address of h->q[x] is passed to intr handler to know which queue */
+        u8 q[MAX_REPLY_QUEUES];
+        u32 TMFSupportFlags; /* cache what task mgmt funcs are supported. */
+#define HPSATMF_BITS_SUPPORTED  (1 << 0)
+#define HPSATMF_PHYS_LUN_RESET  (1 << 1)
+#define HPSATMF_PHYS_NEX_RESET  (1 << 2)
+#define HPSATMF_PHYS_TASK_ABORT (1 << 3)
+#define HPSATMF_PHYS_TSET_ABORT (1 << 4)
+#define HPSATMF_PHYS_CLEAR_ACA  (1 << 5)
+#define HPSATMF_PHYS_CLEAR_TSET (1 << 6)
+#define HPSATMF_PHYS_QRY_TASK   (1 << 7)
+#define HPSATMF_PHYS_QRY_TSET   (1 << 8)
+#define HPSATMF_PHYS_QRY_ASYNC  (1 << 9)
+#define HPSATMF_MASK_SUPPORTED  (1 << 16)
+#define HPSATMF_LOG_LUN_RESET   (1 << 17)
+#define HPSATMF_LOG_NEX_RESET   (1 << 18)
+#define HPSATMF_LOG_TASK_ABORT  (1 << 19)
+#define HPSATMF_LOG_TSET_ABORT  (1 << 20)
+#define HPSATMF_LOG_CLEAR_ACA   (1 << 21)
+#define HPSATMF_LOG_CLEAR_TSET  (1 << 22)
+#define HPSATMF_LOG_QRY_TASK    (1 << 23)
+#define HPSATMF_LOG_QRY_TSET    (1 << 24)
+#define HPSATMF_LOG_QRY_ASYNC   (1 << 25)
 };
 #define HPSA_ABORT_MSG 0
 #define HPSA_DEVICE_RESET_MSG 1
@@ -216,9 +247,6 @@ static void SA5_submit_command(struct ctlr_info *h,
                 c->Header.Tag.lower);
         writel(c->busaddr, h->vaddr + SA5_REQUEST_PORT_OFFSET);
         (void) readl(h->vaddr + SA5_SCRATCHPAD_OFFSET);
-        h->commands_outstanding++;
-        if (h->commands_outstanding > h->max_outstanding)
-                h->max_outstanding = h->commands_outstanding;
 }
 
 /*
@@ -254,16 +282,17 @@ static void SA5_performant_intr_mask(struct ctlr_info *h, unsigned long val)
         }
 }
 
-static unsigned long SA5_performant_completed(struct ctlr_info *h)
+static unsigned long SA5_performant_completed(struct ctlr_info *h, u8 q)
 {
-        unsigned long register_value = FIFO_EMPTY;
+        struct reply_pool *rq = &h->reply_queue[q];
+        unsigned long flags, register_value = FIFO_EMPTY;
 
-        /* flush the controller write of the reply queue by reading
-         * outbound doorbell status register.
-         */
-        register_value = readl(h->vaddr + SA5_OUTDB_STATUS);
         /* msi auto clears the interrupt pending bit. */
         if (!(h->msi_vector || h->msix_vector)) {
+                /* flush the controller write of the reply queue by reading
+                 * outbound doorbell status register.
+                 */
+                register_value = readl(h->vaddr + SA5_OUTDB_STATUS);
                 writel(SA5_OUTDB_CLEAR_PERF_BIT, h->vaddr + SA5_OUTDB_CLEAR);
                 /* Do a read in order to flush the write to the controller
                  * (as per spec.)
@@ -271,19 +300,20 @@ static unsigned long SA5_performant_completed(struct ctlr_info *h)
                 register_value = readl(h->vaddr + SA5_OUTDB_STATUS);
         }
 
-        if ((*(h->reply_pool_head) & 1) == (h->reply_pool_wraparound)) {
-                register_value = *(h->reply_pool_head);
-                (h->reply_pool_head)++;
+        if ((rq->head[rq->current_entry] & 1) == rq->wraparound) {
+                register_value = rq->head[rq->current_entry];
+                rq->current_entry++;
+                spin_lock_irqsave(&h->lock, flags);
                 h->commands_outstanding--;
+                spin_unlock_irqrestore(&h->lock, flags);
         } else {
                 register_value = FIFO_EMPTY;
         }
         /* Check for wraparound */
-        if (h->reply_pool_head == (h->reply_pool + h->max_commands)) {
-                h->reply_pool_head = h->reply_pool;
-                h->reply_pool_wraparound ^= 1;
+        if (rq->current_entry == h->max_commands) {
+                rq->current_entry = 0;
+                rq->wraparound ^= 1;
         }
-
         return register_value;
 }
 
@@ -303,13 +333,18 @@ static unsigned long SA5_fifo_full(struct ctlr_info *h)
  *   returns value read from hardware.
  *     returns FIFO_EMPTY if there is nothing to read
  */
-static unsigned long SA5_completed(struct ctlr_info *h)
+static unsigned long SA5_completed(struct ctlr_info *h,
+        __attribute__((unused)) u8 q)
 {
         unsigned long register_value
                 = readl(h->vaddr + SA5_REPLY_PORT_OFFSET);
+        unsigned long flags;
 
-        if (register_value != FIFO_EMPTY)
+        if (register_value != FIFO_EMPTY) {
+                spin_lock_irqsave(&h->lock, flags);
                 h->commands_outstanding--;
+                spin_unlock_irqrestore(&h->lock, flags);
+        }
 
 #ifdef HPSA_DEBUG
         if (register_value != FIFO_EMPTY)
diff --git a/drivers/scsi/hpsa_cmd.h b/drivers/scsi/hpsa_cmd.h
index 8049815d8c1e..a894f2eca7ac 100644
--- a/drivers/scsi/hpsa_cmd.h
+++ b/drivers/scsi/hpsa_cmd.h
@@ -82,6 +82,29 @@
 #define TYPE_CMD                                0x00
 #define TYPE_MSG                                0x01
 
+/* Message Types  */
+#define HPSA_TASK_MANAGEMENT    0x00
+#define HPSA_RESET              0x01
+#define HPSA_SCAN               0x02
+#define HPSA_NOOP               0x03
+
+#define HPSA_CTLR_RESET_TYPE    0x00
+#define HPSA_BUS_RESET_TYPE     0x01
+#define HPSA_TARGET_RESET_TYPE  0x03
+#define HPSA_LUN_RESET_TYPE     0x04
+#define HPSA_NEXUS_RESET_TYPE   0x05
+
+/* Task Management Functions */
+#define HPSA_TMF_ABORT_TASK     0x00
+#define HPSA_TMF_ABORT_TASK_SET 0x01
+#define HPSA_TMF_CLEAR_ACA      0x02
+#define HPSA_TMF_CLEAR_TASK_SET 0x03
+#define HPSA_TMF_QUERY_TASK     0x04
+#define HPSA_TMF_QUERY_TASK_SET 0x05
+#define HPSA_TMF_QUERY_ASYNCEVENT 0x06
+
+
+
 /* config space register offsets */
 #define CFG_VENDORID            0x00
 #define CFG_DEVICEID            0x02
@@ -106,6 +129,7 @@
 #define CFGTBL_Trans_Simple     0x00000002l
 #define CFGTBL_Trans_Performant 0x00000004l
 #define CFGTBL_Trans_use_short_tags 0x20000000l
+#define CFGTBL_Trans_enable_directed_msix (1 << 30)
 
 #define CFGTBL_BusType_Ultra2   0x00000001l
 #define CFGTBL_BusType_Ultra3   0x00000002l
@@ -162,6 +186,7 @@ struct SenseSubsystem_info {
 #define BMIC_WRITE 0x27
 #define BMIC_CACHE_FLUSH 0xc2
 #define HPSA_CACHE_FLUSH 0x01   /* C2 was already being used by HPSA */
+#define BMIC_FLASH_FIRMWARE 0xF7
 
 /* Command List Structure */
 union SCSI3Addr {
@@ -337,11 +362,17 @@ struct CfgTable {
         u32             MaxPhysicalDevices;
         u32             MaxPhysicalDrivesPerLogicalUnit;
         u32             MaxPerformantModeCommands;
-        u8              reserved[0x78 - 0x58];
+        u32             MaxBlockFetch;
+        u32             PowerConservationSupport;
+        u32             PowerConservationEnable;
+        u32             TMFSupportFlags;
+        u8              TMFTagMask[8];
+        u8              reserved[0x78 - 0x70];
         u32             misc_fw_support; /* offset 0x78 */
 #define                 MISC_FW_DOORBELL_RESET (0x02)
 #define                 MISC_FW_DOORBELL_RESET2 (0x010)
         u8              driver_version[32];
+
 };
 
 #define NUM_BLOCKFETCH_ENTRIES 8
@@ -351,8 +382,8 @@ struct TransTable_struct {
         u32            RepQCount;
         u32            RepQCtrAddrLow32;
         u32            RepQCtrAddrHigh32;
-        u32            RepQAddr0Low32;
-        u32            RepQAddr0High32;
+#define MAX_REPLY_QUEUES 8
+        struct vals32  RepQAddr[MAX_REPLY_QUEUES];
 };
 
 struct hpsa_pci_info {
diff --git a/drivers/scsi/isci/host.c b/drivers/scsi/isci/host.c
index d4bf9c12ecd4..45385f531649 100644
--- a/drivers/scsi/isci/host.c
+++ b/drivers/scsi/isci/host.c
@@ -192,22 +192,27 @@ static bool sci_controller_completion_queue_has_entries(struct isci_host *ihost)
 
 static bool sci_controller_isr(struct isci_host *ihost)
 {
-        if (sci_controller_completion_queue_has_entries(ihost)) {
+        if (sci_controller_completion_queue_has_entries(ihost))
                 return true;
-        } else {
-                /*
-                 * we have a spurious interrupt it could be that we have already
-                 * emptied the completion queue from a previous interrupt */
-                writel(SMU_ISR_COMPLETION, &ihost->smu_registers->interrupt_status);
 
-                /*
-                 * There is a race in the hardware that could cause us not to be notified
-                 * of an interrupt completion if we do not take this step.  We will mask
-                 * then unmask the interrupts so if there is another interrupt pending
-                 * the clearing of the interrupt source we get the next interrupt message. */
+        /* we have a spurious interrupt it could be that we have already
+         * emptied the completion queue from a previous interrupt
+         * FIXME: really!?
+         */
+        writel(SMU_ISR_COMPLETION, &ihost->smu_registers->interrupt_status);
+
+        /* There is a race in the hardware that could cause us not to be
+         * notified of an interrupt completion if we do not take this
+         * step.  We will mask then unmask the interrupts so if there is
+         * another interrupt pending the clearing of the interrupt
+         * source we get the next interrupt message.
+         */
+        spin_lock(&ihost->scic_lock);
+        if (test_bit(IHOST_IRQ_ENABLED, &ihost->flags)) {
                 writel(0xFF000000, &ihost->smu_registers->interrupt_mask);
                 writel(0, &ihost->smu_registers->interrupt_mask);
         }
+        spin_unlock(&ihost->scic_lock);
 
         return false;
 }
@@ -642,7 +647,6 @@ static void isci_host_start_complete(struct isci_host *ihost, enum sci_status co
         if (completion_status != SCI_SUCCESS)
                 dev_info(&ihost->pdev->dev,
                         "controller start timed out, continuing...\n");
-        isci_host_change_state(ihost, isci_ready);
         clear_bit(IHOST_START_PENDING, &ihost->flags);
         wake_up(&ihost->eventq);
 }
@@ -657,12 +661,7 @@ int isci_host_scan_finished(struct Scsi_Host *shost, unsigned long time)
 
         sas_drain_work(ha);
 
-        dev_dbg(&ihost->pdev->dev,
-                "%s: ihost->status = %d, time = %ld\n",
-                 __func__, isci_host_get_state(ihost), time);
-
         return 1;
-
 }
 
 /**
@@ -704,14 +703,15 @@ static u32 sci_controller_get_suggested_start_timeout(struct isci_host *ihost)
 
 static void sci_controller_enable_interrupts(struct isci_host *ihost)
 {
-        BUG_ON(ihost->smu_registers == NULL);
+        set_bit(IHOST_IRQ_ENABLED, &ihost->flags);
         writel(0, &ihost->smu_registers->interrupt_mask);
 }
 
 void sci_controller_disable_interrupts(struct isci_host *ihost)
 {
-        BUG_ON(ihost->smu_registers == NULL);
+        clear_bit(IHOST_IRQ_ENABLED, &ihost->flags);
         writel(0xffffffff, &ihost->smu_registers->interrupt_mask);
+        readl(&ihost->smu_registers->interrupt_mask); /* flush */
 }
 
 static void sci_controller_enable_port_task_scheduler(struct isci_host *ihost)
@@ -822,7 +822,7 @@ static void sci_controller_initialize_unsolicited_frame_queue(struct isci_host *
                &ihost->scu_registers->sdma.unsolicited_frame_put_pointer);
 }
 
-static void sci_controller_transition_to_ready(struct isci_host *ihost, enum sci_status status)
+void sci_controller_transition_to_ready(struct isci_host *ihost, enum sci_status status)
 {
         if (ihost->sm.current_state_id == SCIC_STARTING) {
                 /*
@@ -849,6 +849,7 @@ static bool is_phy_starting(struct isci_phy *iphy)
         case SCI_PHY_SUB_AWAIT_SATA_POWER:
         case SCI_PHY_SUB_AWAIT_SATA_PHY_EN:
         case SCI_PHY_SUB_AWAIT_SATA_SPEED_EN:
+        case SCI_PHY_SUB_AWAIT_OSSP_EN:
         case SCI_PHY_SUB_AWAIT_SIG_FIS_UF:
         case SCI_PHY_SUB_FINAL:
                 return true;
@@ -857,6 +858,39 @@ static bool is_phy_starting(struct isci_phy *iphy)
         }
 }
 
+bool is_controller_start_complete(struct isci_host *ihost)
+{
+        int i;
+
+        for (i = 0; i < SCI_MAX_PHYS; i++) {
+                struct isci_phy *iphy = &ihost->phys[i];
+                u32 state = iphy->sm.current_state_id;
+
+                /* in apc mode we need to check every phy, in
+                 * mpc mode we only need to check phys that have
+                 * been configured into a port
+                 */
+                if (is_port_config_apc(ihost))
+                        /* pass */;
+                else if (!phy_get_non_dummy_port(iphy))
+                        continue;
+
+                /* The controller start operation is complete iff:
+                 * - all links have been given an opportunity to start
+                 * - have no indication of a connected device
+                 * - have an indication of a connected device and it has
+                 *   finished the link training process.
+                 */
+                if ((iphy->is_in_link_training == false && state == SCI_PHY_INITIAL) ||
+                    (iphy->is_in_link_training == false && state == SCI_PHY_STOPPED) ||
+                    (iphy->is_in_link_training == true && is_phy_starting(iphy)) ||
+                    (ihost->port_agent.phy_ready_mask != ihost->port_agent.phy_configured_mask))
+                        return false;
+        }
+
+        return true;
+}
+
 /**
  * sci_controller_start_next_phy - start phy
  * @scic: controller
@@ -877,36 +911,7 @@ static enum sci_status sci_controller_start_next_phy(struct isci_host *ihost)
                 return status;
 
         if (ihost->next_phy_to_start >= SCI_MAX_PHYS) {
-                bool is_controller_start_complete = true;
-                u32 state;
-                u8 index;
-
-                for (index = 0; index < SCI_MAX_PHYS; index++) {
-                        iphy = &ihost->phys[index];
-                        state = iphy->sm.current_state_id;
-
-                        if (!phy_get_non_dummy_port(iphy))
-                                continue;
-
-                        /* The controller start operation is complete iff:
-                         * - all links have been given an opportunity to start
-                         * - have no indication of a connected device
-                         * - have an indication of a connected device and it has
-                         *   finished the link training process.
-                         */
-                        if ((iphy->is_in_link_training == false && state == SCI_PHY_INITIAL) ||
-                            (iphy->is_in_link_training == false && state == SCI_PHY_STOPPED) ||
-                            (iphy->is_in_link_training == true && is_phy_starting(iphy)) ||
-                            (ihost->port_agent.phy_ready_mask != ihost->port_agent.phy_configured_mask)) {
-                                is_controller_start_complete = false;
-                                break;
-                        }
-                }
-
-                /*
-                 * The controller has successfully finished the start process.
-                 * Inform the SCI Core user and transition to the READY state. */
-                if (is_controller_start_complete == true) {
+                if (is_controller_start_complete(ihost)) {
                         sci_controller_transition_to_ready(ihost, SCI_SUCCESS);
                         sci_del_timer(&ihost->phy_timer);
                         ihost->phy_startup_timer_pending = false;
@@ -987,9 +992,8 @@ static enum sci_status sci_controller_start(struct isci_host *ihost,
         u16 index;
 
         if (ihost->sm.current_state_id != SCIC_INITIALIZED) {
-                dev_warn(&ihost->pdev->dev,
-                         "SCIC Controller start operation requested in "
-                         "invalid state\n");
+                dev_warn(&ihost->pdev->dev, "%s invalid state: %d\n",
+                         __func__, ihost->sm.current_state_id);
                 return SCI_FAILURE_INVALID_STATE;
         }
 
@@ -1053,9 +1057,8 @@ void isci_host_scan_start(struct Scsi_Host *shost)
         spin_unlock_irq(&ihost->scic_lock);
 }
 
-static void isci_host_stop_complete(struct isci_host *ihost, enum sci_status completion_status)
+static void isci_host_stop_complete(struct isci_host *ihost)
 {
-        isci_host_change_state(ihost, isci_stopped);
         sci_controller_disable_interrupts(ihost);
         clear_bit(IHOST_STOP_PENDING, &ihost->flags);
         wake_up(&ihost->eventq);
@@ -1074,6 +1077,32 @@ static void sci_controller_completion_handler(struct isci_host *ihost)
         writel(0, &ihost->smu_registers->interrupt_mask);
 }
 
+void ireq_done(struct isci_host *ihost, struct isci_request *ireq, struct sas_task *task)
+{
+        task->lldd_task = NULL;
+        if (!test_bit(IREQ_ABORT_PATH_ACTIVE, &ireq->flags) &&
+            !(task->task_state_flags & SAS_TASK_STATE_ABORTED)) {
+                if (test_bit(IREQ_COMPLETE_IN_TARGET, &ireq->flags)) {
+                        /* Normal notification (task_done) */
+                        dev_dbg(&ihost->pdev->dev,
+                                "%s: Normal - ireq/task = %p/%p\n",
+                                __func__, ireq, task);
+
+                        task->task_done(task);
+                } else {
+                        dev_dbg(&ihost->pdev->dev,
+                                "%s: Error - ireq/task = %p/%p\n",
+                                __func__, ireq, task);
+
+                        sas_task_abort(task);
+                }
+        }
+        if (test_and_clear_bit(IREQ_ABORT_PATH_ACTIVE, &ireq->flags))
+                wake_up_all(&ihost->eventq);
+
+        if (!test_bit(IREQ_NO_AUTO_FREE_TAG, &ireq->flags))
+                isci_free_tag(ihost, ireq->io_tag);
+}
 /**
  * isci_host_completion_routine() - This function is the delayed service
  *    routine that calls the sci core library's completion handler. It's
@@ -1082,107 +1111,15 @@ static void sci_controller_completion_handler(struct isci_host *ihost)
  * @data: This parameter specifies the ISCI host object
  *
  */
-static void isci_host_completion_routine(unsigned long data)
+void isci_host_completion_routine(unsigned long data)
 {
         struct isci_host *ihost = (struct isci_host *)data;
-        struct list_head    completed_request_list;
-        struct list_head    errored_request_list;
-        struct list_head    *current_position;
-        struct list_head    *next_position;
-        struct isci_request *request;
-        struct isci_request *next_request;
-        struct sas_task     *task;
         u16 active;
 
-        INIT_LIST_HEAD(&completed_request_list);
-        INIT_LIST_HEAD(&errored_request_list);
-
         spin_lock_irq(&ihost->scic_lock);
-
         sci_controller_completion_handler(ihost);
-
-        /* Take the lists of completed I/Os from the host. */
-
-        list_splice_init(&ihost->requests_to_complete,
-                         &completed_request_list);
-
-        /* Take the list of errored I/Os from the host. */
-        list_splice_init(&ihost->requests_to_errorback,
-                         &errored_request_list);
-
         spin_unlock_irq(&ihost->scic_lock);
 
-        /* Process any completions in the lists. */
-        list_for_each_safe(current_position, next_position,
-                           &completed_request_list) {
-
-                request = list_entry(current_position, struct isci_request,
-                                     completed_node);
-                task = isci_request_access_task(request);
-
-                /* Normal notification (task_done) */
-                dev_dbg(&ihost->pdev->dev,
-                        "%s: Normal - request/task = %p/%p\n",
-                        __func__,
-                        request,
-                        task);
-
-                /* Return the task to libsas */
-                if (task != NULL) {
-
-                        task->lldd_task = NULL;
-                        if (!(task->task_state_flags & SAS_TASK_STATE_ABORTED)) {
-
-                                /* If the task is already in the abort path,
-                                * the task_done callback cannot be called.
-                                */
-                                task->task_done(task);
-                        }
-                }
-
-                spin_lock_irq(&ihost->scic_lock);
-                isci_free_tag(ihost, request->io_tag);
-                spin_unlock_irq(&ihost->scic_lock);
-        }
-        list_for_each_entry_safe(request, next_request, &errored_request_list,
-                                 completed_node) {
-
-                task = isci_request_access_task(request);
-
-                /* Use sas_task_abort */
-                dev_warn(&ihost->pdev->dev,
-                         "%s: Error - request/task = %p/%p\n",
-                         __func__,
-                         request,
-                         task);
-
-                if (task != NULL) {
-
-                        /* Put the task into the abort path if it's not there
-                         * already.
-                         */
-                        if (!(task->task_state_flags & SAS_TASK_STATE_ABORTED))
-                                sas_task_abort(task);
-
-                } else {
-                        /* This is a case where the request has completed with a
-                         * status such that it needed further target servicing,
-                         * but the sas_task reference has already been removed
-                         * from the request.  Since it was errored, it was not
-                         * being aborted, so there is nothing to do except free
-                         * it.
-                         */
-
-                        spin_lock_irq(&ihost->scic_lock);
-                        /* Remove the request from the remote device's list
-                        * of pending requests.
-                        */
-                        list_del_init(&request->dev_node);
-                        isci_free_tag(ihost, request->io_tag);
-                        spin_unlock_irq(&ihost->scic_lock);
-                }
-        }
-
         /* the coalesence timeout doubles at each encoding step, so
          * update it based on the ilog2 value of the outstanding requests
          */
@@ -1213,9 +1150,8 @@ static void isci_host_completion_routine(unsigned long data)
 static enum sci_status sci_controller_stop(struct isci_host *ihost, u32 timeout)
 {
         if (ihost->sm.current_state_id != SCIC_READY) {
-                dev_warn(&ihost->pdev->dev,
-                         "SCIC Controller stop operation requested in "
-                         "invalid state\n");
+                dev_warn(&ihost->pdev->dev, "%s invalid state: %d\n",
+                         __func__, ihost->sm.current_state_id);
                 return SCI_FAILURE_INVALID_STATE;
         }
 
@@ -1241,7 +1177,7 @@ static enum sci_status sci_controller_reset(struct isci_host *ihost)
         switch (ihost->sm.current_state_id) {
         case SCIC_RESET:
         case SCIC_READY:
-        case SCIC_STOPPED:
+        case SCIC_STOPPING:
         case SCIC_FAILED:
                 /*
                  * The reset operation is not a graceful cleanup, just
@@ -1250,13 +1186,50 @@ static enum sci_status sci_controller_reset(struct isci_host *ihost)
                 sci_change_state(&ihost->sm, SCIC_RESETTING);
                 return SCI_SUCCESS;
         default:
-                dev_warn(&ihost->pdev->dev,
-                         "SCIC Controller reset operation requested in "
-                         "invalid state\n");
+                dev_warn(&ihost->pdev->dev, "%s invalid state: %d\n",
+                         __func__, ihost->sm.current_state_id);
                 return SCI_FAILURE_INVALID_STATE;
         }
 }
 
+static enum sci_status sci_controller_stop_phys(struct isci_host *ihost)
+{
+        u32 index;
+        enum sci_status status;
+        enum sci_status phy_status;
+
+        status = SCI_SUCCESS;
+
+        for (index = 0; index < SCI_MAX_PHYS; index++) {
+                phy_status = sci_phy_stop(&ihost->phys[index]);
+
+                if (phy_status != SCI_SUCCESS &&
+                    phy_status != SCI_FAILURE_INVALID_STATE) {
+                        status = SCI_FAILURE;
+
+                        dev_warn(&ihost->pdev->dev,
+                                 "%s: Controller stop operation failed to stop "
+                                 "phy %d because of status %d.\n",
+                                 __func__,
+                                 ihost->phys[index].phy_index, phy_status);
+                }
+        }
+
+        return status;
+}
+
+
+/**
+ * isci_host_deinit - shutdown frame reception and dma
+ * @ihost: host to take down
+ *
+ * This is called in either the driver shutdown or the suspend path.  In
+ * the shutdown case libsas went through port teardown and normal device
+ * removal (i.e. physical links stayed up to service scsi_device removal
+ * commands).  In the suspend case we disable the hardware without
+ * notifying libsas of the link down events since we want libsas to
+ * remember the domain across the suspend/resume cycle
+ */
 void isci_host_deinit(struct isci_host *ihost)
 {
         int i;
@@ -1265,17 +1238,6 @@ void isci_host_deinit(struct isci_host *ihost)
         for (i = 0; i < isci_gpio_count(ihost); i++)
                 writel(SGPIO_HW_CONTROL, &ihost->scu_registers->peg0.sgpio.output_data_select[i]);
 
-        isci_host_change_state(ihost, isci_stopping);
-        for (i = 0; i < SCI_MAX_PORTS; i++) {
-                struct isci_port *iport = &ihost->ports[i];
-                struct isci_remote_device *idev, *d;
-
-                list_for_each_entry_safe(idev, d, &iport->remote_dev_list, node) {
-                        if (test_bit(IDEV_ALLOCATED, &idev->flags))
-                                isci_remote_device_stop(ihost, idev);
-                }
-        }
-
         set_bit(IHOST_STOP_PENDING, &ihost->flags);
 
         spin_lock_irq(&ihost->scic_lock);
@@ -1284,12 +1246,21 @@ void isci_host_deinit(struct isci_host *ihost)
 
         wait_for_stop(ihost);
 
+        /* phy stop is after controller stop to allow port and device to
+         * go idle before shutting down the phys, but the expectation is
+         * that i/o has been shut off well before we reach this
+         * function.
+         */
+        sci_controller_stop_phys(ihost);
+
         /* disable sgpio: where the above wait should give time for the
          * enclosure to sample the gpios going inactive
          */
         writel(0, &ihost->scu_registers->peg0.sgpio.interface_control);
 
+        spin_lock_irq(&ihost->scic_lock);
         sci_controller_reset(ihost);
+        spin_unlock_irq(&ihost->scic_lock);
 
         /* Cancel any/all outstanding port timers */
         for (i = 0; i < ihost->logical_port_entries; i++) {
@@ -1328,29 +1299,6 @@ static void __iomem *smu_base(struct isci_host *isci_host)
         return pcim_iomap_table(pdev)[SCI_SMU_BAR * 2] + SCI_SMU_BAR_SIZE * id;
 }
 
-static void isci_user_parameters_get(struct sci_user_parameters *u)
-{
-        int i;
-
-        for (i = 0; i < SCI_MAX_PHYS; i++) {
-                struct sci_phy_user_params *u_phy = &u->phys[i];
-
-                u_phy->max_speed_generation = phy_gen;
-
-                /* we are not exporting these for now */
-                u_phy->align_insertion_frequency = 0x7f;
-                u_phy->in_connection_align_insertion_frequency = 0xff;
-                u_phy->notify_enable_spin_up_insertion_frequency = 0x33;
-        }
-
-        u->stp_inactivity_timeout = stp_inactive_to;
-        u->ssp_inactivity_timeout = ssp_inactive_to;
-        u->stp_max_occupancy_timeout = stp_max_occ_to;
-        u->ssp_max_occupancy_timeout = ssp_max_occ_to;
-        u->no_outbound_task_timeout = no_outbound_task_to;
-        u->max_concurr_spinup = max_concurr_spinup;
-}
-
 static void sci_controller_initial_state_enter(struct sci_base_state_machine *sm)
 {
         struct isci_host *ihost = container_of(sm, typeof(*ihost), sm);
@@ -1510,32 +1458,6 @@ static void sci_controller_ready_state_exit(struct sci_base_state_machine *sm)
         sci_controller_set_interrupt_coalescence(ihost, 0, 0);
 }
 
-static enum sci_status sci_controller_stop_phys(struct isci_host *ihost)
-{
-        u32 index;
-        enum sci_status status;
-        enum sci_status phy_status;
-
-        status = SCI_SUCCESS;
-
-        for (index = 0; index < SCI_MAX_PHYS; index++) {
-                phy_status = sci_phy_stop(&ihost->phys[index]);
-
-                if (phy_status != SCI_SUCCESS &&
-                    phy_status != SCI_FAILURE_INVALID_STATE) {
-                        status = SCI_FAILURE;
-
-                        dev_warn(&ihost->pdev->dev,
-                                 "%s: Controller stop operation failed to stop "
-                                 "phy %d because of status %d.\n",
-                                 __func__,
-                                 ihost->phys[index].phy_index, phy_status);
-                }
-        }
-
-        return status;
-}
-
 static enum sci_status sci_controller_stop_ports(struct isci_host *ihost)
 {
         u32 index;
@@ -1595,10 +1517,11 @@ static void sci_controller_stopping_state_enter(struct sci_base_state_machine *s
 {
         struct isci_host *ihost = container_of(sm, typeof(*ihost), sm);
 
-        /* Stop all of the components for this controller */
-        sci_controller_stop_phys(ihost);
-        sci_controller_stop_ports(ihost);
         sci_controller_stop_devices(ihost);
+        sci_controller_stop_ports(ihost);
+
+        if (!sci_controller_has_remote_devices_stopping(ihost))
+                isci_host_stop_complete(ihost);
 }
 
 static void sci_controller_stopping_state_exit(struct sci_base_state_machine *sm)
@@ -1624,6 +1547,9 @@ static void sci_controller_reset_hardware(struct isci_host *ihost)
 
         /* The write to the UFQGP clears the UFQPR */
         writel(0, &ihost->scu_registers->sdma.unsolicited_frame_get_pointer);
+
+        /* clear all interrupts */
+        writel(~SMU_INTERRUPT_STATUS_RESERVED_MASK, &ihost->smu_registers->interrupt_status);
 }
 
 static void sci_controller_resetting_state_enter(struct sci_base_state_machine *sm)
@@ -1655,59 +1581,9 @@ static const struct sci_base_state sci_controller_state_table[] = {
                 .enter_state = sci_controller_stopping_state_enter,
                 .exit_state = sci_controller_stopping_state_exit,
         },
-        [SCIC_STOPPED] = {},
         [SCIC_FAILED] = {}
 };
 
-static void sci_controller_set_default_config_parameters(struct isci_host *ihost)
-{
-        /* these defaults are overridden by the platform / firmware */
-        u16 index;
-
-        /* Default to APC mode. */
-        ihost->oem_parameters.controller.mode_type = SCIC_PORT_AUTOMATIC_CONFIGURATION_MODE;
-
-        /* Default to APC mode. */
-        ihost->oem_parameters.controller.max_concurr_spin_up = 1;
-
-        /* Default to no SSC operation. */
-        ihost->oem_parameters.controller.do_enable_ssc = false;
-
-        /* Default to short cables on all phys. */
-        ihost->oem_parameters.controller.cable_selection_mask = 0;
-
-        /* Initialize all of the port parameter information to narrow ports. */
-        for (index = 0; index < SCI_MAX_PORTS; index++) {
-                ihost->oem_parameters.ports[index].phy_mask = 0;
-        }
-
-        /* Initialize all of the phy parameter information. */
-        for (index = 0; index < SCI_MAX_PHYS; index++) {
-                /* Default to 3G (i.e. Gen 2). */
-                ihost->user_parameters.phys[index].max_speed_generation =
-                        SCIC_SDS_PARM_GEN2_SPEED;
-
-                /* the frequencies cannot be 0 */
-                ihost->user_parameters.phys[index].align_insertion_frequency = 0x7f;
-                ihost->user_parameters.phys[index].in_connection_align_insertion_frequency = 0xff;
-                ihost->user_parameters.phys[index].notify_enable_spin_up_insertion_frequency = 0x33;
-
-                /*
-                 * Previous Vitesse based expanders had a arbitration issue that
-                 * is worked around by having the upper 32-bits of SAS address
-                 * with a value greater then the Vitesse company identifier.
-                 * Hence, usage of 0x5FCFFFFF. */
-                ihost->oem_parameters.phys[index].sas_address.low = 0x1 + ihost->id;
-                ihost->oem_parameters.phys[index].sas_address.high = 0x5FCFFFFF;
-        }
-
-        ihost->user_parameters.stp_inactivity_timeout = 5;
-        ihost->user_parameters.ssp_inactivity_timeout = 5;
-        ihost->user_parameters.stp_max_occupancy_timeout = 5;
-        ihost->user_parameters.ssp_max_occupancy_timeout = 20;
-        ihost->user_parameters.no_outbound_task_timeout = 2;
-}
-
 static void controller_timeout(unsigned long data)
 {
         struct sci_timer *tmr = (struct sci_timer *)data;
@@ -1724,7 +1600,7 @@ static void controller_timeout(unsigned long data)
                 sci_controller_transition_to_ready(ihost, SCI_FAILURE_TIMEOUT);
         else if (sm->current_state_id == SCIC_STOPPING) {
                 sci_change_state(sm, SCIC_FAILED);
-                isci_host_stop_complete(ihost, SCI_FAILURE_TIMEOUT);
+                isci_host_stop_complete(ihost);
         } else  /* / @todo Now what do we want to do in this case? */
                 dev_err(&ihost->pdev->dev,
                         "%s: Controller timer fired when controller was not "
@@ -1764,9 +1640,6 @@ static enum sci_status sci_controller_construct(struct isci_host *ihost,
 
         sci_init_timer(&ihost->timer, controller_timeout);
 
-        /* Initialize the User and OEM parameters to default values. */
-        sci_controller_set_default_config_parameters(ihost);
-
         return sci_controller_reset(ihost);
 }
 
@@ -1846,27 +1719,6 @@ int sci_oem_parameters_validate(struct sci_oem_params *oem, u8 version)
         return 0;
 }
 
-static enum sci_status sci_oem_parameters_set(struct isci_host *ihost)
-{
-        u32 state = ihost->sm.current_state_id;
-        struct isci_pci_info *pci_info = to_pci_info(ihost->pdev);
-
-        if (state == SCIC_RESET ||
-            state == SCIC_INITIALIZING ||
-            state == SCIC_INITIALIZED) {
-                u8 oem_version = pci_info->orom ? pci_info->orom->hdr.version :
-                        ISCI_ROM_VER_1_0;
-
-                if (sci_oem_parameters_validate(&ihost->oem_parameters,
-                                                oem_version))
-                        return SCI_FAILURE_INVALID_PARAMETER_VALUE;
-
-                return SCI_SUCCESS;
-        }
-
-        return SCI_FAILURE_INVALID_STATE;
-}
-
 static u8 max_spin_up(struct isci_host *ihost)
 {
         if (ihost->user_parameters.max_concurr_spinup)
@@ -1914,7 +1766,7 @@ static void power_control_timeout(unsigned long data)
                 ihost->power_control.phys_granted_power++;
                 sci_phy_consume_power_handler(iphy);
 
-                if (iphy->protocol == SCIC_SDS_PHY_PROTOCOL_SAS) {
+                if (iphy->protocol == SAS_PROTOCOL_SSP) {
                         u8 j;
 
                         for (j = 0; j < SCI_MAX_PHYS; j++) {
@@ -1988,7 +1840,7 @@ void sci_controller_power_control_queue_insert(struct isci_host *ihost,
                                        sizeof(current_phy->frame_rcvd.iaf.sas_addr));
 
                         if (current_phy->sm.current_state_id == SCI_PHY_READY &&
-                            current_phy->protocol == SCIC_SDS_PHY_PROTOCOL_SAS &&
+                            current_phy->protocol == SAS_PROTOCOL_SSP &&
                             other == 0) {
                                 sci_phy_consume_power_handler(iphy);
                                 break;
@@ -2279,9 +2131,8 @@ static enum sci_status sci_controller_initialize(struct isci_host *ihost)
         unsigned long i, state, val;
 
         if (ihost->sm.current_state_id != SCIC_RESET) {
-                dev_warn(&ihost->pdev->dev,
-                         "SCIC Controller initialize operation requested "
-                         "in invalid state\n");
+                dev_warn(&ihost->pdev->dev, "%s invalid state: %d\n",
+                         __func__, ihost->sm.current_state_id);
                 return SCI_FAILURE_INVALID_STATE;
         }
 
@@ -2384,96 +2235,76 @@ static enum sci_status sci_controller_initialize(struct isci_host *ihost)
         return result;
 }
 
-static enum sci_status sci_user_parameters_set(struct isci_host *ihost,
-                                               struct sci_user_parameters *sci_parms)
-{
-        u32 state = ihost->sm.current_state_id;
-
-        if (state == SCIC_RESET ||
-            state == SCIC_INITIALIZING ||
-            state == SCIC_INITIALIZED) {
-                u16 index;
-
-                /*
-                 * Validate the user parameters.  If they are not legal, then
-                 * return a failure.
-                 */
-                for (index = 0; index < SCI_MAX_PHYS; index++) {
-                        struct sci_phy_user_params *user_phy;
-
-                        user_phy = &sci_parms->phys[index];
-
-                        if (!((user_phy->max_speed_generation <=
-                                                SCIC_SDS_PARM_MAX_SPEED) &&
-                              (user_phy->max_speed_generation >
-                                                SCIC_SDS_PARM_NO_SPEED)))
-                                return SCI_FAILURE_INVALID_PARAMETER_VALUE;
-
-                        if (user_phy->in_connection_align_insertion_frequency <
-                                        3)
-                                return SCI_FAILURE_INVALID_PARAMETER_VALUE;
-
-                        if ((user_phy->in_connection_align_insertion_frequency <
-                                                3) ||
-                            (user_phy->align_insertion_frequency == 0) ||
-                            (user_phy->
-                                notify_enable_spin_up_insertion_frequency ==
-                                                0))
-                                return SCI_FAILURE_INVALID_PARAMETER_VALUE;
-                }
-
-                if ((sci_parms->stp_inactivity_timeout == 0) ||
-                    (sci_parms->ssp_inactivity_timeout == 0) ||
-                    (sci_parms->stp_max_occupancy_timeout == 0) ||
-                    (sci_parms->ssp_max_occupancy_timeout == 0) ||
-                    (sci_parms->no_outbound_task_timeout == 0))
-                        return SCI_FAILURE_INVALID_PARAMETER_VALUE;
-
-                memcpy(&ihost->user_parameters, sci_parms, sizeof(*sci_parms));
-
-                return SCI_SUCCESS;
-        }
-
-        return SCI_FAILURE_INVALID_STATE;
-}
-
-static int sci_controller_mem_init(struct isci_host *ihost)
+static int sci_controller_dma_alloc(struct isci_host *ihost)
 {
         struct device *dev = &ihost->pdev->dev;
-        dma_addr_t dma;
         size_t size;
-        int err;
+        int i;
+
+        /* detect re-initialization */
+        if (ihost->completion_queue)
+                return 0;
 
         size = SCU_MAX_COMPLETION_QUEUE_ENTRIES * sizeof(u32);
-        ihost->completion_queue = dmam_alloc_coherent(dev, size, &dma, GFP_KERNEL);
+        ihost->completion_queue = dmam_alloc_coherent(dev, size, &ihost->cq_dma,
+                                                      GFP_KERNEL);
         if (!ihost->completion_queue)
                 return -ENOMEM;
 
-        writel(lower_32_bits(dma), &ihost->smu_registers->completion_queue_lower);
-        writel(upper_32_bits(dma), &ihost->smu_registers->completion_queue_upper);
-
         size = ihost->remote_node_entries * sizeof(union scu_remote_node_context);
-        ihost->remote_node_context_table = dmam_alloc_coherent(dev, size, &dma,
+        ihost->remote_node_context_table = dmam_alloc_coherent(dev, size, &ihost->rnc_dma,
                                                                GFP_KERNEL);
+
         if (!ihost->remote_node_context_table)
                 return -ENOMEM;
 
-        writel(lower_32_bits(dma), &ihost->smu_registers->remote_node_context_lower);
-        writel(upper_32_bits(dma), &ihost->smu_registers->remote_node_context_upper);
-
         size = ihost->task_context_entries * sizeof(struct scu_task_context),
-        ihost->task_context_table = dmam_alloc_coherent(dev, size, &dma, GFP_KERNEL);
+        ihost->task_context_table = dmam_alloc_coherent(dev, size, &ihost->tc_dma,
+                                                        GFP_KERNEL);
         if (!ihost->task_context_table)
                 return -ENOMEM;
 
-        ihost->task_context_dma = dma;
-        writel(lower_32_bits(dma), &ihost->smu_registers->host_task_table_lower);
-        writel(upper_32_bits(dma), &ihost->smu_registers->host_task_table_upper);
+        size = SCI_UFI_TOTAL_SIZE;
+        ihost->ufi_buf = dmam_alloc_coherent(dev, size, &ihost->ufi_dma, GFP_KERNEL);
+        if (!ihost->ufi_buf)
+                return -ENOMEM;
+
+        for (i = 0; i < SCI_MAX_IO_REQUESTS; i++) {
+                struct isci_request *ireq;
+                dma_addr_t dma;
+
+                ireq = dmam_alloc_coherent(dev, sizeof(*ireq), &dma, GFP_KERNEL);
+                if (!ireq)
+                        return -ENOMEM;
+
+                ireq->tc = &ihost->task_context_table[i];
+                ireq->owning_controller = ihost;
+                ireq->request_daddr = dma;
+                ireq->isci_host = ihost;
+                ihost->reqs[i] = ireq;
+        }
+
+        return 0;
+}
+
+static int sci_controller_mem_init(struct isci_host *ihost)
+{
+        int err = sci_controller_dma_alloc(ihost);
 
-        err = sci_unsolicited_frame_control_construct(ihost);
         if (err)
                 return err;
 
+        writel(lower_32_bits(ihost->cq_dma), &ihost->smu_registers->completion_queue_lower);
+        writel(upper_32_bits(ihost->cq_dma), &ihost->smu_registers->completion_queue_upper);
+
+        writel(lower_32_bits(ihost->rnc_dma), &ihost->smu_registers->remote_node_context_lower);
+        writel(upper_32_bits(ihost->rnc_dma), &ihost->smu_registers->remote_node_context_upper);
+
+        writel(lower_32_bits(ihost->tc_dma), &ihost->smu_registers->host_task_table_lower);
+        writel(upper_32_bits(ihost->tc_dma), &ihost->smu_registers->host_task_table_upper);
+
+        sci_unsolicited_frame_control_construct(ihost);
+
         /*
          * Inform the silicon as to the location of the UF headers and
          * address table.
@@ -2491,22 +2322,22 @@ static int sci_controller_mem_init(struct isci_host *ihost)
         return 0;
 }
 
+/**
+ * isci_host_init - (re-)initialize hardware and internal (private) state
+ * @ihost: host to init
+ *
+ * Any public facing objects (like asd_sas_port, and asd_sas_phys), or
+ * one-time initialization objects like locks and waitqueues, are
+ * not touched (they are initialized in isci_host_alloc)
+ */
 int isci_host_init(struct isci_host *ihost)
 {
-        int err = 0, i;
+        int i, err;
         enum sci_status status;
-        struct sci_user_parameters sci_user_params;
-        struct isci_pci_info *pci_info = to_pci_info(ihost->pdev);
-
-        spin_lock_init(&ihost->state_lock);
-        spin_lock_init(&ihost->scic_lock);
-        init_waitqueue_head(&ihost->eventq);
-
-        isci_host_change_state(ihost, isci_starting);
-
-        status = sci_controller_construct(ihost, scu_base(ihost),
-                                          smu_base(ihost));
 
+        spin_lock_irq(&ihost->scic_lock);
+        status = sci_controller_construct(ihost, scu_base(ihost), smu_base(ihost));
+        spin_unlock_irq(&ihost->scic_lock);
         if (status != SCI_SUCCESS) {
                 dev_err(&ihost->pdev->dev,
                         "%s: sci_controller_construct failed - status = %x\n",
@@ -2515,48 +2346,6 @@ int isci_host_init(struct isci_host *ihost)
                 return -ENODEV;
         }
 
-        ihost->sas_ha.dev = &ihost->pdev->dev;
-        ihost->sas_ha.lldd_ha = ihost;
-
-        /*
-         * grab initial values stored in the controller object for OEM and USER
-         * parameters
-         */
-        isci_user_parameters_get(&sci_user_params);
-        status = sci_user_parameters_set(ihost, &sci_user_params);
-        if (status != SCI_SUCCESS) {
-                dev_warn(&ihost->pdev->dev,
-                         "%s: sci_user_parameters_set failed\n",
-                         __func__);
-                return -ENODEV;
-        }
-
-        /* grab any OEM parameters specified in orom */
-        if (pci_info->orom) {
-                status = isci_parse_oem_parameters(&ihost->oem_parameters,
-                                                   pci_info->orom,
-                                                   ihost->id);
-                if (status != SCI_SUCCESS) {
-                        dev_warn(&ihost->pdev->dev,
-                                 "parsing firmware oem parameters failed\n");
-                        return -EINVAL;
-                }
-        }
-
-        status = sci_oem_parameters_set(ihost);
-        if (status != SCI_SUCCESS) {
-                dev_warn(&ihost->pdev->dev,
-                                "%s: sci_oem_parameters_set failed\n",
-                                __func__);
-                return -ENODEV;
-        }
-
-        tasklet_init(&ihost->completion_tasklet,
-                     isci_host_completion_routine, (unsigned long)ihost);
-
-        INIT_LIST_HEAD(&ihost->requests_to_complete);
-        INIT_LIST_HEAD(&ihost->requests_to_errorback);
-
         spin_lock_irq(&ihost->scic_lock);
         status = sci_controller_initialize(ihost);
         spin_unlock_irq(&ihost->scic_lock);
@@ -2572,43 +2361,12 @@ int isci_host_init(struct isci_host *ihost)
         if (err)
                 return err;
 
-        for (i = 0; i < SCI_MAX_PORTS; i++)
-                isci_port_init(&ihost->ports[i], ihost, i);
-
-        for (i = 0; i < SCI_MAX_PHYS; i++)
-                isci_phy_init(&ihost->phys[i], ihost, i);
-
         /* enable sgpio */
         writel(1, &ihost->scu_registers->peg0.sgpio.interface_control);
         for (i = 0; i < isci_gpio_count(ihost); i++)
                 writel(SGPIO_HW_CONTROL, &ihost->scu_registers->peg0.sgpio.output_data_select[i]);
         writel(0, &ihost->scu_registers->peg0.sgpio.vendor_specific_code);
 
-        for (i = 0; i < SCI_MAX_REMOTE_DEVICES; i++) {
-                struct isci_remote_device *idev = &ihost->devices[i];
-
-                INIT_LIST_HEAD(&idev->reqs_in_process);
-                INIT_LIST_HEAD(&idev->node);
-        }
-
-        for (i = 0; i < SCI_MAX_IO_REQUESTS; i++) {
-                struct isci_request *ireq;
-                dma_addr_t dma;
-
-                ireq = dmam_alloc_coherent(&ihost->pdev->dev,
-                                           sizeof(struct isci_request), &dma,
-                                           GFP_KERNEL);
-                if (!ireq)
-                        return -ENOMEM;
-
-                ireq->tc = &ihost->task_context_table[i];
-                ireq->owning_controller = ihost;
-                spin_lock_init(&ireq->state_lock);
-                ireq->request_daddr = dma;
-                ireq->isci_host = ihost;
-                ihost->reqs[i] = ireq;
-        }
-
         return 0;
 }
 
@@ -2654,7 +2412,7 @@ void sci_controller_link_down(struct isci_host *ihost, struct isci_port *iport,
         }
 }
 
-static bool sci_controller_has_remote_devices_stopping(struct isci_host *ihost)
+bool sci_controller_has_remote_devices_stopping(struct isci_host *ihost)
 {
         u32 index;
 
@@ -2680,7 +2438,7 @@ void sci_controller_remote_device_stopped(struct isci_host *ihost,
         }
 
         if (!sci_controller_has_remote_devices_stopping(ihost))
-                sci_change_state(&ihost->sm, SCIC_STOPPED);
+                isci_host_stop_complete(ihost);
 }
 
 void sci_controller_post_request(struct isci_host *ihost, u32 request)
@@ -2842,7 +2600,8 @@ enum sci_status sci_controller_start_io(struct isci_host *ihost,
         enum sci_status status;
 
         if (ihost->sm.current_state_id != SCIC_READY) {
-                dev_warn(&ihost->pdev->dev, "invalid state to start I/O");
+                dev_warn(&ihost->pdev->dev, "%s invalid state: %d\n",
+                         __func__, ihost->sm.current_state_id);
                 return SCI_FAILURE_INVALID_STATE;
         }
 
@@ -2866,22 +2625,26 @@ enum sci_status sci_controller_terminate_request(struct isci_host *ihost,
         enum sci_status status;
 
         if (ihost->sm.current_state_id != SCIC_READY) {
-                dev_warn(&ihost->pdev->dev,
-                         "invalid state to terminate request\n");
+                dev_warn(&ihost->pdev->dev, "%s invalid state: %d\n",
+                         __func__, ihost->sm.current_state_id);
                 return SCI_FAILURE_INVALID_STATE;
         }
-
         status = sci_io_request_terminate(ireq);
-        if (status != SCI_SUCCESS)
-                return status;
 
-        /*
-         * Utilize the original post context command and or in the POST_TC_ABORT
-         * request sub-type.
-         */
-        sci_controller_post_request(ihost,
-                                    ireq->post_context | SCU_CONTEXT_COMMAND_REQUEST_POST_TC_ABORT);
-        return SCI_SUCCESS;
+        dev_dbg(&ihost->pdev->dev, "%s: status=%d; ireq=%p; flags=%lx\n",
+                __func__, status, ireq, ireq->flags);
+
+        if ((status == SCI_SUCCESS) &&
+            !test_bit(IREQ_PENDING_ABORT, &ireq->flags) &&
+            !test_and_set_bit(IREQ_TC_ABORT_POSTED, &ireq->flags)) {
+                /* Utilize the original post context command and or in the
+                 * POST_TC_ABORT request sub-type.
+                 */
+                sci_controller_post_request(
+                        ihost, ireq->post_context |
+                                SCU_CONTEXT_COMMAND_REQUEST_POST_TC_ABORT);
+        }
+        return status;
 }
 
 /**
@@ -2915,7 +2678,8 @@ enum sci_status sci_controller_complete_io(struct isci_host *ihost,
                 clear_bit(IREQ_ACTIVE, &ireq->flags);
                 return SCI_SUCCESS;
         default:
-                dev_warn(&ihost->pdev->dev, "invalid state to complete I/O");
+                dev_warn(&ihost->pdev->dev, "%s invalid state: %d\n",
+                         __func__, ihost->sm.current_state_id);
                 return SCI_FAILURE_INVALID_STATE;
         }
 
@@ -2926,7 +2690,8 @@ enum sci_status sci_controller_continue_io(struct isci_request *ireq)
         struct isci_host *ihost = ireq->owning_controller;
 
         if (ihost->sm.current_state_id != SCIC_READY) {
-                dev_warn(&ihost->pdev->dev, "invalid state to continue I/O");
+                dev_warn(&ihost->pdev->dev, "%s invalid state: %d\n",
+                         __func__, ihost->sm.current_state_id);
                 return SCI_FAILURE_INVALID_STATE;
         }
 
diff --git a/drivers/scsi/isci/host.h b/drivers/scsi/isci/host.h
index adbad69d1069..9ab58e0540e7 100644
--- a/drivers/scsi/isci/host.h
+++ b/drivers/scsi/isci/host.h
@@ -55,6 +55,7 @@
 #ifndef _SCI_HOST_H_
 #define _SCI_HOST_H_
 
+#include <scsi/sas_ata.h>
 #include "remote_device.h"
 #include "phy.h"
 #include "isci.h"
@@ -108,6 +109,8 @@ struct sci_port_configuration_agent;
 typedef void (*port_config_fn)(struct isci_host *,
                                struct sci_port_configuration_agent *,
                                struct isci_port *, struct isci_phy *);
+bool is_port_config_apc(struct isci_host *ihost);
+bool is_controller_start_complete(struct isci_host *ihost);
 
 struct sci_port_configuration_agent {
         u16 phy_configured_mask;
@@ -157,13 +160,17 @@ struct isci_host {
         struct sci_power_control power_control;
         u8 io_request_sequence[SCI_MAX_IO_REQUESTS];
         struct scu_task_context *task_context_table;
-        dma_addr_t task_context_dma;
+        dma_addr_t tc_dma;
         union scu_remote_node_context *remote_node_context_table;
+        dma_addr_t rnc_dma;
         u32 *completion_queue;
+        dma_addr_t cq_dma;
         u32 completion_queue_get;
         u32 logical_port_entries;
         u32 remote_node_entries;
         u32 task_context_entries;
+        void *ufi_buf;
+        dma_addr_t ufi_dma;
         struct sci_unsolicited_frame_control uf_control;
 
         /* phy startup */
@@ -190,17 +197,13 @@ struct isci_host {
         struct asd_sas_port sas_ports[SCI_MAX_PORTS];
         struct sas_ha_struct sas_ha;
 
-        spinlock_t state_lock;
         struct pci_dev *pdev;
-        enum isci_status status;
         #define IHOST_START_PENDING 0
         #define IHOST_STOP_PENDING 1
+        #define IHOST_IRQ_ENABLED 2
         unsigned long flags;
         wait_queue_head_t eventq;
-        struct Scsi_Host *shost;
         struct tasklet_struct completion_tasklet;
-        struct list_head requests_to_complete;
-        struct list_head requests_to_errorback;
         spinlock_t scic_lock;
         struct isci_request *reqs[SCI_MAX_IO_REQUESTS];
         struct isci_remote_device devices[SCI_MAX_REMOTE_DEVICES];
@@ -274,13 +277,6 @@ enum sci_controller_states {
         SCIC_STOPPING,
 
         /**
-         * This state indicates that the controller has successfully been stopped.
-         * In this state no new IO operations are permitted.
-         * This state is entered from the STOPPING state.
-         */
-        SCIC_STOPPED,
-
-        /**
          * This state indicates that the controller could not successfully be
          * initialized.  In this state no new IO operations are permitted.
          * This state is entered from the INITIALIZING state.
@@ -309,32 +305,16 @@ static inline struct isci_pci_info *to_pci_info(struct pci_dev *pdev)
         return pci_get_drvdata(pdev);
 }
 
+static inline struct Scsi_Host *to_shost(struct isci_host *ihost)
+{
+        return ihost->sas_ha.core.shost;
+}
+
 #define for_each_isci_host(id, ihost, pdev) \
         for (id = 0, ihost = to_pci_info(pdev)->hosts[id]; \
              id < ARRAY_SIZE(to_pci_info(pdev)->hosts) && ihost; \
              ihost = to_pci_info(pdev)->hosts[++id])
 
-static inline enum isci_status isci_host_get_state(struct isci_host *isci_host)
-{
-        return isci_host->status;
-}
-
-static inline void isci_host_change_state(struct isci_host *isci_host,
-                                          enum isci_status status)
-{
-        unsigned long flags;
-
-        dev_dbg(&isci_host->pdev->dev,
-                "%s: isci_host = %p, state = 0x%x",
-                __func__,
-                isci_host,
-                status);
-        spin_lock_irqsave(&isci_host->state_lock, flags);
-        isci_host->status = status;
-        spin_unlock_irqrestore(&isci_host->state_lock, flags);
-
-}
-
 static inline void wait_for_start(struct isci_host *ihost)
 {
         wait_event(ihost->eventq, !test_bit(IHOST_START_PENDING, &ihost->flags));
@@ -360,6 +340,11 @@ static inline struct isci_host *dev_to_ihost(struct domain_device *dev)
         return dev->port->ha->lldd_ha;
 }
 
+static inline struct isci_host *idev_to_ihost(struct isci_remote_device *idev)
+{
+        return dev_to_ihost(idev->domain_dev);
+}
+
 /* we always use protocol engine group zero */
 #define ISCI_PEG 0
 
@@ -378,8 +363,7 @@ static inline int sci_remote_device_node_count(struct isci_remote_device *idev)
 {
         struct domain_device *dev = idev->domain_dev;
 
-        if ((dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP)) &&
-            !idev->is_direct_attached)
+        if (dev_is_sata(dev) && dev->parent)
                 return SCU_STP_REMOTE_NODE_COUNT;
         return SCU_SSP_REMOTE_NODE_COUNT;
 }
@@ -475,36 +459,17 @@ void sci_controller_free_remote_node_context(
         struct isci_remote_device *idev,
         u16 node_id);
 
-struct isci_request *sci_request_by_tag(struct isci_host *ihost,
-                                             u16 io_tag);
-
-void sci_controller_power_control_queue_insert(
-        struct isci_host *ihost,
-        struct isci_phy *iphy);
-
-void sci_controller_power_control_queue_remove(
-        struct isci_host *ihost,
-        struct isci_phy *iphy);
-
-void sci_controller_link_up(
-        struct isci_host *ihost,
-        struct isci_port *iport,
-        struct isci_phy *iphy);
-
-void sci_controller_link_down(
-        struct isci_host *ihost,
-        struct isci_port *iport,
-        struct isci_phy *iphy);
-
-void sci_controller_remote_device_stopped(
-        struct isci_host *ihost,
-        struct isci_remote_device *idev);
-
-void sci_controller_copy_task_context(
-        struct isci_host *ihost,
-        struct isci_request *ireq);
-
-void sci_controller_register_setup(struct isci_host *ihost);
+struct isci_request *sci_request_by_tag(struct isci_host *ihost, u16 io_tag);
+void sci_controller_power_control_queue_insert(struct isci_host *ihost,
+                                               struct isci_phy *iphy);
+void sci_controller_power_control_queue_remove(struct isci_host *ihost,
+                                               struct isci_phy *iphy);
+void sci_controller_link_up(struct isci_host *ihost, struct isci_port *iport,
+                            struct isci_phy *iphy);
+void sci_controller_link_down(struct isci_host *ihost, struct isci_port *iport,
+                              struct isci_phy *iphy);
+void sci_controller_remote_device_stopped(struct isci_host *ihost,
+                                          struct isci_remote_device *idev);
 
 enum sci_status sci_controller_continue_io(struct isci_request *ireq);
 int isci_host_scan_finished(struct Scsi_Host *, unsigned long);
@@ -512,29 +477,14 @@ void isci_host_scan_start(struct Scsi_Host *);
 u16 isci_alloc_tag(struct isci_host *ihost);
 enum sci_status isci_free_tag(struct isci_host *ihost, u16 io_tag);
 void isci_tci_free(struct isci_host *ihost, u16 tci);
+void ireq_done(struct isci_host *ihost, struct isci_request *ireq, struct sas_task *task);
 
 int isci_host_init(struct isci_host *);
-
-void isci_host_init_controller_names(
-        struct isci_host *isci_host,
-        unsigned int controller_idx);
-
-void isci_host_deinit(
-        struct isci_host *);
-
-void isci_host_port_link_up(
-        struct isci_host *,
-        struct isci_port *,
-        struct isci_phy *);
-int isci_host_dev_found(struct domain_device *);
-
-void isci_host_remote_device_start_complete(
-        struct isci_host *,
-        struct isci_remote_device *,
-        enum sci_status);
-
-void sci_controller_disable_interrupts(
-        struct isci_host *ihost);
+void isci_host_completion_routine(unsigned long data);
+void isci_host_deinit(struct isci_host *);
+void sci_controller_disable_interrupts(struct isci_host *ihost);
+bool sci_controller_has_remote_devices_stopping(struct isci_host *ihost);
+void sci_controller_transition_to_ready(struct isci_host *ihost, enum sci_status status);
 
 enum sci_status sci_controller_start_io(
         struct isci_host *ihost,
diff --git a/drivers/scsi/isci/init.c b/drivers/scsi/isci/init.c
index 5137db5a5d85..47e28b555029 100644
--- a/drivers/scsi/isci/init.c
+++ b/drivers/scsi/isci/init.c
@@ -271,13 +271,12 @@ static void isci_unregister(struct isci_host *isci_host)
         if (!isci_host)
                 return;
 
-        shost = isci_host->shost;
-
         sas_unregister_ha(&isci_host->sas_ha);
 
-        sas_remove_host(isci_host->shost);
-        scsi_remove_host(isci_host->shost);
-        scsi_host_put(isci_host->shost);
+        shost = to_shost(isci_host);
+        sas_remove_host(shost);
+        scsi_remove_host(shost);
+        scsi_host_put(shost);
 }
 
 static int __devinit isci_pci_init(struct pci_dev *pdev)
@@ -397,38 +396,199 @@ static int isci_setup_interrupts(struct pci_dev *pdev)
         return err;
 }
 
+static void isci_user_parameters_get(struct sci_user_parameters *u)
+{
+        int i;
+
+        for (i = 0; i < SCI_MAX_PHYS; i++) {
+                struct sci_phy_user_params *u_phy = &u->phys[i];
+
+                u_phy->max_speed_generation = phy_gen;
+
+                /* we are not exporting these for now */
+                u_phy->align_insertion_frequency = 0x7f;
+                u_phy->in_connection_align_insertion_frequency = 0xff;
+                u_phy->notify_enable_spin_up_insertion_frequency = 0x33;
+        }
+
+        u->stp_inactivity_timeout = stp_inactive_to;
+        u->ssp_inactivity_timeout = ssp_inactive_to;
+        u->stp_max_occupancy_timeout = stp_max_occ_to;
+        u->ssp_max_occupancy_timeout = ssp_max_occ_to;
+        u->no_outbound_task_timeout = no_outbound_task_to;
+        u->max_concurr_spinup = max_concurr_spinup;
+}
+
+static enum sci_status sci_user_parameters_set(struct isci_host *ihost,
+                                               struct sci_user_parameters *sci_parms)
+{
+        u16 index;
+
+        /*
+         * Validate the user parameters.  If they are not legal, then
+         * return a failure.
+         */
+        for (index = 0; index < SCI_MAX_PHYS; index++) {
+                struct sci_phy_user_params *u;
+
+                u = &sci_parms->phys[index];
+
+                if (!((u->max_speed_generation <= SCIC_SDS_PARM_MAX_SPEED) &&
+                      (u->max_speed_generation > SCIC_SDS_PARM_NO_SPEED)))
+                        return SCI_FAILURE_INVALID_PARAMETER_VALUE;
+
+                if (u->in_connection_align_insertion_frequency < 3)
+                        return SCI_FAILURE_INVALID_PARAMETER_VALUE;
+
+                if ((u->in_connection_align_insertion_frequency < 3) ||
+                    (u->align_insertion_frequency == 0) ||
+                    (u->notify_enable_spin_up_insertion_frequency == 0))
+                        return SCI_FAILURE_INVALID_PARAMETER_VALUE;
+        }
+
+        if ((sci_parms->stp_inactivity_timeout == 0) ||
+            (sci_parms->ssp_inactivity_timeout == 0) ||
+            (sci_parms->stp_max_occupancy_timeout == 0) ||
+            (sci_parms->ssp_max_occupancy_timeout == 0) ||
+            (sci_parms->no_outbound_task_timeout == 0))
+                return SCI_FAILURE_INVALID_PARAMETER_VALUE;
+
+        memcpy(&ihost->user_parameters, sci_parms, sizeof(*sci_parms));
+
+        return SCI_SUCCESS;
+}
+
+static void sci_oem_defaults(struct isci_host *ihost)
+{
+        /* these defaults are overridden by the platform / firmware */
+        struct sci_user_parameters *user = &ihost->user_parameters;
+        struct sci_oem_params *oem = &ihost->oem_parameters;
+        int i;
+
+        /* Default to APC mode. */
+        oem->controller.mode_type = SCIC_PORT_AUTOMATIC_CONFIGURATION_MODE;
+
+        /* Default to APC mode. */
+        oem->controller.max_concurr_spin_up = 1;
+
+        /* Default to no SSC operation. */
+        oem->controller.do_enable_ssc = false;
+
+        /* Default to short cables on all phys. */
+        oem->controller.cable_selection_mask = 0;
+
+        /* Initialize all of the port parameter information to narrow ports. */
+        for (i = 0; i < SCI_MAX_PORTS; i++)
+                oem->ports[i].phy_mask = 0;
+
+        /* Initialize all of the phy parameter information. */
+        for (i = 0; i < SCI_MAX_PHYS; i++) {
+                /* Default to 3G (i.e. Gen 2). */
+                user->phys[i].max_speed_generation = SCIC_SDS_PARM_GEN2_SPEED;
+
+                /* the frequencies cannot be 0 */
+                user->phys[i].align_insertion_frequency = 0x7f;
+                user->phys[i].in_connection_align_insertion_frequency = 0xff;
+                user->phys[i].notify_enable_spin_up_insertion_frequency = 0x33;
+
+                /* Previous Vitesse based expanders had a arbitration issue that
+                 * is worked around by having the upper 32-bits of SAS address
+                 * with a value greater then the Vitesse company identifier.
+                 * Hence, usage of 0x5FCFFFFF.
+                 */
+                oem->phys[i].sas_address.low = 0x1 + ihost->id;
+                oem->phys[i].sas_address.high = 0x5FCFFFFF;
+        }
+
+        user->stp_inactivity_timeout = 5;
+        user->ssp_inactivity_timeout = 5;
+        user->stp_max_occupancy_timeout = 5;
+        user->ssp_max_occupancy_timeout = 20;
+        user->no_outbound_task_timeout = 2;
+}
+
 static struct isci_host *isci_host_alloc(struct pci_dev *pdev, int id)
 {
-        struct isci_host *isci_host;
+        struct isci_orom *orom = to_pci_info(pdev)->orom;
+        struct sci_user_parameters sci_user_params;
+        u8 oem_version = ISCI_ROM_VER_1_0;
+        struct isci_host *ihost;
         struct Scsi_Host *shost;
-        int err;
+        int err, i;
 
-        isci_host = devm_kzalloc(&pdev->dev, sizeof(*isci_host), GFP_KERNEL);
-        if (!isci_host)
+        ihost = devm_kzalloc(&pdev->dev, sizeof(*ihost), GFP_KERNEL);
+        if (!ihost)
                 return NULL;
 
-        isci_host->pdev = pdev;
-        isci_host->id = id;
+        ihost->pdev = pdev;
+        ihost->id = id;
+        spin_lock_init(&ihost->scic_lock);
+        init_waitqueue_head(&ihost->eventq);
+        ihost->sas_ha.dev = &ihost->pdev->dev;
+        ihost->sas_ha.lldd_ha = ihost;
+        tasklet_init(&ihost->completion_tasklet,
+                     isci_host_completion_routine, (unsigned long)ihost);
+
+        /* validate module parameters */
+        /* TODO: kill struct sci_user_parameters and reference directly */
+        sci_oem_defaults(ihost);
+        isci_user_parameters_get(&sci_user_params);
+        if (sci_user_parameters_set(ihost, &sci_user_params)) {
+                dev_warn(&pdev->dev,
+                         "%s: sci_user_parameters_set failed\n", __func__);
+                return NULL;
+        }
+
+        /* sanity check platform (or 'firmware') oem parameters */
+        if (orom) {
+                if (id < 0 || id >= SCI_MAX_CONTROLLERS || id > orom->hdr.num_elements) {
+                        dev_warn(&pdev->dev, "parsing firmware oem parameters failed\n");
+                        return NULL;
+                }
+                ihost->oem_parameters = orom->ctrl[id];
+                oem_version = orom->hdr.version;
+        }
+
+        /* validate oem parameters (platform, firmware, or built-in defaults) */
+        if (sci_oem_parameters_validate(&ihost->oem_parameters, oem_version)) {
+                dev_warn(&pdev->dev, "oem parameter validation failed\n");
+                return NULL;
+        }
+
+        for (i = 0; i < SCI_MAX_PORTS; i++) {
+                struct isci_port *iport = &ihost->ports[i];
+
+                INIT_LIST_HEAD(&iport->remote_dev_list);
+                iport->isci_host = ihost;
+        }
+
+        for (i = 0; i < SCI_MAX_PHYS; i++)
+                isci_phy_init(&ihost->phys[i], ihost, i);
+
+        for (i = 0; i < SCI_MAX_REMOTE_DEVICES; i++) {
+                struct isci_remote_device *idev = &ihost->devices[i];
+
+                INIT_LIST_HEAD(&idev->node);
+        }
 
         shost = scsi_host_alloc(&isci_sht, sizeof(void *));
         if (!shost)
                 return NULL;
-        isci_host->shost = shost;
 
         dev_info(&pdev->dev, "%sSCU controller %d: phy 3-0 cables: "
                  "{%s, %s, %s, %s}\n",
-                 (is_cable_select_overridden() ? "* " : ""), isci_host->id,
-                 lookup_cable_names(decode_cable_selection(isci_host, 3)),
-                 lookup_cable_names(decode_cable_selection(isci_host, 2)),
-                 lookup_cable_names(decode_cable_selection(isci_host, 1)),
-                 lookup_cable_names(decode_cable_selection(isci_host, 0)));
+                 (is_cable_select_overridden() ? "* " : ""), ihost->id,
+                 lookup_cable_names(decode_cable_selection(ihost, 3)),
+                 lookup_cable_names(decode_cable_selection(ihost, 2)),
+                 lookup_cable_names(decode_cable_selection(ihost, 1)),
+                 lookup_cable_names(decode_cable_selection(ihost, 0)));
 
-        err = isci_host_init(isci_host);
+        err = isci_host_init(ihost);
         if (err)
                 goto err_shost;
 
-        SHOST_TO_SAS_HA(shost) = &isci_host->sas_ha;
-        isci_host->sas_ha.core.shost = shost;
+        SHOST_TO_SAS_HA(shost) = &ihost->sas_ha;
+        ihost->sas_ha.core.shost = shost;
         shost->transportt = isci_transport_template;
 
         shost->max_id = ~0;
@@ -439,11 +599,11 @@ static struct isci_host *isci_host_alloc(struct pci_dev *pdev, int id)
         if (err)
                 goto err_shost;
 
-        err = isci_register_sas_ha(isci_host);
+        err = isci_register_sas_ha(ihost);
         if (err)
                 goto err_shost_remove;
 
-        return isci_host;
+        return ihost;
 
  err_shost_remove:
         scsi_remove_host(shost);
@@ -476,7 +636,7 @@ static int __devinit isci_pci_probe(struct pci_dev *pdev, const struct pci_devic
         if (!orom)
                 orom = isci_request_oprom(pdev);
 
-        for (i = 0; orom && i < ARRAY_SIZE(orom->ctrl); i++) {
+        for (i = 0; orom && i < num_controllers(pdev); i++) {
                 if (sci_oem_parameters_validate(&orom->ctrl[i],
                                                 orom->hdr.version)) {
                         dev_warn(&pdev->dev,
@@ -525,11 +685,11 @@ static int __devinit isci_pci_probe(struct pci_dev *pdev, const struct pci_devic
                 pci_info->hosts[i] = h;
 
                 /* turn on DIF support */
-                scsi_host_set_prot(h->shost,
+                scsi_host_set_prot(to_shost(h),
                                    SHOST_DIF_TYPE1_PROTECTION |
                                    SHOST_DIF_TYPE2_PROTECTION |
                                    SHOST_DIF_TYPE3_PROTECTION);
-                scsi_host_set_guard(h->shost, SHOST_DIX_GUARD_CRC);
+                scsi_host_set_guard(to_shost(h), SHOST_DIX_GUARD_CRC);
         }
 
         err = isci_setup_interrupts(pdev);
@@ -537,7 +697,7 @@ static int __devinit isci_pci_probe(struct pci_dev *pdev, const struct pci_devic
                 goto err_host_alloc;
 
         for_each_isci_host(i, isci_host, pdev)
-                scsi_scan_host(isci_host->shost);
+                scsi_scan_host(to_shost(isci_host));
 
         return 0;
 
diff --git a/drivers/scsi/isci/phy.c b/drivers/scsi/isci/phy.c
index fab3586840b5..18f43d4c30ba 100644
--- a/drivers/scsi/isci/phy.c
+++ b/drivers/scsi/isci/phy.c
@@ -580,7 +580,7 @@ static void sci_phy_start_sas_link_training(struct isci_phy *iphy)
 
         sci_change_state(&iphy->sm, SCI_PHY_SUB_AWAIT_SAS_SPEED_EN);
 
-        iphy->protocol = SCIC_SDS_PHY_PROTOCOL_SAS;
+        iphy->protocol = SAS_PROTOCOL_SSP;
 }
 
 static void sci_phy_start_sata_link_training(struct isci_phy *iphy)
@@ -591,7 +591,7 @@ static void sci_phy_start_sata_link_training(struct isci_phy *iphy)
          */
         sci_change_state(&iphy->sm, SCI_PHY_SUB_AWAIT_SATA_POWER);
 
-        iphy->protocol = SCIC_SDS_PHY_PROTOCOL_SATA;
+        iphy->protocol = SAS_PROTOCOL_SATA;
 }
 
 /**
@@ -668,6 +668,19 @@ static const char *phy_event_name(u32 event_code)
                 phy_to_host(iphy)->id, iphy->phy_index, \
                 phy_state_name(state), phy_event_name(code), code)
 
+
+void scu_link_layer_set_txcomsas_timeout(struct isci_phy *iphy, u32 timeout)
+{
+        u32 val;
+
+        /* Extend timeout */
+        val = readl(&iphy->link_layer_registers->transmit_comsas_signal);
+        val &= ~SCU_SAS_LLTXCOMSAS_GEN_VAL(NEGTIME, SCU_SAS_LINK_LAYER_TXCOMSAS_NEGTIME_MASK);
+        val |= SCU_SAS_LLTXCOMSAS_GEN_VAL(NEGTIME, timeout);
+
+        writel(val, &iphy->link_layer_registers->transmit_comsas_signal);
+}
+
 enum sci_status sci_phy_event_handler(struct isci_phy *iphy, u32 event_code)
 {
         enum sci_phy_states state = iphy->sm.current_state_id;
@@ -683,6 +696,13 @@ enum sci_status sci_phy_event_handler(struct isci_phy *iphy, u32 event_code)
                         sci_phy_start_sata_link_training(iphy);
                         iphy->is_in_link_training = true;
                         break;
+                case SCU_EVENT_RECEIVED_IDENTIFY_TIMEOUT:
+                       /* Extend timeout value */
+                       scu_link_layer_set_txcomsas_timeout(iphy, SCU_SAS_LINK_LAYER_TXCOMSAS_NEGTIME_EXTENDED);
+
+                       /* Start the oob/sn state machine over again */
+                       sci_change_state(&iphy->sm, SCI_PHY_STARTING);
+                       break;
                 default:
                         phy_event_dbg(iphy, state, event_code);
                         return SCI_FAILURE;
@@ -717,9 +737,19 @@ enum sci_status sci_phy_event_handler(struct isci_phy *iphy, u32 event_code)
                         sci_phy_start_sata_link_training(iphy);
                         break;
                 case SCU_EVENT_LINK_FAILURE:
+                        /* Change the timeout value to default */
+                        scu_link_layer_set_txcomsas_timeout(iphy, SCU_SAS_LINK_LAYER_TXCOMSAS_NEGTIME_DEFAULT);
+
                         /* Link failure change state back to the starting state */
                         sci_change_state(&iphy->sm, SCI_PHY_STARTING);
                         break;
+                case SCU_EVENT_RECEIVED_IDENTIFY_TIMEOUT:
+                       /* Extend the timeout value */
+                       scu_link_layer_set_txcomsas_timeout(iphy, SCU_SAS_LINK_LAYER_TXCOMSAS_NEGTIME_EXTENDED);
+
+                       /* Start the oob/sn state machine over again */
+                       sci_change_state(&iphy->sm, SCI_PHY_STARTING);
+                       break;
                 default:
                         phy_event_warn(iphy, state, event_code);
                         return SCI_FAILURE;
@@ -740,7 +770,14 @@ enum sci_status sci_phy_event_handler(struct isci_phy *iphy, u32 event_code)
                         sci_phy_start_sata_link_training(iphy);
                         break;
                 case SCU_EVENT_RECEIVED_IDENTIFY_TIMEOUT:
+                        /* Extend the timeout value */
+                        scu_link_layer_set_txcomsas_timeout(iphy, SCU_SAS_LINK_LAYER_TXCOMSAS_NEGTIME_EXTENDED);
+
+                        /* Start the oob/sn state machine over again */
+                        sci_change_state(&iphy->sm, SCI_PHY_STARTING);
+                        break;
                 case SCU_EVENT_LINK_FAILURE:
+                        scu_link_layer_set_txcomsas_timeout(iphy, SCU_SAS_LINK_LAYER_TXCOMSAS_NEGTIME_DEFAULT);
                 case SCU_EVENT_HARD_RESET_RECEIVED:
                         /* Start the oob/sn state machine over again */
                         sci_change_state(&iphy->sm, SCI_PHY_STARTING);
@@ -753,6 +790,9 @@ enum sci_status sci_phy_event_handler(struct isci_phy *iphy, u32 event_code)
         case SCI_PHY_SUB_AWAIT_SAS_POWER:
                 switch (scu_get_event_code(event_code)) {
                 case SCU_EVENT_LINK_FAILURE:
+                        /* Change the timeout value to default */
+                        scu_link_layer_set_txcomsas_timeout(iphy, SCU_SAS_LINK_LAYER_TXCOMSAS_NEGTIME_DEFAULT);
+
                         /* Link failure change state back to the starting state */
                         sci_change_state(&iphy->sm, SCI_PHY_STARTING);
                         break;
@@ -764,6 +804,9 @@ enum sci_status sci_phy_event_handler(struct isci_phy *iphy, u32 event_code)
         case SCI_PHY_SUB_AWAIT_SATA_POWER:
                 switch (scu_get_event_code(event_code)) {
                 case SCU_EVENT_LINK_FAILURE:
+                        /* Change the timeout value to default */
+                        scu_link_layer_set_txcomsas_timeout(iphy, SCU_SAS_LINK_LAYER_TXCOMSAS_NEGTIME_DEFAULT);
+
                         /* Link failure change state back to the starting state */
                         sci_change_state(&iphy->sm, SCI_PHY_STARTING);
                         break;
@@ -788,6 +831,9 @@ enum sci_status sci_phy_event_handler(struct isci_phy *iphy, u32 event_code)
         case SCI_PHY_SUB_AWAIT_SATA_PHY_EN:
                 switch (scu_get_event_code(event_code)) {
                 case SCU_EVENT_LINK_FAILURE:
+                        /* Change the timeout value to default */
+                        scu_link_layer_set_txcomsas_timeout(iphy, SCU_SAS_LINK_LAYER_TXCOMSAS_NEGTIME_DEFAULT);
+
                         /* Link failure change state back to the starting state */
                         sci_change_state(&iphy->sm, SCI_PHY_STARTING);
                         break;
@@ -797,7 +843,7 @@ enum sci_status sci_phy_event_handler(struct isci_phy *iphy, u32 event_code)
                          */
                         break;
                 case SCU_EVENT_SATA_PHY_DETECTED:
-                        iphy->protocol = SCIC_SDS_PHY_PROTOCOL_SATA;
+                        iphy->protocol = SAS_PROTOCOL_SATA;
 
                         /* We have received the SATA PHY notification change state */
                         sci_change_state(&iphy->sm, SCI_PHY_SUB_AWAIT_SATA_SPEED_EN);
@@ -836,6 +882,9 @@ enum sci_status sci_phy_event_handler(struct isci_phy *iphy, u32 event_code)
                                                        SCI_PHY_SUB_AWAIT_SIG_FIS_UF);
                         break;
                 case SCU_EVENT_LINK_FAILURE:
+                        /* Change the timeout value to default */
+                        scu_link_layer_set_txcomsas_timeout(iphy, SCU_SAS_LINK_LAYER_TXCOMSAS_NEGTIME_DEFAULT);
+
                         /* Link failure change state back to the starting state */
                         sci_change_state(&iphy->sm, SCI_PHY_STARTING);
                         break;
@@ -859,6 +908,9 @@ enum sci_status sci_phy_event_handler(struct isci_phy *iphy, u32 event_code)
                         break;
 
                 case SCU_EVENT_LINK_FAILURE:
+                        /* Change the timeout value to default */
+                        scu_link_layer_set_txcomsas_timeout(iphy, SCU_SAS_LINK_LAYER_TXCOMSAS_NEGTIME_DEFAULT);
+
                         /* Link failure change state back to the starting state */
                         sci_change_state(&iphy->sm, SCI_PHY_STARTING);
                         break;
@@ -871,16 +923,26 @@ enum sci_status sci_phy_event_handler(struct isci_phy *iphy, u32 event_code)
         case SCI_PHY_READY:
                 switch (scu_get_event_code(event_code)) {
                 case SCU_EVENT_LINK_FAILURE:
+                        /* Set default timeout */
+                        scu_link_layer_set_txcomsas_timeout(iphy, SCU_SAS_LINK_LAYER_TXCOMSAS_NEGTIME_DEFAULT);
+
                         /* Link failure change state back to the starting state */
                         sci_change_state(&iphy->sm, SCI_PHY_STARTING);
                         break;
                 case SCU_EVENT_BROADCAST_CHANGE:
+                case SCU_EVENT_BROADCAST_SES:
+                case SCU_EVENT_BROADCAST_RESERVED0:
+                case SCU_EVENT_BROADCAST_RESERVED1:
+                case SCU_EVENT_BROADCAST_EXPANDER:
+                case SCU_EVENT_BROADCAST_AEN:
                         /* Broadcast change received. Notify the port. */
                         if (phy_get_non_dummy_port(iphy) != NULL)
                                 sci_port_broadcast_change_received(iphy->owning_port, iphy);
                         else
                                 iphy->bcn_received_while_port_unassigned = true;
                         break;
+                case SCU_EVENT_BROADCAST_RESERVED3:
+                case SCU_EVENT_BROADCAST_RESERVED4:
                 default:
                         phy_event_warn(iphy, state, event_code);
                         return SCI_FAILURE_INVALID_STATE;
@@ -1215,7 +1277,7 @@ static void sci_phy_starting_state_enter(struct sci_base_state_machine *sm)
         scu_link_layer_start_oob(iphy);
 
         /* We don't know what kind of phy we are going to be just yet */
-        iphy->protocol = SCIC_SDS_PHY_PROTOCOL_UNKNOWN;
+        iphy->protocol = SAS_PROTOCOL_NONE;
         iphy->bcn_received_while_port_unassigned = false;
 
         if (iphy->sm.previous_state_id == SCI_PHY_READY)
@@ -1250,7 +1312,7 @@ static void sci_phy_resetting_state_enter(struct sci_base_state_machine *sm)
          */
         sci_port_deactivate_phy(iphy->owning_port, iphy, false);
 
-        if (iphy->protocol == SCIC_SDS_PHY_PROTOCOL_SAS) {
+        if (iphy->protocol == SAS_PROTOCOL_SSP) {
                 scu_link_layer_tx_hard_reset(iphy);
         } else {
                 /* The SCU does not need to have a discrete reset state so
@@ -1316,7 +1378,7 @@ void sci_phy_construct(struct isci_phy *iphy,
         iphy->owning_port = iport;
         iphy->phy_index = phy_index;
         iphy->bcn_received_while_port_unassigned = false;
-        iphy->protocol = SCIC_SDS_PHY_PROTOCOL_UNKNOWN;
+        iphy->protocol = SAS_PROTOCOL_NONE;
         iphy->link_layer_registers = NULL;
         iphy->max_negotiated_speed = SAS_LINK_RATE_UNKNOWN;
 
@@ -1380,12 +1442,14 @@ int isci_phy_control(struct asd_sas_phy *sas_phy,
         switch (func) {
         case PHY_FUNC_DISABLE:
                 spin_lock_irqsave(&ihost->scic_lock, flags);
+                scu_link_layer_start_oob(iphy);
                 sci_phy_stop(iphy);
                 spin_unlock_irqrestore(&ihost->scic_lock, flags);
                 break;
 
         case PHY_FUNC_LINK_RESET:
                 spin_lock_irqsave(&ihost->scic_lock, flags);
+                scu_link_layer_start_oob(iphy);
                 sci_phy_stop(iphy);
                 sci_phy_start(iphy);
                 spin_unlock_irqrestore(&ihost->scic_lock, flags);
diff --git a/drivers/scsi/isci/phy.h b/drivers/scsi/isci/phy.h
index 0e45833ba06d..45fecfa36a98 100644
--- a/drivers/scsi/isci/phy.h
+++ b/drivers/scsi/isci/phy.h
@@ -76,13 +76,6 @@
  */
 #define SCIC_SDS_SATA_LINK_TRAINING_TIMEOUT  250
 
-enum sci_phy_protocol {
-        SCIC_SDS_PHY_PROTOCOL_UNKNOWN,
-        SCIC_SDS_PHY_PROTOCOL_SAS,
-        SCIC_SDS_PHY_PROTOCOL_SATA,
-        SCIC_SDS_MAX_PHY_PROTOCOLS
-};
-
 /**
  * isci_phy - hba local phy infrastructure
  * @sm:
@@ -95,7 +88,7 @@ struct isci_phy {
         struct sci_base_state_machine sm;
         struct isci_port *owning_port;
         enum sas_linkrate max_negotiated_speed;
-        enum sci_phy_protocol protocol;
+        enum sas_protocol protocol;
         u8 phy_index;
         bool bcn_received_while_port_unassigned;
         bool is_in_link_training;
diff --git a/drivers/scsi/isci/port.c b/drivers/scsi/isci/port.c
index 5fada73b71ff..2fb85bf75449 100644
--- a/drivers/scsi/isci/port.c
+++ b/drivers/scsi/isci/port.c
@@ -184,7 +184,7 @@ static void isci_port_link_up(struct isci_host *isci_host,
 
         sci_port_get_properties(iport, &properties);
 
-        if (iphy->protocol == SCIC_SDS_PHY_PROTOCOL_SATA) {
+        if (iphy->protocol == SAS_PROTOCOL_SATA) {
                 u64 attached_sas_address;
 
                 iphy->sas_phy.oob_mode = SATA_OOB_MODE;
@@ -204,7 +204,7 @@ static void isci_port_link_up(struct isci_host *isci_host,
 
                 memcpy(&iphy->sas_phy.attached_sas_addr,
                        &attached_sas_address, sizeof(attached_sas_address));
-        } else if (iphy->protocol == SCIC_SDS_PHY_PROTOCOL_SAS) {
+        } else if (iphy->protocol == SAS_PROTOCOL_SSP) {
                 iphy->sas_phy.oob_mode = SAS_OOB_MODE;
                 iphy->sas_phy.frame_rcvd_size = sizeof(struct sas_identify_frame);
 
@@ -251,10 +251,10 @@ static void isci_port_link_down(struct isci_host *isci_host,
                 if (isci_phy->sas_phy.port &&
                     isci_phy->sas_phy.port->num_phys == 1) {
                         /* change the state for all devices on this port.  The
-                         * next task sent to this device will be returned as
-                         * SAS_TASK_UNDELIVERED, and the scsi mid layer will
-                         * remove the target
-                         */
+                        * next task sent to this device will be returned as
+                        * SAS_TASK_UNDELIVERED, and the scsi mid layer will
+                        * remove the target
+                        */
                         list_for_each_entry(isci_device,
                                             &isci_port->remote_dev_list,
                                             node) {
@@ -517,7 +517,7 @@ void sci_port_get_attached_sas_address(struct isci_port *iport, struct sci_sas_a
          */
         iphy = sci_port_get_a_connected_phy(iport);
         if (iphy) {
-                if (iphy->protocol != SCIC_SDS_PHY_PROTOCOL_SATA) {
+                if (iphy->protocol != SAS_PROTOCOL_SATA) {
                         sci_phy_get_attached_sas_address(iphy, sas);
                 } else {
                         sci_phy_get_sas_address(iphy, sas);
@@ -624,7 +624,7 @@ static void sci_port_activate_phy(struct isci_port *iport,
 {
         struct isci_host *ihost = iport->owning_controller;
 
-        if (iphy->protocol != SCIC_SDS_PHY_PROTOCOL_SATA && (flags & PF_RESUME))
+        if (iphy->protocol != SAS_PROTOCOL_SATA && (flags & PF_RESUME))
                 sci_phy_resume(iphy);
 
         iport->active_phy_mask |= 1 << iphy->phy_index;
@@ -751,12 +751,10 @@ static bool sci_port_is_wide(struct isci_port *iport)
  * wide ports and direct attached phys.  Since there are no wide ported SATA
  * devices this could become an invalid port configuration.
  */
-bool sci_port_link_detected(
-        struct isci_port *iport,
-        struct isci_phy *iphy)
+bool sci_port_link_detected(struct isci_port *iport, struct isci_phy *iphy)
 {
         if ((iport->logical_port_index != SCIC_SDS_DUMMY_PORT) &&
-            (iphy->protocol == SCIC_SDS_PHY_PROTOCOL_SATA)) {
+            (iphy->protocol == SAS_PROTOCOL_SATA)) {
                 if (sci_port_is_wide(iport)) {
                         sci_port_invalid_link_up(iport, iphy);
                         return false;
@@ -1201,6 +1199,8 @@ enum sci_status sci_port_add_phy(struct isci_port *iport,
         enum sci_status status;
         enum sci_port_states state;
 
+        sci_port_bcn_enable(iport);
+
         state = iport->sm.current_state_id;
         switch (state) {
         case SCI_PORT_STOPPED: {
@@ -1548,6 +1548,29 @@ static void sci_port_failed_state_enter(struct sci_base_state_machine *sm)
         isci_port_hard_reset_complete(iport, SCI_FAILURE_TIMEOUT);
 }
 
+void sci_port_set_hang_detection_timeout(struct isci_port *iport, u32 timeout)
+{
+        int phy_index;
+        u32 phy_mask = iport->active_phy_mask;
+
+        if (timeout)
+                ++iport->hang_detect_users;
+        else if (iport->hang_detect_users > 1)
+                --iport->hang_detect_users;
+        else
+                iport->hang_detect_users = 0;
+
+        if (timeout || (iport->hang_detect_users == 0)) {
+                for (phy_index = 0; phy_index < SCI_MAX_PHYS; phy_index++) {
+                        if ((phy_mask >> phy_index) & 1) {
+                                writel(timeout,
+                                       &iport->phy_table[phy_index]
+                                          ->link_layer_registers
+                                          ->link_layer_hang_detection_timeout);
+                        }
+                }
+        }
+}
 /* --------------------------------------------------------------------------- */
 
 static const struct sci_base_state sci_port_state_table[] = {
@@ -1596,6 +1619,7 @@ void sci_port_construct(struct isci_port *iport, u8 index,
 
         iport->started_request_count = 0;
         iport->assigned_device_count = 0;
+        iport->hang_detect_users = 0;
 
         iport->reserved_rni = SCU_DUMMY_INDEX;
         iport->reserved_tag = SCI_CONTROLLER_INVALID_IO_TAG;
@@ -1608,13 +1632,6 @@ void sci_port_construct(struct isci_port *iport, u8 index,
                 iport->phy_table[index] = NULL;
 }
 
-void isci_port_init(struct isci_port *iport, struct isci_host *ihost, int index)
-{
-        INIT_LIST_HEAD(&iport->remote_dev_list);
-        INIT_LIST_HEAD(&iport->domain_dev_list);
-        iport->isci_host = ihost;
-}
-
 void sci_port_broadcast_change_received(struct isci_port *iport, struct isci_phy *iphy)
 {
         struct isci_host *ihost = iport->owning_controller;
@@ -1671,17 +1688,6 @@ int isci_port_perform_hard_reset(struct isci_host *ihost, struct isci_port *ipor
                         __func__, iport, status);
 
         }
-
-        /* If the hard reset for the port has failed, consider this
-         * the same as link failures on all phys in the port.
-         */
-        if (ret != TMF_RESP_FUNC_COMPLETE) {
-
-                dev_err(&ihost->pdev->dev,
-                        "%s: iport = %p; hard reset failed "
-                        "(0x%x) - driving explicit link fail for all phys\n",
-                        __func__, iport, iport->hard_reset_status);
-        }
         return ret;
 }
 
@@ -1740,7 +1746,7 @@ void isci_port_formed(struct asd_sas_phy *phy)
         struct isci_host *ihost = phy->ha->lldd_ha;
         struct isci_phy *iphy = to_iphy(phy);
         struct asd_sas_port *port = phy->port;
-        struct isci_port *iport;
+        struct isci_port *iport = NULL;
         unsigned long flags;
         int i;
 
diff --git a/drivers/scsi/isci/port.h b/drivers/scsi/isci/port.h
index 6b56240c2051..861e8f72811b 100644
--- a/drivers/scsi/isci/port.h
+++ b/drivers/scsi/isci/port.h
@@ -97,7 +97,6 @@ enum isci_status {
 struct isci_port {
         struct isci_host *isci_host;
         struct list_head remote_dev_list;
-        struct list_head domain_dev_list;
         #define IPORT_RESET_PENDING 0
         unsigned long state;
         enum sci_status hard_reset_status;
@@ -112,6 +111,7 @@ struct isci_port {
         u16 reserved_tag;
         u32 started_request_count;
         u32 assigned_device_count;
+        u32 hang_detect_users;
         u32 not_ready_reason;
         struct isci_phy *phy_table[SCI_MAX_PHYS];
         struct isci_host *owning_controller;
@@ -270,14 +270,13 @@ void sci_port_get_attached_sas_address(
         struct isci_port *iport,
         struct sci_sas_address *sas_address);
 
+void sci_port_set_hang_detection_timeout(
+        struct isci_port *isci_port,
+        u32 timeout);
+
 void isci_port_formed(struct asd_sas_phy *);
 void isci_port_deformed(struct asd_sas_phy *);
 
-void isci_port_init(
-        struct isci_port *port,
-        struct isci_host *host,
-        int index);
-
 int isci_port_perform_hard_reset(struct isci_host *ihost, struct isci_port *iport,
                                  struct isci_phy *iphy);
 int isci_ata_check_ready(struct domain_device *dev);
diff --git a/drivers/scsi/isci/port_config.c b/drivers/scsi/isci/port_config.c
index 6d1e9544cbe5..cd962da4a57a 100644
--- a/drivers/scsi/isci/port_config.c
+++ b/drivers/scsi/isci/port_config.c
@@ -57,7 +57,7 @@
 
 #define SCIC_SDS_MPC_RECONFIGURATION_TIMEOUT    (10)
 #define SCIC_SDS_APC_RECONFIGURATION_TIMEOUT    (10)
-#define SCIC_SDS_APC_WAIT_LINK_UP_NOTIFICATION  (250)
+#define SCIC_SDS_APC_WAIT_LINK_UP_NOTIFICATION  (1000)
 
 enum SCIC_SDS_APC_ACTIVITY {
         SCIC_SDS_APC_SKIP_PHY,
@@ -472,13 +472,9 @@ sci_apc_agent_validate_phy_configuration(struct isci_host *ihost,
  * down event or a link up event where we can not yet tell to which a phy
  * belongs.
  */
-static void sci_apc_agent_start_timer(
-        struct sci_port_configuration_agent *port_agent,
-        u32 timeout)
+static void sci_apc_agent_start_timer(struct sci_port_configuration_agent *port_agent,
+                                      u32 timeout)
 {
-        if (port_agent->timer_pending)
-                sci_del_timer(&port_agent->timer);
-
         port_agent->timer_pending = true;
         sci_mod_timer(&port_agent->timer, timeout);
 }
@@ -697,6 +693,9 @@ static void apc_agent_timeout(unsigned long data)
                                                    &ihost->phys[index], false);
         }
 
+        if (is_controller_start_complete(ihost))
+                sci_controller_transition_to_ready(ihost, SCI_SUCCESS);
+
 done:
         spin_unlock_irqrestore(&ihost->scic_lock, flags);
 }
@@ -732,6 +731,11 @@ void sci_port_configuration_agent_construct(
         }
 }
 
+bool is_port_config_apc(struct isci_host *ihost)
+{
+        return ihost->port_agent.link_up_handler == sci_apc_agent_link_up;
+}
+
 enum sci_status sci_port_configuration_agent_initialize(
         struct isci_host *ihost,
         struct sci_port_configuration_agent *port_agent)
diff --git a/drivers/scsi/isci/probe_roms.c b/drivers/scsi/isci/probe_roms.c
index 9b8117b9d756..4d95654c3fd4 100644
--- a/drivers/scsi/isci/probe_roms.c
+++ b/drivers/scsi/isci/probe_roms.c
@@ -112,18 +112,6 @@ struct isci_orom *isci_request_oprom(struct pci_dev *pdev)
         return rom;
 }
 
-enum sci_status isci_parse_oem_parameters(struct sci_oem_params *oem,
-                                          struct isci_orom *orom, int scu_index)
-{
-        /* check for valid inputs */
-        if (scu_index < 0 || scu_index >= SCI_MAX_CONTROLLERS ||
-            scu_index > orom->hdr.num_elements || !oem)
-                return -EINVAL;
-
-        *oem = orom->ctrl[scu_index];
-        return 0;
-}
-
 struct isci_orom *isci_request_firmware(struct pci_dev *pdev, const struct firmware *fw)
 {
         struct isci_orom *orom = NULL, *data;
diff --git a/drivers/scsi/isci/probe_roms.h b/drivers/scsi/isci/probe_roms.h
index bb0e9d4d97c9..e08b578241f8 100644
--- a/drivers/scsi/isci/probe_roms.h
+++ b/drivers/scsi/isci/probe_roms.h
@@ -156,8 +156,6 @@ int sci_oem_parameters_validate(struct sci_oem_params *oem, u8 version);
 
 struct isci_orom;
 struct isci_orom *isci_request_oprom(struct pci_dev *pdev);
-enum sci_status isci_parse_oem_parameters(struct sci_oem_params *oem,
-                                          struct isci_orom *orom, int scu_index);
 struct isci_orom *isci_request_firmware(struct pci_dev *pdev, const struct firmware *fw);
 struct isci_orom *isci_get_efi_var(struct pci_dev *pdev);
 
diff --git a/drivers/scsi/isci/registers.h b/drivers/scsi/isci/registers.h
index 7eb0ccd45fe6..97f3ceb8d724 100644
--- a/drivers/scsi/isci/registers.h
+++ b/drivers/scsi/isci/registers.h
@@ -1239,6 +1239,14 @@ struct scu_transport_layer_registers {
 #define SCU_SAS_LLCTL_GEN_BIT(name) \
         SCU_GEN_BIT(SCU_SAS_LINK_LAYER_CONTROL_ ## name)
 
+#define SCU_SAS_LINK_LAYER_TXCOMSAS_NEGTIME_DEFAULT                     (0xF0)
+#define SCU_SAS_LINK_LAYER_TXCOMSAS_NEGTIME_EXTENDED                    (0x1FF)
+#define SCU_SAS_LINK_LAYER_TXCOMSAS_NEGTIME_SHIFT                       (0)
+#define SCU_SAS_LINK_LAYER_TXCOMSAS_NEGTIME_MASK                        (0x3FF)
+
+#define SCU_SAS_LLTXCOMSAS_GEN_VAL(name, value) \
+        SCU_GEN_VALUE(SCU_SAS_LINK_LAYER_TXCOMSAS_ ## name, value)
+
 
 /* #define SCU_FRXHECR_DCNT_OFFSET      0x00B0 */
 #define SCU_PSZGCR_OFFSET           0x00E4
diff --git a/drivers/scsi/isci/remote_device.c b/drivers/scsi/isci/remote_device.c
index 8f501b0a81d6..c3aa6c5457b9 100644
--- a/drivers/scsi/isci/remote_device.c
+++ b/drivers/scsi/isci/remote_device.c
@@ -72,46 +72,11 @@ const char *dev_state_name(enum sci_remote_device_states state)
 }
 #undef C
 
-/**
- * isci_remote_device_not_ready() - This function is called by the ihost when
- *    the remote device is not ready. We mark the isci device as ready (not
- *    "ready_for_io") and signal the waiting proccess.
- * @isci_host: This parameter specifies the isci host object.
- * @isci_device: This parameter specifies the remote device
- *
- * sci_lock is held on entrance to this function.
- */
-static void isci_remote_device_not_ready(struct isci_host *ihost,
-                                  struct isci_remote_device *idev, u32 reason)
+enum sci_status sci_remote_device_suspend(struct isci_remote_device *idev,
+                                          enum sci_remote_node_suspension_reasons reason)
 {
-        struct isci_request *ireq;
-
-        dev_dbg(&ihost->pdev->dev,
-                "%s: isci_device = %p\n", __func__, idev);
-
-        switch (reason) {
-        case SCIC_REMOTE_DEVICE_NOT_READY_STOP_REQUESTED:
-                set_bit(IDEV_GONE, &idev->flags);
-                break;
-        case SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED:
-                set_bit(IDEV_IO_NCQERROR, &idev->flags);
-
-                /* Kill all outstanding requests for the device. */
-                list_for_each_entry(ireq, &idev->reqs_in_process, dev_node) {
-
-                        dev_dbg(&ihost->pdev->dev,
-                                "%s: isci_device = %p request = %p\n",
-                                __func__, idev, ireq);
-
-                        sci_controller_terminate_request(ihost,
-                                                          idev,
-                                                          ireq);
-                }
-                /* Fall through into the default case... */
-        default:
-                clear_bit(IDEV_IO_READY, &idev->flags);
-                break;
-        }
+        return sci_remote_node_context_suspend(&idev->rnc, reason,
+                                               SCI_SOFTWARE_SUSPEND_EXPECTED_EVENT);
 }
 
 /**
@@ -133,18 +98,29 @@ static void isci_remote_device_ready(struct isci_host *ihost, struct isci_remote
                 wake_up(&ihost->eventq);
 }
 
-/* called once the remote node context is ready to be freed.
- * The remote device can now report that its stop operation is complete. none
- */
-static void rnc_destruct_done(void *_dev)
+static enum sci_status sci_remote_device_terminate_req(
+        struct isci_host *ihost,
+        struct isci_remote_device *idev,
+        int check_abort,
+        struct isci_request *ireq)
 {
-        struct isci_remote_device *idev = _dev;
+        if (!test_bit(IREQ_ACTIVE, &ireq->flags) ||
+            (ireq->target_device != idev) ||
+            (check_abort && !test_bit(IREQ_PENDING_ABORT, &ireq->flags)))
+                return SCI_SUCCESS;
 
-        BUG_ON(idev->started_request_count != 0);
-        sci_change_state(&idev->sm, SCI_DEV_STOPPED);
+        dev_dbg(&ihost->pdev->dev,
+                "%s: idev=%p; flags=%lx; req=%p; req target=%p\n",
+                __func__, idev, idev->flags, ireq, ireq->target_device);
+
+        set_bit(IREQ_ABORT_PATH_ACTIVE, &ireq->flags);
+
+        return sci_controller_terminate_request(ihost, idev, ireq);
 }
 
-static enum sci_status sci_remote_device_terminate_requests(struct isci_remote_device *idev)
+static enum sci_status sci_remote_device_terminate_reqs_checkabort(
+        struct isci_remote_device *idev,
+        int chk)
 {
         struct isci_host *ihost = idev->owning_port->owning_controller;
         enum sci_status status  = SCI_SUCCESS;
@@ -154,18 +130,210 @@ static enum sci_status sci_remote_device_terminate_requests(struct isci_remote_d
                 struct isci_request *ireq = ihost->reqs[i];
                 enum sci_status s;
 
-                if (!test_bit(IREQ_ACTIVE, &ireq->flags) ||
-                    ireq->target_device != idev)
-                        continue;
-
-                s = sci_controller_terminate_request(ihost, idev, ireq);
+                s = sci_remote_device_terminate_req(ihost, idev, chk, ireq);
                 if (s != SCI_SUCCESS)
                         status = s;
         }
+        return status;
+}
+
+static bool isci_compare_suspendcount(
+        struct isci_remote_device *idev,
+        u32 localcount)
+{
+        smp_rmb();
+
+        /* Check for a change in the suspend count, or the RNC
+         * being destroyed.
+         */
+        return (localcount != idev->rnc.suspend_count)
+            || sci_remote_node_context_is_being_destroyed(&idev->rnc);
+}
+
+static bool isci_check_reqterm(
+        struct isci_host *ihost,
+        struct isci_remote_device *idev,
+        struct isci_request *ireq,
+        u32 localcount)
+{
+        unsigned long flags;
+        bool res;
 
+        spin_lock_irqsave(&ihost->scic_lock, flags);
+        res = isci_compare_suspendcount(idev, localcount)
+                && !test_bit(IREQ_ABORT_PATH_ACTIVE, &ireq->flags);
+        spin_unlock_irqrestore(&ihost->scic_lock, flags);
+
+        return res;
+}
+
+static bool isci_check_devempty(
+        struct isci_host *ihost,
+        struct isci_remote_device *idev,
+        u32 localcount)
+{
+        unsigned long flags;
+        bool res;
+
+        spin_lock_irqsave(&ihost->scic_lock, flags);
+        res = isci_compare_suspendcount(idev, localcount)
+                && idev->started_request_count == 0;
+        spin_unlock_irqrestore(&ihost->scic_lock, flags);
+
+        return res;
+}
+
+enum sci_status isci_remote_device_terminate_requests(
+        struct isci_host *ihost,
+        struct isci_remote_device *idev,
+        struct isci_request *ireq)
+{
+        enum sci_status status = SCI_SUCCESS;
+        unsigned long flags;
+        u32 rnc_suspend_count;
+
+        spin_lock_irqsave(&ihost->scic_lock, flags);
+
+        if (isci_get_device(idev) == NULL) {
+                dev_dbg(&ihost->pdev->dev, "%s: failed isci_get_device(idev=%p)\n",
+                        __func__, idev);
+                spin_unlock_irqrestore(&ihost->scic_lock, flags);
+                status = SCI_FAILURE;
+        } else {
+                /* If already suspended, don't wait for another suspension. */
+                smp_rmb();
+                rnc_suspend_count
+                        = sci_remote_node_context_is_suspended(&idev->rnc)
+                                ? 0 : idev->rnc.suspend_count;
+
+                dev_dbg(&ihost->pdev->dev,
+                        "%s: idev=%p, ireq=%p; started_request_count=%d, "
+                                "rnc_suspend_count=%d, rnc.suspend_count=%d"
+                                "about to wait\n",
+                        __func__, idev, ireq, idev->started_request_count,
+                        rnc_suspend_count, idev->rnc.suspend_count);
+
+                #define MAX_SUSPEND_MSECS 10000
+                if (ireq) {
+                        /* Terminate a specific TC. */
+                        set_bit(IREQ_NO_AUTO_FREE_TAG, &ireq->flags);
+                        sci_remote_device_terminate_req(ihost, idev, 0, ireq);
+                        spin_unlock_irqrestore(&ihost->scic_lock, flags);
+                        if (!wait_event_timeout(ihost->eventq,
+                                                isci_check_reqterm(ihost, idev, ireq,
+                                                                   rnc_suspend_count),
+                                                msecs_to_jiffies(MAX_SUSPEND_MSECS))) {
+
+                                dev_warn(&ihost->pdev->dev, "%s host%d timeout single\n",
+                                         __func__, ihost->id);
+                                dev_dbg(&ihost->pdev->dev,
+                                         "%s: ******* Timeout waiting for "
+                                         "suspend; idev=%p, current state %s; "
+                                         "started_request_count=%d, flags=%lx\n\t"
+                                         "rnc_suspend_count=%d, rnc.suspend_count=%d "
+                                         "RNC: current state %s, current "
+                                         "suspend_type %x dest state %d;\n"
+                                         "ireq=%p, ireq->flags = %lx\n",
+                                         __func__, idev,
+                                         dev_state_name(idev->sm.current_state_id),
+                                         idev->started_request_count, idev->flags,
+                                         rnc_suspend_count, idev->rnc.suspend_count,
+                                         rnc_state_name(idev->rnc.sm.current_state_id),
+                                         idev->rnc.suspend_type,
+                                         idev->rnc.destination_state,
+                                         ireq, ireq->flags);
+                        }
+                        spin_lock_irqsave(&ihost->scic_lock, flags);
+                        clear_bit(IREQ_NO_AUTO_FREE_TAG, &ireq->flags);
+                        if (!test_bit(IREQ_ABORT_PATH_ACTIVE, &ireq->flags))
+                                isci_free_tag(ihost, ireq->io_tag);
+                        spin_unlock_irqrestore(&ihost->scic_lock, flags);
+                } else {
+                        /* Terminate all TCs. */
+                        sci_remote_device_terminate_requests(idev);
+                        spin_unlock_irqrestore(&ihost->scic_lock, flags);
+                        if (!wait_event_timeout(ihost->eventq,
+                                                isci_check_devempty(ihost, idev,
+                                                                    rnc_suspend_count),
+                                                msecs_to_jiffies(MAX_SUSPEND_MSECS))) {
+
+                                dev_warn(&ihost->pdev->dev, "%s host%d timeout all\n",
+                                         __func__, ihost->id);
+                                dev_dbg(&ihost->pdev->dev,
+                                        "%s: ******* Timeout waiting for "
+                                        "suspend; idev=%p, current state %s; "
+                                        "started_request_count=%d, flags=%lx\n\t"
+                                        "rnc_suspend_count=%d, "
+                                        "RNC: current state %s, "
+                                        "rnc.suspend_count=%d, current "
+                                        "suspend_type %x dest state %d\n",
+                                        __func__, idev,
+                                        dev_state_name(idev->sm.current_state_id),
+                                        idev->started_request_count, idev->flags,
+                                        rnc_suspend_count,
+                                        rnc_state_name(idev->rnc.sm.current_state_id),
+                                        idev->rnc.suspend_count,
+                                        idev->rnc.suspend_type,
+                                        idev->rnc.destination_state);
+                        }
+                }
+                dev_dbg(&ihost->pdev->dev, "%s: idev=%p, wait done\n",
+                        __func__, idev);
+                isci_put_device(idev);
+        }
         return status;
 }
 
+/**
+* isci_remote_device_not_ready() - This function is called by the ihost when
+*    the remote device is not ready. We mark the isci device as ready (not
+*    "ready_for_io") and signal the waiting proccess.
+* @isci_host: This parameter specifies the isci host object.
+* @isci_device: This parameter specifies the remote device
+*
+* sci_lock is held on entrance to this function.
+*/
+static void isci_remote_device_not_ready(struct isci_host *ihost,
+                                         struct isci_remote_device *idev,
+                                         u32 reason)
+{
+        dev_dbg(&ihost->pdev->dev,
+                "%s: isci_device = %p; reason = %d\n", __func__, idev, reason);
+
+        switch (reason) {
+        case SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED:
+                set_bit(IDEV_IO_NCQERROR, &idev->flags);
+
+                /* Suspend the remote device so the I/O can be terminated. */
+                sci_remote_device_suspend(idev, SCI_SW_SUSPEND_NORMAL);
+
+                /* Kill all outstanding requests for the device. */
+                sci_remote_device_terminate_requests(idev);
+
+                /* Fall through into the default case... */
+        default:
+                clear_bit(IDEV_IO_READY, &idev->flags);
+                break;
+        }
+}
+
+/* called once the remote node context is ready to be freed.
+ * The remote device can now report that its stop operation is complete. none
+ */
+static void rnc_destruct_done(void *_dev)
+{
+        struct isci_remote_device *idev = _dev;
+
+        BUG_ON(idev->started_request_count != 0);
+        sci_change_state(&idev->sm, SCI_DEV_STOPPED);
+}
+
+enum sci_status sci_remote_device_terminate_requests(
+        struct isci_remote_device *idev)
+{
+        return sci_remote_device_terminate_reqs_checkabort(idev, 0);
+}
+
 enum sci_status sci_remote_device_stop(struct isci_remote_device *idev,
                                         u32 timeout)
 {
@@ -201,13 +369,16 @@ enum sci_status sci_remote_device_stop(struct isci_remote_device *idev,
         case SCI_SMP_DEV_IDLE:
         case SCI_SMP_DEV_CMD:
                 sci_change_state(sm, SCI_DEV_STOPPING);
-                if (idev->started_request_count == 0) {
+                if (idev->started_request_count == 0)
                         sci_remote_node_context_destruct(&idev->rnc,
-                                                              rnc_destruct_done, idev);
-                        return SCI_SUCCESS;
-                } else
-                        return sci_remote_device_terminate_requests(idev);
-                break;
+                                                         rnc_destruct_done,
+                                                         idev);
+                else {
+                        sci_remote_device_suspend(
+                                idev, SCI_SW_SUSPEND_LINKHANG_DETECT);
+                        sci_remote_device_terminate_requests(idev);
+                }
+                return SCI_SUCCESS;
         case SCI_DEV_STOPPING:
                 /* All requests should have been terminated, but if there is an
                  * attempt to stop a device already in the stopping state, then
@@ -265,22 +436,6 @@ enum sci_status sci_remote_device_reset_complete(struct isci_remote_device *idev
         return SCI_SUCCESS;
 }
 
-enum sci_status sci_remote_device_suspend(struct isci_remote_device *idev,
-                                               u32 suspend_type)
-{
-        struct sci_base_state_machine *sm = &idev->sm;
-        enum sci_remote_device_states state = sm->current_state_id;
-
-        if (state != SCI_STP_DEV_CMD) {
-                dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
-                         __func__, dev_state_name(state));
-                return SCI_FAILURE_INVALID_STATE;
-        }
-
-        return sci_remote_node_context_suspend(&idev->rnc,
-                                                    suspend_type, NULL, NULL);
-}
-
 enum sci_status sci_remote_device_frame_handler(struct isci_remote_device *idev,
                                                      u32 frame_index)
 {
@@ -412,9 +567,9 @@ static void atapi_remote_device_resume_done(void *_dev)
 enum sci_status sci_remote_device_event_handler(struct isci_remote_device *idev,
                                                      u32 event_code)
 {
+        enum sci_status status;
         struct sci_base_state_machine *sm = &idev->sm;
         enum sci_remote_device_states state = sm->current_state_id;
-        enum sci_status status;
 
         switch (scu_get_event_type(event_code)) {
         case SCU_EVENT_TYPE_RNC_OPS_MISC:
@@ -427,9 +582,7 @@ enum sci_status sci_remote_device_event_handler(struct isci_remote_device *idev,
                         status = SCI_SUCCESS;
 
                         /* Suspend the associated RNC */
-                        sci_remote_node_context_suspend(&idev->rnc,
-                                                              SCI_SOFTWARE_SUSPENSION,
-                                                              NULL, NULL);
+                        sci_remote_device_suspend(idev, SCI_SW_SUSPEND_NORMAL);
 
                         dev_dbg(scirdev_to_dev(idev),
                                 "%s: device: %p event code: %x: %s\n",
@@ -455,6 +608,10 @@ enum sci_status sci_remote_device_event_handler(struct isci_remote_device *idev,
         if (status != SCI_SUCCESS)
                 return status;
 
+        /* Decode device-specific states that may require an RNC resume during
+         * normal operation.  When the abort path is active, these resumes are
+         * managed when the abort path exits.
+         */
         if (state == SCI_STP_DEV_ATAPI_ERROR) {
                 /* For ATAPI error state resume the RNC right away. */
                 if (scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX ||
@@ -743,10 +900,6 @@ enum sci_status sci_remote_device_start_task(struct isci_host *ihost,
                 if (status != SCI_SUCCESS)
                         return status;
 
-                status = sci_remote_node_context_start_task(&idev->rnc, ireq);
-                if (status != SCI_SUCCESS)
-                        goto out;
-
                 status = sci_request_start(ireq);
                 if (status != SCI_SUCCESS)
                         goto out;
@@ -765,11 +918,11 @@ enum sci_status sci_remote_device_start_task(struct isci_host *ihost,
                  * the correct action when the remote node context is suspended
                  * and later resumed.
                  */
-                sci_remote_node_context_suspend(&idev->rnc,
-                                SCI_SOFTWARE_SUSPENSION, NULL, NULL);
-                sci_remote_node_context_resume(&idev->rnc,
-                                sci_remote_device_continue_request,
-                                                    idev);
+                sci_remote_device_suspend(idev,
+                                          SCI_SW_SUSPEND_LINKHANG_DETECT);
+
+                status = sci_remote_node_context_start_task(&idev->rnc, ireq,
+                                sci_remote_device_continue_request, idev);
 
         out:
                 sci_remote_device_start_request(idev, ireq, status);
@@ -783,7 +936,9 @@ enum sci_status sci_remote_device_start_task(struct isci_host *ihost,
                 if (status != SCI_SUCCESS)
                         return status;
 
-                status = sci_remote_node_context_start_task(&idev->rnc, ireq);
+                /* Resume the RNC as needed: */
+                status = sci_remote_node_context_start_task(&idev->rnc, ireq,
+                                                            NULL, NULL);
                 if (status != SCI_SUCCESS)
                         break;
 
@@ -892,7 +1047,7 @@ static void isci_remote_device_deconstruct(struct isci_host *ihost, struct isci_
          * here should go through isci_remote_device_nuke_requests.
          * If we hit this condition, we will need a way to complete
          * io requests in process */
-        BUG_ON(!list_empty(&idev->reqs_in_process));
+        BUG_ON(idev->started_request_count > 0);
 
         sci_remote_device_destruct(idev);
         list_del_init(&idev->node);
@@ -954,14 +1109,21 @@ static void sci_remote_device_ready_state_exit(struct sci_base_state_machine *sm
 static void sci_remote_device_resetting_state_enter(struct sci_base_state_machine *sm)
 {
         struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
+        struct isci_host *ihost = idev->owning_port->owning_controller;
 
-        sci_remote_node_context_suspend(
-                &idev->rnc, SCI_SOFTWARE_SUSPENSION, NULL, NULL);
+        dev_dbg(&ihost->pdev->dev,
+                "%s: isci_device = %p\n", __func__, idev);
+
+        sci_remote_device_suspend(idev, SCI_SW_SUSPEND_LINKHANG_DETECT);
 }
 
 static void sci_remote_device_resetting_state_exit(struct sci_base_state_machine *sm)
 {
         struct isci_remote_device *idev = container_of(sm, typeof(*idev), sm);
+        struct isci_host *ihost = idev->owning_port->owning_controller;
+
+        dev_dbg(&ihost->pdev->dev,
+                "%s: isci_device = %p\n", __func__, idev);
 
         sci_remote_node_context_resume(&idev->rnc, NULL, NULL);
 }
@@ -1113,33 +1275,20 @@ static enum sci_status sci_remote_device_da_construct(struct isci_port *iport,
 {
         enum sci_status status;
         struct sci_port_properties properties;
-        struct domain_device *dev = idev->domain_dev;
 
         sci_remote_device_construct(iport, idev);
 
-        /*
-         * This information is request to determine how many remote node context
-         * entries will be needed to store the remote node.
-         */
-        idev->is_direct_attached = true;
-
         sci_port_get_properties(iport, &properties);
         /* Get accurate port width from port's phy mask for a DA device. */
         idev->device_port_width = hweight32(properties.phy_mask);
 
         status = sci_controller_allocate_remote_node_context(iport->owning_controller,
-                                                                  idev,
-                                                                  &idev->rnc.remote_node_index);
+                                                             idev,
+                                                             &idev->rnc.remote_node_index);
 
         if (status != SCI_SUCCESS)
                 return status;
 
-        if (dev->dev_type == SAS_END_DEV || dev->dev_type == SATA_DEV ||
-            (dev->tproto & SAS_PROTOCOL_STP) || dev_is_expander(dev))
-                /* pass */;
-        else
-                return SCI_FAILURE_UNSUPPORTED_PROTOCOL;
-
         idev->connection_rate = sci_port_get_max_allowed_speed(iport);
 
         return SCI_SUCCESS;
@@ -1171,19 +1320,13 @@ static enum sci_status sci_remote_device_ea_construct(struct isci_port *iport,
         if (status != SCI_SUCCESS)
                 return status;
 
-        if (dev->dev_type == SAS_END_DEV || dev->dev_type == SATA_DEV ||
-            (dev->tproto & SAS_PROTOCOL_STP) || dev_is_expander(dev))
-                /* pass */;
-        else
-                return SCI_FAILURE_UNSUPPORTED_PROTOCOL;
-
-        /*
-         * For SAS-2 the physical link rate is actually a logical link
+        /* For SAS-2 the physical link rate is actually a logical link
          * rate that incorporates multiplexing.  The SCU doesn't
          * incorporate multiplexing and for the purposes of the
          * connection the logical link rate is that same as the
          * physical.  Furthermore, the SAS-2 and SAS-1.1 fields overlay
-         * one another, so this code works for both situations. */
+         * one another, so this code works for both situations.
+         */
         idev->connection_rate = min_t(u16, sci_port_get_max_allowed_speed(iport),
                                          dev->linkrate);
 
@@ -1193,6 +1336,105 @@ static enum sci_status sci_remote_device_ea_construct(struct isci_port *iport,
         return SCI_SUCCESS;
 }
 
+enum sci_status sci_remote_device_resume(
+        struct isci_remote_device *idev,
+        scics_sds_remote_node_context_callback cb_fn,
+        void *cb_p)
+{
+        enum sci_status status;
+
+        status = sci_remote_node_context_resume(&idev->rnc, cb_fn, cb_p);
+        if (status != SCI_SUCCESS)
+                dev_dbg(scirdev_to_dev(idev), "%s: failed to resume: %d\n",
+                        __func__, status);
+        return status;
+}
+
+static void isci_remote_device_resume_from_abort_complete(void *cbparam)
+{
+        struct isci_remote_device *idev = cbparam;
+        struct isci_host *ihost = idev->owning_port->owning_controller;
+        scics_sds_remote_node_context_callback abort_resume_cb =
+                idev->abort_resume_cb;
+
+        dev_dbg(scirdev_to_dev(idev), "%s: passing-along resume: %p\n",
+                __func__, abort_resume_cb);
+
+        if (abort_resume_cb != NULL) {
+                idev->abort_resume_cb = NULL;
+                abort_resume_cb(idev->abort_resume_cbparam);
+        }
+        clear_bit(IDEV_ABORT_PATH_RESUME_PENDING, &idev->flags);
+        wake_up(&ihost->eventq);
+}
+
+static bool isci_remote_device_test_resume_done(
+        struct isci_host *ihost,
+        struct isci_remote_device *idev)
+{
+        unsigned long flags;
+        bool done;
+
+        spin_lock_irqsave(&ihost->scic_lock, flags);
+        done = !test_bit(IDEV_ABORT_PATH_RESUME_PENDING, &idev->flags)
+                || test_bit(IDEV_STOP_PENDING, &idev->flags)
+                || sci_remote_node_context_is_being_destroyed(&idev->rnc);
+        spin_unlock_irqrestore(&ihost->scic_lock, flags);
+
+        return done;
+}
+
+void isci_remote_device_wait_for_resume_from_abort(
+        struct isci_host *ihost,
+        struct isci_remote_device *idev)
+{
+        dev_dbg(&ihost->pdev->dev, "%s: starting resume wait: %p\n",
+                 __func__, idev);
+
+        #define MAX_RESUME_MSECS 10000
+        if (!wait_event_timeout(ihost->eventq,
+                                isci_remote_device_test_resume_done(ihost, idev),
+                                msecs_to_jiffies(MAX_RESUME_MSECS))) {
+
+                dev_warn(&ihost->pdev->dev, "%s: #### Timeout waiting for "
+                         "resume: %p\n", __func__, idev);
+        }
+        clear_bit(IDEV_ABORT_PATH_RESUME_PENDING, &idev->flags);
+
+        dev_dbg(&ihost->pdev->dev, "%s: resume wait done: %p\n",
+                 __func__, idev);
+}
+
+enum sci_status isci_remote_device_resume_from_abort(
+        struct isci_host *ihost,
+        struct isci_remote_device *idev)
+{
+        unsigned long flags;
+        enum sci_status status = SCI_SUCCESS;
+        int destroyed;
+
+        spin_lock_irqsave(&ihost->scic_lock, flags);
+        /* Preserve any current resume callbacks, for instance from other
+         * resumptions.
+         */
+        idev->abort_resume_cb = idev->rnc.user_callback;
+        idev->abort_resume_cbparam = idev->rnc.user_cookie;
+        set_bit(IDEV_ABORT_PATH_RESUME_PENDING, &idev->flags);
+        clear_bit(IDEV_ABORT_PATH_ACTIVE, &idev->flags);
+        destroyed = sci_remote_node_context_is_being_destroyed(&idev->rnc);
+        if (!destroyed)
+                status = sci_remote_device_resume(
+                        idev, isci_remote_device_resume_from_abort_complete,
+                        idev);
+        spin_unlock_irqrestore(&ihost->scic_lock, flags);
+        if (!destroyed && (status == SCI_SUCCESS))
+                isci_remote_device_wait_for_resume_from_abort(ihost, idev);
+        else
+                clear_bit(IDEV_ABORT_PATH_RESUME_PENDING, &idev->flags);
+
+        return status;
+}
+
 /**
  * sci_remote_device_start() - This method will start the supplied remote
  *    device.  This method enables normal IO requests to flow through to the
@@ -1207,7 +1449,7 @@ static enum sci_status sci_remote_device_ea_construct(struct isci_port *iport,
  * the device when there have been no phys added to it.
  */
 static enum sci_status sci_remote_device_start(struct isci_remote_device *idev,
-                                                u32 timeout)
+                                               u32 timeout)
 {
         struct sci_base_state_machine *sm = &idev->sm;
         enum sci_remote_device_states state = sm->current_state_id;
@@ -1219,9 +1461,8 @@ static enum sci_status sci_remote_device_start(struct isci_remote_device *idev,
                 return SCI_FAILURE_INVALID_STATE;
         }
 
-        status = sci_remote_node_context_resume(&idev->rnc,
-                                                     remote_device_resume_done,
-                                                     idev);
+        status = sci_remote_device_resume(idev, remote_device_resume_done,
+                                          idev);
         if (status != SCI_SUCCESS)
                 return status;
 
@@ -1259,20 +1500,6 @@ static enum sci_status isci_remote_device_construct(struct isci_port *iport,
         return status;
 }
 
-void isci_remote_device_nuke_requests(struct isci_host *ihost, struct isci_remote_device *idev)
-{
-        DECLARE_COMPLETION_ONSTACK(aborted_task_completion);
-
-        dev_dbg(&ihost->pdev->dev,
-                "%s: idev = %p\n", __func__, idev);
-
-        /* Cleanup all requests pending for this device. */
-        isci_terminate_pending_requests(ihost, idev);
-
-        dev_dbg(&ihost->pdev->dev,
-                "%s: idev = %p, done\n", __func__, idev);
-}
-
 /**
  * This function builds the isci_remote_device when a libsas dev_found message
  *    is received.
@@ -1297,10 +1524,6 @@ isci_remote_device_alloc(struct isci_host *ihost, struct isci_port *iport)
                 dev_warn(&ihost->pdev->dev, "%s: failed\n", __func__);
                 return NULL;
         }
-
-        if (WARN_ONCE(!list_empty(&idev->reqs_in_process), "found requests in process\n"))
-                return NULL;
-
         if (WARN_ONCE(!list_empty(&idev->node), "found non-idle remote device\n"))
                 return NULL;
 
@@ -1342,14 +1565,8 @@ enum sci_status isci_remote_device_stop(struct isci_host *ihost, struct isci_rem
         spin_lock_irqsave(&ihost->scic_lock, flags);
         idev->domain_dev->lldd_dev = NULL; /* disable new lookups */
         set_bit(IDEV_GONE, &idev->flags);
-        spin_unlock_irqrestore(&ihost->scic_lock, flags);
-
-        /* Kill all outstanding requests. */
-        isci_remote_device_nuke_requests(ihost, idev);
 
         set_bit(IDEV_STOP_PENDING, &idev->flags);
-
-        spin_lock_irqsave(&ihost->scic_lock, flags);
         status = sci_remote_device_stop(idev, 50);
         spin_unlock_irqrestore(&ihost->scic_lock, flags);
 
@@ -1359,6 +1576,9 @@ enum sci_status isci_remote_device_stop(struct isci_host *ihost, struct isci_rem
         else
                 wait_for_device_stop(ihost, idev);
 
+        dev_dbg(&ihost->pdev->dev,
+                "%s: isci_device = %p, waiting done.\n", __func__, idev);
+
         return status;
 }
 
@@ -1434,3 +1654,73 @@ int isci_remote_device_found(struct domain_device *dev)
 
         return status == SCI_SUCCESS ? 0 : -ENODEV;
 }
+
+enum sci_status isci_remote_device_suspend_terminate(
+        struct isci_host *ihost,
+        struct isci_remote_device *idev,
+        struct isci_request *ireq)
+{
+        unsigned long flags;
+        enum sci_status status;
+
+        /* Put the device into suspension. */
+        spin_lock_irqsave(&ihost->scic_lock, flags);
+        set_bit(IDEV_ABORT_PATH_ACTIVE, &idev->flags);
+        sci_remote_device_suspend(idev, SCI_SW_SUSPEND_LINKHANG_DETECT);
+        spin_unlock_irqrestore(&ihost->scic_lock, flags);
+
+        /* Terminate and wait for the completions. */
+        status = isci_remote_device_terminate_requests(ihost, idev, ireq);
+        if (status != SCI_SUCCESS)
+                dev_dbg(&ihost->pdev->dev,
+                        "%s: isci_remote_device_terminate_requests(%p) "
+                                "returned %d!\n",
+                        __func__, idev, status);
+
+        /* NOTE: RNC resumption is left to the caller! */
+        return status;
+}
+
+int isci_remote_device_is_safe_to_abort(
+        struct isci_remote_device *idev)
+{
+        return sci_remote_node_context_is_safe_to_abort(&idev->rnc);
+}
+
+enum sci_status sci_remote_device_abort_requests_pending_abort(
+        struct isci_remote_device *idev)
+{
+        return sci_remote_device_terminate_reqs_checkabort(idev, 1);
+}
+
+enum sci_status isci_remote_device_reset_complete(
+        struct isci_host *ihost,
+        struct isci_remote_device *idev)
+{
+        unsigned long flags;
+        enum sci_status status;
+
+        spin_lock_irqsave(&ihost->scic_lock, flags);
+        status = sci_remote_device_reset_complete(idev);
+        spin_unlock_irqrestore(&ihost->scic_lock, flags);
+
+        return status;
+}
+
+void isci_dev_set_hang_detection_timeout(
+        struct isci_remote_device *idev,
+        u32 timeout)
+{
+        if (dev_is_sata(idev->domain_dev)) {
+                if (timeout) {
+                        if (test_and_set_bit(IDEV_RNC_LLHANG_ENABLED,
+                                             &idev->flags))
+                                return;  /* Already enabled. */
+                } else if (!test_and_clear_bit(IDEV_RNC_LLHANG_ENABLED,
+                                               &idev->flags))
+                        return;  /* Not enabled. */
+
+                sci_port_set_hang_detection_timeout(idev->owning_port,
+                                                    timeout);
+        }
+}
diff --git a/drivers/scsi/isci/remote_device.h b/drivers/scsi/isci/remote_device.h
index 58637ee08f55..7674caae1d88 100644
--- a/drivers/scsi/isci/remote_device.h
+++ b/drivers/scsi/isci/remote_device.h
@@ -85,27 +85,38 @@ struct isci_remote_device {
         #define IDEV_GONE 3
         #define IDEV_IO_READY 4
         #define IDEV_IO_NCQERROR 5
+        #define IDEV_RNC_LLHANG_ENABLED 6
+        #define IDEV_ABORT_PATH_ACTIVE 7
+        #define IDEV_ABORT_PATH_RESUME_PENDING 8
         unsigned long flags;
         struct kref kref;
         struct isci_port *isci_port;
         struct domain_device *domain_dev;
         struct list_head node;
-        struct list_head reqs_in_process;
         struct sci_base_state_machine sm;
         u32 device_port_width;
         enum sas_linkrate connection_rate;
-        bool is_direct_attached;
         struct isci_port *owning_port;
         struct sci_remote_node_context rnc;
         /* XXX unify with device reference counting and delete */
         u32 started_request_count;
         struct isci_request *working_request;
         u32 not_ready_reason;
+        scics_sds_remote_node_context_callback abort_resume_cb;
+        void *abort_resume_cbparam;
 };
 
 #define ISCI_REMOTE_DEVICE_START_TIMEOUT 5000
 
 /* device reference routines must be called under sci_lock */
+static inline struct isci_remote_device *isci_get_device(
+        struct isci_remote_device *idev)
+{
+        if (idev)
+                kref_get(&idev->kref);
+        return idev;
+}
+
 static inline struct isci_remote_device *isci_lookup_device(struct domain_device *dev)
 {
         struct isci_remote_device *idev = dev->lldd_dev;
@@ -302,6 +313,8 @@ static inline void sci_remote_device_decrement_request_count(struct isci_remote_
                 idev->started_request_count--;
 }
 
+void isci_dev_set_hang_detection_timeout(struct isci_remote_device *idev, u32 timeout);
+
 enum sci_status sci_remote_device_frame_handler(
         struct isci_remote_device *idev,
         u32 frame_index);
@@ -325,12 +338,50 @@ enum sci_status sci_remote_device_complete_io(
         struct isci_remote_device *idev,
         struct isci_request *ireq);
 
-enum sci_status sci_remote_device_suspend(
-        struct isci_remote_device *idev,
-        u32 suspend_type);
-
 void sci_remote_device_post_request(
         struct isci_remote_device *idev,
         u32 request);
 
+enum sci_status sci_remote_device_terminate_requests(
+        struct isci_remote_device *idev);
+
+int isci_remote_device_is_safe_to_abort(
+        struct isci_remote_device *idev);
+
+enum sci_status
+sci_remote_device_abort_requests_pending_abort(
+        struct isci_remote_device *idev);
+
+enum sci_status isci_remote_device_suspend(
+        struct isci_host *ihost,
+        struct isci_remote_device *idev);
+
+enum sci_status sci_remote_device_resume(
+        struct isci_remote_device *idev,
+        scics_sds_remote_node_context_callback cb_fn,
+        void *cb_p);
+
+enum sci_status isci_remote_device_resume_from_abort(
+        struct isci_host *ihost,
+        struct isci_remote_device *idev);
+
+enum sci_status isci_remote_device_reset(
+        struct isci_host *ihost,
+        struct isci_remote_device *idev);
+
+enum sci_status isci_remote_device_reset_complete(
+        struct isci_host *ihost,
+        struct isci_remote_device *idev);
+
+enum sci_status isci_remote_device_suspend_terminate(
+        struct isci_host *ihost,
+        struct isci_remote_device *idev,
+        struct isci_request *ireq);
+
+enum sci_status isci_remote_device_terminate_requests(
+        struct isci_host *ihost,
+        struct isci_remote_device *idev,
+        struct isci_request *ireq);
+enum sci_status sci_remote_device_suspend(struct isci_remote_device *idev,
+                                          enum sci_remote_node_suspension_reasons reason);
 #endif /* !defined(_ISCI_REMOTE_DEVICE_H_) */
diff --git a/drivers/scsi/isci/remote_node_context.c b/drivers/scsi/isci/remote_node_context.c
index 3a9463481f38..1910100638a2 100644
--- a/drivers/scsi/isci/remote_node_context.c
+++ b/drivers/scsi/isci/remote_node_context.c
@@ -52,7 +52,7 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-
+#include <scsi/sas_ata.h>
 #include "host.h"
 #include "isci.h"
 #include "remote_device.h"
@@ -90,6 +90,15 @@ bool sci_remote_node_context_is_ready(
         return false;
 }
 
+bool sci_remote_node_context_is_suspended(struct sci_remote_node_context *sci_rnc)
+{
+        u32 current_state = sci_rnc->sm.current_state_id;
+
+        if (current_state == SCI_RNC_TX_RX_SUSPENDED)
+                return true;
+        return false;
+}
+
 static union scu_remote_node_context *sci_rnc_by_id(struct isci_host *ihost, u16 id)
 {
         if (id < ihost->remote_node_entries &&
@@ -131,7 +140,7 @@ static void sci_remote_node_context_construct_buffer(struct sci_remote_node_cont
 
         rnc->ssp.arbitration_wait_time = 0;
 
-        if (dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP)) {
+        if (dev_is_sata(dev)) {
                 rnc->ssp.connection_occupancy_timeout =
                         ihost->user_parameters.stp_max_occupancy_timeout;
                 rnc->ssp.connection_inactivity_timeout =
@@ -151,7 +160,6 @@ static void sci_remote_node_context_construct_buffer(struct sci_remote_node_cont
         rnc->ssp.oaf_source_zone_group = 0;
         rnc->ssp.oaf_more_compatibility_features = 0;
 }
-
 /**
  *
  * @sci_rnc:
@@ -165,23 +173,30 @@ static void sci_remote_node_context_construct_buffer(struct sci_remote_node_cont
 static void sci_remote_node_context_setup_to_resume(
         struct sci_remote_node_context *sci_rnc,
         scics_sds_remote_node_context_callback callback,
-        void *callback_parameter)
+        void *callback_parameter,
+        enum sci_remote_node_context_destination_state dest_param)
 {
-        if (sci_rnc->destination_state != SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_FINAL) {
-                sci_rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_READY;
-                sci_rnc->user_callback     = callback;
-                sci_rnc->user_cookie       = callback_parameter;
+        if (sci_rnc->destination_state != RNC_DEST_FINAL) {
+                sci_rnc->destination_state = dest_param;
+                if (callback != NULL) {
+                        sci_rnc->user_callback = callback;
+                        sci_rnc->user_cookie   = callback_parameter;
+                }
         }
 }
 
-static void sci_remote_node_context_setup_to_destory(
+static void sci_remote_node_context_setup_to_destroy(
         struct sci_remote_node_context *sci_rnc,
         scics_sds_remote_node_context_callback callback,
         void *callback_parameter)
 {
-        sci_rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_FINAL;
+        struct isci_host *ihost = idev_to_ihost(rnc_to_dev(sci_rnc));
+
+        sci_rnc->destination_state = RNC_DEST_FINAL;
         sci_rnc->user_callback     = callback;
         sci_rnc->user_cookie       = callback_parameter;
+
+        wake_up(&ihost->eventq);
 }
 
 /**
@@ -203,9 +218,19 @@ static void sci_remote_node_context_notify_user(
 
 static void sci_remote_node_context_continue_state_transitions(struct sci_remote_node_context *rnc)
 {
-        if (rnc->destination_state == SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_READY)
+        switch (rnc->destination_state) {
+        case RNC_DEST_READY:
+        case RNC_DEST_SUSPENDED_RESUME:
+                rnc->destination_state = RNC_DEST_READY;
+                /* Fall through... */
+        case RNC_DEST_FINAL:
                 sci_remote_node_context_resume(rnc, rnc->user_callback,
-                                                    rnc->user_cookie);
+                                               rnc->user_cookie);
+                break;
+        default:
+                rnc->destination_state = RNC_DEST_UNSPECIFIED;
+                break;
+        }
 }
 
 static void sci_remote_node_context_validate_context_buffer(struct sci_remote_node_context *sci_rnc)
@@ -219,13 +244,12 @@ static void sci_remote_node_context_validate_context_buffer(struct sci_remote_no
 
         rnc_buffer->ssp.is_valid = true;
 
-        if (!idev->is_direct_attached &&
-            (dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP))) {
+        if (dev_is_sata(dev) && dev->parent) {
                 sci_remote_device_post_request(idev, SCU_CONTEXT_COMMAND_POST_RNC_96);
         } else {
                 sci_remote_device_post_request(idev, SCU_CONTEXT_COMMAND_POST_RNC_32);
 
-                if (idev->is_direct_attached)
+                if (!dev->parent)
                         sci_port_setup_transports(idev->owning_port,
                                                   sci_rnc->remote_node_index);
         }
@@ -248,13 +272,18 @@ static void sci_remote_node_context_invalidate_context_buffer(struct sci_remote_
 static void sci_remote_node_context_initial_state_enter(struct sci_base_state_machine *sm)
 {
         struct sci_remote_node_context *rnc = container_of(sm, typeof(*rnc), sm);
+        struct isci_remote_device *idev = rnc_to_dev(rnc);
+        struct isci_host *ihost = idev->owning_port->owning_controller;
 
         /* Check to see if we have gotten back to the initial state because
          * someone requested to destroy the remote node context object.
          */
         if (sm->previous_state_id == SCI_RNC_INVALIDATING) {
-                rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_UNSPECIFIED;
+                rnc->destination_state = RNC_DEST_UNSPECIFIED;
                 sci_remote_node_context_notify_user(rnc);
+
+                smp_wmb();
+                wake_up(&ihost->eventq);
         }
 }
 
@@ -269,6 +298,8 @@ static void sci_remote_node_context_invalidating_state_enter(struct sci_base_sta
 {
         struct sci_remote_node_context *rnc = container_of(sm, typeof(*rnc), sm);
 
+        /* Terminate all outstanding requests. */
+        sci_remote_device_terminate_requests(rnc_to_dev(rnc));
         sci_remote_node_context_invalidate_context_buffer(rnc);
 }
 
@@ -287,10 +318,8 @@ static void sci_remote_node_context_resuming_state_enter(struct sci_base_state_m
          * resume because of a target reset we also need to update
          * the STPTLDARNI register with the RNi of the device
          */
-        if ((dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP)) &&
-            idev->is_direct_attached)
-                sci_port_setup_transports(idev->owning_port,
-                                               rnc->remote_node_index);
+        if (dev_is_sata(dev) && !dev->parent)
+                sci_port_setup_transports(idev->owning_port, rnc->remote_node_index);
 
         sci_remote_device_post_request(idev, SCU_CONTEXT_COMMAND_POST_RNC_RESUME);
 }
@@ -298,10 +327,22 @@ static void sci_remote_node_context_resuming_state_enter(struct sci_base_state_m
 static void sci_remote_node_context_ready_state_enter(struct sci_base_state_machine *sm)
 {
         struct sci_remote_node_context *rnc = container_of(sm, typeof(*rnc), sm);
+        enum sci_remote_node_context_destination_state dest_select;
+        int tell_user = 1;
+
+        dest_select = rnc->destination_state;
+        rnc->destination_state = RNC_DEST_UNSPECIFIED;
 
-        rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_UNSPECIFIED;
+        if ((dest_select == RNC_DEST_SUSPENDED) ||
+            (dest_select == RNC_DEST_SUSPENDED_RESUME)) {
+                sci_remote_node_context_suspend(
+                        rnc, rnc->suspend_reason,
+                        SCI_SOFTWARE_SUSPEND_EXPECTED_EVENT);
 
-        if (rnc->user_callback)
+                if (dest_select == RNC_DEST_SUSPENDED_RESUME)
+                        tell_user = 0;  /* Wait until ready again. */
+        }
+        if (tell_user)
                 sci_remote_node_context_notify_user(rnc);
 }
 
@@ -315,10 +356,34 @@ static void sci_remote_node_context_tx_suspended_state_enter(struct sci_base_sta
 static void sci_remote_node_context_tx_rx_suspended_state_enter(struct sci_base_state_machine *sm)
 {
         struct sci_remote_node_context *rnc = container_of(sm, typeof(*rnc), sm);
+        struct isci_remote_device *idev = rnc_to_dev(rnc);
+        struct isci_host *ihost = idev->owning_port->owning_controller;
+        u32 new_count = rnc->suspend_count + 1;
+
+        if (new_count == 0)
+                rnc->suspend_count = 1;
+        else
+                rnc->suspend_count = new_count;
+        smp_wmb();
 
+        /* Terminate outstanding requests pending abort. */
+        sci_remote_device_abort_requests_pending_abort(idev);
+
+        wake_up(&ihost->eventq);
         sci_remote_node_context_continue_state_transitions(rnc);
 }
 
+static void sci_remote_node_context_await_suspend_state_exit(
+        struct sci_base_state_machine *sm)
+{
+        struct sci_remote_node_context *rnc
+                = container_of(sm, typeof(*rnc), sm);
+        struct isci_remote_device *idev = rnc_to_dev(rnc);
+
+        if (dev_is_sata(idev->domain_dev))
+                isci_dev_set_hang_detection_timeout(idev, 0);
+}
+
 static const struct sci_base_state sci_remote_node_context_state_table[] = {
         [SCI_RNC_INITIAL] = {
                 .enter_state = sci_remote_node_context_initial_state_enter,
@@ -341,7 +406,9 @@ static const struct sci_base_state sci_remote_node_context_state_table[] = {
         [SCI_RNC_TX_RX_SUSPENDED] = {
                 .enter_state = sci_remote_node_context_tx_rx_suspended_state_enter,
         },
-        [SCI_RNC_AWAIT_SUSPENSION] = { },
+        [SCI_RNC_AWAIT_SUSPENSION] = {
+                .exit_state = sci_remote_node_context_await_suspend_state_exit,
+        },
 };
 
 void sci_remote_node_context_construct(struct sci_remote_node_context *rnc,
@@ -350,7 +417,7 @@ void sci_remote_node_context_construct(struct sci_remote_node_context *rnc,
         memset(rnc, 0, sizeof(struct sci_remote_node_context));
 
         rnc->remote_node_index = remote_node_index;
-        rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_UNSPECIFIED;
+        rnc->destination_state = RNC_DEST_UNSPECIFIED;
 
         sci_init_sm(&rnc->sm, sci_remote_node_context_state_table, SCI_RNC_INITIAL);
 }
@@ -359,6 +426,7 @@ enum sci_status sci_remote_node_context_event_handler(struct sci_remote_node_con
                                                            u32 event_code)
 {
         enum scis_sds_remote_node_context_states state;
+        u32 next_state;
 
         state = sci_rnc->sm.current_state_id;
         switch (state) {
@@ -373,18 +441,18 @@ enum sci_status sci_remote_node_context_event_handler(struct sci_remote_node_con
                 break;
         case SCI_RNC_INVALIDATING:
                 if (scu_get_event_code(event_code) == SCU_EVENT_POST_RNC_INVALIDATE_COMPLETE) {
-                        if (sci_rnc->destination_state == SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_FINAL)
-                                state = SCI_RNC_INITIAL;
+                        if (sci_rnc->destination_state == RNC_DEST_FINAL)
+                                next_state = SCI_RNC_INITIAL;
                         else
-                                state = SCI_RNC_POSTING;
-                        sci_change_state(&sci_rnc->sm, state);
+                                next_state = SCI_RNC_POSTING;
+                        sci_change_state(&sci_rnc->sm, next_state);
                 } else {
                         switch (scu_get_event_type(event_code)) {
                         case SCU_EVENT_TYPE_RNC_SUSPEND_TX:
                         case SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX:
                                 /* We really dont care if the hardware is going to suspend
                                  * the device since it's being invalidated anyway */
-                                dev_dbg(scirdev_to_dev(rnc_to_dev(sci_rnc)),
+                                dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
                                         "%s: SCIC Remote Node Context 0x%p was "
                                         "suspeneded by hardware while being "
                                         "invalidated.\n", __func__, sci_rnc);
@@ -403,7 +471,7 @@ enum sci_status sci_remote_node_context_event_handler(struct sci_remote_node_con
                         case SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX:
                                 /* We really dont care if the hardware is going to suspend
                                  * the device since it's being resumed anyway */
-                                dev_dbg(scirdev_to_dev(rnc_to_dev(sci_rnc)),
+                                dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
                                         "%s: SCIC Remote Node Context 0x%p was "
                                         "suspeneded by hardware while being resumed.\n",
                                         __func__, sci_rnc);
@@ -417,11 +485,11 @@ enum sci_status sci_remote_node_context_event_handler(struct sci_remote_node_con
                 switch (scu_get_event_type(event_code)) {
                 case SCU_EVENT_TL_RNC_SUSPEND_TX:
                         sci_change_state(&sci_rnc->sm, SCI_RNC_TX_SUSPENDED);
-                        sci_rnc->suspension_code = scu_get_event_specifier(event_code);
+                        sci_rnc->suspend_type = scu_get_event_type(event_code);
                         break;
                 case SCU_EVENT_TL_RNC_SUSPEND_TX_RX:
                         sci_change_state(&sci_rnc->sm, SCI_RNC_TX_RX_SUSPENDED);
-                        sci_rnc->suspension_code = scu_get_event_specifier(event_code);
+                        sci_rnc->suspend_type = scu_get_event_type(event_code);
                         break;
                 default:
                         goto out;
@@ -430,27 +498,29 @@ enum sci_status sci_remote_node_context_event_handler(struct sci_remote_node_con
         case SCI_RNC_AWAIT_SUSPENSION:
                 switch (scu_get_event_type(event_code)) {
                 case SCU_EVENT_TL_RNC_SUSPEND_TX:
-                        sci_change_state(&sci_rnc->sm, SCI_RNC_TX_SUSPENDED);
-                        sci_rnc->suspension_code = scu_get_event_specifier(event_code);
+                        next_state = SCI_RNC_TX_SUSPENDED;
                         break;
                 case SCU_EVENT_TL_RNC_SUSPEND_TX_RX:
-                        sci_change_state(&sci_rnc->sm, SCI_RNC_TX_RX_SUSPENDED);
-                        sci_rnc->suspension_code = scu_get_event_specifier(event_code);
+                        next_state = SCI_RNC_TX_RX_SUSPENDED;
                         break;
                 default:
                         goto out;
                 }
+                if (sci_rnc->suspend_type == scu_get_event_type(event_code))
+                        sci_change_state(&sci_rnc->sm, next_state);
                 break;
         default:
                 dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
-                         "%s: invalid state %d\n", __func__, state);
+                         "%s: invalid state: %s\n", __func__,
+                         rnc_state_name(state));
                 return SCI_FAILURE_INVALID_STATE;
         }
         return SCI_SUCCESS;
 
  out:
         dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
-                 "%s: code: %#x state: %d\n", __func__, event_code, state);
+                 "%s: code: %#x state: %s\n", __func__, event_code,
+                 rnc_state_name(state));
         return SCI_FAILURE;
 
 }
@@ -464,20 +534,23 @@ enum sci_status sci_remote_node_context_destruct(struct sci_remote_node_context
         state = sci_rnc->sm.current_state_id;
         switch (state) {
         case SCI_RNC_INVALIDATING:
-                sci_remote_node_context_setup_to_destory(sci_rnc, cb_fn, cb_p);
+                sci_remote_node_context_setup_to_destroy(sci_rnc, cb_fn, cb_p);
                 return SCI_SUCCESS;
         case SCI_RNC_POSTING:
         case SCI_RNC_RESUMING:
         case SCI_RNC_READY:
         case SCI_RNC_TX_SUSPENDED:
         case SCI_RNC_TX_RX_SUSPENDED:
-        case SCI_RNC_AWAIT_SUSPENSION:
-                sci_remote_node_context_setup_to_destory(sci_rnc, cb_fn, cb_p);
+                sci_remote_node_context_setup_to_destroy(sci_rnc, cb_fn, cb_p);
                 sci_change_state(&sci_rnc->sm, SCI_RNC_INVALIDATING);
                 return SCI_SUCCESS;
+        case SCI_RNC_AWAIT_SUSPENSION:
+                sci_remote_node_context_setup_to_destroy(sci_rnc, cb_fn, cb_p);
+                return SCI_SUCCESS;
         case SCI_RNC_INITIAL:
                 dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
-                         "%s: invalid state %d\n", __func__, state);
+                         "%s: invalid state: %s\n", __func__,
+                         rnc_state_name(state));
                 /* We have decided that the destruct request on the remote node context
                  * can not fail since it is either in the initial/destroyed state or is
                  * can be destroyed.
@@ -485,35 +558,101 @@ enum sci_status sci_remote_node_context_destruct(struct sci_remote_node_context
                 return SCI_SUCCESS;
         default:
                 dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
-                         "%s: invalid state %d\n", __func__, state);
+                         "%s: invalid state %s\n", __func__,
+                         rnc_state_name(state));
                 return SCI_FAILURE_INVALID_STATE;
         }
 }
 
-enum sci_status sci_remote_node_context_suspend(struct sci_remote_node_context *sci_rnc,
-                                                     u32 suspend_type,
-                                                     scics_sds_remote_node_context_callback cb_fn,
-                                                     void *cb_p)
+enum sci_status sci_remote_node_context_suspend(
+                        struct sci_remote_node_context *sci_rnc,
+                        enum sci_remote_node_suspension_reasons suspend_reason,
+                        u32 suspend_type)
 {
-        enum scis_sds_remote_node_context_states state;
+        enum scis_sds_remote_node_context_states state
+                = sci_rnc->sm.current_state_id;
+        struct isci_remote_device *idev = rnc_to_dev(sci_rnc);
+        enum sci_status status = SCI_FAILURE_INVALID_STATE;
+        enum sci_remote_node_context_destination_state dest_param =
+                RNC_DEST_UNSPECIFIED;
+
+        dev_dbg(scirdev_to_dev(idev),
+                "%s: current state %s, current suspend_type %x dest state %d,"
+                        " arg suspend_reason %d, arg suspend_type %x",
+                __func__, rnc_state_name(state), sci_rnc->suspend_type,
+                sci_rnc->destination_state, suspend_reason,
+                suspend_type);
+
+        /* Disable automatic state continuations if explicitly suspending. */
+        if ((suspend_reason == SCI_HW_SUSPEND) ||
+            (sci_rnc->destination_state == RNC_DEST_FINAL))
+                dest_param = sci_rnc->destination_state;
 
-        state = sci_rnc->sm.current_state_id;
-        if (state != SCI_RNC_READY) {
+        switch (state) {
+        case SCI_RNC_READY:
+                break;
+        case SCI_RNC_INVALIDATING:
+                if (sci_rnc->destination_state == RNC_DEST_FINAL) {
+                        dev_warn(scirdev_to_dev(idev),
+                                 "%s: already destroying %p\n",
+                                 __func__, sci_rnc);
+                        return SCI_FAILURE_INVALID_STATE;
+                }
+                /* Fall through and handle like SCI_RNC_POSTING */
+        case SCI_RNC_RESUMING:
+                /* Fall through and handle like SCI_RNC_POSTING */
+        case SCI_RNC_POSTING:
+                /* Set the destination state to AWAIT - this signals the
+                 * entry into the SCI_RNC_READY state that a suspension
+                 * needs to be done immediately.
+                 */
+                if (sci_rnc->destination_state != RNC_DEST_FINAL)
+                        sci_rnc->destination_state = RNC_DEST_SUSPENDED;
+                sci_rnc->suspend_type = suspend_type;
+                sci_rnc->suspend_reason = suspend_reason;
+                return SCI_SUCCESS;
+
+        case SCI_RNC_TX_SUSPENDED:
+                if (suspend_type == SCU_EVENT_TL_RNC_SUSPEND_TX)
+                        status = SCI_SUCCESS;
+                break;
+        case SCI_RNC_TX_RX_SUSPENDED:
+                if (suspend_type == SCU_EVENT_TL_RNC_SUSPEND_TX_RX)
+                        status = SCI_SUCCESS;
+                break;
+        case SCI_RNC_AWAIT_SUSPENSION:
+                if ((sci_rnc->suspend_type == SCU_EVENT_TL_RNC_SUSPEND_TX_RX)
+                    || (suspend_type == sci_rnc->suspend_type))
+                        return SCI_SUCCESS;
+                break;
+        default:
                 dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
-                         "%s: invalid state %d\n", __func__, state);
+                         "%s: invalid state %s\n", __func__,
+                         rnc_state_name(state));
                 return SCI_FAILURE_INVALID_STATE;
         }
+        sci_rnc->destination_state = dest_param;
+        sci_rnc->suspend_type = suspend_type;
+        sci_rnc->suspend_reason = suspend_reason;
+
+        if (status == SCI_SUCCESS) { /* Already in the destination state? */
+                struct isci_host *ihost = idev->owning_port->owning_controller;
+
+                wake_up_all(&ihost->eventq); /* Let observers look. */
+                return SCI_SUCCESS;
+        }
+        if ((suspend_reason == SCI_SW_SUSPEND_NORMAL) ||
+            (suspend_reason == SCI_SW_SUSPEND_LINKHANG_DETECT)) {
 
-        sci_rnc->user_callback   = cb_fn;
-        sci_rnc->user_cookie     = cb_p;
-        sci_rnc->suspension_code = suspend_type;
+                if (suspend_reason == SCI_SW_SUSPEND_LINKHANG_DETECT)
+                        isci_dev_set_hang_detection_timeout(idev, 0x00000001);
 
-        if (suspend_type == SCI_SOFTWARE_SUSPENSION) {
-                sci_remote_device_post_request(rnc_to_dev(sci_rnc),
-                                                    SCU_CONTEXT_COMMAND_POST_RNC_SUSPEND_TX);
+                sci_remote_device_post_request(
+                        idev, SCI_SOFTWARE_SUSPEND_CMD);
         }
+        if (state != SCI_RNC_AWAIT_SUSPENSION)
+                sci_change_state(&sci_rnc->sm, SCI_RNC_AWAIT_SUSPENSION);
 
-        sci_change_state(&sci_rnc->sm, SCI_RNC_AWAIT_SUSPENSION);
         return SCI_SUCCESS;
 }
 
@@ -522,56 +661,86 @@ enum sci_status sci_remote_node_context_resume(struct sci_remote_node_context *s
                                                     void *cb_p)
 {
         enum scis_sds_remote_node_context_states state;
+        struct isci_remote_device *idev = rnc_to_dev(sci_rnc);
 
         state = sci_rnc->sm.current_state_id;
+        dev_dbg(scirdev_to_dev(idev),
+                "%s: state %s, cb_fn = %p, cb_p = %p; dest_state = %d; "
+                        "dev resume path %s\n",
+                __func__, rnc_state_name(state), cb_fn, cb_p,
+                sci_rnc->destination_state,
+                test_bit(IDEV_ABORT_PATH_ACTIVE, &idev->flags)
+                        ? "<abort active>" : "<normal>");
+
         switch (state) {
         case SCI_RNC_INITIAL:
                 if (sci_rnc->remote_node_index == SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX)
                         return SCI_FAILURE_INVALID_STATE;
 
-                sci_remote_node_context_setup_to_resume(sci_rnc, cb_fn, cb_p);
-                sci_remote_node_context_construct_buffer(sci_rnc);
-                sci_change_state(&sci_rnc->sm, SCI_RNC_POSTING);
+                sci_remote_node_context_setup_to_resume(sci_rnc, cb_fn, cb_p,
+                                                        RNC_DEST_READY);
+                if (!test_bit(IDEV_ABORT_PATH_ACTIVE, &idev->flags)) {
+                        sci_remote_node_context_construct_buffer(sci_rnc);
+                        sci_change_state(&sci_rnc->sm, SCI_RNC_POSTING);
+                }
                 return SCI_SUCCESS;
+
         case SCI_RNC_POSTING:
         case SCI_RNC_INVALIDATING:
         case SCI_RNC_RESUMING:
-                if (sci_rnc->destination_state != SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_READY)
-                        return SCI_FAILURE_INVALID_STATE;
-
-                sci_rnc->user_callback = cb_fn;
-                sci_rnc->user_cookie   = cb_p;
+                /* We are still waiting to post when a resume was
+                 * requested.
+                 */
+                switch (sci_rnc->destination_state) {
+                case RNC_DEST_SUSPENDED:
+                case RNC_DEST_SUSPENDED_RESUME:
+                        /* Previously waiting to suspend after posting.
+                         * Now continue onto resumption.
+                         */
+                        sci_remote_node_context_setup_to_resume(
+                                sci_rnc, cb_fn, cb_p,
+                                RNC_DEST_SUSPENDED_RESUME);
+                        break;
+                default:
+                        sci_remote_node_context_setup_to_resume(
+                                sci_rnc, cb_fn, cb_p,
+                                RNC_DEST_READY);
+                        break;
+                }
                 return SCI_SUCCESS;
-        case SCI_RNC_TX_SUSPENDED: {
-                struct isci_remote_device *idev = rnc_to_dev(sci_rnc);
-                struct domain_device *dev = idev->domain_dev;
-
-                sci_remote_node_context_setup_to_resume(sci_rnc, cb_fn, cb_p);
-
-                /* TODO: consider adding a resume action of NONE, INVALIDATE, WRITE_TLCR */
-                if (dev->dev_type == SAS_END_DEV || dev_is_expander(dev))
-                        sci_change_state(&sci_rnc->sm, SCI_RNC_RESUMING);
-                else if (dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP)) {
-                        if (idev->is_direct_attached) {
-                                /* @todo Fix this since I am being silly in writing to the STPTLDARNI register. */
-                                sci_change_state(&sci_rnc->sm, SCI_RNC_RESUMING);
-                        } else {
-                                sci_change_state(&sci_rnc->sm, SCI_RNC_INVALIDATING);
+
+        case SCI_RNC_TX_SUSPENDED:
+        case SCI_RNC_TX_RX_SUSPENDED:
+                {
+                        struct domain_device *dev = idev->domain_dev;
+                        /* If this is an expander attached SATA device we must
+                         * invalidate and repost the RNC since this is the only
+                         * way to clear the TCi to NCQ tag mapping table for
+                         * the RNi. All other device types we can just resume.
+                         */
+                        sci_remote_node_context_setup_to_resume(
+                                sci_rnc, cb_fn, cb_p, RNC_DEST_READY);
+
+                        if (!test_bit(IDEV_ABORT_PATH_ACTIVE, &idev->flags)) {
+                                if ((dev_is_sata(dev) && dev->parent) ||
+                                    (sci_rnc->destination_state == RNC_DEST_FINAL))
+                                        sci_change_state(&sci_rnc->sm,
+                                                         SCI_RNC_INVALIDATING);
+                                else
+                                        sci_change_state(&sci_rnc->sm,
+                                                         SCI_RNC_RESUMING);
                         }
-                } else
-                        return SCI_FAILURE;
+                }
                 return SCI_SUCCESS;
-        }
-        case SCI_RNC_TX_RX_SUSPENDED:
-                sci_remote_node_context_setup_to_resume(sci_rnc, cb_fn, cb_p);
-                sci_change_state(&sci_rnc->sm, SCI_RNC_RESUMING);
-                return SCI_FAILURE_INVALID_STATE;
+
         case SCI_RNC_AWAIT_SUSPENSION:
-                sci_remote_node_context_setup_to_resume(sci_rnc, cb_fn, cb_p);
+                sci_remote_node_context_setup_to_resume(
+                        sci_rnc, cb_fn, cb_p, RNC_DEST_SUSPENDED_RESUME);
                 return SCI_SUCCESS;
         default:
                 dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
-                         "%s: invalid state %d\n", __func__, state);
+                         "%s: invalid state %s\n", __func__,
+                         rnc_state_name(state));
                 return SCI_FAILURE_INVALID_STATE;
         }
 }
@@ -590,35 +759,51 @@ enum sci_status sci_remote_node_context_start_io(struct sci_remote_node_context
         case SCI_RNC_TX_RX_SUSPENDED:
         case SCI_RNC_AWAIT_SUSPENSION:
                 dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
-                         "%s: invalid state %d\n", __func__, state);
+                         "%s: invalid state %s\n", __func__,
+                         rnc_state_name(state));
                 return SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
         default:
-                break;
+                dev_dbg(scirdev_to_dev(rnc_to_dev(sci_rnc)),
+                        "%s: invalid state %s\n", __func__,
+                        rnc_state_name(state));
+                return SCI_FAILURE_INVALID_STATE;
         }
-        dev_dbg(scirdev_to_dev(rnc_to_dev(sci_rnc)),
-                "%s: requested to start IO while still resuming, %d\n",
-                __func__, state);
-        return SCI_FAILURE_INVALID_STATE;
 }
 
-enum sci_status sci_remote_node_context_start_task(struct sci_remote_node_context *sci_rnc,
-                                                        struct isci_request *ireq)
+enum sci_status sci_remote_node_context_start_task(
+        struct sci_remote_node_context *sci_rnc,
+        struct isci_request *ireq,
+        scics_sds_remote_node_context_callback cb_fn,
+        void *cb_p)
+{
+        enum sci_status status = sci_remote_node_context_resume(sci_rnc,
+                                                                cb_fn, cb_p);
+        if (status != SCI_SUCCESS)
+                dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
+                        "%s: resume failed: %d\n", __func__, status);
+        return status;
+}
+
+int sci_remote_node_context_is_safe_to_abort(
+        struct sci_remote_node_context *sci_rnc)
 {
         enum scis_sds_remote_node_context_states state;
 
         state = sci_rnc->sm.current_state_id;
         switch (state) {
+        case SCI_RNC_INVALIDATING:
+        case SCI_RNC_TX_RX_SUSPENDED:
+                return 1;
+        case SCI_RNC_POSTING:
         case SCI_RNC_RESUMING:
         case SCI_RNC_READY:
-        case SCI_RNC_AWAIT_SUSPENSION:
-                return SCI_SUCCESS;
         case SCI_RNC_TX_SUSPENDED:
-        case SCI_RNC_TX_RX_SUSPENDED:
-                sci_remote_node_context_resume(sci_rnc, NULL, NULL);
-                return SCI_SUCCESS;
+        case SCI_RNC_AWAIT_SUSPENSION:
+        case SCI_RNC_INITIAL:
+                return 0;
         default:
                 dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
                          "%s: invalid state %d\n", __func__, state);
-                return SCI_FAILURE_INVALID_STATE;
+                return 0;
         }
 }
diff --git a/drivers/scsi/isci/remote_node_context.h b/drivers/scsi/isci/remote_node_context.h
index a241e0f4c865..a703b9ce0c2c 100644
--- a/drivers/scsi/isci/remote_node_context.h
+++ b/drivers/scsi/isci/remote_node_context.h
@@ -75,8 +75,13 @@
  */
 #define SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX    0x0FFF
 
-#define SCU_HARDWARE_SUSPENSION  (0)
-#define SCI_SOFTWARE_SUSPENSION  (1)
+enum sci_remote_node_suspension_reasons {
+        SCI_HW_SUSPEND,
+        SCI_SW_SUSPEND_NORMAL,
+        SCI_SW_SUSPEND_LINKHANG_DETECT
+};
+#define SCI_SOFTWARE_SUSPEND_CMD SCU_CONTEXT_COMMAND_POST_RNC_SUSPEND_TX_RX
+#define SCI_SOFTWARE_SUSPEND_EXPECTED_EVENT SCU_EVENT_TL_RNC_SUSPEND_TX_RX
 
 struct isci_request;
 struct isci_remote_device;
@@ -137,9 +142,13 @@ const char *rnc_state_name(enum scis_sds_remote_node_context_states state);
  * node context.
  */
 enum sci_remote_node_context_destination_state {
-        SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_UNSPECIFIED,
-        SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_READY,
-        SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_FINAL
+        RNC_DEST_UNSPECIFIED,
+        RNC_DEST_READY,
+        RNC_DEST_FINAL,
+        RNC_DEST_SUSPENDED,       /* Set when suspend during post/invalidate */
+        RNC_DEST_SUSPENDED_RESUME /* Set when a resume was done during posting
+                                   * or invalidating and already suspending.
+                                   */
 };
 
 /**
@@ -156,10 +165,12 @@ struct sci_remote_node_context {
         u16 remote_node_index;
 
         /**
-         * This field is the recored suspension code or the reason for the remote node
+         * This field is the recored suspension type of the remote node
          * context suspension.
          */
-        u32 suspension_code;
+        u32 suspend_type;
+        enum sci_remote_node_suspension_reasons suspend_reason;
+        u32 suspend_count;
 
         /**
          * This field is true if the remote node context is resuming from its current
@@ -193,6 +204,8 @@ void sci_remote_node_context_construct(struct sci_remote_node_context *rnc,
 bool sci_remote_node_context_is_ready(
         struct sci_remote_node_context *sci_rnc);
 
+bool sci_remote_node_context_is_suspended(struct sci_remote_node_context *sci_rnc);
+
 enum sci_status sci_remote_node_context_event_handler(struct sci_remote_node_context *sci_rnc,
                                                            u32 event_code);
 enum sci_status sci_remote_node_context_destruct(struct sci_remote_node_context *sci_rnc,
@@ -200,14 +213,24 @@ enum sci_status sci_remote_node_context_destruct(struct sci_remote_node_context
                                                       void *callback_parameter);
 enum sci_status sci_remote_node_context_suspend(struct sci_remote_node_context *sci_rnc,
                                                      u32 suspend_type,
-                                                     scics_sds_remote_node_context_callback cb_fn,
-                                                     void *cb_p);
+                                                     u32 suspension_code);
 enum sci_status sci_remote_node_context_resume(struct sci_remote_node_context *sci_rnc,
                                                     scics_sds_remote_node_context_callback cb_fn,
                                                     void *cb_p);
 enum sci_status sci_remote_node_context_start_task(struct sci_remote_node_context *sci_rnc,
-                                                        struct isci_request *ireq);
+                                                   struct isci_request *ireq,
+                                                   scics_sds_remote_node_context_callback cb_fn,
+                                                   void *cb_p);
 enum sci_status sci_remote_node_context_start_io(struct sci_remote_node_context *sci_rnc,
                                                       struct isci_request *ireq);
+int sci_remote_node_context_is_safe_to_abort(
+        struct sci_remote_node_context *sci_rnc);
 
+static inline bool sci_remote_node_context_is_being_destroyed(
+        struct sci_remote_node_context *sci_rnc)
+{
+        return (sci_rnc->destination_state == RNC_DEST_FINAL)
+                || ((sci_rnc->sm.current_state_id == SCI_RNC_INITIAL)
+                    && (sci_rnc->destination_state == RNC_DEST_UNSPECIFIED));
+}
 #endif  /* _SCIC_SDS_REMOTE_NODE_CONTEXT_H_ */
diff --git a/drivers/scsi/isci/request.c b/drivers/scsi/isci/request.c
index 2def1e3960f6..7a0431c73493 100644
--- a/drivers/scsi/isci/request.c
+++ b/drivers/scsi/isci/request.c
@@ -92,11 +92,11 @@ static dma_addr_t to_sgl_element_pair_dma(struct isci_host *ihost,
         if (idx == 0) {
                 offset = (void *) &ireq->tc->sgl_pair_ab -
                          (void *) &ihost->task_context_table[0];
-                return ihost->task_context_dma + offset;
+                return ihost->tc_dma + offset;
         } else if (idx == 1) {
                 offset = (void *) &ireq->tc->sgl_pair_cd -
                          (void *) &ihost->task_context_table[0];
-                return ihost->task_context_dma + offset;
+                return ihost->tc_dma + offset;
         }
 
         return sci_io_request_get_dma_addr(ireq, &ireq->sg_table[idx - 2]);
@@ -730,7 +730,7 @@ static enum sci_status sci_io_request_construct_basic_ssp(struct isci_request *i
 {
         struct sas_task *task = isci_request_access_task(ireq);
 
-        ireq->protocol = SCIC_SSP_PROTOCOL;
+        ireq->protocol = SAS_PROTOCOL_SSP;
 
         scu_ssp_io_request_construct_task_context(ireq,
                                                   task->data_dir,
@@ -763,7 +763,7 @@ static enum sci_status sci_io_request_construct_basic_sata(struct isci_request *
         bool copy = false;
         struct sas_task *task = isci_request_access_task(ireq);
 
-        ireq->protocol = SCIC_STP_PROTOCOL;
+        ireq->protocol = SAS_PROTOCOL_STP;
 
         copy = (task->data_dir == DMA_NONE) ? false : true;
 
@@ -863,6 +863,8 @@ sci_io_request_terminate(struct isci_request *ireq)
 
         switch (state) {
         case SCI_REQ_CONSTRUCTED:
+                /* Set to make sure no HW terminate posting is done: */
+                set_bit(IREQ_TC_ABORT_POSTED, &ireq->flags);
                 ireq->scu_status = SCU_TASK_DONE_TASK_ABORT;
                 ireq->sci_status = SCI_FAILURE_IO_TERMINATED;
                 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
@@ -883,8 +885,7 @@ sci_io_request_terminate(struct isci_request *ireq)
         case SCI_REQ_ATAPI_WAIT_PIO_SETUP:
         case SCI_REQ_ATAPI_WAIT_D2H:
         case SCI_REQ_ATAPI_WAIT_TC_COMP:
-                sci_change_state(&ireq->sm, SCI_REQ_ABORTING);
-                return SCI_SUCCESS;
+                /* Fall through and change state to ABORTING... */
         case SCI_REQ_TASK_WAIT_TC_RESP:
                 /* The task frame was already confirmed to have been
                  * sent by the SCU HW.  Since the state machine is
@@ -893,20 +894,21 @@ sci_io_request_terminate(struct isci_request *ireq)
                  * and don't wait for the task response.
                  */
                 sci_change_state(&ireq->sm, SCI_REQ_ABORTING);
-                sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
-                return SCI_SUCCESS;
+                /* Fall through and handle like ABORTING... */
         case SCI_REQ_ABORTING:
-                /* If a request has a termination requested twice, return
-                 * a failure indication, since HW confirmation of the first
-                 * abort is still outstanding.
+                if (!isci_remote_device_is_safe_to_abort(ireq->target_device))
+                        set_bit(IREQ_PENDING_ABORT, &ireq->flags);
+                else
+                        clear_bit(IREQ_PENDING_ABORT, &ireq->flags);
+                /* If the request is only waiting on the remote device
+                 * suspension, return SUCCESS so the caller will wait too.
                  */
+                return SCI_SUCCESS;
         case SCI_REQ_COMPLETED:
         default:
                 dev_warn(&ireq->owning_controller->pdev->dev,
                          "%s: SCIC IO Request requested to abort while in wrong "
-                         "state %d\n",
-                         __func__,
-                         ireq->sm.current_state_id);
+                         "state %d\n", __func__, ireq->sm.current_state_id);
                 break;
         }
 
@@ -1070,7 +1072,7 @@ request_started_state_tc_event(struct isci_request *ireq,
         case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_UNEXP_SDBFIS):
         case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_REG_ERR):
         case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SDB_ERR):
-                if (ireq->protocol == SCIC_STP_PROTOCOL) {
+                if (ireq->protocol == SAS_PROTOCOL_STP) {
                         ireq->scu_status = SCU_GET_COMPLETION_TL_STATUS(completion_code) >>
                                            SCU_COMPLETION_TL_STATUS_SHIFT;
                         ireq->sci_status = SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
@@ -2117,7 +2119,7 @@ static enum sci_status stp_request_udma_await_tc_event(struct isci_request *ireq
                  */
                 if (ireq->stp.rsp.fis_type == FIS_REGD2H) {
                         sci_remote_device_suspend(ireq->target_device,
-                                SCU_EVENT_SPECIFIC(SCU_NORMALIZE_COMPLETION_STATUS(completion_code)));
+                                                  SCI_SW_SUSPEND_NORMAL);
 
                         ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
                         ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
@@ -2138,13 +2140,6 @@ static enum sci_status stp_request_udma_await_tc_event(struct isci_request *ireq
         /* TODO We can retry the command for SCU_TASK_DONE_CMD_LL_R_ERR
          * - this comes only for B0
          */
-        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_INV_FIS_LEN):
-        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_MAX_PLD_ERR):
-        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_LL_R_ERR):
-        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_CMD_LL_R_ERR):
-                sci_remote_device_suspend(ireq->target_device,
-                        SCU_EVENT_SPECIFIC(SCU_NORMALIZE_COMPLETION_STATUS(completion_code)));
-                /* Fall through to the default case */
         default:
                 /* All other completion status cause the IO to be complete. */
                 ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
@@ -2262,15 +2257,151 @@ static enum sci_status atapi_data_tc_completion_handler(struct isci_request *ire
         return status;
 }
 
+static int sci_request_smp_completion_status_is_tx_suspend(
+        unsigned int completion_status)
+{
+        switch (completion_status) {
+        case SCU_TASK_OPEN_REJECT_WRONG_DESTINATION:
+        case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_1:
+        case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_2:
+        case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_3:
+        case SCU_TASK_OPEN_REJECT_BAD_DESTINATION:
+        case SCU_TASK_OPEN_REJECT_ZONE_VIOLATION:
+                return 1;
+        }
+        return 0;
+}
+
+static int sci_request_smp_completion_status_is_tx_rx_suspend(
+        unsigned int completion_status)
+{
+        return 0; /* There are no Tx/Rx SMP suspend conditions. */
+}
+
+static int sci_request_ssp_completion_status_is_tx_suspend(
+        unsigned int completion_status)
+{
+        switch (completion_status) {
+        case SCU_TASK_DONE_TX_RAW_CMD_ERR:
+        case SCU_TASK_DONE_LF_ERR:
+        case SCU_TASK_OPEN_REJECT_WRONG_DESTINATION:
+        case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_1:
+        case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_2:
+        case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_3:
+        case SCU_TASK_OPEN_REJECT_BAD_DESTINATION:
+        case SCU_TASK_OPEN_REJECT_ZONE_VIOLATION:
+        case SCU_TASK_OPEN_REJECT_STP_RESOURCES_BUSY:
+        case SCU_TASK_OPEN_REJECT_PROTOCOL_NOT_SUPPORTED:
+        case SCU_TASK_OPEN_REJECT_CONNECTION_RATE_NOT_SUPPORTED:
+                return 1;
+        }
+        return 0;
+}
+
+static int sci_request_ssp_completion_status_is_tx_rx_suspend(
+        unsigned int completion_status)
+{
+        return 0; /* There are no Tx/Rx SSP suspend conditions. */
+}
+
+static int sci_request_stpsata_completion_status_is_tx_suspend(
+        unsigned int completion_status)
+{
+        switch (completion_status) {
+        case SCU_TASK_DONE_TX_RAW_CMD_ERR:
+        case SCU_TASK_DONE_LL_R_ERR:
+        case SCU_TASK_DONE_LL_PERR:
+        case SCU_TASK_DONE_REG_ERR:
+        case SCU_TASK_DONE_SDB_ERR:
+        case SCU_TASK_OPEN_REJECT_WRONG_DESTINATION:
+        case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_1:
+        case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_2:
+        case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_3:
+        case SCU_TASK_OPEN_REJECT_BAD_DESTINATION:
+        case SCU_TASK_OPEN_REJECT_ZONE_VIOLATION:
+        case SCU_TASK_OPEN_REJECT_STP_RESOURCES_BUSY:
+        case SCU_TASK_OPEN_REJECT_PROTOCOL_NOT_SUPPORTED:
+        case SCU_TASK_OPEN_REJECT_CONNECTION_RATE_NOT_SUPPORTED:
+                return 1;
+        }
+        return 0;
+}
+
+
+static int sci_request_stpsata_completion_status_is_tx_rx_suspend(
+        unsigned int completion_status)
+{
+        switch (completion_status) {
+        case SCU_TASK_DONE_LF_ERR:
+        case SCU_TASK_DONE_LL_SY_TERM:
+        case SCU_TASK_DONE_LL_LF_TERM:
+        case SCU_TASK_DONE_BREAK_RCVD:
+        case SCU_TASK_DONE_INV_FIS_LEN:
+        case SCU_TASK_DONE_UNEXP_FIS:
+        case SCU_TASK_DONE_UNEXP_SDBFIS:
+        case SCU_TASK_DONE_MAX_PLD_ERR:
+                return 1;
+        }
+        return 0;
+}
+
+static void sci_request_handle_suspending_completions(
+        struct isci_request *ireq,
+        u32 completion_code)
+{
+        int is_tx = 0;
+        int is_tx_rx = 0;
+
+        switch (ireq->protocol) {
+        case SAS_PROTOCOL_SMP:
+                is_tx = sci_request_smp_completion_status_is_tx_suspend(
+                        completion_code);
+                is_tx_rx = sci_request_smp_completion_status_is_tx_rx_suspend(
+                        completion_code);
+                break;
+        case SAS_PROTOCOL_SSP:
+                is_tx = sci_request_ssp_completion_status_is_tx_suspend(
+                        completion_code);
+                is_tx_rx = sci_request_ssp_completion_status_is_tx_rx_suspend(
+                        completion_code);
+                break;
+        case SAS_PROTOCOL_STP:
+                is_tx = sci_request_stpsata_completion_status_is_tx_suspend(
+                        completion_code);
+                is_tx_rx =
+                        sci_request_stpsata_completion_status_is_tx_rx_suspend(
+                                completion_code);
+                break;
+        default:
+                dev_warn(&ireq->isci_host->pdev->dev,
+                         "%s: request %p has no valid protocol\n",
+                         __func__, ireq);
+                break;
+        }
+        if (is_tx || is_tx_rx) {
+                BUG_ON(is_tx && is_tx_rx);
+
+                sci_remote_node_context_suspend(
+                        &ireq->target_device->rnc,
+                        SCI_HW_SUSPEND,
+                        (is_tx_rx) ? SCU_EVENT_TL_RNC_SUSPEND_TX_RX
+                                   : SCU_EVENT_TL_RNC_SUSPEND_TX);
+        }
+}
+
 enum sci_status
 sci_io_request_tc_completion(struct isci_request *ireq,
-                                  u32 completion_code)
+                             u32 completion_code)
 {
         enum sci_base_request_states state;
         struct isci_host *ihost = ireq->owning_controller;
 
         state = ireq->sm.current_state_id;
 
+        /* Decode those completions that signal upcoming suspension events. */
+        sci_request_handle_suspending_completions(
+                ireq, SCU_GET_COMPLETION_TL_STATUS(completion_code));
+
         switch (state) {
         case SCI_REQ_STARTED:
                 return request_started_state_tc_event(ireq, completion_code);
@@ -2362,9 +2493,6 @@ static void isci_request_process_response_iu(
  * @request: This parameter is the completed isci_request object.
  * @response_ptr: This parameter specifies the service response for the I/O.
  * @status_ptr: This parameter specifies the exec status for the I/O.
- * @complete_to_host_ptr: This parameter specifies the action to be taken by
- *    the LLDD with respect to completing this request or forcing an abort
- *    condition on the I/O.
  * @open_rej_reason: This parameter specifies the encoded reason for the
  *    abandon-class reject.
  *
@@ -2375,14 +2503,12 @@ static void isci_request_set_open_reject_status(
         struct sas_task *task,
         enum service_response *response_ptr,
         enum exec_status *status_ptr,
-        enum isci_completion_selection *complete_to_host_ptr,
         enum sas_open_rej_reason open_rej_reason)
 {
         /* Task in the target is done. */
         set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
         *response_ptr                     = SAS_TASK_UNDELIVERED;
         *status_ptr                       = SAS_OPEN_REJECT;
-        *complete_to_host_ptr             = isci_perform_normal_io_completion;
         task->task_status.open_rej_reason = open_rej_reason;
 }
 
@@ -2392,9 +2518,6 @@ static void isci_request_set_open_reject_status(
  * @request: This parameter is the completed isci_request object.
  * @response_ptr: This parameter specifies the service response for the I/O.
  * @status_ptr: This parameter specifies the exec status for the I/O.
- * @complete_to_host_ptr: This parameter specifies the action to be taken by
- *    the LLDD with respect to completing this request or forcing an abort
- *    condition on the I/O.
  *
  * none.
  */
@@ -2403,8 +2526,7 @@ static void isci_request_handle_controller_specific_errors(
         struct isci_request *request,
         struct sas_task *task,
         enum service_response *response_ptr,
-        enum exec_status *status_ptr,
-        enum isci_completion_selection *complete_to_host_ptr)
+        enum exec_status *status_ptr)
 {
         unsigned int cstatus;
 
@@ -2445,9 +2567,6 @@ static void isci_request_handle_controller_specific_errors(
                                 *status_ptr = SAS_ABORTED_TASK;
 
                         set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
-
-                        *complete_to_host_ptr =
-                                isci_perform_normal_io_completion;
                 } else {
                         /* Task in the target is not done. */
                         *response_ptr = SAS_TASK_UNDELIVERED;
@@ -2458,9 +2577,6 @@ static void isci_request_handle_controller_specific_errors(
                                 *status_ptr = SAM_STAT_TASK_ABORTED;
 
                         clear_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
-
-                        *complete_to_host_ptr =
-                                isci_perform_error_io_completion;
                 }
 
                 break;
@@ -2489,8 +2605,6 @@ static void isci_request_handle_controller_specific_errors(
                         *status_ptr = SAS_ABORTED_TASK;
 
                 set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
-
-                *complete_to_host_ptr = isci_perform_normal_io_completion;
                 break;
 
 
@@ -2501,7 +2615,7 @@ static void isci_request_handle_controller_specific_errors(
 
                 isci_request_set_open_reject_status(
                         request, task, response_ptr, status_ptr,
-                        complete_to_host_ptr, SAS_OREJ_WRONG_DEST);
+                        SAS_OREJ_WRONG_DEST);
                 break;
 
         case SCU_TASK_OPEN_REJECT_ZONE_VIOLATION:
@@ -2511,56 +2625,56 @@ static void isci_request_handle_controller_specific_errors(
                  */
                 isci_request_set_open_reject_status(
                         request, task, response_ptr, status_ptr,
-                        complete_to_host_ptr, SAS_OREJ_RESV_AB0);
+                        SAS_OREJ_RESV_AB0);
                 break;
 
         case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_1:
 
                 isci_request_set_open_reject_status(
                         request, task, response_ptr, status_ptr,
-                        complete_to_host_ptr, SAS_OREJ_RESV_AB1);
+                        SAS_OREJ_RESV_AB1);
                 break;
 
         case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_2:
 
                 isci_request_set_open_reject_status(
                         request, task, response_ptr, status_ptr,
-                        complete_to_host_ptr, SAS_OREJ_RESV_AB2);
+                        SAS_OREJ_RESV_AB2);
                 break;
 
         case SCU_TASK_OPEN_REJECT_RESERVED_ABANDON_3:
 
                 isci_request_set_open_reject_status(
                         request, task, response_ptr, status_ptr,
-                        complete_to_host_ptr, SAS_OREJ_RESV_AB3);
+                        SAS_OREJ_RESV_AB3);
                 break;
 
         case SCU_TASK_OPEN_REJECT_BAD_DESTINATION:
 
                 isci_request_set_open_reject_status(
                         request, task, response_ptr, status_ptr,
-                        complete_to_host_ptr, SAS_OREJ_BAD_DEST);
+                        SAS_OREJ_BAD_DEST);
                 break;
 
         case SCU_TASK_OPEN_REJECT_STP_RESOURCES_BUSY:
 
                 isci_request_set_open_reject_status(
                         request, task, response_ptr, status_ptr,
-                        complete_to_host_ptr, SAS_OREJ_STP_NORES);
+                        SAS_OREJ_STP_NORES);
                 break;
 
         case SCU_TASK_OPEN_REJECT_PROTOCOL_NOT_SUPPORTED:
 
                 isci_request_set_open_reject_status(
                         request, task, response_ptr, status_ptr,
-                        complete_to_host_ptr, SAS_OREJ_EPROTO);
+                        SAS_OREJ_EPROTO);
                 break;
 
         case SCU_TASK_OPEN_REJECT_CONNECTION_RATE_NOT_SUPPORTED:
 
                 isci_request_set_open_reject_status(
                         request, task, response_ptr, status_ptr,
-                        complete_to_host_ptr, SAS_OREJ_CONN_RATE);
+                        SAS_OREJ_CONN_RATE);
                 break;
 
         case SCU_TASK_DONE_LL_R_ERR:
@@ -2592,95 +2706,12 @@ static void isci_request_handle_controller_specific_errors(
                 *response_ptr = SAS_TASK_UNDELIVERED;
                 *status_ptr = SAM_STAT_TASK_ABORTED;
 
-                if (task->task_proto == SAS_PROTOCOL_SMP) {
+                if (task->task_proto == SAS_PROTOCOL_SMP)
                         set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
-
-                        *complete_to_host_ptr = isci_perform_normal_io_completion;
-                } else {
+                else
                         clear_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
-
-                        *complete_to_host_ptr = isci_perform_error_io_completion;
-                }
-                break;
-        }
-}
-
-/**
- * isci_task_save_for_upper_layer_completion() - This function saves the
- *    request for later completion to the upper layer driver.
- * @host: This parameter is a pointer to the host on which the the request
- *    should be queued (either as an error or success).
- * @request: This parameter is the completed request.
- * @response: This parameter is the response code for the completed task.
- * @status: This parameter is the status code for the completed task.
- *
- * none.
- */
-static void isci_task_save_for_upper_layer_completion(
-        struct isci_host *host,
-        struct isci_request *request,
-        enum service_response response,
-        enum exec_status status,
-        enum isci_completion_selection task_notification_selection)
-{
-        struct sas_task *task = isci_request_access_task(request);
-
-        task_notification_selection
-                = isci_task_set_completion_status(task, response, status,
-                                                  task_notification_selection);
-
-        /* Tasks aborted specifically by a call to the lldd_abort_task
-         * function should not be completed to the host in the regular path.
-         */
-        switch (task_notification_selection) {
-
-        case isci_perform_normal_io_completion:
-                /* Normal notification (task_done) */
-
-                /* Add to the completed list. */
-                list_add(&request->completed_node,
-                         &host->requests_to_complete);
-
-                /* Take the request off the device's pending request list. */
-                list_del_init(&request->dev_node);
-                break;
-
-        case isci_perform_aborted_io_completion:
-                /* No notification to libsas because this request is
-                 * already in the abort path.
-                 */
-                /* Wake up whatever process was waiting for this
-                 * request to complete.
-                 */
-                WARN_ON(request->io_request_completion == NULL);
-
-                if (request->io_request_completion != NULL) {
-
-                        /* Signal whoever is waiting that this
-                        * request is complete.
-                        */
-                        complete(request->io_request_completion);
-                }
-                break;
-
-        case isci_perform_error_io_completion:
-                /* Use sas_task_abort */
-                /* Add to the aborted list. */
-                list_add(&request->completed_node,
-                         &host->requests_to_errorback);
-                break;
-
-        default:
-                /* Add to the error to libsas list. */
-                list_add(&request->completed_node,
-                         &host->requests_to_errorback);
                 break;
         }
-        dev_dbg(&host->pdev->dev,
-                "%s: %d - task = %p, response=%d (%d), status=%d (%d)\n",
-                __func__, task_notification_selection, task,
-                (task) ? task->task_status.resp : 0, response,
-                (task) ? task->task_status.stat : 0, status);
 }
 
 static void isci_process_stp_response(struct sas_task *task, struct dev_to_host_fis *fis)
@@ -2715,295 +2746,164 @@ static void isci_request_io_request_complete(struct isci_host *ihost,
         struct isci_remote_device *idev = request->target_device;
         enum service_response response = SAS_TASK_UNDELIVERED;
         enum exec_status status = SAS_ABORTED_TASK;
-        enum isci_request_status request_status;
-        enum isci_completion_selection complete_to_host
-                = isci_perform_normal_io_completion;
 
         dev_dbg(&ihost->pdev->dev,
-                "%s: request = %p, task = %p,\n"
+                "%s: request = %p, task = %p, "
                 "task->data_dir = %d completion_status = 0x%x\n",
-                __func__,
-                request,
-                task,
-                task->data_dir,
-                completion_status);
+                __func__, request, task, task->data_dir, completion_status);
 
-        spin_lock(&request->state_lock);
-        request_status = request->status;
+        /* The request is done from an SCU HW perspective. */
 
-        /* Decode the request status.  Note that if the request has been
-         * aborted by a task management function, we don't care
-         * what the status is.
-         */
-        switch (request_status) {
-
-        case aborted:
-                /* "aborted" indicates that the request was aborted by a task
-                 * management function, since once a task management request is
-                 * perfomed by the device, the request only completes because
-                 * of the subsequent driver terminate.
-                 *
-                 * Aborted also means an external thread is explicitly managing
-                 * this request, so that we do not complete it up the stack.
-                 *
-                 * The target is still there (since the TMF was successful).
-                 */
-                set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
-                response = SAS_TASK_COMPLETE;
+        /* This is an active request being completed from the core. */
+        switch (completion_status) {
 
-                /* See if the device has been/is being stopped. Note
-                 * that we ignore the quiesce state, since we are
-                 * concerned about the actual device state.
-                 */
-                if (!idev)
-                        status = SAS_DEVICE_UNKNOWN;
-                else
-                        status = SAS_ABORTED_TASK;
+        case SCI_IO_FAILURE_RESPONSE_VALID:
+                dev_dbg(&ihost->pdev->dev,
+                        "%s: SCI_IO_FAILURE_RESPONSE_VALID (%p/%p)\n",
+                        __func__, request, task);
+
+                if (sas_protocol_ata(task->task_proto)) {
+                        isci_process_stp_response(task, &request->stp.rsp);
+                } else if (SAS_PROTOCOL_SSP == task->task_proto) {
+
+                        /* crack the iu response buffer. */
+                        resp_iu = &request->ssp.rsp;
+                        isci_request_process_response_iu(task, resp_iu,
+                                                         &ihost->pdev->dev);
+
+                } else if (SAS_PROTOCOL_SMP == task->task_proto) {
+
+                        dev_err(&ihost->pdev->dev,
+                                "%s: SCI_IO_FAILURE_RESPONSE_VALID: "
+                                        "SAS_PROTOCOL_SMP protocol\n",
+                                __func__);
 
-                complete_to_host = isci_perform_aborted_io_completion;
-                /* This was an aborted request. */
+                } else
+                        dev_err(&ihost->pdev->dev,
+                                "%s: unknown protocol\n", __func__);
 
-                spin_unlock(&request->state_lock);
+                /* use the task status set in the task struct by the
+                * isci_request_process_response_iu call.
+                */
+                set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
+                response = task->task_status.resp;
+                status = task->task_status.stat;
                 break;
 
-        case aborting:
-                /* aborting means that the task management function tried and
-                 * failed to abort the request. We need to note the request
-                 * as SAS_TASK_UNDELIVERED, so that the scsi mid layer marks the
-                 * target as down.
-                 *
-                 * Aborting also means an external thread is explicitly managing
-                 * this request, so that we do not complete it up the stack.
-                 */
+        case SCI_IO_SUCCESS:
+        case SCI_IO_SUCCESS_IO_DONE_EARLY:
+
+                response = SAS_TASK_COMPLETE;
+                status   = SAM_STAT_GOOD;
                 set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
-                response = SAS_TASK_UNDELIVERED;
 
-                if (!idev)
-                        /* The device has been /is being stopped. Note that
-                         * we ignore the quiesce state, since we are
-                         * concerned about the actual device state.
-                         */
-                        status = SAS_DEVICE_UNKNOWN;
-                else
-                        status = SAS_PHY_DOWN;
+                if (completion_status == SCI_IO_SUCCESS_IO_DONE_EARLY) {
 
-                complete_to_host = isci_perform_aborted_io_completion;
+                        /* This was an SSP / STP / SATA transfer.
+                        * There is a possibility that less data than
+                        * the maximum was transferred.
+                        */
+                        u32 transferred_length = sci_req_tx_bytes(request);
 
-                /* This was an aborted request. */
+                        task->task_status.residual
+                                = task->total_xfer_len - transferred_length;
+
+                        /* If there were residual bytes, call this an
+                        * underrun.
+                        */
+                        if (task->task_status.residual != 0)
+                                status = SAS_DATA_UNDERRUN;
 
-                spin_unlock(&request->state_lock);
+                        dev_dbg(&ihost->pdev->dev,
+                                "%s: SCI_IO_SUCCESS_IO_DONE_EARLY %d\n",
+                                __func__, status);
+
+                } else
+                        dev_dbg(&ihost->pdev->dev, "%s: SCI_IO_SUCCESS\n",
+                                __func__);
                 break;
 
-        case terminating:
+        case SCI_IO_FAILURE_TERMINATED:
 
-                /* This was an terminated request.  This happens when
-                 * the I/O is being terminated because of an action on
-                 * the device (reset, tear down, etc.), and the I/O needs
-                 * to be completed up the stack.
-                 */
+                dev_dbg(&ihost->pdev->dev,
+                        "%s: SCI_IO_FAILURE_TERMINATED (%p/%p)\n",
+                        __func__, request, task);
+
+                /* The request was terminated explicitly. */
                 set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
                 response = SAS_TASK_UNDELIVERED;
 
                 /* See if the device has been/is being stopped. Note
-                 * that we ignore the quiesce state, since we are
-                 * concerned about the actual device state.
-                 */
+                * that we ignore the quiesce state, since we are
+                * concerned about the actual device state.
+                */
                 if (!idev)
                         status = SAS_DEVICE_UNKNOWN;
                 else
                         status = SAS_ABORTED_TASK;
-
-                complete_to_host = isci_perform_aborted_io_completion;
-
-                /* This was a terminated request. */
-
-                spin_unlock(&request->state_lock);
                 break;
 
-        case dead:
-                /* This was a terminated request that timed-out during the
-                 * termination process.  There is no task to complete to
-                 * libsas.
-                 */
-                complete_to_host = isci_perform_normal_io_completion;
-                spin_unlock(&request->state_lock);
-                break;
+        case SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR:
 
-        default:
-
-                /* The request is done from an SCU HW perspective. */
-                request->status = completed;
-
-                spin_unlock(&request->state_lock);
-
-                /* This is an active request being completed from the core. */
-                switch (completion_status) {
-
-                case SCI_IO_FAILURE_RESPONSE_VALID:
-                        dev_dbg(&ihost->pdev->dev,
-                                "%s: SCI_IO_FAILURE_RESPONSE_VALID (%p/%p)\n",
-                                __func__,
-                                request,
-                                task);
-
-                        if (sas_protocol_ata(task->task_proto)) {
-                                isci_process_stp_response(task, &request->stp.rsp);
-                        } else if (SAS_PROTOCOL_SSP == task->task_proto) {
-
-                                /* crack the iu response buffer. */
-                                resp_iu = &request->ssp.rsp;
-                                isci_request_process_response_iu(task, resp_iu,
-                                                                 &ihost->pdev->dev);
-
-                        } else if (SAS_PROTOCOL_SMP == task->task_proto) {
-
-                                dev_err(&ihost->pdev->dev,
-                                        "%s: SCI_IO_FAILURE_RESPONSE_VALID: "
-                                        "SAS_PROTOCOL_SMP protocol\n",
-                                        __func__);
-
-                        } else
-                                dev_err(&ihost->pdev->dev,
-                                        "%s: unknown protocol\n", __func__);
-
-                        /* use the task status set in the task struct by the
-                         * isci_request_process_response_iu call.
-                         */
-                        set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
-                        response = task->task_status.resp;
-                        status = task->task_status.stat;
-                        break;
+                isci_request_handle_controller_specific_errors(idev, request,
+                                                               task, &response,
+                                                               &status);
+                break;
 
-                case SCI_IO_SUCCESS:
-                case SCI_IO_SUCCESS_IO_DONE_EARLY:
+        case SCI_IO_FAILURE_REMOTE_DEVICE_RESET_REQUIRED:
+                /* This is a special case, in that the I/O completion
+                * is telling us that the device needs a reset.
+                * In order for the device reset condition to be
+                * noticed, the I/O has to be handled in the error
+                * handler.  Set the reset flag and cause the
+                * SCSI error thread to be scheduled.
+                */
+                spin_lock_irqsave(&task->task_state_lock, task_flags);
+                task->task_state_flags |= SAS_TASK_NEED_DEV_RESET;
+                spin_unlock_irqrestore(&task->task_state_lock, task_flags);
 
-                        response = SAS_TASK_COMPLETE;
-                        status   = SAM_STAT_GOOD;
-                        set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
+                /* Fail the I/O. */
+                response = SAS_TASK_UNDELIVERED;
+                status = SAM_STAT_TASK_ABORTED;
 
-                        if (completion_status == SCI_IO_SUCCESS_IO_DONE_EARLY) {
+                clear_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
+                break;
 
-                                /* This was an SSP / STP / SATA transfer.
-                                 * There is a possibility that less data than
-                                 * the maximum was transferred.
-                                 */
-                                u32 transferred_length = sci_req_tx_bytes(request);
+        case SCI_FAILURE_RETRY_REQUIRED:
 
-                                task->task_status.residual
-                                        = task->total_xfer_len - transferred_length;
+                /* Fail the I/O so it can be retried. */
+                response = SAS_TASK_UNDELIVERED;
+                if (!idev)
+                        status = SAS_DEVICE_UNKNOWN;
+                else
+                        status = SAS_ABORTED_TASK;
 
-                                /* If there were residual bytes, call this an
-                                 * underrun.
-                                 */
-                                if (task->task_status.residual != 0)
-                                        status = SAS_DATA_UNDERRUN;
+                set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
+                break;
 
-                                dev_dbg(&ihost->pdev->dev,
-                                        "%s: SCI_IO_SUCCESS_IO_DONE_EARLY %d\n",
-                                        __func__,
-                                        status);
 
-                        } else
-                                dev_dbg(&ihost->pdev->dev,
-                                        "%s: SCI_IO_SUCCESS\n",
-                                        __func__);
+        default:
+                /* Catch any otherwise unhandled error codes here. */
+                dev_dbg(&ihost->pdev->dev,
+                        "%s: invalid completion code: 0x%x - "
+                                "isci_request = %p\n",
+                        __func__, completion_status, request);
 
-                        break;
+                response = SAS_TASK_UNDELIVERED;
 
-                case SCI_IO_FAILURE_TERMINATED:
-                        dev_dbg(&ihost->pdev->dev,
-                                "%s: SCI_IO_FAILURE_TERMINATED (%p/%p)\n",
-                                __func__,
-                                request,
-                                task);
+                /* See if the device has been/is being stopped. Note
+                * that we ignore the quiesce state, since we are
+                * concerned about the actual device state.
+                */
+                if (!idev)
+                        status = SAS_DEVICE_UNKNOWN;
+                else
+                        status = SAS_ABORTED_TASK;
 
-                        /* The request was terminated explicitly.  No handling
-                         * is needed in the SCSI error handler path.
-                         */
+                if (SAS_PROTOCOL_SMP == task->task_proto)
                         set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
-                        response = SAS_TASK_UNDELIVERED;
-
-                        /* See if the device has been/is being stopped. Note
-                         * that we ignore the quiesce state, since we are
-                         * concerned about the actual device state.
-                         */
-                        if (!idev)
-                                status = SAS_DEVICE_UNKNOWN;
-                        else
-                                status = SAS_ABORTED_TASK;
-
-                        complete_to_host = isci_perform_normal_io_completion;
-                        break;
-
-                case SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR:
-
-                        isci_request_handle_controller_specific_errors(
-                                idev, request, task, &response, &status,
-                                &complete_to_host);
-
-                        break;
-
-                case SCI_IO_FAILURE_REMOTE_DEVICE_RESET_REQUIRED:
-                        /* This is a special case, in that the I/O completion
-                         * is telling us that the device needs a reset.
-                         * In order for the device reset condition to be
-                         * noticed, the I/O has to be handled in the error
-                         * handler.  Set the reset flag and cause the
-                         * SCSI error thread to be scheduled.
-                         */
-                        spin_lock_irqsave(&task->task_state_lock, task_flags);
-                        task->task_state_flags |= SAS_TASK_NEED_DEV_RESET;
-                        spin_unlock_irqrestore(&task->task_state_lock, task_flags);
-
-                        /* Fail the I/O. */
-                        response = SAS_TASK_UNDELIVERED;
-                        status = SAM_STAT_TASK_ABORTED;
-
-                        complete_to_host = isci_perform_error_io_completion;
+                else
                         clear_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
-                        break;
-
-                case SCI_FAILURE_RETRY_REQUIRED:
-
-                        /* Fail the I/O so it can be retried. */
-                        response = SAS_TASK_UNDELIVERED;
-                        if (!idev)
-                                status = SAS_DEVICE_UNKNOWN;
-                        else
-                                status = SAS_ABORTED_TASK;
-
-                        complete_to_host = isci_perform_normal_io_completion;
-                        set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
-                        break;
-
-
-                default:
-                        /* Catch any otherwise unhandled error codes here. */
-                        dev_dbg(&ihost->pdev->dev,
-                                 "%s: invalid completion code: 0x%x - "
-                                 "isci_request = %p\n",
-                                 __func__, completion_status, request);
-
-                        response = SAS_TASK_UNDELIVERED;
-
-                        /* See if the device has been/is being stopped. Note
-                         * that we ignore the quiesce state, since we are
-                         * concerned about the actual device state.
-                         */
-                        if (!idev)
-                                status = SAS_DEVICE_UNKNOWN;
-                        else
-                                status = SAS_ABORTED_TASK;
-
-                        if (SAS_PROTOCOL_SMP == task->task_proto) {
-                                set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
-                                complete_to_host = isci_perform_normal_io_completion;
-                        } else {
-                                clear_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
-                                complete_to_host = isci_perform_error_io_completion;
-                        }
-                        break;
-                }
                 break;
         }
 
@@ -3038,10 +2938,18 @@ static void isci_request_io_request_complete(struct isci_host *ihost,
                 break;
         }
 
-        /* Put the completed request on the correct list */
-        isci_task_save_for_upper_layer_completion(ihost, request, response,
-                                                  status, complete_to_host
-                                                  );
+        spin_lock_irqsave(&task->task_state_lock, task_flags);
+
+        task->task_status.resp = response;
+        task->task_status.stat = status;
+
+        if (test_bit(IREQ_COMPLETE_IN_TARGET, &request->flags)) {
+                /* Normal notification (task_done) */
+                task->task_state_flags |= SAS_TASK_STATE_DONE;
+                task->task_state_flags &= ~(SAS_TASK_AT_INITIATOR |
+                                            SAS_TASK_STATE_PENDING);
+        }
+        spin_unlock_irqrestore(&task->task_state_lock, task_flags);
 
         /* complete the io request to the core. */
         sci_controller_complete_io(ihost, request->target_device, request);
@@ -3051,6 +2959,8 @@ static void isci_request_io_request_complete(struct isci_host *ihost,
          * task to recognize the already completed case.
          */
         set_bit(IREQ_TERMINATED, &request->flags);
+
+        ireq_done(ihost, request, task);
 }
 
 static void sci_request_started_state_enter(struct sci_base_state_machine *sm)
@@ -3169,7 +3079,7 @@ sci_general_request_construct(struct isci_host *ihost,
         sci_init_sm(&ireq->sm, sci_request_state_table, SCI_REQ_INIT);
 
         ireq->target_device = idev;
-        ireq->protocol = SCIC_NO_PROTOCOL;
+        ireq->protocol = SAS_PROTOCOL_NONE;
         ireq->saved_rx_frame_index = SCU_INVALID_FRAME_INDEX;
 
         ireq->sci_status   = SCI_SUCCESS;
@@ -3193,7 +3103,7 @@ sci_io_request_construct(struct isci_host *ihost,
 
         if (dev->dev_type == SAS_END_DEV)
                 /* pass */;
-        else if (dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP))
+        else if (dev_is_sata(dev))
                 memset(&ireq->stp.cmd, 0, sizeof(ireq->stp.cmd));
         else if (dev_is_expander(dev))
                 /* pass */;
@@ -3215,10 +3125,15 @@ 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->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP)) {
+        if (dev->dev_type == SAS_END_DEV || dev_is_sata(dev)) {
                 set_bit(IREQ_TMF, &ireq->flags);
                 memset(ireq->tc, 0, sizeof(struct scu_task_context));
+
+                /* Set the protocol indicator. */
+                if (dev_is_sata(dev))
+                        ireq->protocol = SAS_PROTOCOL_STP;
+                else
+                        ireq->protocol = SAS_PROTOCOL_SSP;
         } else
                 status = SCI_FAILURE_UNSUPPORTED_PROTOCOL;
 
@@ -3311,7 +3226,7 @@ sci_io_request_construct_smp(struct device *dev,
         if (!dma_map_sg(dev, sg, 1, DMA_TO_DEVICE))
                 return SCI_FAILURE;
 
-        ireq->protocol = SCIC_SMP_PROTOCOL;
+        ireq->protocol = SAS_PROTOCOL_SMP;
 
         /* byte swap the smp request. */
 
@@ -3496,9 +3411,6 @@ static struct isci_request *isci_request_from_tag(struct isci_host *ihost, u16 t
         ireq->io_request_completion = NULL;
         ireq->flags = 0;
         ireq->num_sg_entries = 0;
-        INIT_LIST_HEAD(&ireq->completed_node);
-        INIT_LIST_HEAD(&ireq->dev_node);
-        isci_request_change_state(ireq, allocated);
 
         return ireq;
 }
@@ -3582,26 +3494,15 @@ int isci_request_execute(struct isci_host *ihost, struct isci_remote_device *ide
                 spin_unlock_irqrestore(&ihost->scic_lock, flags);
                 return status;
         }
-
         /* Either I/O started OK, or the core has signaled that
          * the device needs a target reset.
-         *
-         * In either case, hold onto the I/O for later.
-         *
-         * Update it's status and add it to the list in the
-         * remote device object.
          */
-        list_add(&ireq->dev_node, &idev->reqs_in_process);
-
-        if (status == SCI_SUCCESS) {
-                isci_request_change_state(ireq, started);
-        } else {
+        if (status != SCI_SUCCESS) {
                 /* The request did not really start in the
                  * hardware, so clear the request handle
                  * here so no terminations will be done.
                  */
                 set_bit(IREQ_TERMINATED, &ireq->flags);
-                isci_request_change_state(ireq, completed);
         }
         spin_unlock_irqrestore(&ihost->scic_lock, flags);
 
diff --git a/drivers/scsi/isci/request.h b/drivers/scsi/isci/request.h
index 057f2378452d..aff95317fcf4 100644
--- a/drivers/scsi/isci/request.h
+++ b/drivers/scsi/isci/request.h
@@ -61,30 +61,6 @@
 #include "scu_task_context.h"
 
 /**
- * struct isci_request_status - This enum defines the possible states of an I/O
- *    request.
- *
- *
- */
-enum isci_request_status {
-        unallocated = 0x00,
-        allocated   = 0x01,
-        started     = 0x02,
-        completed   = 0x03,
-        aborting    = 0x04,
-        aborted     = 0x05,
-        terminating = 0x06,
-        dead        = 0x07
-};
-
-enum sci_request_protocol {
-        SCIC_NO_PROTOCOL,
-        SCIC_SMP_PROTOCOL,
-        SCIC_SSP_PROTOCOL,
-        SCIC_STP_PROTOCOL
-}; /* XXX remove me, use sas_task.{dev|task_proto} instead */;
-
-/**
  * isci_stp_request - extra request infrastructure to handle pio/atapi protocol
  * @pio_len - number of bytes requested at PIO setup
  * @status - pio setup ending status value to tell us if we need
@@ -104,11 +80,14 @@ struct isci_stp_request {
 };
 
 struct isci_request {
-        enum isci_request_status status;
         #define IREQ_COMPLETE_IN_TARGET 0
         #define IREQ_TERMINATED 1
         #define IREQ_TMF 2
         #define IREQ_ACTIVE 3
+        #define IREQ_PENDING_ABORT 4 /* Set == device was not suspended yet */
+        #define IREQ_TC_ABORT_POSTED 5
+        #define IREQ_ABORT_PATH_ACTIVE 6
+        #define IREQ_NO_AUTO_FREE_TAG 7 /* Set when being explicitly managed */
         unsigned long flags;
         /* XXX kill ttype and ttype_ptr, allocate full sas_task */
         union ttype_ptr_union {
@@ -116,11 +95,6 @@ struct isci_request {
                 struct isci_tmf *tmf_task_ptr;  /* When ttype==tmf_task */
         } ttype_ptr;
         struct isci_host *isci_host;
-        /* For use in the requests_to_{complete|abort} lists: */
-        struct list_head completed_node;
-        /* For use in the reqs_in_process list: */
-        struct list_head dev_node;
-        spinlock_t state_lock;
         dma_addr_t request_daddr;
         dma_addr_t zero_scatter_daddr;
         unsigned int num_sg_entries;
@@ -140,7 +114,7 @@ struct isci_request {
         struct isci_host *owning_controller;
         struct isci_remote_device *target_device;
         u16 io_tag;
-        enum sci_request_protocol protocol;
+        enum sas_protocol protocol;
         u32 scu_status; /* hardware result */
         u32 sci_status; /* upper layer disposition */
         u32 post_context;
@@ -309,92 +283,6 @@ sci_io_request_get_dma_addr(struct isci_request *ireq, void *virt_addr)
         return ireq->request_daddr + (requested_addr - base_addr);
 }
 
-/**
- * isci_request_change_state() - This function sets the status of the request
- *    object.
- * @request: This parameter points to the isci_request object
- * @status: This Parameter is the new status of the object
- *
- */
-static inline enum isci_request_status
-isci_request_change_state(struct isci_request *isci_request,
-                          enum isci_request_status status)
-{
-        enum isci_request_status old_state;
-        unsigned long flags;
-
-        dev_dbg(&isci_request->isci_host->pdev->dev,
-                "%s: isci_request = %p, state = 0x%x\n",
-                __func__,
-                isci_request,
-                status);
-
-        BUG_ON(isci_request == NULL);
-
-        spin_lock_irqsave(&isci_request->state_lock, flags);
-        old_state = isci_request->status;
-        isci_request->status = status;
-        spin_unlock_irqrestore(&isci_request->state_lock, flags);
-
-        return old_state;
-}
-
-/**
- * isci_request_change_started_to_newstate() - This function sets the status of
- *    the request object.
- * @request: This parameter points to the isci_request object
- * @status: This Parameter is the new status of the object
- *
- * state previous to any change.
- */
-static inline enum isci_request_status
-isci_request_change_started_to_newstate(struct isci_request *isci_request,
-                                        struct completion *completion_ptr,
-                                        enum isci_request_status newstate)
-{
-        enum isci_request_status old_state;
-        unsigned long flags;
-
-        spin_lock_irqsave(&isci_request->state_lock, flags);
-
-        old_state = isci_request->status;
-
-        if (old_state == started || old_state == aborting) {
-                BUG_ON(isci_request->io_request_completion != NULL);
-
-                isci_request->io_request_completion = completion_ptr;
-                isci_request->status = newstate;
-        }
-
-        spin_unlock_irqrestore(&isci_request->state_lock, flags);
-
-        dev_dbg(&isci_request->isci_host->pdev->dev,
-                "%s: isci_request = %p, old_state = 0x%x\n",
-                __func__,
-                isci_request,
-                old_state);
-
-        return old_state;
-}
-
-/**
- * isci_request_change_started_to_aborted() - This function sets the status of
- *    the request object.
- * @request: This parameter points to the isci_request object
- * @completion_ptr: This parameter is saved as the kernel completion structure
- *    signalled when the old request completes.
- *
- * state previous to any change.
- */
-static inline enum isci_request_status
-isci_request_change_started_to_aborted(struct isci_request *isci_request,
-                                       struct completion *completion_ptr)
-{
-        return isci_request_change_started_to_newstate(isci_request,
-                                                       completion_ptr,
-                                                       aborted);
-}
-
 #define isci_request_access_task(req) ((req)->ttype_ptr.io_task_ptr)
 
 #define isci_request_access_tmf(req) ((req)->ttype_ptr.tmf_task_ptr)
@@ -404,8 +292,6 @@ struct isci_request *isci_tmf_request_from_tag(struct isci_host *ihost,
                                                u16 tag);
 int isci_request_execute(struct isci_host *ihost, struct isci_remote_device *idev,
                          struct sas_task *task, u16 tag);
-void isci_terminate_pending_requests(struct isci_host *ihost,
-                                     struct isci_remote_device *idev);
 enum sci_status
 sci_task_request_construct(struct isci_host *ihost,
                             struct isci_remote_device *idev,
@@ -421,5 +307,4 @@ static inline int isci_task_is_ncq_recovery(struct sas_task *task)
                 task->ata_task.fis.lbal == ATA_LOG_SATA_NCQ);
 
 }
-
 #endif /* !defined(_ISCI_REQUEST_H_) */
diff --git a/drivers/scsi/isci/scu_completion_codes.h b/drivers/scsi/isci/scu_completion_codes.h
index c8b329c695f9..071cb74a211c 100644
--- a/drivers/scsi/isci/scu_completion_codes.h
+++ b/drivers/scsi/isci/scu_completion_codes.h
@@ -224,6 +224,7 @@
  * 32-bit value like we want, each immediate value must be cast to a u32.
  */
 #define SCU_TASK_DONE_GOOD                                  ((u32)0x00)
+#define SCU_TASK_DONE_TX_RAW_CMD_ERR                        ((u32)0x08)
 #define SCU_TASK_DONE_CRC_ERR                               ((u32)0x14)
 #define SCU_TASK_DONE_CHECK_RESPONSE                        ((u32)0x14)
 #define SCU_TASK_DONE_GEN_RESPONSE                          ((u32)0x15)
@@ -237,6 +238,7 @@
 #define SCU_TASK_DONE_LL_LF_TERM                            ((u32)0x1A)
 #define SCU_TASK_DONE_DATA_LEN_ERR                          ((u32)0x1A)
 #define SCU_TASK_DONE_LL_CL_TERM                            ((u32)0x1B)
+#define SCU_TASK_DONE_BREAK_RCVD                            ((u32)0x1B)
 #define SCU_TASK_DONE_LL_ABORT_ERR                          ((u32)0x1B)
 #define SCU_TASK_DONE_SEQ_INV_TYPE                          ((u32)0x1C)
 #define SCU_TASK_DONE_UNEXP_XR                              ((u32)0x1C)
diff --git a/drivers/scsi/isci/task.c b/drivers/scsi/isci/task.c
index 374254ede9d4..6bc74eb012c9 100644
--- a/drivers/scsi/isci/task.c
+++ b/drivers/scsi/isci/task.c
@@ -78,54 +78,25 @@ static void isci_task_refuse(struct isci_host *ihost, struct sas_task *task,
                              enum exec_status status)
 
 {
-        enum isci_completion_selection disposition;
+        unsigned long flags;
 
-        disposition = isci_perform_normal_io_completion;
-        disposition = isci_task_set_completion_status(task, response, status,
-                                                      disposition);
+        /* Normal notification (task_done) */
+        dev_dbg(&ihost->pdev->dev, "%s: task = %p, response=%d, status=%d\n",
+                __func__, task, response, status);
 
-        /* Tasks aborted specifically by a call to the lldd_abort_task
-         * function should not be completed to the host in the regular path.
-         */
-        switch (disposition) {
-        case isci_perform_normal_io_completion:
-                /* Normal notification (task_done) */
-                dev_dbg(&ihost->pdev->dev,
-                        "%s: Normal - task = %p, response=%d, "
-                        "status=%d\n",
-                        __func__, task, response, status);
-
-                task->lldd_task = NULL;
-                task->task_done(task);
-                break;
-
-        case isci_perform_aborted_io_completion:
-                /*
-                 * No notification because this request is already in the
-                 * abort path.
-                 */
-                dev_dbg(&ihost->pdev->dev,
-                        "%s: Aborted - task = %p, response=%d, "
-                        "status=%d\n",
-                        __func__, task, response, status);
-                break;
+        spin_lock_irqsave(&task->task_state_lock, flags);
 
-        case isci_perform_error_io_completion:
-                /* Use sas_task_abort */
-                dev_dbg(&ihost->pdev->dev,
-                        "%s: Error - task = %p, response=%d, "
-                        "status=%d\n",
-                        __func__, task, response, status);
-                sas_task_abort(task);
-                break;
+        task->task_status.resp = response;
+        task->task_status.stat = status;
 
-        default:
-                dev_dbg(&ihost->pdev->dev,
-                        "%s: isci task notification default case!",
-                        __func__);
-                sas_task_abort(task);
-                break;
-        }
+        /* Normal notification (task_done) */
+        task->task_state_flags |= SAS_TASK_STATE_DONE;
+        task->task_state_flags &= ~(SAS_TASK_AT_INITIATOR |
+                                    SAS_TASK_STATE_PENDING);
+        task->lldd_task = NULL;
+        spin_unlock_irqrestore(&task->task_state_lock, flags);
+
+        task->task_done(task);
 }
 
 #define for_each_sas_task(num, task) \
@@ -289,60 +260,6 @@ static struct isci_request *isci_task_request_build(struct isci_host *ihost,
         return ireq;
 }
 
-/**
-* isci_request_mark_zombie() - This function must be called with scic_lock held.
-*/
-static void isci_request_mark_zombie(struct isci_host *ihost, struct isci_request *ireq)
-{
-        struct completion *tmf_completion = NULL;
-        struct completion *req_completion;
-
-        /* Set the request state to "dead". */
-        ireq->status = dead;
-
-        req_completion = ireq->io_request_completion;
-        ireq->io_request_completion = NULL;
-
-        if (test_bit(IREQ_TMF, &ireq->flags)) {
-                /* Break links with the TMF request. */
-                struct isci_tmf *tmf = isci_request_access_tmf(ireq);
-
-                /* In the case where a task request is dying,
-                 * the thread waiting on the complete will sit and
-                 * timeout unless we wake it now.  Since the TMF
-                 * has a default error status, complete it here
-                 * to wake the waiting thread.
-                 */
-                if (tmf) {
-                        tmf_completion = tmf->complete;
-                        tmf->complete = NULL;
-                }
-                ireq->ttype_ptr.tmf_task_ptr = NULL;
-                dev_dbg(&ihost->pdev->dev, "%s: tmf_code %d, managed tag %#x\n",
-                        __func__, tmf->tmf_code, tmf->io_tag);
-        } else {
-                /* Break links with the sas_task - the callback is done
-                 * elsewhere.
-                 */
-                struct sas_task *task = isci_request_access_task(ireq);
-
-                if (task)
-                        task->lldd_task = NULL;
-
-                ireq->ttype_ptr.io_task_ptr = NULL;
-        }
-
-        dev_warn(&ihost->pdev->dev, "task context unrecoverable (tag: %#x)\n",
-                 ireq->io_tag);
-
-        /* Don't force waiting threads to timeout. */
-        if (req_completion)
-                complete(req_completion);
-
-        if (tmf_completion != NULL)
-                complete(tmf_completion);
-}
-
 static int isci_task_execute_tmf(struct isci_host *ihost,
                                  struct isci_remote_device *idev,
                                  struct isci_tmf *tmf, unsigned long timeout_ms)
@@ -400,17 +317,11 @@ static int isci_task_execute_tmf(struct isci_host *ihost,
                 spin_unlock_irqrestore(&ihost->scic_lock, flags);
                 goto err_tci;
         }
-
-        if (tmf->cb_state_func != NULL)
-                tmf->cb_state_func(isci_tmf_started, tmf, tmf->cb_data);
-
-        isci_request_change_state(ireq, started);
-
-        /* add the request to the remote device request list. */
-        list_add(&ireq->dev_node, &idev->reqs_in_process);
-
         spin_unlock_irqrestore(&ihost->scic_lock, flags);
 
+        /* The RNC must be unsuspended before the TMF can get a response. */
+        isci_remote_device_resume_from_abort(ihost, idev);
+
         /* Wait for the TMF to complete, or a timeout. */
         timeleft = wait_for_completion_timeout(&completion,
                                                msecs_to_jiffies(timeout_ms));
@@ -419,32 +330,7 @@ static int isci_task_execute_tmf(struct isci_host *ihost,
                 /* The TMF did not complete - this could be because
                  * of an unplug.  Terminate the TMF request now.
                  */
-                spin_lock_irqsave(&ihost->scic_lock, flags);
-
-                if (tmf->cb_state_func != NULL)
-                        tmf->cb_state_func(isci_tmf_timed_out, tmf,
-                                           tmf->cb_data);
-
-                sci_controller_terminate_request(ihost, idev, ireq);
-
-                spin_unlock_irqrestore(&ihost->scic_lock, flags);
-
-                timeleft = wait_for_completion_timeout(
-                        &completion,
-                        msecs_to_jiffies(ISCI_TERMINATION_TIMEOUT_MSEC));
-
-                if (!timeleft) {
-                        /* Strange condition - the termination of the TMF
-                         * request timed-out.
-                         */
-                        spin_lock_irqsave(&ihost->scic_lock, flags);
-
-                        /* If the TMF status has not changed, kill it. */
-                        if (tmf->status == SCI_FAILURE_TIMEOUT)
-                                isci_request_mark_zombie(ihost, ireq);
-
-                        spin_unlock_irqrestore(&ihost->scic_lock, flags);
-                }
+                isci_remote_device_suspend_terminate(ihost, idev, ireq);
         }
 
         isci_print_tmf(ihost, tmf);
@@ -476,315 +362,21 @@ static int isci_task_execute_tmf(struct isci_host *ihost,
 }
 
 static void isci_task_build_tmf(struct isci_tmf *tmf,
-                                enum isci_tmf_function_codes code,
-                                void (*tmf_sent_cb)(enum isci_tmf_cb_state,
-                                                    struct isci_tmf *,
-                                                    void *),
-                                void *cb_data)
+                                enum isci_tmf_function_codes code)
 {
         memset(tmf, 0, sizeof(*tmf));
-
-        tmf->tmf_code      = code;
-        tmf->cb_state_func = tmf_sent_cb;
-        tmf->cb_data       = cb_data;
+        tmf->tmf_code = code;
 }
 
 static void isci_task_build_abort_task_tmf(struct isci_tmf *tmf,
                                            enum isci_tmf_function_codes code,
-                                           void (*tmf_sent_cb)(enum isci_tmf_cb_state,
-                                                               struct isci_tmf *,
-                                                               void *),
                                            struct isci_request *old_request)
 {
-        isci_task_build_tmf(tmf, code, tmf_sent_cb, old_request);
+        isci_task_build_tmf(tmf, code);
         tmf->io_tag = old_request->io_tag;
 }
 
 /**
- * isci_task_validate_request_to_abort() - This function checks the given I/O
- *    against the "started" state.  If the request is still "started", it's
- *    state is changed to aborted. NOTE: isci_host->scic_lock MUST BE HELD
- *    BEFORE CALLING THIS FUNCTION.
- * @isci_request: This parameter specifies the request object to control.
- * @isci_host: This parameter specifies the ISCI host object
- * @isci_device: This is the device to which the request is pending.
- * @aborted_io_completion: This is a completion structure that will be added to
- *    the request in case it is changed to aborting; this completion is
- *    triggered when the request is fully completed.
- *
- * Either "started" on successful change of the task status to "aborted", or
- * "unallocated" if the task cannot be controlled.
- */
-static enum isci_request_status isci_task_validate_request_to_abort(
-        struct isci_request *isci_request,
-        struct isci_host *isci_host,
-        struct isci_remote_device *isci_device,
-        struct completion *aborted_io_completion)
-{
-        enum isci_request_status old_state = unallocated;
-
-        /* Only abort the task if it's in the
-         *  device's request_in_process list
-         */
-        if (isci_request && !list_empty(&isci_request->dev_node)) {
-                old_state = isci_request_change_started_to_aborted(
-                        isci_request, aborted_io_completion);
-
-        }
-
-        return old_state;
-}
-
-static int isci_request_is_dealloc_managed(enum isci_request_status stat)
-{
-        switch (stat) {
-        case aborted:
-        case aborting:
-        case terminating:
-        case completed:
-        case dead:
-                return true;
-        default:
-                return false;
-        }
-}
-
-/**
- * isci_terminate_request_core() - This function will terminate the given
- *    request, and wait for it to complete.  This function must only be called
- *    from a thread that can wait.  Note that the request is terminated and
- *    completed (back to the host, if started there).
- * @ihost: This SCU.
- * @idev: The target.
- * @isci_request: The I/O request to be terminated.
- *
- */
-static void isci_terminate_request_core(struct isci_host *ihost,
-                                        struct isci_remote_device *idev,
-                                        struct isci_request *isci_request)
-{
-        enum sci_status status      = SCI_SUCCESS;
-        bool was_terminated         = false;
-        bool needs_cleanup_handling = false;
-        unsigned long     flags;
-        unsigned long     termination_completed = 1;
-        struct completion *io_request_completion;
-
-        dev_dbg(&ihost->pdev->dev,
-                "%s: device = %p; request = %p\n",
-                __func__, idev, isci_request);
-
-        spin_lock_irqsave(&ihost->scic_lock, flags);
-
-        io_request_completion = isci_request->io_request_completion;
-
-        /* Note that we are not going to control
-         * the target to abort the request.
-         */
-        set_bit(IREQ_COMPLETE_IN_TARGET, &isci_request->flags);
-
-        /* Make sure the request wasn't just sitting around signalling
-         * device condition (if the request handle is NULL, then the
-         * request completed but needed additional handling here).
-         */
-        if (!test_bit(IREQ_TERMINATED, &isci_request->flags)) {
-                was_terminated = true;
-                needs_cleanup_handling = true;
-                status = sci_controller_terminate_request(ihost,
-                                                           idev,
-                                                           isci_request);
-        }
-        spin_unlock_irqrestore(&ihost->scic_lock, flags);
-
-        /*
-         * The only time the request to terminate will
-         * fail is when the io request is completed and
-         * being aborted.
-         */
-        if (status != SCI_SUCCESS) {
-                dev_dbg(&ihost->pdev->dev,
-                        "%s: sci_controller_terminate_request"
-                        " returned = 0x%x\n",
-                        __func__, status);
-
-                isci_request->io_request_completion = NULL;
-
-        } else {
-                if (was_terminated) {
-                        dev_dbg(&ihost->pdev->dev,
-                                "%s: before completion wait (%p/%p)\n",
-                                __func__, isci_request, io_request_completion);
-
-                        /* Wait here for the request to complete. */
-                        termination_completed
-                                = wait_for_completion_timeout(
-                                   io_request_completion,
-                                   msecs_to_jiffies(ISCI_TERMINATION_TIMEOUT_MSEC));
-
-                        if (!termination_completed) {
-
-                                /* The request to terminate has timed out.  */
-                                spin_lock_irqsave(&ihost->scic_lock, flags);
-
-                                /* Check for state changes. */
-                                if (!test_bit(IREQ_TERMINATED,
-                                              &isci_request->flags)) {
-
-                                        /* The best we can do is to have the
-                                         * request die a silent death if it
-                                         * ever really completes.
-                                         */
-                                        isci_request_mark_zombie(ihost,
-                                                                 isci_request);
-                                        needs_cleanup_handling = true;
-                                } else
-                                        termination_completed = 1;
-
-                                spin_unlock_irqrestore(&ihost->scic_lock,
-                                                       flags);
-
-                                if (!termination_completed) {
-
-                                        dev_dbg(&ihost->pdev->dev,
-                                                "%s: *** Timeout waiting for "
-                                                "termination(%p/%p)\n",
-                                                __func__, io_request_completion,
-                                                isci_request);
-
-                                        /* The request can no longer be referenced
-                                         * safely since it may go away if the
-                                         * termination every really does complete.
-                                         */
-                                        isci_request = NULL;
-                                }
-                        }
-                        if (termination_completed)
-                                dev_dbg(&ihost->pdev->dev,
-                                        "%s: after completion wait (%p/%p)\n",
-                                        __func__, isci_request, io_request_completion);
-                }
-
-                if (termination_completed) {
-
-                        isci_request->io_request_completion = NULL;
-
-                        /* Peek at the status of the request.  This will tell
-                         * us if there was special handling on the request such that it
-                         * needs to be detached and freed here.
-                         */
-                        spin_lock_irqsave(&isci_request->state_lock, flags);
-
-                        needs_cleanup_handling
-                                = isci_request_is_dealloc_managed(
-                                        isci_request->status);
-
-                        spin_unlock_irqrestore(&isci_request->state_lock, flags);
-
-                }
-                if (needs_cleanup_handling) {
-
-                        dev_dbg(&ihost->pdev->dev,
-                                "%s: cleanup isci_device=%p, request=%p\n",
-                                __func__, idev, isci_request);
-
-                        if (isci_request != NULL) {
-                                spin_lock_irqsave(&ihost->scic_lock, flags);
-                                isci_free_tag(ihost, isci_request->io_tag);
-                                isci_request_change_state(isci_request, unallocated);
-                                list_del_init(&isci_request->dev_node);
-                                spin_unlock_irqrestore(&ihost->scic_lock, flags);
-                        }
-                }
-        }
-}
-
-/**
- * isci_terminate_pending_requests() - This function will change the all of the
- *    requests on the given device's state to "aborting", will terminate the
- *    requests, and wait for them to complete.  This function must only be
- *    called from a thread that can wait.  Note that the requests are all
- *    terminated and completed (back to the host, if started there).
- * @isci_host: This parameter specifies SCU.
- * @idev: This parameter specifies the target.
- *
- */
-void isci_terminate_pending_requests(struct isci_host *ihost,
-                                     struct isci_remote_device *idev)
-{
-        struct completion request_completion;
-        enum isci_request_status old_state;
-        unsigned long flags;
-        LIST_HEAD(list);
-
-        spin_lock_irqsave(&ihost->scic_lock, flags);
-        list_splice_init(&idev->reqs_in_process, &list);
-
-        /* assumes that isci_terminate_request_core deletes from the list */
-        while (!list_empty(&list)) {
-                struct isci_request *ireq = list_entry(list.next, typeof(*ireq), dev_node);
-
-                /* Change state to "terminating" if it is currently
-                 * "started".
-                 */
-                old_state = isci_request_change_started_to_newstate(ireq,
-                                                                    &request_completion,
-                                                                    terminating);
-                switch (old_state) {
-                case started:
-                case completed:
-                case aborting:
-                        break;
-                default:
-                        /* termination in progress, or otherwise dispositioned.
-                         * We know the request was on 'list' so should be safe
-                         * to move it back to reqs_in_process
-                         */
-                        list_move(&ireq->dev_node, &idev->reqs_in_process);
-                        ireq = NULL;
-                        break;
-                }
-
-                if (!ireq)
-                        continue;
-                spin_unlock_irqrestore(&ihost->scic_lock, flags);
-
-                init_completion(&request_completion);
-
-                dev_dbg(&ihost->pdev->dev,
-                         "%s: idev=%p request=%p; task=%p old_state=%d\n",
-                         __func__, idev, ireq,
-                        (!test_bit(IREQ_TMF, &ireq->flags)
-                                ? isci_request_access_task(ireq)
-                                : NULL),
-                        old_state);
-
-                /* If the old_state is started:
-                 * This request was not already being aborted. If it had been,
-                 * then the aborting I/O (ie. the TMF request) would not be in
-                 * the aborting state, and thus would be terminated here.  Note
-                 * that since the TMF completion's call to the kernel function
-                 * "complete()" does not happen until the pending I/O request
-                 * terminate fully completes, we do not have to implement a
-                 * special wait here for already aborting requests - the
-                 * termination of the TMF request will force the request
-                 * to finish it's already started terminate.
-                 *
-                 * If old_state == completed:
-                 * This request completed from the SCU hardware perspective
-                 * and now just needs cleaning up in terms of freeing the
-                 * request and potentially calling up to libsas.
-                 *
-                 * If old_state == aborting:
-                 * This request has already gone through a TMF timeout, but may
-                 * not have been terminated; needs cleaning up at least.
-                 */
-                isci_terminate_request_core(ihost, idev, ireq);
-                spin_lock_irqsave(&ihost->scic_lock, flags);
-        }
-        spin_unlock_irqrestore(&ihost->scic_lock, flags);
-}
-
-/**
  * isci_task_send_lu_reset_sas() - This function is called by of the SAS Domain
  *    Template functions.
  * @lun: This parameter specifies the lun to be reset.
@@ -807,7 +399,7 @@ static int isci_task_send_lu_reset_sas(
          * value is "TMF_RESP_FUNC_COMPLETE", or the request timed-out (or
          * was otherwise unable to be executed ("TMF_RESP_FUNC_FAILED").
          */
-        isci_task_build_tmf(&tmf, isci_tmf_ssp_lun_reset, NULL, NULL);
+        isci_task_build_tmf(&tmf, isci_tmf_ssp_lun_reset);
 
         #define ISCI_LU_RESET_TIMEOUT_MS 2000 /* 2 second timeout. */
         ret = isci_task_execute_tmf(isci_host, isci_device, &tmf, ISCI_LU_RESET_TIMEOUT_MS);
@@ -826,42 +418,44 @@ static int isci_task_send_lu_reset_sas(
 
 int isci_task_lu_reset(struct domain_device *dev, u8 *lun)
 {
-        struct isci_host *isci_host = dev_to_ihost(dev);
-        struct isci_remote_device *isci_device;
+        struct isci_host *ihost = dev_to_ihost(dev);
+        struct isci_remote_device *idev;
         unsigned long flags;
-        int ret;
+        int ret = TMF_RESP_FUNC_COMPLETE;
 
-        spin_lock_irqsave(&isci_host->scic_lock, flags);
-        isci_device = isci_lookup_device(dev);
-        spin_unlock_irqrestore(&isci_host->scic_lock, flags);
+        spin_lock_irqsave(&ihost->scic_lock, flags);
+        idev = isci_get_device(dev->lldd_dev);
+        spin_unlock_irqrestore(&ihost->scic_lock, flags);
 
-        dev_dbg(&isci_host->pdev->dev,
+        dev_dbg(&ihost->pdev->dev,
                 "%s: domain_device=%p, isci_host=%p; isci_device=%p\n",
-                 __func__, dev, isci_host, isci_device);
+                __func__, dev, ihost, idev);
 
-        if (!isci_device) {
-                /* If the device is gone, stop the escalations. */
-                dev_dbg(&isci_host->pdev->dev, "%s: No dev\n", __func__);
+        if (!idev) {
+                /* If the device is gone, escalate to I_T_Nexus_Reset. */
+                dev_dbg(&ihost->pdev->dev, "%s: No dev\n", __func__);
 
-                ret = TMF_RESP_FUNC_COMPLETE;
+                ret = TMF_RESP_FUNC_FAILED;
                 goto out;
         }
 
-        /* Send the task management part of the reset. */
-        if (dev_is_sata(dev)) {
-                sas_ata_schedule_reset(dev);
-                ret = TMF_RESP_FUNC_COMPLETE;
-        } else
-                ret = isci_task_send_lu_reset_sas(isci_host, isci_device, lun);
-
-        /* If the LUN reset worked, all the I/O can now be terminated. */
-        if (ret == TMF_RESP_FUNC_COMPLETE)
-                /* Terminate all I/O now. */
-                isci_terminate_pending_requests(isci_host,
-                                                isci_device);
-
+        /* Suspend the RNC, kill all TCs */
+        if (isci_remote_device_suspend_terminate(ihost, idev, NULL)
+            != SCI_SUCCESS) {
+                /* The suspend/terminate only fails if isci_get_device fails */
+                ret = TMF_RESP_FUNC_FAILED;
+                goto out;
+        }
+        /* All pending I/Os have been terminated and cleaned up. */
+        if (!test_bit(IDEV_GONE, &idev->flags)) {
+                if (dev_is_sata(dev))
+                        sas_ata_schedule_reset(dev);
+                else
+                        /* Send the task management part of the reset. */
+                        ret = isci_task_send_lu_reset_sas(ihost, idev, lun);
+        }
  out:
-        isci_put_device(isci_device);
+        isci_put_device(idev);
         return ret;
 }
 
@@ -882,63 +476,6 @@ int isci_task_clear_nexus_ha(struct sas_ha_struct *ha)
 /* Task Management Functions. Must be called from process context.       */
 
 /**
- * isci_abort_task_process_cb() - This is a helper function for the abort task
- *    TMF command.  It manages the request state with respect to the successful
- *    transmission / completion of the abort task request.
- * @cb_state: This parameter specifies when this function was called - after
- *    the TMF request has been started and after it has timed-out.
- * @tmf: This parameter specifies the TMF in progress.
- *
- *
- */
-static void isci_abort_task_process_cb(
-        enum isci_tmf_cb_state cb_state,
-        struct isci_tmf *tmf,
-        void *cb_data)
-{
-        struct isci_request *old_request;
-
-        old_request = (struct isci_request *)cb_data;
-
-        dev_dbg(&old_request->isci_host->pdev->dev,
-                "%s: tmf=%p, old_request=%p\n",
-                __func__, tmf, old_request);
-
-        switch (cb_state) {
-
-        case isci_tmf_started:
-                /* The TMF has been started.  Nothing to do here, since the
-                 * request state was already set to "aborted" by the abort
-                 * task function.
-                 */
-                if ((old_request->status != aborted)
-                        && (old_request->status != completed))
-                        dev_dbg(&old_request->isci_host->pdev->dev,
-                                "%s: Bad request status (%d): tmf=%p, old_request=%p\n",
-                                __func__, old_request->status, tmf, old_request);
-                break;
-
-        case isci_tmf_timed_out:
-
-                /* Set the task's state to "aborting", since the abort task
-                 * function thread set it to "aborted" (above) in anticipation
-                 * of the task management request working correctly.  Since the
-                 * timeout has now fired, the TMF request failed.  We set the
-                 * state such that the request completion will indicate the
-                 * device is no longer present.
-                 */
-                isci_request_change_state(old_request, aborting);
-                break;
-
-        default:
-                dev_dbg(&old_request->isci_host->pdev->dev,
-                        "%s: Bad cb_state (%d): tmf=%p, old_request=%p\n",
-                        __func__, cb_state, tmf, old_request);
-                break;
-        }
-}
-
-/**
  * isci_task_abort_task() - This function is one of the SAS Domain Template
  *    functions. This function is called by libsas to abort a specified task.
  * @task: This parameter specifies the SAS task to abort.
@@ -947,22 +484,20 @@ static void isci_abort_task_process_cb(
  */
 int isci_task_abort_task(struct sas_task *task)
 {
-        struct isci_host *isci_host = dev_to_ihost(task->dev);
+        struct isci_host *ihost = dev_to_ihost(task->dev);
         DECLARE_COMPLETION_ONSTACK(aborted_io_completion);
         struct isci_request       *old_request = NULL;
-        enum isci_request_status  old_state;
-        struct isci_remote_device *isci_device = NULL;
+        struct isci_remote_device *idev = NULL;
         struct isci_tmf           tmf;
         int                       ret = TMF_RESP_FUNC_FAILED;
         unsigned long             flags;
-        int                       perform_termination = 0;
 
         /* Get the isci_request reference from the task.  Note that
          * this check does not depend on the pending request list
          * in the device, because tasks driving resets may land here
          * after completion in the core.
          */
-        spin_lock_irqsave(&isci_host->scic_lock, flags);
+        spin_lock_irqsave(&ihost->scic_lock, flags);
         spin_lock(&task->task_state_lock);
 
         old_request = task->lldd_task;
@@ -971,20 +506,29 @@ int isci_task_abort_task(struct sas_task *task)
         if (!(task->task_state_flags & SAS_TASK_STATE_DONE) &&
             (task->task_state_flags & SAS_TASK_AT_INITIATOR) &&
             old_request)
-                isci_device = isci_lookup_device(task->dev);
+                idev = isci_get_device(task->dev->lldd_dev);
 
         spin_unlock(&task->task_state_lock);
-        spin_unlock_irqrestore(&isci_host->scic_lock, flags);
+        spin_unlock_irqrestore(&ihost->scic_lock, flags);
 
-        dev_dbg(&isci_host->pdev->dev,
-                "%s: dev = %p, task = %p, old_request == %p\n",
-                __func__, isci_device, task, old_request);
+        dev_warn(&ihost->pdev->dev,
+                 "%s: dev = %p (%s%s), task = %p, old_request == %p\n",
+                 __func__, idev,
+                 (dev_is_sata(task->dev) ? "STP/SATA"
+                                         : ((dev_is_expander(task->dev))
+                                                ? "SMP"
+                                                : "SSP")),
+                 ((idev) ? ((test_bit(IDEV_GONE, &idev->flags))
+                           ? " IDEV_GONE"
+                           : "")
+                         : " <NULL>"),
+                 task, old_request);
 
         /* Device reset conditions signalled in task_state_flags are the
          * responsbility of libsas to observe at the start of the error
          * handler thread.
          */
-        if (!isci_device || !old_request) {
+        if (!idev || !old_request) {
                 /* The request has already completed and there
                 * is nothing to do here other than to set the task
                 * done bit, and indicate that the task abort function
@@ -998,108 +542,72 @@ int isci_task_abort_task(struct sas_task *task)
 
                 ret = TMF_RESP_FUNC_COMPLETE;
 
-                dev_dbg(&isci_host->pdev->dev,
-                        "%s: abort task not needed for %p\n",
-                        __func__, task);
+                dev_warn(&ihost->pdev->dev,
+                         "%s: abort task not needed for %p\n",
+                         __func__, task);
                 goto out;
         }
-
-        spin_lock_irqsave(&isci_host->scic_lock, flags);
-
-        /* Check the request status and change to "aborted" if currently
-         * "starting"; if true then set the I/O kernel completion
-         * struct that will be triggered when the request completes.
-         */
-        old_state = isci_task_validate_request_to_abort(
-                                old_request, isci_host, isci_device,
-                                &aborted_io_completion);
-        if ((old_state != started) &&
-            (old_state != completed) &&
-            (old_state != aborting)) {
-
-                spin_unlock_irqrestore(&isci_host->scic_lock, flags);
-
-                /* The request was already being handled by someone else (because
-                * they got to set the state away from started).
-                */
-                dev_dbg(&isci_host->pdev->dev,
-                        "%s:  device = %p; old_request %p already being aborted\n",
-                        __func__,
-                        isci_device, old_request);
-                ret = TMF_RESP_FUNC_COMPLETE;
+        /* Suspend the RNC, kill the TC */
+        if (isci_remote_device_suspend_terminate(ihost, idev, old_request)
+            != SCI_SUCCESS) {
+                dev_warn(&ihost->pdev->dev,
+                         "%s: isci_remote_device_reset_terminate(dev=%p, "
+                                 "req=%p, task=%p) failed\n",
+                         __func__, idev, old_request, task);
+                ret = TMF_RESP_FUNC_FAILED;
                 goto out;
         }
+        spin_lock_irqsave(&ihost->scic_lock, flags);
+
         if (task->task_proto == SAS_PROTOCOL_SMP ||
             sas_protocol_ata(task->task_proto) ||
-            test_bit(IREQ_COMPLETE_IN_TARGET, &old_request->flags)) {
+            test_bit(IREQ_COMPLETE_IN_TARGET, &old_request->flags) ||
+            test_bit(IDEV_GONE, &idev->flags)) {
 
-                spin_unlock_irqrestore(&isci_host->scic_lock, flags);
+                spin_unlock_irqrestore(&ihost->scic_lock, flags);
 
-                dev_dbg(&isci_host->pdev->dev,
-                        "%s: %s request"
-                        " or complete_in_target (%d), thus no TMF\n",
-                        __func__,
-                        ((task->task_proto == SAS_PROTOCOL_SMP)
-                                ? "SMP"
-                                : (sas_protocol_ata(task->task_proto)
-                                        ? "SATA/STP"
-                                        : "<other>")
-                         ),
-                        test_bit(IREQ_COMPLETE_IN_TARGET, &old_request->flags));
-
-                if (test_bit(IREQ_COMPLETE_IN_TARGET, &old_request->flags)) {
-                        spin_lock_irqsave(&task->task_state_lock, flags);
-                        task->task_state_flags |= SAS_TASK_STATE_DONE;
-                        task->task_state_flags &= ~(SAS_TASK_AT_INITIATOR |
-                                                    SAS_TASK_STATE_PENDING);
-                        spin_unlock_irqrestore(&task->task_state_lock, flags);
-                        ret = TMF_RESP_FUNC_COMPLETE;
-                } else {
-                        spin_lock_irqsave(&task->task_state_lock, flags);
-                        task->task_state_flags &= ~(SAS_TASK_AT_INITIATOR |
-                                                    SAS_TASK_STATE_PENDING);
-                        spin_unlock_irqrestore(&task->task_state_lock, flags);
-                }
+                /* No task to send, so explicitly resume the device here */
+                isci_remote_device_resume_from_abort(ihost, idev);
 
-                /* STP and SMP devices are not sent a TMF, but the
-                 * outstanding I/O request is terminated below.  This is
-                 * because SATA/STP and SMP discovery path timeouts directly
-                 * call the abort task interface for cleanup.
-                 */
-                perform_termination = 1;
+                dev_warn(&ihost->pdev->dev,
+                         "%s: %s request"
+                                 " or complete_in_target (%d), "
+                                 "or IDEV_GONE (%d), thus no TMF\n",
+                         __func__,
+                         ((task->task_proto == SAS_PROTOCOL_SMP)
+                          ? "SMP"
+                          : (sas_protocol_ata(task->task_proto)
+                                ? "SATA/STP"
+                                : "<other>")
+                          ),
+                         test_bit(IREQ_COMPLETE_IN_TARGET,
+                                  &old_request->flags),
+                         test_bit(IDEV_GONE, &idev->flags));
+
+                spin_lock_irqsave(&task->task_state_lock, flags);
+                task->task_state_flags &= ~(SAS_TASK_AT_INITIATOR |
+                                            SAS_TASK_STATE_PENDING);
+                task->task_state_flags |= SAS_TASK_STATE_DONE;
+                spin_unlock_irqrestore(&task->task_state_lock, flags);
 
+                ret = TMF_RESP_FUNC_COMPLETE;
         } else {
                 /* Fill in the tmf stucture */
                 isci_task_build_abort_task_tmf(&tmf, isci_tmf_ssp_task_abort,
-                                               isci_abort_task_process_cb,
                                                old_request);
 
-                spin_unlock_irqrestore(&isci_host->scic_lock, flags);
+                spin_unlock_irqrestore(&ihost->scic_lock, flags);
 
+                /* Send the task management request. */
                 #define ISCI_ABORT_TASK_TIMEOUT_MS 500 /* 1/2 second timeout */
-                ret = isci_task_execute_tmf(isci_host, isci_device, &tmf,
+                ret = isci_task_execute_tmf(ihost, idev, &tmf,
                                             ISCI_ABORT_TASK_TIMEOUT_MS);
-
-                if (ret == TMF_RESP_FUNC_COMPLETE)
-                        perform_termination = 1;
-                else
-                        dev_dbg(&isci_host->pdev->dev,
-                                "%s: isci_task_send_tmf failed\n", __func__);
         }
-        if (perform_termination) {
-                set_bit(IREQ_COMPLETE_IN_TARGET, &old_request->flags);
-
-                /* Clean up the request on our side, and wait for the aborted
-                 * I/O to complete.
-                 */
-                isci_terminate_request_core(isci_host, isci_device,
-                                            old_request);
-        }
-
-        /* Make sure we do not leave a reference to aborted_io_completion */
-        old_request->io_request_completion = NULL;
- out:
-        isci_put_device(isci_device);
+out:
+        dev_warn(&ihost->pdev->dev,
+                 "%s: Done; dev = %p, task = %p , old_request == %p\n",
+                 __func__, idev, task, old_request);
+        isci_put_device(idev);
         return ret;
 }
 
@@ -1195,14 +703,11 @@ isci_task_request_complete(struct isci_host *ihost,
 {
         struct isci_tmf *tmf = isci_request_access_tmf(ireq);
         struct completion *tmf_complete = NULL;
-        struct completion *request_complete = ireq->io_request_completion;
 
         dev_dbg(&ihost->pdev->dev,
                 "%s: request = %p, status=%d\n",
                 __func__, ireq, completion_status);
 
-        isci_request_change_state(ireq, completed);
-
         set_bit(IREQ_COMPLETE_IN_TARGET, &ireq->flags);
 
         if (tmf) {
@@ -1226,20 +731,11 @@ isci_task_request_complete(struct isci_host *ihost,
          */
         set_bit(IREQ_TERMINATED, &ireq->flags);
 
-        /* As soon as something is in the terminate path, deallocation is
-         * managed there.  Note that the final non-managed state of a task
-         * request is "completed".
-         */
-        if ((ireq->status == completed) ||
-            !isci_request_is_dealloc_managed(ireq->status)) {
-                isci_request_change_state(ireq, unallocated);
-                isci_free_tag(ihost, ireq->io_tag);
-                list_del_init(&ireq->dev_node);
-        }
+        if (test_and_clear_bit(IREQ_ABORT_PATH_ACTIVE, &ireq->flags))
+                wake_up_all(&ihost->eventq);
 
-        /* "request_complete" is set if the task was being terminated. */
-        if (request_complete)
-                complete(request_complete);
+        if (!test_bit(IREQ_NO_AUTO_FREE_TAG, &ireq->flags))
+                isci_free_tag(ihost, ireq->io_tag);
 
         /* The task management part completes last. */
         if (tmf_complete)
@@ -1250,48 +746,38 @@ static int isci_reset_device(struct isci_host *ihost,
                              struct domain_device *dev,
                              struct isci_remote_device *idev)
 {
-        int rc;
-        unsigned long flags;
-        enum sci_status status;
+        int rc = TMF_RESP_FUNC_COMPLETE, reset_stat = -1;
         struct sas_phy *phy = sas_get_local_phy(dev);
         struct isci_port *iport = dev->port->lldd_port;
 
         dev_dbg(&ihost->pdev->dev, "%s: idev %p\n", __func__, idev);
 
-        spin_lock_irqsave(&ihost->scic_lock, flags);
-        status = sci_remote_device_reset(idev);
-        spin_unlock_irqrestore(&ihost->scic_lock, flags);
-
-        if (status != SCI_SUCCESS) {
-                dev_dbg(&ihost->pdev->dev,
-                         "%s: sci_remote_device_reset(%p) returned %d!\n",
-                         __func__, idev, status);
+        /* Suspend the RNC, terminate all outstanding TCs. */
+        if (isci_remote_device_suspend_terminate(ihost, idev, NULL)
+            != SCI_SUCCESS) {
                 rc = TMF_RESP_FUNC_FAILED;
                 goto out;
         }
-
-        if (scsi_is_sas_phy_local(phy)) {
-                struct isci_phy *iphy = &ihost->phys[phy->number];
-
-                rc = isci_port_perform_hard_reset(ihost, iport, iphy);
-        } else
-                rc = sas_phy_reset(phy, !dev_is_sata(dev));
-
-        /* Terminate in-progress I/O now. */
-        isci_remote_device_nuke_requests(ihost, idev);
-
-        /* Since all pending TCs have been cleaned, resume the RNC. */
-        spin_lock_irqsave(&ihost->scic_lock, flags);
-        status = sci_remote_device_reset_complete(idev);
-        spin_unlock_irqrestore(&ihost->scic_lock, flags);
-
-        if (status != SCI_SUCCESS) {
-                dev_dbg(&ihost->pdev->dev,
-                         "%s: sci_remote_device_reset_complete(%p) "
-                         "returned %d!\n", __func__, idev, status);
+        /* Note that since the termination for outstanding requests succeeded,
+         * this function will return success.  This is because the resets will
+         * only fail if the device has been removed (ie. hotplug), and the
+         * primary duty of this function is to cleanup tasks, so that is the
+         * relevant status.
+         */
+        if (!test_bit(IDEV_GONE, &idev->flags)) {
+                if (scsi_is_sas_phy_local(phy)) {
+                        struct isci_phy *iphy = &ihost->phys[phy->number];
+
+                        reset_stat = isci_port_perform_hard_reset(ihost, iport,
+                                                                  iphy);
+                } else
+                        reset_stat = sas_phy_reset(phy, !dev_is_sata(dev));
         }
+        /* Explicitly resume the RNC here, since there was no task sent. */
+        isci_remote_device_resume_from_abort(ihost, idev);
 
-        dev_dbg(&ihost->pdev->dev, "%s: idev %p complete.\n", __func__, idev);
+        dev_dbg(&ihost->pdev->dev, "%s: idev %p complete, reset_stat=%d.\n",
+                __func__, idev, reset_stat);
  out:
         sas_put_local_phy(phy);
         return rc;
@@ -1305,7 +791,7 @@ int isci_task_I_T_nexus_reset(struct domain_device *dev)
         int ret;
 
         spin_lock_irqsave(&ihost->scic_lock, flags);
-        idev = isci_lookup_device(dev);
+        idev = isci_get_device(dev->lldd_dev);
         spin_unlock_irqrestore(&ihost->scic_lock, flags);
 
         if (!idev) {
diff --git a/drivers/scsi/isci/task.h b/drivers/scsi/isci/task.h
index 7b6d0e32fd9b..9c06cbad1d26 100644
--- a/drivers/scsi/isci/task.h
+++ b/drivers/scsi/isci/task.h
@@ -63,19 +63,6 @@
 struct isci_request;
 
 /**
- * enum isci_tmf_cb_state - This enum defines the possible states in which the
- *    TMF callback function is invoked during the TMF execution process.
- *
- *
- */
-enum isci_tmf_cb_state {
-
-        isci_tmf_init_state = 0,
-        isci_tmf_started,
-        isci_tmf_timed_out
-};
-
-/**
  * enum isci_tmf_function_codes - This enum defines the possible preparations
  *    of task management requests.
  *
@@ -87,6 +74,7 @@ enum isci_tmf_function_codes {
         isci_tmf_ssp_task_abort = TMF_ABORT_TASK,
         isci_tmf_ssp_lun_reset  = TMF_LU_RESET,
 };
+
 /**
  * struct isci_tmf - This class represents the task management object which
  *    acts as an interface to libsas for processing task management requests
@@ -106,15 +94,6 @@ struct isci_tmf {
         u16 io_tag;
         enum isci_tmf_function_codes tmf_code;
         int status;
-
-        /* The optional callback function allows the user process to
-         * track the TMF transmit / timeout conditions.
-         */
-        void (*cb_state_func)(
-                enum isci_tmf_cb_state,
-                struct isci_tmf *, void *);
-        void *cb_data;
-
 };
 
 static inline void isci_print_tmf(struct isci_host *ihost, struct isci_tmf *tmf)
@@ -208,113 +187,4 @@ int isci_queuecommand(
         struct scsi_cmnd *scsi_cmd,
         void (*donefunc)(struct scsi_cmnd *));
 
-/**
- * enum isci_completion_selection - This enum defines the possible actions to
- *    take with respect to a given request's notification back to libsas.
- *
- *
- */
-enum isci_completion_selection {
-
-        isci_perform_normal_io_completion,      /* Normal notify (task_done) */
-        isci_perform_aborted_io_completion,     /* No notification.   */
-        isci_perform_error_io_completion        /* Use sas_task_abort */
-};
-
-/**
- * isci_task_set_completion_status() - This function sets the completion status
- *    for the request.
- * @task: This parameter is the completed request.
- * @response: This parameter is the response code for the completed task.
- * @status: This parameter is the status code for the completed task.
- *
-* @return The new notification mode for the request.
-*/
-static inline enum isci_completion_selection
-isci_task_set_completion_status(
-        struct sas_task *task,
-        enum service_response response,
-        enum exec_status status,
-        enum isci_completion_selection task_notification_selection)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&task->task_state_lock, flags);
-
-        /* If a device reset is being indicated, make sure the I/O
-        * is in the error path.
-        */
-        if (task->task_state_flags & SAS_TASK_NEED_DEV_RESET) {
-                /* Fail the I/O to make sure it goes into the error path. */
-                response = SAS_TASK_UNDELIVERED;
-                status = SAM_STAT_TASK_ABORTED;
-
-                task_notification_selection = isci_perform_error_io_completion;
-        }
-        task->task_status.resp = response;
-        task->task_status.stat = status;
-
-        switch (task->task_proto) {
-
-        case SAS_PROTOCOL_SATA:
-        case SAS_PROTOCOL_STP:
-        case SAS_PROTOCOL_SATA | SAS_PROTOCOL_STP:
-
-                if (task_notification_selection
-                    == isci_perform_error_io_completion) {
-                        /* SATA/STP I/O has it's own means of scheduling device
-                        * error handling on the normal path.
-                        */
-                        task_notification_selection
-                                = isci_perform_normal_io_completion;
-                }
-                break;
-        default:
-                break;
-        }
-
-        switch (task_notification_selection) {
-
-        case isci_perform_error_io_completion:
-
-                if (task->task_proto == SAS_PROTOCOL_SMP) {
-                        /* There is no error escalation in the SMP case.
-                         * Convert to a normal completion to avoid the
-                         * timeout in the discovery path and to let the
-                         * next action take place quickly.
-                         */
-                        task_notification_selection
-                                = isci_perform_normal_io_completion;
-
-                        /* Fall through to the normal case... */
-                } else {
-                        /* Use sas_task_abort */
-                        /* Leave SAS_TASK_STATE_DONE clear
-                         * Leave SAS_TASK_AT_INITIATOR set.
-                         */
-                        break;
-                }
-
-        case isci_perform_aborted_io_completion:
-                /* This path can occur with task-managed requests as well as
-                 * requests terminated because of LUN or device resets.
-                 */
-                /* Fall through to the normal case... */
-        case isci_perform_normal_io_completion:
-                /* Normal notification (task_done) */
-                task->task_state_flags |= SAS_TASK_STATE_DONE;
-                task->task_state_flags &= ~(SAS_TASK_AT_INITIATOR |
-                                            SAS_TASK_STATE_PENDING);
-                break;
-        default:
-                WARN_ONCE(1, "unknown task_notification_selection: %d\n",
-                         task_notification_selection);
-                break;
-        }
-
-        spin_unlock_irqrestore(&task->task_state_lock, flags);
-
-        return task_notification_selection;
-
-}
 #endif /* !defined(_SCI_TASK_H_) */
diff --git a/drivers/scsi/isci/unsolicited_frame_control.c b/drivers/scsi/isci/unsolicited_frame_control.c
index 16f88ab939c8..04a6d0d59a22 100644
--- a/drivers/scsi/isci/unsolicited_frame_control.c
+++ b/drivers/scsi/isci/unsolicited_frame_control.c
@@ -57,31 +57,19 @@
 #include "unsolicited_frame_control.h"
 #include "registers.h"
 
-int sci_unsolicited_frame_control_construct(struct isci_host *ihost)
+void sci_unsolicited_frame_control_construct(struct isci_host *ihost)
 {
         struct sci_unsolicited_frame_control *uf_control = &ihost->uf_control;
         struct sci_unsolicited_frame *uf;
-        u32 buf_len, header_len, i;
-        dma_addr_t dma;
-        size_t size;
-        void *virt;
-
-        /*
-         * Prepare all of the memory sizes for the UF headers, UF address
-         * table, and UF buffers themselves.
-         */
-        buf_len = SCU_MAX_UNSOLICITED_FRAMES * SCU_UNSOLICITED_FRAME_BUFFER_SIZE;
-        header_len = SCU_MAX_UNSOLICITED_FRAMES * sizeof(struct scu_unsolicited_frame_header);
-        size = buf_len + header_len + SCU_MAX_UNSOLICITED_FRAMES * sizeof(uf_control->address_table.array[0]);
+        dma_addr_t dma = ihost->ufi_dma;
+        void *virt = ihost->ufi_buf;
+        int i;
 
         /*
          * The Unsolicited Frame buffers are set at the start of the UF
          * memory descriptor entry. The headers and address table will be
          * placed after the buffers.
          */
-        virt = dmam_alloc_coherent(&ihost->pdev->dev, size, &dma, GFP_KERNEL);
-        if (!virt)
-                return -ENOMEM;
 
         /*
          * Program the location of the UF header table into the SCU.
@@ -93,8 +81,8 @@ int sci_unsolicited_frame_control_construct(struct isci_host *ihost)
          *   headers, since we program the UF address table pointers to
          *   NULL.
          */
-        uf_control->headers.physical_address = dma + buf_len;
-        uf_control->headers.array = virt + buf_len;
+        uf_control->headers.physical_address = dma + SCI_UFI_BUF_SIZE;
+        uf_control->headers.array = virt + SCI_UFI_BUF_SIZE;
 
         /*
          * Program the location of the UF address table into the SCU.
@@ -103,8 +91,8 @@ int sci_unsolicited_frame_control_construct(struct isci_host *ihost)
          *   byte boundary already due to above programming headers being on a
          *   64-bit boundary and headers are on a 64-bytes in size.
          */
-        uf_control->address_table.physical_address = dma + buf_len + header_len;
-        uf_control->address_table.array = virt + buf_len + header_len;
+        uf_control->address_table.physical_address = dma + SCI_UFI_BUF_SIZE + SCI_UFI_HDR_SIZE;
+        uf_control->address_table.array = virt + SCI_UFI_BUF_SIZE + SCI_UFI_HDR_SIZE;
         uf_control->get = 0;
 
         /*
@@ -135,8 +123,6 @@ int sci_unsolicited_frame_control_construct(struct isci_host *ihost)
                 virt += SCU_UNSOLICITED_FRAME_BUFFER_SIZE;
                 dma += SCU_UNSOLICITED_FRAME_BUFFER_SIZE;
         }
-
-        return 0;
 }
 
 enum sci_status sci_unsolicited_frame_control_get_header(struct sci_unsolicited_frame_control *uf_control,
diff --git a/drivers/scsi/isci/unsolicited_frame_control.h b/drivers/scsi/isci/unsolicited_frame_control.h
index 75d896686f5a..1bc551ec611f 100644
--- a/drivers/scsi/isci/unsolicited_frame_control.h
+++ b/drivers/scsi/isci/unsolicited_frame_control.h
@@ -257,9 +257,13 @@ struct sci_unsolicited_frame_control {
 
 };
 
+#define SCI_UFI_BUF_SIZE (SCU_MAX_UNSOLICITED_FRAMES * SCU_UNSOLICITED_FRAME_BUFFER_SIZE)
+#define SCI_UFI_HDR_SIZE (SCU_MAX_UNSOLICITED_FRAMES * sizeof(struct scu_unsolicited_frame_header))
+#define SCI_UFI_TOTAL_SIZE (SCI_UFI_BUF_SIZE + SCI_UFI_HDR_SIZE + SCU_MAX_UNSOLICITED_FRAMES * sizeof(u64))
+
 struct isci_host;
 
-int sci_unsolicited_frame_control_construct(struct isci_host *ihost);
+void sci_unsolicited_frame_control_construct(struct isci_host *ihost);
 
 enum sci_status sci_unsolicited_frame_control_get_header(
         struct sci_unsolicited_frame_control *uf_control,
diff --git a/drivers/scsi/libfc/fc_lport.c b/drivers/scsi/libfc/fc_lport.c
index cc83b66d45b7..c1402fb499ab 100644
--- a/drivers/scsi/libfc/fc_lport.c
+++ b/drivers/scsi/libfc/fc_lport.c
@@ -648,6 +648,7 @@ int fc_lport_destroy(struct fc_lport *lport)
         lport->tt.fcp_abort_io(lport);
         lport->tt.disc_stop_final(lport);
         lport->tt.exch_mgr_reset(lport, 0, 0);
+        cancel_delayed_work_sync(&lport->retry_work);
         fc_fc4_del_lport(lport);
         return 0;
 }
@@ -1564,7 +1565,6 @@ static void fc_lport_timeout(struct work_struct *work)
 
         switch (lport->state) {
         case LPORT_ST_DISABLED:
-                WARN_ON(1);
                 break;
         case LPORT_ST_READY:
                 break;
diff --git a/drivers/scsi/lpfc/lpfc.h b/drivers/scsi/lpfc/lpfc.h
index 3a1ffdd6d831..e5da6da20f8a 100644
--- a/drivers/scsi/lpfc/lpfc.h
+++ b/drivers/scsi/lpfc/lpfc.h
@@ -93,6 +93,9 @@ struct lpfc_sli2_slim;
 /* lpfc wait event data ready flag */
 #define LPFC_DATA_READY         (1<<0)
 
+/* queue dump line buffer size */
+#define LPFC_LBUF_SZ            128
+
 enum lpfc_polling_flags {
         ENABLE_FCP_RING_POLLING = 0x1,
         DISABLE_FCP_RING_INT    = 0x2
@@ -620,6 +623,7 @@ struct lpfc_hba {
 #define HBA_AER_ENABLED         0x1000 /* AER enabled with HBA */
 #define HBA_DEVLOSS_TMO         0x2000 /* HBA in devloss timeout */
 #define HBA_RRQ_ACTIVE          0x4000 /* process the rrq active list */
+#define HBA_FCP_IOQ_FLUSH       0x8000 /* FCP I/O queues being flushed */
         uint32_t fcp_ring_in_use; /* When polling test if intr-hndlr active*/
         struct lpfc_dmabuf slim2p;
 
diff --git a/drivers/scsi/lpfc/lpfc_bsg.c b/drivers/scsi/lpfc/lpfc_bsg.c
index 141e4b40bb55..253d9a857346 100644
--- a/drivers/scsi/lpfc/lpfc_bsg.c
+++ b/drivers/scsi/lpfc/lpfc_bsg.c
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2009-2011 Emulex.  All rights reserved.           *
+ * Copyright (C) 2009-2012 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  *                                                                 *
@@ -599,6 +599,7 @@ lpfc_bsg_rport_els(struct fc_bsg_job *job)
 
         cmdiocbq->iocb_cmpl = lpfc_bsg_rport_els_cmp;
         cmdiocbq->context1 = dd_data;
+        cmdiocbq->context_un.ndlp = ndlp;
         cmdiocbq->context2 = rspiocbq;
         dd_data->type = TYPE_IOCB;
         dd_data->context_un.iocb.cmdiocbq = cmdiocbq;
@@ -3978,6 +3979,7 @@ lpfc_bsg_handle_sli_cfg_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
                 } else if (subsys == SLI_CONFIG_SUBSYS_COMN) {
                         switch (opcode) {
                         case COMN_OPCODE_GET_CNTL_ADDL_ATTRIBUTES:
+                        case COMN_OPCODE_GET_CNTL_ATTRIBUTES:
                                 lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
                                                 "3106 Handled SLI_CONFIG "
                                                 "subsys_comn, opcode:x%x\n",
diff --git a/drivers/scsi/lpfc/lpfc_bsg.h b/drivers/scsi/lpfc/lpfc_bsg.h
index edfe61fc52b1..67f7d0a160d1 100644
--- a/drivers/scsi/lpfc/lpfc_bsg.h
+++ b/drivers/scsi/lpfc/lpfc_bsg.h
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2010 Emulex.  All rights reserved.                *
+ * Copyright (C) 2010-2012 Emulex.  All rights reserved.                *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  *                                                                 *
@@ -249,6 +249,7 @@ struct lpfc_sli_config_emb1_subsys {
 #define COMN_OPCODE_READ_OBJECT_LIST    0xAD
 #define COMN_OPCODE_DELETE_OBJECT       0xAE
 #define COMN_OPCODE_GET_CNTL_ADDL_ATTRIBUTES    0x79
+#define COMN_OPCODE_GET_CNTL_ATTRIBUTES 0x20
         uint32_t timeout;
         uint32_t request_length;
         uint32_t word9;
diff --git a/drivers/scsi/lpfc/lpfc_crtn.h b/drivers/scsi/lpfc/lpfc_crtn.h
index 330dd7192a7f..9b2a16f3bc79 100644
--- a/drivers/scsi/lpfc/lpfc_crtn.h
+++ b/drivers/scsi/lpfc/lpfc_crtn.h
@@ -254,6 +254,7 @@ int
 lpfc_sli_handle_fast_ring_event(struct lpfc_hba *,
                         struct lpfc_sli_ring *, uint32_t);
 
+struct lpfc_iocbq *__lpfc_sli_get_iocbq(struct lpfc_hba *);
 struct lpfc_iocbq * lpfc_sli_get_iocbq(struct lpfc_hba *);
 void lpfc_sli_release_iocbq(struct lpfc_hba *, struct lpfc_iocbq *);
 uint16_t lpfc_sli_next_iotag(struct lpfc_hba *, struct lpfc_iocbq *);
@@ -460,6 +461,7 @@ int lpfc_hba_init_link_fc_topology(struct lpfc_hba *, uint32_t, uint32_t);
 int lpfc_issue_reg_vfi(struct lpfc_vport *);
 int lpfc_issue_unreg_vfi(struct lpfc_vport *);
 int lpfc_selective_reset(struct lpfc_hba *);
-int lpfc_sli4_read_config(struct lpfc_hba *phba);
-int lpfc_scsi_buf_update(struct lpfc_hba *phba);
-void lpfc_sli4_node_prep(struct lpfc_hba *phba);
+int lpfc_sli4_read_config(struct lpfc_hba *);
+void lpfc_sli4_node_prep(struct lpfc_hba *);
+int lpfc_sli4_xri_sgl_update(struct lpfc_hba *);
+void lpfc_free_sgl_list(struct lpfc_hba *, struct list_head *);
diff --git a/drivers/scsi/lpfc/lpfc_debugfs.c b/drivers/scsi/lpfc/lpfc_debugfs.c
index af04b0d6688d..3217d63ed282 100644
--- a/drivers/scsi/lpfc/lpfc_debugfs.c
+++ b/drivers/scsi/lpfc/lpfc_debugfs.c
@@ -4466,3 +4466,49 @@ lpfc_debugfs_terminate(struct lpfc_vport *vport)
 #endif
         return;
 }
+
+/*
+ * Driver debug utility routines outside of debugfs. The debug utility
+ * routines implemented here is intended to be used in the instrumented
+ * debug driver for debugging host or port issues.
+ */
+
+/**
+ * lpfc_debug_dump_all_queues - dump all the queues with a hba
+ * @phba: Pointer to HBA context object.
+ *
+ * This function dumps entries of all the queues asociated with the @phba.
+ **/
+void
+lpfc_debug_dump_all_queues(struct lpfc_hba *phba)
+{
+        int fcp_wqidx;
+
+        /*
+         * Dump Work Queues (WQs)
+         */
+        lpfc_debug_dump_mbx_wq(phba);
+        lpfc_debug_dump_els_wq(phba);
+
+        for (fcp_wqidx = 0; fcp_wqidx < phba->cfg_fcp_wq_count; fcp_wqidx++)
+                lpfc_debug_dump_fcp_wq(phba, fcp_wqidx);
+
+        lpfc_debug_dump_hdr_rq(phba);
+        lpfc_debug_dump_dat_rq(phba);
+        /*
+         * Dump Complete Queues (CQs)
+         */
+        lpfc_debug_dump_mbx_cq(phba);
+        lpfc_debug_dump_els_cq(phba);
+
+        for (fcp_wqidx = 0; fcp_wqidx < phba->cfg_fcp_wq_count; fcp_wqidx++)
+                lpfc_debug_dump_fcp_cq(phba, fcp_wqidx);
+
+        /*
+         * Dump Event Queues (EQs)
+         */
+        lpfc_debug_dump_sp_eq(phba);
+
+        for (fcp_wqidx = 0; fcp_wqidx < phba->cfg_fcp_wq_count; fcp_wqidx++)
+                lpfc_debug_dump_fcp_eq(phba, fcp_wqidx);
+}
diff --git a/drivers/scsi/lpfc/lpfc_debugfs.h b/drivers/scsi/lpfc/lpfc_debugfs.h
index f83bd944edd8..616c400dae14 100644
--- a/drivers/scsi/lpfc/lpfc_debugfs.h
+++ b/drivers/scsi/lpfc/lpfc_debugfs.h
@@ -267,3 +267,421 @@ struct lpfc_idiag {
 #define LPFC_DISC_TRC_DISCOVERY         0xef    /* common mask for general
                                                  * discovery */
 #endif /* H_LPFC_DEBUG_FS */
+
+
+/*
+ * Driver debug utility routines outside of debugfs. The debug utility
+ * routines implemented here is intended to be used in the instrumented
+ * debug driver for debugging host or port issues.
+ */
+
+/**
+ * lpfc_debug_dump_qe - dump an specific entry from a queue
+ * @q: Pointer to the queue descriptor.
+ * @idx: Index to the entry on the queue.
+ *
+ * This function dumps an entry indexed by @idx from a queue specified by the
+ * queue descriptor @q.
+ **/
+static inline void
+lpfc_debug_dump_qe(struct lpfc_queue *q, uint32_t idx)
+{
+        char line_buf[LPFC_LBUF_SZ];
+        int i, esize, qe_word_cnt, len;
+        uint32_t *pword;
+
+        /* sanity checks */
+        if (!q)
+                return;
+        if (idx >= q->entry_count)
+                return;
+
+        esize = q->entry_size;
+        qe_word_cnt = esize / sizeof(uint32_t);
+        pword = q->qe[idx].address;
+
+        len = 0;
+        len += snprintf(line_buf+len, LPFC_LBUF_SZ-len, "QE[%04d]: ", idx);
+        if (qe_word_cnt > 8)
+                printk(KERN_ERR "%s\n", line_buf);
+
+        for (i = 0; i < qe_word_cnt; i++) {
+                if (!(i % 8)) {
+                        if (i != 0)
+                                printk(KERN_ERR "%s\n", line_buf);
+                        if (qe_word_cnt > 8) {
+                                len = 0;
+                                memset(line_buf, 0, LPFC_LBUF_SZ);
+                                len += snprintf(line_buf+len, LPFC_LBUF_SZ-len,
+                                                "%03d: ", i);
+                        }
+                }
+                len += snprintf(line_buf+len, LPFC_LBUF_SZ-len, "%08x ",
+                                ((uint32_t)*pword) & 0xffffffff);
+                pword++;
+        }
+        if (qe_word_cnt <= 8 || (i - 1) % 8)
+                printk(KERN_ERR "%s\n", line_buf);
+}
+
+/**
+ * lpfc_debug_dump_q - dump all entries from an specific queue
+ * @q: Pointer to the queue descriptor.
+ *
+ * This function dumps all entries from a queue specified by the queue
+ * descriptor @q.
+ **/
+static inline void
+lpfc_debug_dump_q(struct lpfc_queue *q)
+{
+        int idx, entry_count;
+
+        /* sanity check */
+        if (!q)
+                return;
+
+        dev_printk(KERN_ERR, &(((q->phba))->pcidev)->dev,
+                "%d: [qid:%d, type:%d, subtype:%d, "
+                "qe_size:%d, qe_count:%d, "
+                "host_index:%d, port_index:%d]\n",
+                (q->phba)->brd_no,
+                q->queue_id, q->type, q->subtype,
+                q->entry_size, q->entry_count,
+                q->host_index, q->hba_index);
+        entry_count = q->entry_count;
+        for (idx = 0; idx < entry_count; idx++)
+                lpfc_debug_dump_qe(q, idx);
+        printk(KERN_ERR "\n");
+}
+
+/**
+ * lpfc_debug_dump_fcp_wq - dump all entries from a fcp work queue
+ * @phba: Pointer to HBA context object.
+ * @fcp_wqidx: Index to a FCP work queue.
+ *
+ * This function dumps all entries from a FCP work queue specified by the
+ * @fcp_wqidx.
+ **/
+static inline void
+lpfc_debug_dump_fcp_wq(struct lpfc_hba *phba, int fcp_wqidx)
+{
+        /* sanity check */
+        if (fcp_wqidx >= phba->cfg_fcp_wq_count)
+                return;
+
+        printk(KERN_ERR "FCP WQ: WQ[Idx:%d|Qid:%d]\n",
+                fcp_wqidx, phba->sli4_hba.fcp_wq[fcp_wqidx]->queue_id);
+        lpfc_debug_dump_q(phba->sli4_hba.fcp_wq[fcp_wqidx]);
+}
+
+/**
+ * lpfc_debug_dump_fcp_cq - dump all entries from a fcp work queue's cmpl queue
+ * @phba: Pointer to HBA context object.
+ * @fcp_wqidx: Index to a FCP work queue.
+ *
+ * This function dumps all entries from a FCP complete queue which is
+ * associated to the FCP work queue specified by the @fcp_wqidx.
+ **/
+static inline void
+lpfc_debug_dump_fcp_cq(struct lpfc_hba *phba, int fcp_wqidx)
+{
+        int fcp_cqidx, fcp_cqid;
+
+        /* sanity check */
+        if (fcp_wqidx >= phba->cfg_fcp_wq_count)
+                return;
+
+        fcp_cqid = phba->sli4_hba.fcp_wq[fcp_wqidx]->assoc_qid;
+        for (fcp_cqidx = 0; fcp_cqidx < phba->cfg_fcp_eq_count; fcp_cqidx++)
+                if (phba->sli4_hba.fcp_cq[fcp_cqidx]->queue_id == fcp_cqid)
+                        break;
+        if (fcp_cqidx >= phba->cfg_fcp_eq_count)
+                return;
+
+        printk(KERN_ERR "FCP CQ: WQ[Idx:%d|Qid%d]->CQ[Idx%d|Qid%d]:\n",
+                fcp_wqidx, phba->sli4_hba.fcp_wq[fcp_wqidx]->queue_id,
+                fcp_cqidx, fcp_cqid);
+        lpfc_debug_dump_q(phba->sli4_hba.fcp_cq[fcp_cqidx]);
+}
+
+/**
+ * lpfc_debug_dump_fcp_eq - dump all entries from a fcp work queue's evt queue
+ * @phba: Pointer to HBA context object.
+ * @fcp_wqidx: Index to a FCP work queue.
+ *
+ * This function dumps all entries from a FCP event queue which is
+ * associated to the FCP work queue specified by the @fcp_wqidx.
+ **/
+static inline void
+lpfc_debug_dump_fcp_eq(struct lpfc_hba *phba, int fcp_wqidx)
+{
+        struct lpfc_queue *qdesc;
+        int fcp_eqidx, fcp_eqid;
+        int fcp_cqidx, fcp_cqid;
+
+        /* sanity check */
+        if (fcp_wqidx >= phba->cfg_fcp_wq_count)
+                return;
+        fcp_cqid = phba->sli4_hba.fcp_wq[fcp_wqidx]->assoc_qid;
+        for (fcp_cqidx = 0; fcp_cqidx < phba->cfg_fcp_eq_count; fcp_cqidx++)
+                if (phba->sli4_hba.fcp_cq[fcp_cqidx]->queue_id == fcp_cqid)
+                        break;
+        if (fcp_cqidx >= phba->cfg_fcp_eq_count)
+                return;
+
+        if (phba->cfg_fcp_eq_count == 0) {
+                fcp_eqidx = -1;
+                fcp_eqid = phba->sli4_hba.sp_eq->queue_id;
+                qdesc = phba->sli4_hba.sp_eq;
+        } else {
+                fcp_eqidx = fcp_cqidx;
+                fcp_eqid = phba->sli4_hba.fp_eq[fcp_eqidx]->queue_id;
+                qdesc = phba->sli4_hba.fp_eq[fcp_eqidx];
+        }
+
+        printk(KERN_ERR "FCP EQ: WQ[Idx:%d|Qid:%d]->CQ[Idx:%d|Qid:%d]->"
+                "EQ[Idx:%d|Qid:%d]\n",
+                fcp_wqidx, phba->sli4_hba.fcp_wq[fcp_wqidx]->queue_id,
+                fcp_cqidx, fcp_cqid, fcp_eqidx, fcp_eqid);
+        lpfc_debug_dump_q(qdesc);
+}
+
+/**
+ * lpfc_debug_dump_els_wq - dump all entries from the els work queue
+ * @phba: Pointer to HBA context object.
+ *
+ * This function dumps all entries from the ELS work queue.
+ **/
+static inline void
+lpfc_debug_dump_els_wq(struct lpfc_hba *phba)
+{
+        printk(KERN_ERR "ELS WQ: WQ[Qid:%d]:\n",
+                phba->sli4_hba.els_wq->queue_id);
+        lpfc_debug_dump_q(phba->sli4_hba.els_wq);
+}
+
+/**
+ * lpfc_debug_dump_mbx_wq - dump all entries from the mbox work queue
+ * @phba: Pointer to HBA context object.
+ *
+ * This function dumps all entries from the MBOX work queue.
+ **/
+static inline void
+lpfc_debug_dump_mbx_wq(struct lpfc_hba *phba)
+{
+        printk(KERN_ERR "MBX WQ: WQ[Qid:%d]\n",
+                phba->sli4_hba.mbx_wq->queue_id);
+        lpfc_debug_dump_q(phba->sli4_hba.mbx_wq);
+}
+
+/**
+ * lpfc_debug_dump_dat_rq - dump all entries from the receive data queue
+ * @phba: Pointer to HBA context object.
+ *
+ * This function dumps all entries from the receive data queue.
+ **/
+static inline void
+lpfc_debug_dump_dat_rq(struct lpfc_hba *phba)
+{
+        printk(KERN_ERR "DAT RQ: RQ[Qid:%d]\n",
+                phba->sli4_hba.dat_rq->queue_id);
+        lpfc_debug_dump_q(phba->sli4_hba.dat_rq);
+}
+
+/**
+ * lpfc_debug_dump_hdr_rq - dump all entries from the receive header queue
+ * @phba: Pointer to HBA context object.
+ *
+ * This function dumps all entries from the receive header queue.
+ **/
+static inline void
+lpfc_debug_dump_hdr_rq(struct lpfc_hba *phba)
+{
+        printk(KERN_ERR "HDR RQ: RQ[Qid:%d]\n",
+                phba->sli4_hba.hdr_rq->queue_id);
+        lpfc_debug_dump_q(phba->sli4_hba.hdr_rq);
+}
+
+/**
+ * lpfc_debug_dump_els_cq - dump all entries from the els complete queue
+ * @phba: Pointer to HBA context object.
+ *
+ * This function dumps all entries from the els complete queue.
+ **/
+static inline void
+lpfc_debug_dump_els_cq(struct lpfc_hba *phba)
+{
+        printk(KERN_ERR "ELS CQ: WQ[Qid:%d]->CQ[Qid:%d]\n",
+                phba->sli4_hba.els_wq->queue_id,
+                phba->sli4_hba.els_cq->queue_id);
+        lpfc_debug_dump_q(phba->sli4_hba.els_cq);
+}
+
+/**
+ * lpfc_debug_dump_mbx_cq - dump all entries from the mbox complete queue
+ * @phba: Pointer to HBA context object.
+ *
+ * This function dumps all entries from the mbox complete queue.
+ **/
+static inline void
+lpfc_debug_dump_mbx_cq(struct lpfc_hba *phba)
+{
+        printk(KERN_ERR "MBX CQ: WQ[Qid:%d]->CQ[Qid:%d]\n",
+                phba->sli4_hba.mbx_wq->queue_id,
+                phba->sli4_hba.mbx_cq->queue_id);
+        lpfc_debug_dump_q(phba->sli4_hba.mbx_cq);
+}
+
+/**
+ * lpfc_debug_dump_sp_eq - dump all entries from slow-path event queue
+ * @phba: Pointer to HBA context object.
+ *
+ * This function dumps all entries from the slow-path event queue.
+ **/
+static inline void
+lpfc_debug_dump_sp_eq(struct lpfc_hba *phba)
+{
+        printk(KERN_ERR "SP EQ: WQ[Qid:%d/Qid:%d]->CQ[Qid:%d/Qid:%d]->"
+                "EQ[Qid:%d]:\n",
+                phba->sli4_hba.mbx_wq->queue_id,
+                phba->sli4_hba.els_wq->queue_id,
+                phba->sli4_hba.mbx_cq->queue_id,
+                phba->sli4_hba.els_cq->queue_id,
+                phba->sli4_hba.sp_eq->queue_id);
+        lpfc_debug_dump_q(phba->sli4_hba.sp_eq);
+}
+
+/**
+ * lpfc_debug_dump_wq_by_id - dump all entries from a work queue by queue id
+ * @phba: Pointer to HBA context object.
+ * @qid: Work queue identifier.
+ *
+ * This function dumps all entries from a work queue identified by the queue
+ * identifier.
+ **/
+static inline void
+lpfc_debug_dump_wq_by_id(struct lpfc_hba *phba, int qid)
+{
+        int wq_idx;
+
+        for (wq_idx = 0; wq_idx < phba->cfg_fcp_wq_count; wq_idx++)
+                if (phba->sli4_hba.fcp_wq[wq_idx]->queue_id == qid)
+                        break;
+        if (wq_idx < phba->cfg_fcp_wq_count) {
+                printk(KERN_ERR "FCP WQ[Idx:%d|Qid:%d]\n", wq_idx, qid);
+                lpfc_debug_dump_q(phba->sli4_hba.fcp_wq[wq_idx]);
+                return;
+        }
+
+        if (phba->sli4_hba.els_wq->queue_id == qid) {
+                printk(KERN_ERR "ELS WQ[Qid:%d]\n", qid);
+                lpfc_debug_dump_q(phba->sli4_hba.els_wq);
+        }
+}
+
+/**
+ * lpfc_debug_dump_mq_by_id - dump all entries from a mbox queue by queue id
+ * @phba: Pointer to HBA context object.
+ * @qid: Mbox work queue identifier.
+ *
+ * This function dumps all entries from a mbox work queue identified by the
+ * queue identifier.
+ **/
+static inline void
+lpfc_debug_dump_mq_by_id(struct lpfc_hba *phba, int qid)
+{
+        if (phba->sli4_hba.mbx_wq->queue_id == qid) {
+                printk(KERN_ERR "MBX WQ[Qid:%d]\n", qid);
+                lpfc_debug_dump_q(phba->sli4_hba.mbx_wq);
+        }
+}
+
+/**
+ * lpfc_debug_dump_rq_by_id - dump all entries from a receive queue by queue id
+ * @phba: Pointer to HBA context object.
+ * @qid: Receive queue identifier.
+ *
+ * This function dumps all entries from a receive queue identified by the
+ * queue identifier.
+ **/
+static inline void
+lpfc_debug_dump_rq_by_id(struct lpfc_hba *phba, int qid)
+{
+        if (phba->sli4_hba.hdr_rq->queue_id == qid) {
+                printk(KERN_ERR "HDR RQ[Qid:%d]\n", qid);
+                lpfc_debug_dump_q(phba->sli4_hba.hdr_rq);
+                return;
+        }
+        if (phba->sli4_hba.dat_rq->queue_id == qid) {
+                printk(KERN_ERR "DAT RQ[Qid:%d]\n", qid);
+                lpfc_debug_dump_q(phba->sli4_hba.dat_rq);
+        }
+}
+
+/**
+ * lpfc_debug_dump_cq_by_id - dump all entries from a cmpl queue by queue id
+ * @phba: Pointer to HBA context object.
+ * @qid: Complete queue identifier.
+ *
+ * This function dumps all entries from a complete queue identified by the
+ * queue identifier.
+ **/
+static inline void
+lpfc_debug_dump_cq_by_id(struct lpfc_hba *phba, int qid)
+{
+        int cq_idx = 0;
+
+        do {
+                if (phba->sli4_hba.fcp_cq[cq_idx]->queue_id == qid)
+                        break;
+        } while (++cq_idx < phba->cfg_fcp_eq_count);
+
+        if (cq_idx < phba->cfg_fcp_eq_count) {
+                printk(KERN_ERR "FCP CQ[Idx:%d|Qid:%d]\n", cq_idx, qid);
+                lpfc_debug_dump_q(phba->sli4_hba.fcp_cq[cq_idx]);
+                return;
+        }
+
+        if (phba->sli4_hba.els_cq->queue_id == qid) {
+                printk(KERN_ERR "ELS CQ[Qid:%d]\n", qid);
+                lpfc_debug_dump_q(phba->sli4_hba.els_cq);
+                return;
+        }
+
+        if (phba->sli4_hba.mbx_cq->queue_id == qid) {
+                printk(KERN_ERR "MBX CQ[Qid:%d]\n", qid);
+                lpfc_debug_dump_q(phba->sli4_hba.mbx_cq);
+        }
+}
+
+/**
+ * lpfc_debug_dump_eq_by_id - dump all entries from an event queue by queue id
+ * @phba: Pointer to HBA context object.
+ * @qid: Complete queue identifier.
+ *
+ * This function dumps all entries from an event queue identified by the
+ * queue identifier.
+ **/
+static inline void
+lpfc_debug_dump_eq_by_id(struct lpfc_hba *phba, int qid)
+{
+        int eq_idx;
+
+        for (eq_idx = 0; eq_idx < phba->cfg_fcp_eq_count; eq_idx++) {
+                if (phba->sli4_hba.fp_eq[eq_idx]->queue_id == qid)
+                        break;
+        }
+
+        if (eq_idx < phba->cfg_fcp_eq_count) {
+                printk(KERN_ERR "FCP EQ[Idx:%d|Qid:%d]\n", eq_idx, qid);
+                lpfc_debug_dump_q(phba->sli4_hba.fp_eq[eq_idx]);
+                return;
+        }
+
+        if (phba->sli4_hba.sp_eq->queue_id == qid) {
+                printk(KERN_ERR "SP EQ[|Qid:%d]\n", qid);
+                lpfc_debug_dump_q(phba->sli4_hba.sp_eq);
+        }
+}
+
+void lpfc_debug_dump_all_queues(struct lpfc_hba *);
diff --git a/drivers/scsi/lpfc/lpfc_els.c b/drivers/scsi/lpfc/lpfc_els.c
index 3407b39e0a3f..d54ae1999797 100644
--- a/drivers/scsi/lpfc/lpfc_els.c
+++ b/drivers/scsi/lpfc/lpfc_els.c
@@ -230,27 +230,43 @@ lpfc_prep_els_iocb(struct lpfc_vport *vport, uint8_t expectRsp,
 
         INIT_LIST_HEAD(&pbuflist->list);
 
-        icmd->un.elsreq64.bdl.addrHigh = putPaddrHigh(pbuflist->phys);
-        icmd->un.elsreq64.bdl.addrLow = putPaddrLow(pbuflist->phys);
-        icmd->un.elsreq64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
-        icmd->un.elsreq64.remoteID = did;       /* DID */
         if (expectRsp) {
+                icmd->un.elsreq64.bdl.addrHigh = putPaddrHigh(pbuflist->phys);
+                icmd->un.elsreq64.bdl.addrLow = putPaddrLow(pbuflist->phys);
+                icmd->un.elsreq64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
                 icmd->un.elsreq64.bdl.bdeSize = (2 * sizeof(struct ulp_bde64));
+
+                icmd->un.elsreq64.remoteID = did;               /* DID */
                 icmd->ulpCommand = CMD_ELS_REQUEST64_CR;
                 icmd->ulpTimeout = phba->fc_ratov * 2;
         } else {
-                icmd->un.elsreq64.bdl.bdeSize = sizeof(struct ulp_bde64);
+                icmd->un.xseq64.bdl.addrHigh = putPaddrHigh(pbuflist->phys);
+                icmd->un.xseq64.bdl.addrLow = putPaddrLow(pbuflist->phys);
+                icmd->un.xseq64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
+                icmd->un.xseq64.bdl.bdeSize = sizeof(struct ulp_bde64);
+                icmd->un.xseq64.xmit_els_remoteID = did;        /* DID */
                 icmd->ulpCommand = CMD_XMIT_ELS_RSP64_CX;
         }
         icmd->ulpBdeCount = 1;
         icmd->ulpLe = 1;
         icmd->ulpClass = CLASS3;
 
-        if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) {
-                icmd->un.elsreq64.myID = vport->fc_myDID;
+        /*
+         * If we have NPIV enabled, we want to send ELS traffic by VPI.
+         * For SLI4, since the driver controls VPIs we also want to include
+         * all ELS pt2pt protocol traffic as well.
+         */
+        if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) ||
+                ((phba->sli_rev == LPFC_SLI_REV4) &&
+                    (vport->fc_flag & FC_PT2PT))) {
+
+                if (expectRsp) {
+                        icmd->un.elsreq64.myID = vport->fc_myDID;
+
+                        /* For ELS_REQUEST64_CR, use the VPI by default */
+                        icmd->ulpContext = phba->vpi_ids[vport->vpi];
+                }
 
-                /* For ELS_REQUEST64_CR, use the VPI by default */
-                icmd->ulpContext = phba->vpi_ids[vport->vpi];
                 icmd->ulpCt_h = 0;
                 /* The CT field must be 0=INVALID_RPI for the ECHO cmd */
                 if (elscmd == ELS_CMD_ECHO)
@@ -438,9 +454,10 @@ lpfc_issue_reg_vfi(struct lpfc_vport *vport)
         int rc = 0;
 
         sp = &phba->fc_fabparam;
-        /* move forward in case of SLI4 FC port loopback test */
+        /* move forward in case of SLI4 FC port loopback test and pt2pt mode */
         if ((phba->sli_rev == LPFC_SLI_REV4) &&
-            !(phba->link_flag & LS_LOOPBACK_MODE)) {
+            !(phba->link_flag & LS_LOOPBACK_MODE) &&
+            !(vport->fc_flag & FC_PT2PT)) {
                 ndlp = lpfc_findnode_did(vport, Fabric_DID);
                 if (!ndlp || !NLP_CHK_NODE_ACT(ndlp)) {
                         rc = -ENODEV;
@@ -707,14 +724,17 @@ lpfc_cmpl_els_flogi_fabric(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
                         lpfc_sli4_unreg_all_rpis(vport);
                         lpfc_mbx_unreg_vpi(vport);
                         spin_lock_irq(shost->host_lock);
-                        vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
-                        /*
-                        * If VPI is unreged, driver need to do INIT_VPI
-                        * before re-registering
-                        */
                         vport->fc_flag |= FC_VPORT_NEEDS_INIT_VPI;
                         spin_unlock_irq(shost->host_lock);
                 }
+
+                /*
+                 * For SLI3 and SLI4, the VPI needs to be reregistered in
+                 * response to this fabric parameter change event.
+                 */
+                spin_lock_irq(shost->host_lock);
+                vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
+                spin_unlock_irq(shost->host_lock);
         } else if ((phba->sli_rev == LPFC_SLI_REV4) &&
                 !(vport->fc_flag & FC_VPORT_NEEDS_REG_VPI)) {
                         /*
@@ -817,6 +837,17 @@ lpfc_cmpl_els_flogi_nport(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
                         mempool_free(mbox, phba->mbox_mem_pool);
                         goto fail;
                 }
+
+                /*
+                 * For SLI4, the VFI/VPI are registered AFTER the
+                 * Nport with the higher WWPN sends the PLOGI with
+                 * an assigned NPortId.
+                 */
+
+                /* not equal */
+                if ((phba->sli_rev == LPFC_SLI_REV4) && rc)
+                        lpfc_issue_reg_vfi(vport);
+
                 /* Decrement ndlp reference count indicating that ndlp can be
                  * safely released when other references to it are done.
                  */
@@ -2972,7 +3003,7 @@ lpfc_els_retry(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                          * ABTS we cannot generate and RRQ.
                          */
                         lpfc_set_rrq_active(phba, ndlp,
-                                         cmdiocb->sli4_xritag, 0, 0);
+                                         cmdiocb->sli4_lxritag, 0, 0);
                 }
                 break;
         case IOSTAT_LOCAL_REJECT:
@@ -3803,10 +3834,11 @@ lpfc_els_rsp_acc(struct lpfc_vport *vport, uint32_t flag,
         /* Xmit ELS ACC response tag <ulpIoTag> */
         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
                          "0128 Xmit ELS ACC response tag x%x, XRI: x%x, "
-                         "DID: x%x, nlp_flag: x%x nlp_state: x%x RPI: x%x\n",
+                         "DID: x%x, nlp_flag: x%x nlp_state: x%x RPI: x%x "
+                         "fc_flag x%x\n",
                          elsiocb->iotag, elsiocb->iocb.ulpContext,
                          ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_state,
-                         ndlp->nlp_rpi);
+                         ndlp->nlp_rpi, vport->fc_flag);
         if (ndlp->nlp_flag & NLP_LOGO_ACC) {
                 spin_lock_irq(shost->host_lock);
                 ndlp->nlp_flag &= ~NLP_LOGO_ACC;
@@ -4936,8 +4968,6 @@ lpfc_els_rcv_flogi(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
                 return 1;
         }
 
-        did = Fabric_DID;
-
         if ((lpfc_check_sparm(vport, ndlp, sp, CLASS3, 1))) {
                 /* For a FLOGI we accept, then if our portname is greater
                  * then the remote portname we initiate Nport login.
@@ -4976,26 +5006,82 @@ lpfc_els_rcv_flogi(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
                         spin_lock_irq(shost->host_lock);
                         vport->fc_flag |= FC_PT2PT_PLOGI;
                         spin_unlock_irq(shost->host_lock);
+
+                        /* If we have the high WWPN we can assign our own
+                         * myDID; otherwise, we have to WAIT for a PLOGI
+                         * from the remote NPort to find out what it
+                         * will be.
+                         */
+                        vport->fc_myDID = PT2PT_LocalID;
                 }
+
+                /*
+                 * The vport state should go to LPFC_FLOGI only
+                 * AFTER we issue a FLOGI, not receive one.
+                 */
                 spin_lock_irq(shost->host_lock);
                 vport->fc_flag |= FC_PT2PT;
                 vport->fc_flag &= ~(FC_FABRIC | FC_PUBLIC_LOOP);
                 spin_unlock_irq(shost->host_lock);
+
+                /*
+                 * We temporarily set fc_myDID to make it look like we are
+                 * a Fabric. This is done just so we end up with the right
+                 * did / sid on the FLOGI ACC rsp.
+                 */
+                did = vport->fc_myDID;
+                vport->fc_myDID = Fabric_DID;
+
         } else {
                 /* Reject this request because invalid parameters */
                 stat.un.b.lsRjtRsvd0 = 0;
                 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
                 stat.un.b.lsRjtRsnCodeExp = LSEXP_SPARM_OPTIONS;
                 stat.un.b.vendorUnique = 0;
+
+                /*
+                 * We temporarily set fc_myDID to make it look like we are
+                 * a Fabric. This is done just so we end up with the right
+                 * did / sid on the FLOGI LS_RJT rsp.
+                 */
+                did = vport->fc_myDID;
+                vport->fc_myDID = Fabric_DID;
+
                 lpfc_els_rsp_reject(vport, stat.un.lsRjtError, cmdiocb, ndlp,
                         NULL);
+
+                /* Now lets put fc_myDID back to what its supposed to be */
+                vport->fc_myDID = did;
+
                 return 1;
         }
 
         /* Send back ACC */
         lpfc_els_rsp_acc(vport, ELS_CMD_PLOGI, cmdiocb, ndlp, NULL);
 
+        /* Now lets put fc_myDID back to what its supposed to be */
+        vport->fc_myDID = did;
+
+        if (!(vport->fc_flag & FC_PT2PT_PLOGI)) {
+
+                mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+                if (!mbox)
+                        goto fail;
+
+                lpfc_config_link(phba, mbox);
+
+                mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
+                mbox->vport = vport;
+                rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
+                if (rc == MBX_NOT_FINISHED) {
+                        mempool_free(mbox, phba->mbox_mem_pool);
+                        goto fail;
+                }
+        }
+
         return 0;
+fail:
+        return 1;
 }
 
 /**
@@ -5176,7 +5262,6 @@ lpfc_els_rsp_rls_acc(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
         }
 
         cmdsize = sizeof(struct RLS_RSP) + sizeof(uint32_t);
-        mempool_free(pmb, phba->mbox_mem_pool);
         elsiocb = lpfc_prep_els_iocb(phba->pport, 0, cmdsize,
                                      lpfc_max_els_tries, ndlp,
                                      ndlp->nlp_DID, ELS_CMD_ACC);
@@ -5184,8 +5269,10 @@ lpfc_els_rsp_rls_acc(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
         /* Decrement the ndlp reference count from previous mbox command */
         lpfc_nlp_put(ndlp);
 
-        if (!elsiocb)
+        if (!elsiocb) {
+                mempool_free(pmb, phba->mbox_mem_pool);
                 return;
+        }
 
         icmd = &elsiocb->iocb;
         icmd->ulpContext = rxid;
@@ -5202,7 +5289,7 @@ lpfc_els_rsp_rls_acc(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
         rls_rsp->primSeqErrCnt = cpu_to_be32(mb->un.varRdLnk.primSeqErrCnt);
         rls_rsp->invalidXmitWord = cpu_to_be32(mb->un.varRdLnk.invalidXmitWord);
         rls_rsp->crcCnt = cpu_to_be32(mb->un.varRdLnk.crcCnt);
-
+        mempool_free(pmb, phba->mbox_mem_pool);
         /* Xmit ELS RLS ACC response tag <ulpIoTag> */
         lpfc_printf_vlog(ndlp->vport, KERN_INFO, LOG_ELS,
                          "2874 Xmit ELS RLS ACC response tag x%x xri x%x, "
@@ -5586,7 +5673,7 @@ lpfc_issue_els_rrq(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
         pcmd += sizeof(uint32_t);
         els_rrq = (struct RRQ *) pcmd;
 
-        bf_set(rrq_oxid, els_rrq, rrq->xritag);
+        bf_set(rrq_oxid, els_rrq, phba->sli4_hba.xri_ids[rrq->xritag]);
         bf_set(rrq_rxid, els_rrq, rrq->rxid);
         bf_set(rrq_did, els_rrq, vport->fc_myDID);
         els_rrq->rrq = cpu_to_be32(els_rrq->rrq);
@@ -7873,7 +7960,9 @@ lpfc_sli4_els_xri_aborted(struct lpfc_hba *phba,
                         sglq_entry->state = SGL_FREED;
                         spin_unlock(&phba->sli4_hba.abts_sgl_list_lock);
                         spin_unlock_irqrestore(&phba->hbalock, iflag);
-                        lpfc_set_rrq_active(phba, ndlp, xri, rxid, 1);
+                        lpfc_set_rrq_active(phba, ndlp,
+                                sglq_entry->sli4_lxritag,
+                                rxid, 1);
 
                         /* Check if TXQ queue needs to be serviced */
                         if (pring->txq_cnt)
diff --git a/drivers/scsi/lpfc/lpfc_hbadisc.c b/drivers/scsi/lpfc/lpfc_hbadisc.c
index b507536dc5b5..5bb269e224f6 100644
--- a/drivers/scsi/lpfc/lpfc_hbadisc.c
+++ b/drivers/scsi/lpfc/lpfc_hbadisc.c
@@ -713,6 +713,7 @@ lpfc_do_work(void *p)
         int rc;
 
         set_user_nice(current, -20);
+        current->flags |= PF_NOFREEZE;
         phba->data_flags = 0;
 
         while (!kthread_should_stop()) {
@@ -1094,7 +1095,7 @@ lpfc_mbx_cmpl_local_config_link(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
         /* Start discovery by sending a FLOGI. port_state is identically
          * LPFC_FLOGI while waiting for FLOGI cmpl
          */
-        if (vport->port_state != LPFC_FLOGI)
+        if (vport->port_state != LPFC_FLOGI || vport->fc_flag & FC_PT2PT_PLOGI)
                 lpfc_initial_flogi(vport);
         return;
 
@@ -2881,9 +2882,14 @@ lpfc_mbx_cmpl_reg_vfi(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
         }
 
         if (vport->port_state == LPFC_FABRIC_CFG_LINK) {
-                /* For private loop just start discovery and we are done. */
-                if ((phba->fc_topology == LPFC_TOPOLOGY_LOOP) &&
-                    !(vport->fc_flag & FC_PUBLIC_LOOP)) {
+                /*
+                 * For private loop or for NPort pt2pt,
+                 * just start discovery and we are done.
+                 */
+                if ((vport->fc_flag & FC_PT2PT) ||
+                    ((phba->fc_topology == LPFC_TOPOLOGY_LOOP) &&
+                    !(vport->fc_flag & FC_PUBLIC_LOOP))) {
+
                         /* Use loop map to make discovery list */
                         lpfc_disc_list_loopmap(vport);
                         /* Start discovery */
@@ -5490,9 +5496,9 @@ lpfc_nlp_release(struct kref *kref)
                 ndlp->nlp_DID, ndlp->nlp_flag, ndlp->nlp_type);
 
         lpfc_printf_vlog(ndlp->vport, KERN_INFO, LOG_NODE,
-                        "0279 lpfc_nlp_release: ndlp:x%p "
+                        "0279 lpfc_nlp_release: ndlp:x%p did %x "
                         "usgmap:x%x refcnt:%d\n",
-                        (void *)ndlp, ndlp->nlp_usg_map,
+                        (void *)ndlp, ndlp->nlp_DID, ndlp->nlp_usg_map,
                         atomic_read(&ndlp->kref.refcount));
 
         /* remove ndlp from action. */
diff --git a/drivers/scsi/lpfc/lpfc_hw.h b/drivers/scsi/lpfc/lpfc_hw.h
index 5f280b5ae3db..41bb1d2fb625 100644
--- a/drivers/scsi/lpfc/lpfc_hw.h
+++ b/drivers/scsi/lpfc/lpfc_hw.h
@@ -3374,6 +3374,9 @@ typedef struct {
         WORD5 w5;               /* Header control/status word */
 } XMT_SEQ_FIELDS64;
 
+/* This word is remote ports D_ID for XMIT_ELS_RSP64 */
+#define xmit_els_remoteID xrsqRo
+
 /* IOCB Command template for 64 bit RCV_SEQUENCE64 */
 typedef struct {
         struct ulp_bde64 rcvBde;
diff --git a/drivers/scsi/lpfc/lpfc_hw4.h b/drivers/scsi/lpfc/lpfc_hw4.h
index 91f09761bd32..f1946dfda5b4 100644
--- a/drivers/scsi/lpfc/lpfc_hw4.h
+++ b/drivers/scsi/lpfc/lpfc_hw4.h
@@ -228,19 +228,15 @@ struct lpfc_sli4_flags {
 #define lpfc_idx_rsrc_rdy_MASK          0x00000001
 #define lpfc_idx_rsrc_rdy_WORD          word0
 #define LPFC_IDX_RSRC_RDY               1
-#define lpfc_xri_rsrc_rdy_SHIFT         1
-#define lpfc_xri_rsrc_rdy_MASK          0x00000001
-#define lpfc_xri_rsrc_rdy_WORD          word0
-#define LPFC_XRI_RSRC_RDY               1
-#define lpfc_rpi_rsrc_rdy_SHIFT         2
+#define lpfc_rpi_rsrc_rdy_SHIFT         1
 #define lpfc_rpi_rsrc_rdy_MASK          0x00000001
 #define lpfc_rpi_rsrc_rdy_WORD          word0
 #define LPFC_RPI_RSRC_RDY               1
-#define lpfc_vpi_rsrc_rdy_SHIFT         3
+#define lpfc_vpi_rsrc_rdy_SHIFT         2
 #define lpfc_vpi_rsrc_rdy_MASK          0x00000001
 #define lpfc_vpi_rsrc_rdy_WORD          word0
 #define LPFC_VPI_RSRC_RDY               1
-#define lpfc_vfi_rsrc_rdy_SHIFT         4
+#define lpfc_vfi_rsrc_rdy_SHIFT         3
 #define lpfc_vfi_rsrc_rdy_MASK          0x00000001
 #define lpfc_vfi_rsrc_rdy_WORD          word0
 #define LPFC_VFI_RSRC_RDY               1
@@ -3299,7 +3295,13 @@ struct els_request64_wqe {
 struct xmit_els_rsp64_wqe {
         struct ulp_bde64 bde;
         uint32_t response_payload_len;
-        uint32_t rsvd4;
+        uint32_t word4;
+#define els_rsp64_sid_SHIFT         0
+#define els_rsp64_sid_MASK          0x00FFFFFF
+#define els_rsp64_sid_WORD          word4
+#define els_rsp64_sp_SHIFT          24
+#define els_rsp64_sp_MASK           0x00000001
+#define els_rsp64_sp_WORD           word4
         struct wqe_did wqe_dest;
         struct wqe_common wqe_com; /* words 6-11 */
         uint32_t word12;
diff --git a/drivers/scsi/lpfc/lpfc_init.c b/drivers/scsi/lpfc/lpfc_init.c
index 9598fdcb08ab..411ed48d79da 100644
--- a/drivers/scsi/lpfc/lpfc_init.c
+++ b/drivers/scsi/lpfc/lpfc_init.c
@@ -64,8 +64,8 @@ static int lpfc_sli4_queue_verify(struct lpfc_hba *);
 static int lpfc_create_bootstrap_mbox(struct lpfc_hba *);
 static int lpfc_setup_endian_order(struct lpfc_hba *);
 static void lpfc_destroy_bootstrap_mbox(struct lpfc_hba *);
-static void lpfc_free_sgl_list(struct lpfc_hba *);
-static int lpfc_init_sgl_list(struct lpfc_hba *);
+static void lpfc_free_els_sgl_list(struct lpfc_hba *);
+static void lpfc_init_sgl_list(struct lpfc_hba *);
 static int lpfc_init_active_sgl_array(struct lpfc_hba *);
 static void lpfc_free_active_sgl(struct lpfc_hba *);
 static int lpfc_hba_down_post_s3(struct lpfc_hba *phba);
@@ -2767,47 +2767,14 @@ lpfc_offline(struct lpfc_hba *phba)
 }
 
 /**
- * lpfc_scsi_buf_update - Update the scsi_buffers that are already allocated.
- * @phba: pointer to lpfc hba data structure.
- *
- * This routine goes through all the scsi buffers in the system and updates the
- * Physical XRIs assigned to the SCSI buffer because these may change after any
- * firmware reset
- *
- * Return codes
- *   0 - successful (for now, it always returns 0)
- **/
-int
-lpfc_scsi_buf_update(struct lpfc_hba *phba)
-{
-        struct lpfc_scsi_buf *sb, *sb_next;
-
-        spin_lock_irq(&phba->hbalock);
-        spin_lock(&phba->scsi_buf_list_lock);
-        list_for_each_entry_safe(sb, sb_next, &phba->lpfc_scsi_buf_list, list) {
-                sb->cur_iocbq.sli4_xritag =
-                        phba->sli4_hba.xri_ids[sb->cur_iocbq.sli4_lxritag];
-                set_bit(sb->cur_iocbq.sli4_lxritag, phba->sli4_hba.xri_bmask);
-                phba->sli4_hba.max_cfg_param.xri_used++;
-                phba->sli4_hba.xri_count++;
-        }
-        spin_unlock(&phba->scsi_buf_list_lock);
-        spin_unlock_irq(&phba->hbalock);
-        return 0;
-}
-
-/**
  * lpfc_scsi_free - Free all the SCSI buffers and IOCBs from driver lists
  * @phba: pointer to lpfc hba data structure.
  *
  * This routine is to free all the SCSI buffers and IOCBs from the driver
  * list back to kernel. It is called from lpfc_pci_remove_one to free
  * the internal resources before the device is removed from the system.
- *
- * Return codes
- *   0 - successful (for now, it always returns 0)
  **/
-static int
+static void
 lpfc_scsi_free(struct lpfc_hba *phba)
 {
         struct lpfc_scsi_buf *sb, *sb_next;
@@ -2833,7 +2800,178 @@ lpfc_scsi_free(struct lpfc_hba *phba)
         }
 
         spin_unlock_irq(&phba->hbalock);
+}
+
+/**
+ * lpfc_sli4_xri_sgl_update - update xri-sgl sizing and mapping
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine first calculates the sizes of the current els and allocated
+ * scsi sgl lists, and then goes through all sgls to updates the physical
+ * XRIs assigned due to port function reset. During port initialization, the
+ * current els and allocated scsi sgl lists are 0s.
+ *
+ * Return codes
+ *   0 - successful (for now, it always returns 0)
+ **/
+int
+lpfc_sli4_xri_sgl_update(struct lpfc_hba *phba)
+{
+        struct lpfc_sglq *sglq_entry = NULL, *sglq_entry_next = NULL;
+        struct lpfc_scsi_buf *psb = NULL, *psb_next = NULL;
+        uint16_t i, lxri, xri_cnt, els_xri_cnt, scsi_xri_cnt;
+        LIST_HEAD(els_sgl_list);
+        LIST_HEAD(scsi_sgl_list);
+        int rc;
+
+        /*
+         * update on pci function's els xri-sgl list
+         */
+        els_xri_cnt = lpfc_sli4_get_els_iocb_cnt(phba);
+        if (els_xri_cnt > phba->sli4_hba.els_xri_cnt) {
+                /* els xri-sgl expanded */
+                xri_cnt = els_xri_cnt - phba->sli4_hba.els_xri_cnt;
+                lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
+                                "3157 ELS xri-sgl count increased from "
+                                "%d to %d\n", phba->sli4_hba.els_xri_cnt,
+                                els_xri_cnt);
+                /* allocate the additional els sgls */
+                for (i = 0; i < xri_cnt; i++) {
+                        sglq_entry = kzalloc(sizeof(struct lpfc_sglq),
+                                             GFP_KERNEL);
+                        if (sglq_entry == NULL) {
+                                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                                                "2562 Failure to allocate an "
+                                                "ELS sgl entry:%d\n", i);
+                                rc = -ENOMEM;
+                                goto out_free_mem;
+                        }
+                        sglq_entry->buff_type = GEN_BUFF_TYPE;
+                        sglq_entry->virt = lpfc_mbuf_alloc(phba, 0,
+                                                           &sglq_entry->phys);
+                        if (sglq_entry->virt == NULL) {
+                                kfree(sglq_entry);
+                                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                                                "2563 Failure to allocate an "
+                                                "ELS mbuf:%d\n", i);
+                                rc = -ENOMEM;
+                                goto out_free_mem;
+                        }
+                        sglq_entry->sgl = sglq_entry->virt;
+                        memset(sglq_entry->sgl, 0, LPFC_BPL_SIZE);
+                        sglq_entry->state = SGL_FREED;
+                        list_add_tail(&sglq_entry->list, &els_sgl_list);
+                }
+                spin_lock(&phba->hbalock);
+                list_splice_init(&els_sgl_list, &phba->sli4_hba.lpfc_sgl_list);
+                spin_unlock(&phba->hbalock);
+        } else if (els_xri_cnt < phba->sli4_hba.els_xri_cnt) {
+                /* els xri-sgl shrinked */
+                xri_cnt = phba->sli4_hba.els_xri_cnt - els_xri_cnt;
+                lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
+                                "3158 ELS xri-sgl count decreased from "
+                                "%d to %d\n", phba->sli4_hba.els_xri_cnt,
+                                els_xri_cnt);
+                spin_lock_irq(&phba->hbalock);
+                list_splice_init(&phba->sli4_hba.lpfc_sgl_list, &els_sgl_list);
+                spin_unlock_irq(&phba->hbalock);
+                /* release extra els sgls from list */
+                for (i = 0; i < xri_cnt; i++) {
+                        list_remove_head(&els_sgl_list,
+                                         sglq_entry, struct lpfc_sglq, list);
+                        if (sglq_entry) {
+                                lpfc_mbuf_free(phba, sglq_entry->virt,
+                                               sglq_entry->phys);
+                                kfree(sglq_entry);
+                        }
+                }
+                spin_lock_irq(&phba->hbalock);
+                list_splice_init(&els_sgl_list, &phba->sli4_hba.lpfc_sgl_list);
+                spin_unlock_irq(&phba->hbalock);
+        } else
+                lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
+                                "3163 ELS xri-sgl count unchanged: %d\n",
+                                els_xri_cnt);
+        phba->sli4_hba.els_xri_cnt = els_xri_cnt;
+
+        /* update xris to els sgls on the list */
+        sglq_entry = NULL;
+        sglq_entry_next = NULL;
+        list_for_each_entry_safe(sglq_entry, sglq_entry_next,
+                                 &phba->sli4_hba.lpfc_sgl_list, list) {
+                lxri = lpfc_sli4_next_xritag(phba);
+                if (lxri == NO_XRI) {
+                        lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                                        "2400 Failed to allocate xri for "
+                                        "ELS sgl\n");
+                        rc = -ENOMEM;
+                        goto out_free_mem;
+                }
+                sglq_entry->sli4_lxritag = lxri;
+                sglq_entry->sli4_xritag = phba->sli4_hba.xri_ids[lxri];
+        }
+
+        /*
+         * update on pci function's allocated scsi xri-sgl list
+         */
+        phba->total_scsi_bufs = 0;
+
+        /* maximum number of xris available for scsi buffers */
+        phba->sli4_hba.scsi_xri_max = phba->sli4_hba.max_cfg_param.max_xri -
+                                      els_xri_cnt;
+
+        lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
+                        "2401 Current allocated SCSI xri-sgl count:%d, "
+                        "maximum  SCSI xri count:%d\n",
+                        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);
+
+        if (phba->sli4_hba.scsi_xri_cnt > phba->sli4_hba.scsi_xri_max) {
+                /* max scsi xri shrinked below the allocated scsi buffers */
+                scsi_xri_cnt = phba->sli4_hba.scsi_xri_cnt -
+                                        phba->sli4_hba.scsi_xri_max;
+                /* release the extra allocated scsi buffers */
+                for (i = 0; i < scsi_xri_cnt; i++) {
+                        list_remove_head(&scsi_sgl_list, psb,
+                                         struct lpfc_scsi_buf, list);
+                        pci_pool_free(phba->lpfc_scsi_dma_buf_pool, psb->data,
+                                      psb->dma_handle);
+                        kfree(psb);
+                }
+                spin_lock_irq(&phba->scsi_buf_list_lock);
+                phba->sli4_hba.scsi_xri_cnt -= scsi_xri_cnt;
+                spin_unlock_irq(&phba->scsi_buf_list_lock);
+        }
+
+        /* update xris associated to remaining allocated scsi buffers */
+        psb = NULL;
+        psb_next = NULL;
+        list_for_each_entry_safe(psb, psb_next, &scsi_sgl_list, list) {
+                lxri = lpfc_sli4_next_xritag(phba);
+                if (lxri == NO_XRI) {
+                        lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                                        "2560 Failed to allocate xri for "
+                                        "scsi buffer\n");
+                        rc = -ENOMEM;
+                        goto out_free_mem;
+                }
+                psb->cur_iocbq.sli4_lxritag = lxri;
+                psb->cur_iocbq.sli4_xritag = phba->sli4_hba.xri_ids[lxri];
+        }
+        spin_lock(&phba->scsi_buf_list_lock);
+        list_splice_init(&scsi_sgl_list, &phba->lpfc_scsi_buf_list);
+        spin_unlock(&phba->scsi_buf_list_lock);
+
         return 0;
+
+out_free_mem:
+        lpfc_free_els_sgl_list(phba);
+        lpfc_scsi_free(phba);
+        return rc;
 }
 
 /**
@@ -4636,18 +4774,15 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
         if (rc)
                 goto out_free_bsmbx;
 
-        /* Initialize and populate the iocb list per host */
-        rc = lpfc_init_sgl_list(phba);
-        if (rc) {
-                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
-                                "1400 Failed to initialize sgl list.\n");
-                goto out_destroy_cq_event_pool;
-        }
+        /* Initialize sgl lists per host */
+        lpfc_init_sgl_list(phba);
+
+        /* Allocate and initialize active sgl array */
         rc = lpfc_init_active_sgl_array(phba);
         if (rc) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
                                 "1430 Failed to initialize sgl list.\n");
-                goto out_free_sgl_list;
+                goto out_destroy_cq_event_pool;
         }
         rc = lpfc_sli4_init_rpi_hdrs(phba);
         if (rc) {
@@ -4722,8 +4857,6 @@ out_remove_rpi_hdrs:
         lpfc_sli4_remove_rpi_hdrs(phba);
 out_free_active_sgl:
         lpfc_free_active_sgl(phba);
-out_free_sgl_list:
-        lpfc_free_sgl_list(phba);
 out_destroy_cq_event_pool:
         lpfc_sli4_cq_event_pool_destroy(phba);
 out_free_bsmbx:
@@ -4760,10 +4893,7 @@ lpfc_sli4_driver_resource_unset(struct lpfc_hba *phba)
 
         /* Free the ELS sgl list */
         lpfc_free_active_sgl(phba);
-        lpfc_free_sgl_list(phba);
-
-        /* Free the SCSI sgl management array */
-        kfree(phba->sli4_hba.lpfc_scsi_psb_array);
+        lpfc_free_els_sgl_list(phba);
 
         /* Free the completion queue EQ event pool */
         lpfc_sli4_cq_event_release_all(phba);
@@ -4990,29 +5120,42 @@ out_free_iocbq:
 }
 
 /**
- * lpfc_free_sgl_list - Free sgl list.
+ * lpfc_free_sgl_list - Free a given sgl list.
  * @phba: pointer to lpfc hba data structure.
+ * @sglq_list: pointer to the head of sgl list.
  *
- * This routine is invoked to free the driver's sgl list and memory.
+ * This routine is invoked to free a give sgl list and memory.
  **/
-static void
-lpfc_free_sgl_list(struct lpfc_hba *phba)
+void
+lpfc_free_sgl_list(struct lpfc_hba *phba, struct list_head *sglq_list)
 {
         struct lpfc_sglq *sglq_entry = NULL, *sglq_next = NULL;
+
+        list_for_each_entry_safe(sglq_entry, sglq_next, sglq_list, list) {
+                list_del(&sglq_entry->list);
+                lpfc_mbuf_free(phba, sglq_entry->virt, sglq_entry->phys);
+                kfree(sglq_entry);
+        }
+}
+
+/**
+ * lpfc_free_els_sgl_list - Free els sgl list.
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine is invoked to free the driver's els sgl list and memory.
+ **/
+static void
+lpfc_free_els_sgl_list(struct lpfc_hba *phba)
+{
         LIST_HEAD(sglq_list);
 
+        /* Retrieve all els sgls from driver list */
         spin_lock_irq(&phba->hbalock);
         list_splice_init(&phba->sli4_hba.lpfc_sgl_list, &sglq_list);
         spin_unlock_irq(&phba->hbalock);
 
-        list_for_each_entry_safe(sglq_entry, sglq_next,
-                                 &sglq_list, list) {
-                list_del(&sglq_entry->list);
-                lpfc_mbuf_free(phba, sglq_entry->virt, sglq_entry->phys);
-                kfree(sglq_entry);
-                phba->sli4_hba.total_sglq_bufs--;
-        }
-        kfree(phba->sli4_hba.lpfc_els_sgl_array);
+        /* Now free the sgl list */
+        lpfc_free_sgl_list(phba, &sglq_list);
 }
 
 /**
@@ -5057,99 +5200,19 @@ lpfc_free_active_sgl(struct lpfc_hba *phba)
  * This routine is invoked to allocate and initizlize the driver's sgl
  * list and set up the sgl xritag tag array accordingly.
  *
- * Return codes
- *      0 - successful
- *      other values - error
  **/
-static int
+static void
 lpfc_init_sgl_list(struct lpfc_hba *phba)
 {
-        struct lpfc_sglq *sglq_entry = NULL;
-        int i;
-        int els_xri_cnt;
-
-        els_xri_cnt = lpfc_sli4_get_els_iocb_cnt(phba);
-        lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
-                                "2400 ELS XRI count %d.\n",
-                                els_xri_cnt);
         /* Initialize and populate the sglq list per host/VF. */
         INIT_LIST_HEAD(&phba->sli4_hba.lpfc_sgl_list);
         INIT_LIST_HEAD(&phba->sli4_hba.lpfc_abts_els_sgl_list);
 
-        /* Sanity check on XRI management */
-        if (phba->sli4_hba.max_cfg_param.max_xri <= els_xri_cnt) {
-                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
-                                "2562 No room left for SCSI XRI allocation: "
-                                "max_xri=%d, els_xri=%d\n",
-                                phba->sli4_hba.max_cfg_param.max_xri,
-                                els_xri_cnt);
-                return -ENOMEM;
-        }
-
-        /* Allocate memory for the ELS XRI management array */
-        phba->sli4_hba.lpfc_els_sgl_array =
-                        kzalloc((sizeof(struct lpfc_sglq *) * els_xri_cnt),
-                        GFP_KERNEL);
-
-        if (!phba->sli4_hba.lpfc_els_sgl_array) {
-                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
-                                "2401 Failed to allocate memory for ELS "
-                                "XRI management array of size %d.\n",
-                                els_xri_cnt);
-                return -ENOMEM;
-        }
+        /* els xri-sgl book keeping */
+        phba->sli4_hba.els_xri_cnt = 0;
 
-        /* Keep the SCSI XRI into the XRI management array */
-        phba->sli4_hba.scsi_xri_max =
-                        phba->sli4_hba.max_cfg_param.max_xri - els_xri_cnt;
+        /* scsi xri-buffer book keeping */
         phba->sli4_hba.scsi_xri_cnt = 0;
-        phba->sli4_hba.lpfc_scsi_psb_array =
-                        kzalloc((sizeof(struct lpfc_scsi_buf *) *
-                        phba->sli4_hba.scsi_xri_max), GFP_KERNEL);
-
-        if (!phba->sli4_hba.lpfc_scsi_psb_array) {
-                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
-                                "2563 Failed to allocate memory for SCSI "
-                                "XRI management array of size %d.\n",
-                                phba->sli4_hba.scsi_xri_max);
-                kfree(phba->sli4_hba.lpfc_els_sgl_array);
-                return -ENOMEM;
-        }
-
-        for (i = 0; i < els_xri_cnt; i++) {
-                sglq_entry = kzalloc(sizeof(struct lpfc_sglq), GFP_KERNEL);
-                if (sglq_entry == NULL) {
-                        printk(KERN_ERR "%s: only allocated %d sgls of "
-                                "expected %d count. Unloading driver.\n",
-                                __func__, i, els_xri_cnt);
-                        goto out_free_mem;
-                }
-
-                sglq_entry->buff_type = GEN_BUFF_TYPE;
-                sglq_entry->virt = lpfc_mbuf_alloc(phba, 0, &sglq_entry->phys);
-                if (sglq_entry->virt == NULL) {
-                        kfree(sglq_entry);
-                        printk(KERN_ERR "%s: failed to allocate mbuf.\n"
-                                "Unloading driver.\n", __func__);
-                        goto out_free_mem;
-                }
-                sglq_entry->sgl = sglq_entry->virt;
-                memset(sglq_entry->sgl, 0, LPFC_BPL_SIZE);
-
-                /* The list order is used by later block SGL registraton */
-                spin_lock_irq(&phba->hbalock);
-                sglq_entry->state = SGL_FREED;
-                list_add_tail(&sglq_entry->list, &phba->sli4_hba.lpfc_sgl_list);
-                phba->sli4_hba.lpfc_els_sgl_array[i] = sglq_entry;
-                phba->sli4_hba.total_sglq_bufs++;
-                spin_unlock_irq(&phba->hbalock);
-        }
-        return 0;
-
-out_free_mem:
-        kfree(phba->sli4_hba.lpfc_scsi_psb_array);
-        lpfc_free_sgl_list(phba);
-        return -ENOMEM;
 }
 
 /**
@@ -7320,9 +7383,11 @@ lpfc_pci_function_reset(struct lpfc_hba *phba)
                                         phba->sli4_hba.u.if_type2.ERR2regaddr);
                                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
                                         "2890 Port error detected during port "
-                                        "reset(%d): port status reg 0x%x, "
+                                        "reset(%d): wait_tmo:%d ms, "
+                                        "port status reg 0x%x, "
                                         "error 1=0x%x, error 2=0x%x\n",
-                                        num_resets, reg_data.word0,
+                                        num_resets, rdy_chk*10,
+                                        reg_data.word0,
                                         phba->work_status[0],
                                         phba->work_status[1]);
                                 rc = -ENODEV;
@@ -8694,8 +8759,11 @@ lpfc_pci_remove_one_s3(struct pci_dev *pdev)
         /* Release all the vports against this physical port */
         vports = lpfc_create_vport_work_array(phba);
         if (vports != NULL)
-                for (i = 1; i <= phba->max_vports && vports[i] != NULL; i++)
+                for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
+                        if (vports[i]->port_type == LPFC_PHYSICAL_PORT)
+                                continue;
                         fc_vport_terminate(vports[i]->fc_vport);
+                }
         lpfc_destroy_vport_work_array(phba, vports);
 
         /* Remove FC host and then SCSI host with the physical port */
@@ -9115,8 +9183,12 @@ lpfc_sli4_get_els_iocb_cnt(struct lpfc_hba *phba)
                         return 50;
                 else if (max_xri <= 1024)
                         return 100;
-                else
+                else if (max_xri <= 1536)
                         return 150;
+                else if (max_xri <= 2048)
+                        return 200;
+                else
+                        return 250;
         } else
                 return 0;
 }
@@ -9455,8 +9527,11 @@ lpfc_pci_remove_one_s4(struct pci_dev *pdev)
         /* Release all the vports against this physical port */
         vports = lpfc_create_vport_work_array(phba);
         if (vports != NULL)
-                for (i = 1; i <= phba->max_vports && vports[i] != NULL; i++)
+                for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
+                        if (vports[i]->port_type == LPFC_PHYSICAL_PORT)
+                                continue;
                         fc_vport_terminate(vports[i]->fc_vport);
+                }
         lpfc_destroy_vport_work_array(phba, vports);
 
         /* Remove FC host and then SCSI host with the physical port */
diff --git a/drivers/scsi/lpfc/lpfc_nportdisc.c b/drivers/scsi/lpfc/lpfc_nportdisc.c
index 15ca2a9a0cdd..9133a97f045f 100644
--- a/drivers/scsi/lpfc/lpfc_nportdisc.c
+++ b/drivers/scsi/lpfc/lpfc_nportdisc.c
@@ -367,8 +367,10 @@ lpfc_rcv_plogi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
                 return 1;
         }
 
+        /* Check for Nport to NPort pt2pt protocol */
         if ((vport->fc_flag & FC_PT2PT) &&
             !(vport->fc_flag & FC_PT2PT_PLOGI)) {
+
                 /* rcv'ed PLOGI decides what our NPortId will be */
                 vport->fc_myDID = icmd->un.rcvels.parmRo;
                 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
@@ -382,6 +384,13 @@ lpfc_rcv_plogi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
                         mempool_free(mbox, phba->mbox_mem_pool);
                         goto out;
                 }
+                /*
+                 * For SLI4, the VFI/VPI are registered AFTER the
+                 * Nport with the higher WWPN sends us a PLOGI with
+                 * our assigned NPortId.
+                 */
+                if (phba->sli_rev == LPFC_SLI_REV4)
+                        lpfc_issue_reg_vfi(vport);
 
                 lpfc_can_disctmo(vport);
         }
diff --git a/drivers/scsi/lpfc/lpfc_scsi.c b/drivers/scsi/lpfc/lpfc_scsi.c
index 88f3a83dbd2e..66e09069f281 100644
--- a/drivers/scsi/lpfc/lpfc_scsi.c
+++ b/drivers/scsi/lpfc/lpfc_scsi.c
@@ -399,6 +399,14 @@ lpfc_ramp_down_queue_handler(struct lpfc_hba *phba)
         num_rsrc_err = atomic_read(&phba->num_rsrc_err);
         num_cmd_success = atomic_read(&phba->num_cmd_success);
 
+        /*
+         * The error and success command counters are global per
+         * driver instance.  If another handler has already
+         * operated on this error event, just exit.
+         */
+        if (num_rsrc_err == 0)
+                return;
+
         vports = lpfc_create_vport_work_array(phba);
         if (vports != NULL)
                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
@@ -688,7 +696,8 @@ lpfc_sli4_fcp_xri_aborted(struct lpfc_hba *phba,
                         rrq_empty = list_empty(&phba->active_rrq_list);
                         spin_unlock_irqrestore(&phba->hbalock, iflag);
                         if (ndlp) {
-                                lpfc_set_rrq_active(phba, ndlp, xri, rxid, 1);
+                                lpfc_set_rrq_active(phba, ndlp,
+                                        psb->cur_iocbq.sli4_lxritag, rxid, 1);
                                 lpfc_sli4_abts_err_handler(phba, ndlp, axri);
                         }
                         lpfc_release_scsi_buf_s4(phba, psb);
@@ -718,72 +727,162 @@ lpfc_sli4_fcp_xri_aborted(struct lpfc_hba *phba,
 }
 
 /**
- * lpfc_sli4_repost_scsi_sgl_list - Repsot the Scsi buffers sgl pages as block
+ * lpfc_sli4_post_scsi_sgl_list - Psot blocks of scsi buffer sgls from a list
  * @phba: pointer to lpfc hba data structure.
+ * @post_sblist: pointer to the scsi buffer list.
  *
- * This routine walks the list of scsi buffers that have been allocated and
- * repost them to the HBA by using SGL block post. This is needed after a
- * pci_function_reset/warm_start or start. The lpfc_hba_down_post_s4 routine
- * is responsible for moving all scsi buffers on the lpfc_abts_scsi_sgl_list
- * to the lpfc_scsi_buf_list. If the repost fails, reject all scsi buffers.
+ * This routine walks a list of scsi buffers that was passed in. It attempts
+ * to construct blocks of scsi buffer sgls which contains contiguous xris and
+ * uses the non-embedded SGL block post mailbox commands to post to the port.
+ * For single SCSI buffer sgl with non-contiguous xri, if any, it shall use
+ * embedded SGL post mailbox command for posting. The @post_sblist passed in
+ * must be local list, thus no lock is needed when manipulate the list.
  *
- * Returns: 0 = success, non-zero failure.
+ * Returns: 0 = failure, non-zero number of successfully posted buffers.
  **/
 int
-lpfc_sli4_repost_scsi_sgl_list(struct lpfc_hba *phba)
+lpfc_sli4_post_scsi_sgl_list(struct lpfc_hba *phba,
+                             struct list_head *post_sblist, int sb_count)
 {
-        struct lpfc_scsi_buf *psb;
-        int index, status, bcnt = 0, rcnt = 0, rc = 0;
-        LIST_HEAD(sblist);
-
-        for (index = 0; index < phba->sli4_hba.scsi_xri_cnt; index++) {
-                psb = phba->sli4_hba.lpfc_scsi_psb_array[index];
-                if (psb) {
-                        /* Remove from SCSI buffer list */
-                        list_del(&psb->list);
-                        /* Add it to a local SCSI buffer list */
-                        list_add_tail(&psb->list, &sblist);
-                        if (++rcnt == LPFC_NEMBED_MBOX_SGL_CNT) {
-                                bcnt = rcnt;
-                                rcnt = 0;
+        struct lpfc_scsi_buf *psb, *psb_next;
+        int status;
+        int post_cnt = 0, block_cnt = 0, num_posting = 0, num_posted = 0;
+        dma_addr_t pdma_phys_bpl1;
+        int last_xritag = NO_XRI;
+        LIST_HEAD(prep_sblist);
+        LIST_HEAD(blck_sblist);
+        LIST_HEAD(scsi_sblist);
+
+        /* sanity check */
+        if (sb_count <= 0)
+                return -EINVAL;
+
+        list_for_each_entry_safe(psb, psb_next, post_sblist, list) {
+                list_del_init(&psb->list);
+                block_cnt++;
+                if ((last_xritag != NO_XRI) &&
+                    (psb->cur_iocbq.sli4_xritag != last_xritag + 1)) {
+                        /* a hole in xri block, form a sgl posting block */
+                        list_splice_init(&prep_sblist, &blck_sblist);
+                        post_cnt = block_cnt - 1;
+                        /* prepare list for next posting block */
+                        list_add_tail(&psb->list, &prep_sblist);
+                        block_cnt = 1;
+                } else {
+                        /* prepare list for next posting block */
+                        list_add_tail(&psb->list, &prep_sblist);
+                        /* enough sgls for non-embed sgl mbox command */
+                        if (block_cnt == LPFC_NEMBED_MBOX_SGL_CNT) {
+                                list_splice_init(&prep_sblist, &blck_sblist);
+                                post_cnt = block_cnt;
+                                block_cnt = 0;
                         }
-                } else
-                        /* A hole present in the XRI array, need to skip */
-                        bcnt = rcnt;
+                }
+                num_posting++;
+                last_xritag = psb->cur_iocbq.sli4_xritag;
 
-                if (index == phba->sli4_hba.scsi_xri_cnt - 1)
-                        /* End of XRI array for SCSI buffer, complete */
-                        bcnt = rcnt;
+                /* end of repost sgl list condition for SCSI buffers */
+                if (num_posting == sb_count) {
+                        if (post_cnt == 0) {
+                                /* last sgl posting block */
+                                list_splice_init(&prep_sblist, &blck_sblist);
+                                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)
+                                        pdma_phys_bpl1 = psb->dma_phys_bpl +
+                                                                SGL_PAGE_SIZE;
+                                else
+                                        pdma_phys_bpl1 = 0;
+                                status = lpfc_sli4_post_sgl(phba,
+                                                psb->dma_phys_bpl,
+                                                pdma_phys_bpl1,
+                                                psb->cur_iocbq.sli4_xritag);
+                                if (status) {
+                                        /* failure, put on abort scsi list */
+                                        psb->exch_busy = 1;
+                                } else {
+                                        /* success, put on SCSI buffer list */
+                                        psb->exch_busy = 0;
+                                        psb->status = IOSTAT_SUCCESS;
+                                        num_posted++;
+                                }
+                                /* success, put on SCSI buffer sgl list */
+                                list_add_tail(&psb->list, &scsi_sblist);
+                        }
+                }
 
-                /* Continue until collect up to a nembed page worth of sgls */
-                if (bcnt == 0)
+                /* continue until a nembed page worth of sgls */
+                if (post_cnt == 0)
                         continue;
-                /* Now, post the SCSI buffer list sgls as a block */
-                if (!phba->sli4_hba.extents_in_use)
-                        status = lpfc_sli4_post_scsi_sgl_block(phba,
-                                                        &sblist,
-                                                        bcnt);
-                else
-                        status = lpfc_sli4_post_scsi_sgl_blk_ext(phba,
-                                                        &sblist,
-                                                        bcnt);
-                /* Reset SCSI buffer count for next round of posting */
-                bcnt = 0;
-                while (!list_empty(&sblist)) {
-                        list_remove_head(&sblist, psb, struct lpfc_scsi_buf,
-                                         list);
+
+                /* post block of SCSI buffer list sgls */
+                status = lpfc_sli4_post_scsi_sgl_block(phba, &blck_sblist,
+                                                       post_cnt);
+
+                /* don't reset xirtag due to hole in xri block */
+                if (block_cnt == 0)
+                        last_xritag = NO_XRI;
+
+                /* reset SCSI buffer post count for next round of posting */
+                post_cnt = 0;
+
+                /* put posted SCSI buffer-sgl posted on SCSI buffer sgl list */
+                while (!list_empty(&blck_sblist)) {
+                        list_remove_head(&blck_sblist, psb,
+                                         struct lpfc_scsi_buf, list);
                         if (status) {
-                                /* Put this back on the abort scsi list */
+                                /* failure, put on abort scsi list */
                                 psb->exch_busy = 1;
-                                rc++;
                         } else {
+                                /* success, put on SCSI buffer list */
                                 psb->exch_busy = 0;
                                 psb->status = IOSTAT_SUCCESS;
+                                num_posted++;
                         }
-                        /* Put it back into the SCSI buffer list */
-                        lpfc_release_scsi_buf_s4(phba, psb);
+                        list_add_tail(&psb->list, &scsi_sblist);
                 }
         }
+        /* Push SCSI buffers with sgl posted to the availble list */
+        while (!list_empty(&scsi_sblist)) {
+                list_remove_head(&scsi_sblist, psb,
+                                 struct lpfc_scsi_buf, list);
+                lpfc_release_scsi_buf_s4(phba, psb);
+        }
+        return num_posted;
+}
+
+/**
+ * lpfc_sli4_repost_scsi_sgl_list - Repsot all the allocated scsi buffer sgls
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine walks the list of scsi buffers that have been allocated and
+ * repost them to the port by using SGL block post. This is needed after a
+ * pci_function_reset/warm_start or start. The lpfc_hba_down_post_s4 routine
+ * is responsible for moving all scsi buffers on the lpfc_abts_scsi_sgl_list
+ * to the lpfc_scsi_buf_list. If the repost fails, reject all scsi buffers.
+ *
+ * Returns: 0 = success, non-zero failure.
+ **/
+int
+lpfc_sli4_repost_scsi_sgl_list(struct lpfc_hba *phba)
+{
+        LIST_HEAD(post_sblist);
+        int num_posted, rc = 0;
+
+        /* get all SCSI buffers need to repost to a local list */
+        spin_lock(&phba->scsi_buf_list_lock);
+        list_splice_init(&phba->lpfc_scsi_buf_list, &post_sblist);
+        spin_unlock(&phba->scsi_buf_list_lock);
+
+        /* post the list of scsi buffer sgls to port if available */
+        if (!list_empty(&post_sblist)) {
+                num_posted = lpfc_sli4_post_scsi_sgl_list(phba, &post_sblist,
+                                                phba->sli4_hba.scsi_xri_cnt);
+                /* failed to post any scsi buffer, return error */
+                if (num_posted == 0)
+                        rc = -EIO;
+        }
         return rc;
 }
 
@@ -792,12 +891,13 @@ lpfc_sli4_repost_scsi_sgl_list(struct lpfc_hba *phba)
  * @vport: The virtual port for which this call being executed.
  * @num_to_allocate: The requested number of buffers to allocate.
  *
- * This routine allocates a scsi buffer for device with SLI-4 interface spec,
+ * This routine allocates scsi buffers for device with SLI-4 interface spec,
  * the scsi buffer contains all the necessary information needed to initiate
- * a SCSI I/O.
+ * a SCSI I/O. After allocating up to @num_to_allocate SCSI buffers and put
+ * them on a list, it post them to the port by using SGL block post.
  *
  * Return codes:
- *   int - number of scsi buffers that were allocated.
+ *   int - number of scsi buffers that were allocated and posted.
  *   0 = failure, less than num_to_alloc is a partial failure.
  **/
 static int
@@ -810,22 +910,21 @@ lpfc_new_scsi_buf_s4(struct lpfc_vport *vport, int num_to_alloc)
         dma_addr_t pdma_phys_fcp_cmd;
         dma_addr_t pdma_phys_fcp_rsp;
         dma_addr_t pdma_phys_bpl, pdma_phys_bpl1;
-        uint16_t iotag, last_xritag = NO_XRI, lxri = 0;
-        int status = 0, index;
-        int bcnt;
-        int non_sequential_xri = 0;
-        LIST_HEAD(sblist);
+        uint16_t iotag, lxri = 0;
+        int bcnt, num_posted;
+        LIST_HEAD(prep_sblist);
+        LIST_HEAD(post_sblist);
+        LIST_HEAD(scsi_sblist);
 
         for (bcnt = 0; bcnt < num_to_alloc; bcnt++) {
                 psb = kzalloc(sizeof(struct lpfc_scsi_buf), GFP_KERNEL);
                 if (!psb)
                         break;
-
                 /*
-                 * Get memory from the pci pool to map the virt space to pci bus
-                 * space for an I/O.  The DMA buffer includes space for the
-                 * struct fcp_cmnd, struct fcp_rsp and the number of bde's
-                 * necessary to support the sg_tablesize.
+                 * Get memory from the pci pool to map the virt space to
+                 * pci bus space for an I/O. The DMA buffer includes space
+                 * for the struct fcp_cmnd, struct fcp_rsp and the number
+                 * of bde's necessary to support the sg_tablesize.
                  */
                 psb->data = pci_pool_alloc(phba->lpfc_scsi_dma_buf_pool,
                                                 GFP_KERNEL, &psb->dma_handle);
@@ -833,8 +932,6 @@ lpfc_new_scsi_buf_s4(struct lpfc_vport *vport, int num_to_alloc)
                         kfree(psb);
                         break;
                 }
-
-                /* Initialize virtual ptrs to dma_buf region. */
                 memset(psb->data, 0, phba->cfg_sg_dma_buf_size);
 
                 /* Allocate iotag for psb->cur_iocbq. */
@@ -855,16 +952,7 @@ lpfc_new_scsi_buf_s4(struct lpfc_vport *vport, int num_to_alloc)
                 }
                 psb->cur_iocbq.sli4_lxritag = lxri;
                 psb->cur_iocbq.sli4_xritag = phba->sli4_hba.xri_ids[lxri];
-                if (last_xritag != NO_XRI
-                        && psb->cur_iocbq.sli4_xritag != (last_xritag+1)) {
-                        non_sequential_xri = 1;
-                } else
-                        list_add_tail(&psb->list, &sblist);
-                last_xritag = psb->cur_iocbq.sli4_xritag;
-
-                index = phba->sli4_hba.scsi_xri_cnt++;
                 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));
@@ -880,9 +968,9 @@ lpfc_new_scsi_buf_s4(struct lpfc_vport *vport, int num_to_alloc)
                 pdma_phys_fcp_rsp = pdma_phys_fcp_cmd + sizeof(struct fcp_cmnd);
 
                 /*
-                 * The first two bdes are the FCP_CMD and FCP_RSP.  The balance
-                 * are sg list bdes.  Initialize the first two and leave the
-                 * rest for queuecommand.
+                 * The first two bdes are the FCP_CMD and FCP_RSP.
+                 * The balance are sg list bdes. Initialize the
+                 * first two and leave the rest for queuecommand.
                  */
                 sgl->addr_hi = cpu_to_le32(putPaddrHigh(pdma_phys_fcp_cmd));
                 sgl->addr_lo = cpu_to_le32(putPaddrLow(pdma_phys_fcp_cmd));
@@ -917,62 +1005,31 @@ lpfc_new_scsi_buf_s4(struct lpfc_vport *vport, int num_to_alloc)
                 iocb->ulpBdeCount = 1;
                 iocb->ulpLe = 1;
                 iocb->ulpClass = CLASS3;
-                psb->cur_iocbq.context1  = psb;
+                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;
-                phba->sli4_hba.lpfc_scsi_psb_array[index] = psb;
-                if (non_sequential_xri) {
-                        status = lpfc_sli4_post_sgl(phba, pdma_phys_bpl,
-                                                pdma_phys_bpl1,
-                                                psb->cur_iocbq.sli4_xritag);
-                        if (status) {
-                                /* Put this back on the abort scsi list */
-                                psb->exch_busy = 1;
-                        } else {
-                                psb->exch_busy = 0;
-                                psb->status = IOSTAT_SUCCESS;
-                        }
-                        /* Put it back into the SCSI buffer list */
-                        lpfc_release_scsi_buf_s4(phba, psb);
-                        break;
-                }
-        }
-        if (bcnt) {
-                if (!phba->sli4_hba.extents_in_use)
-                        status = lpfc_sli4_post_scsi_sgl_block(phba,
-                                                                &sblist,
-                                                                bcnt);
-                else
-                        status = lpfc_sli4_post_scsi_sgl_blk_ext(phba,
-                                                                &sblist,
-                                                                bcnt);
-
-                if (status) {
-                        lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
-                                        "3021 SCSI SGL post error %d\n",
-                                        status);
-                        bcnt = 0;
-                }
-                /* Reset SCSI buffer count for next round of posting */
-                while (!list_empty(&sblist)) {
-                        list_remove_head(&sblist, psb, struct lpfc_scsi_buf,
-                                 list);
-                        if (status) {
-                                /* Put this back on the abort scsi list */
-                                psb->exch_busy = 1;
-                        } else {
-                                psb->exch_busy = 0;
-                                psb->status = IOSTAT_SUCCESS;
-                        }
-                        /* Put it back into the SCSI buffer list */
-                        lpfc_release_scsi_buf_s4(phba, psb);
-                }
+
+                /* add the scsi buffer to a post list */
+                list_add_tail(&psb->list, &post_sblist);
+                spin_lock_irq(&phba->scsi_buf_list_lock);
+                phba->sli4_hba.scsi_xri_cnt++;
+                spin_unlock_irq(&phba->scsi_buf_list_lock);
         }
+        lpfc_printf_log(phba, KERN_INFO, LOG_BG,
+                        "3021 Allocate %d out of %d requested new SCSI "
+                        "buffers\n", bcnt, num_to_alloc);
+
+        /* post the list of scsi buffer sgls to port if available */
+        if (!list_empty(&post_sblist))
+                num_posted = lpfc_sli4_post_scsi_sgl_list(phba,
+                                                          &post_sblist, bcnt);
+        else
+                num_posted = 0;
 
-        return bcnt + non_sequential_xri;
+        return num_posted;
 }
 
 /**
@@ -1043,7 +1100,7 @@ lpfc_get_scsi_buf_s4(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp)
         list_for_each_entry(lpfc_cmd, &phba->lpfc_scsi_buf_list,
                                                         list) {
                 if (lpfc_test_rrq_active(phba, ndlp,
-                                         lpfc_cmd->cur_iocbq.sli4_xritag))
+                                         lpfc_cmd->cur_iocbq.sli4_lxritag))
                         continue;
                 list_del(&lpfc_cmd->list);
                 found = 1;
@@ -1897,7 +1954,9 @@ lpfc_bg_setup_bpl(struct lpfc_hba *phba, struct scsi_cmnd *sc,
         dma_addr_t physaddr;
         int i = 0, num_bde = 0, status;
         int datadir = sc->sc_data_direction;
+#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
         uint32_t rc;
+#endif
         uint32_t checking = 1;
         uint32_t reftag;
         unsigned blksize;
@@ -2034,7 +2093,9 @@ lpfc_bg_setup_bpl_prot(struct lpfc_hba *phba, struct scsi_cmnd *sc,
         int datadir = sc->sc_data_direction;
         unsigned char pgdone = 0, alldone = 0;
         unsigned blksize;
+#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
         uint32_t rc;
+#endif
         uint32_t checking = 1;
         uint32_t reftag;
         uint8_t txop, rxop;
@@ -2253,7 +2314,9 @@ lpfc_bg_setup_sgl(struct lpfc_hba *phba, struct scsi_cmnd *sc,
         uint32_t reftag;
         unsigned blksize;
         uint8_t txop, rxop;
+#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
         uint32_t rc;
+#endif
         uint32_t checking = 1;
         uint32_t dma_len;
         uint32_t dma_offset = 0;
@@ -2383,7 +2446,9 @@ lpfc_bg_setup_sgl_prot(struct lpfc_hba *phba, struct scsi_cmnd *sc,
         uint32_t reftag;
         uint8_t txop, rxop;
         uint32_t dma_len;
+#ifdef CONFIG_SCSI_LPFC_DEBUG_FS
         uint32_t rc;
+#endif
         uint32_t checking = 1;
         uint32_t dma_offset = 0;
         int num_sge = 0;
@@ -3604,11 +3669,16 @@ lpfc_scsi_cmd_iocb_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *pIocbIn,
                         logit = LOG_FCP | LOG_FCP_UNDER;
                 lpfc_printf_vlog(vport, KERN_WARNING, logit,
                          "9030 FCP cmd x%x failed <%d/%d> "
-                         "status: x%x result: x%x Data: x%x x%x\n",
+                         "status: x%x result: x%x "
+                         "sid: x%x did: x%x oxid: x%x "
+                         "Data: x%x x%x\n",
                          cmd->cmnd[0],
                          cmd->device ? cmd->device->id : 0xffff,
                          cmd->device ? cmd->device->lun : 0xffff,
                          lpfc_cmd->status, lpfc_cmd->result,
+                         vport->fc_myDID, pnode->nlp_DID,
+                         phba->sli_rev == LPFC_SLI_REV4 ?
+                             lpfc_cmd->cur_iocbq.sli4_xritag : 0xffff,
                          pIocbOut->iocb.ulpContext,
                          lpfc_cmd->cur_iocbq.iocb.ulpIoTag);
 
@@ -3689,8 +3759,8 @@ lpfc_scsi_cmd_iocb_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *pIocbIn,
                                  * ABTS we cannot generate and RRQ.
                                  */
                                 lpfc_set_rrq_active(phba, pnode,
-                                                lpfc_cmd->cur_iocbq.sli4_xritag,
-                                                0, 0);
+                                        lpfc_cmd->cur_iocbq.sli4_lxritag,
+                                        0, 0);
                         }
                 /* else: fall through */
                 default:
@@ -4348,8 +4418,20 @@ lpfc_abort_handler(struct scsi_cmnd *cmnd)
         ret = fc_block_scsi_eh(cmnd);
         if (ret)
                 return ret;
+
+        spin_lock_irq(&phba->hbalock);
+        /* driver queued commands are in process of being flushed */
+        if (phba->hba_flag & HBA_FCP_IOQ_FLUSH) {
+                spin_unlock_irq(&phba->hbalock);
+                lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
+                        "3168 SCSI Layer abort requested I/O has been "
+                        "flushed by LLD.\n");
+                return FAILED;
+        }
+
         lpfc_cmd = (struct lpfc_scsi_buf *)cmnd->host_scribble;
         if (!lpfc_cmd) {
+                spin_unlock_irq(&phba->hbalock);
                 lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
                          "2873 SCSI Layer I/O Abort Request IO CMPL Status "
                          "x%x ID %d LUN %d\n",
@@ -4357,23 +4439,34 @@ lpfc_abort_handler(struct scsi_cmnd *cmnd)
                 return SUCCESS;
         }
 
+        iocb = &lpfc_cmd->cur_iocbq;
+        /* the command is in process of being cancelled */
+        if (!(iocb->iocb_flag & LPFC_IO_ON_TXCMPLQ)) {
+                spin_unlock_irq(&phba->hbalock);
+                lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
+                        "3169 SCSI Layer abort requested I/O has been "
+                        "cancelled by LLD.\n");
+                return FAILED;
+        }
         /*
          * If pCmd field of the corresponding lpfc_scsi_buf structure
          * points to a different SCSI command, then the driver has
          * already completed this command, but the midlayer did not
-         * see the completion before the eh fired.  Just return
-         * SUCCESS.
+         * see the completion before the eh fired. Just return SUCCESS.
          */
-        iocb = &lpfc_cmd->cur_iocbq;
-        if (lpfc_cmd->pCmd != cmnd)
-                goto out;
+        if (lpfc_cmd->pCmd != cmnd) {
+                lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
+                        "3170 SCSI Layer abort requested I/O has been "
+                        "completed by LLD.\n");
+                goto out_unlock;
+        }
 
         BUG_ON(iocb->context1 != lpfc_cmd);
 
-        abtsiocb = lpfc_sli_get_iocbq(phba);
+        abtsiocb = __lpfc_sli_get_iocbq(phba);
         if (abtsiocb == NULL) {
                 ret = FAILED;
-                goto out;
+                goto out_unlock;
         }
 
         /*
@@ -4405,6 +4498,9 @@ lpfc_abort_handler(struct scsi_cmnd *cmnd)
 
         abtsiocb->iocb_cmpl = lpfc_sli_abort_fcp_cmpl;
         abtsiocb->vport = vport;
+        /* no longer need the lock after this point */
+        spin_unlock_irq(&phba->hbalock);
+
         if (lpfc_sli_issue_iocb(phba, LPFC_FCP_RING, abtsiocb, 0) ==
             IOCB_ERROR) {
                 lpfc_sli_release_iocbq(phba, abtsiocb);
@@ -4421,10 +4517,7 @@ lpfc_abort_handler(struct scsi_cmnd *cmnd)
         wait_event_timeout(waitq,
                           (lpfc_cmd->pCmd != cmnd),
                            (2*vport->cfg_devloss_tmo*HZ));
-
-        spin_lock_irq(shost->host_lock);
         lpfc_cmd->waitq = NULL;
-        spin_unlock_irq(shost->host_lock);
 
         if (lpfc_cmd->pCmd == cmnd) {
                 ret = FAILED;
@@ -4434,8 +4527,11 @@ lpfc_abort_handler(struct scsi_cmnd *cmnd)
                                  "LUN %d\n",
                                  ret, cmnd->device->id, cmnd->device->lun);
         }
+        goto out;
 
- out:
+out_unlock:
+        spin_unlock_irq(&phba->hbalock);
+out:
         lpfc_printf_vlog(vport, KERN_WARNING, LOG_FCP,
                          "0749 SCSI Layer I/O Abort Request Status x%x ID %d "
                          "LUN %d\n", ret, cmnd->device->id,
@@ -4863,6 +4959,43 @@ lpfc_bus_reset_handler(struct scsi_cmnd *cmnd)
 }
 
 /**
+ * lpfc_host_reset_handler - scsi_host_template eh_host_reset_handler entry pt
+ * @cmnd: Pointer to scsi_cmnd data structure.
+ *
+ * This routine does host reset to the adaptor port. It brings the HBA
+ * offline, performs a board restart, and then brings the board back online.
+ * The lpfc_offline calls lpfc_sli_hba_down which will abort and local
+ * reject all outstanding SCSI commands to the host and error returned
+ * back to SCSI mid-level. As this will be SCSI mid-level's last resort
+ * of error handling, it will only return error if resetting of the adapter
+ * is not successful; in all other cases, will return success.
+ *
+ * Return code :
+ *  0x2003 - Error
+ *  0x2002 - Success
+ **/
+static int
+lpfc_host_reset_handler(struct scsi_cmnd *cmnd)
+{
+        struct Scsi_Host *shost = cmnd->device->host;
+        struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
+        struct lpfc_hba *phba = vport->phba;
+        int rc, ret = SUCCESS;
+
+        lpfc_offline_prep(phba);
+        lpfc_offline(phba);
+        rc = lpfc_sli_brdrestart(phba);
+        if (rc)
+                ret = FAILED;
+        lpfc_online(phba);
+        lpfc_unblock_mgmt_io(phba);
+
+        lpfc_printf_log(phba, KERN_ERR, LOG_FCP,
+                        "3172 SCSI layer issued Host Reset Data: x%x\n", ret);
+        return ret;
+}
+
+/**
  * lpfc_slave_alloc - scsi_host_template slave_alloc entry point
  * @sdev: Pointer to scsi_device.
  *
@@ -4994,6 +5127,7 @@ struct scsi_host_template lpfc_template = {
         .eh_device_reset_handler = lpfc_device_reset_handler,
         .eh_target_reset_handler = lpfc_target_reset_handler,
         .eh_bus_reset_handler   = lpfc_bus_reset_handler,
+        .eh_host_reset_handler  = lpfc_host_reset_handler,
         .slave_alloc            = lpfc_slave_alloc,
         .slave_configure        = lpfc_slave_configure,
         .slave_destroy          = lpfc_slave_destroy,
diff --git a/drivers/scsi/lpfc/lpfc_sli.c b/drivers/scsi/lpfc/lpfc_sli.c
index dbaf5b963bff..b4720a109817 100644
--- a/drivers/scsi/lpfc/lpfc_sli.c
+++ b/drivers/scsi/lpfc/lpfc_sli.c
@@ -67,6 +67,8 @@ static void lpfc_sli4_send_seq_to_ulp(struct lpfc_vport *,
                                       struct hbq_dmabuf *);
 static int lpfc_sli4_fp_handle_wcqe(struct lpfc_hba *, struct lpfc_queue *,
                                     struct lpfc_cqe *);
+static int lpfc_sli4_post_els_sgl_list(struct lpfc_hba *, struct list_head *,
+                                       int);
 
 static IOCB_t *
 lpfc_get_iocb_from_iocbq(struct lpfc_iocbq *iocbq)
@@ -500,7 +502,7 @@ lpfc_resp_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring)
  * allocation is successful, it returns pointer to the newly
  * allocated iocb object else it returns NULL.
  **/
-static struct lpfc_iocbq *
+struct lpfc_iocbq *
 __lpfc_sli_get_iocbq(struct lpfc_hba *phba)
 {
         struct list_head *lpfc_iocb_list = &phba->lpfc_iocb_list;
@@ -875,6 +877,9 @@ __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))
+                ndlp = piocbq->context_un.ndlp;
         else
                 ndlp = piocbq->context1;
 
@@ -883,7 +888,7 @@ __lpfc_sli_get_sglq(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq)
         while (!found) {
                 if (!sglq)
                         return NULL;
-                if (lpfc_test_rrq_active(phba, ndlp, sglq->sli4_xritag)) {
+                if (lpfc_test_rrq_active(phba, ndlp, sglq->sli4_lxritag)) {
                         /* This xri has an rrq outstanding for this DID.
                          * put it back in the list and get another xri.
                          */
@@ -1257,7 +1262,7 @@ lpfc_sli_ringtxcmpl_put(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
                         struct lpfc_iocbq *piocb)
 {
         list_add_tail(&piocb->list, &pring->txcmplq);
-        piocb->iocb_flag |= LPFC_IO_ON_Q;
+        piocb->iocb_flag |= LPFC_IO_ON_TXCMPLQ;
         pring->txcmplq_cnt++;
         if (pring->txcmplq_cnt > pring->txcmplq_max)
                 pring->txcmplq_max = pring->txcmplq_cnt;
@@ -2556,9 +2561,9 @@ lpfc_sli_iocbq_lookup(struct lpfc_hba *phba,
         if (iotag != 0 && iotag <= phba->sli.last_iotag) {
                 cmd_iocb = phba->sli.iocbq_lookup[iotag];
                 list_del_init(&cmd_iocb->list);
-                if (cmd_iocb->iocb_flag & LPFC_IO_ON_Q) {
+                if (cmd_iocb->iocb_flag & LPFC_IO_ON_TXCMPLQ) {
                         pring->txcmplq_cnt--;
-                        cmd_iocb->iocb_flag &= ~LPFC_IO_ON_Q;
+                        cmd_iocb->iocb_flag &= ~LPFC_IO_ON_TXCMPLQ;
                 }
                 return cmd_iocb;
         }
@@ -2591,14 +2596,14 @@ lpfc_sli_iocbq_lookup_by_tag(struct lpfc_hba *phba,
 
         if (iotag != 0 && iotag <= phba->sli.last_iotag) {
                 cmd_iocb = phba->sli.iocbq_lookup[iotag];
-                list_del_init(&cmd_iocb->list);
-                if (cmd_iocb->iocb_flag & LPFC_IO_ON_Q) {
-                        cmd_iocb->iocb_flag &= ~LPFC_IO_ON_Q;
+                if (cmd_iocb->iocb_flag & LPFC_IO_ON_TXCMPLQ) {
+                        /* remove from txcmpl queue list */
+                        list_del_init(&cmd_iocb->list);
+                        cmd_iocb->iocb_flag &= ~LPFC_IO_ON_TXCMPLQ;
                         pring->txcmplq_cnt--;
+                        return cmd_iocb;
                 }
-                return cmd_iocb;
         }
-
         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                         "0372 iotag x%x is out off range: max iotag (x%x)\n",
                         iotag, phba->sli.last_iotag);
@@ -3466,6 +3471,9 @@ lpfc_sli_flush_fcp_rings(struct lpfc_hba *phba)
         /* Retrieve everything on the txcmplq */
         list_splice_init(&pring->txcmplq, &txcmplq);
         pring->txcmplq_cnt = 0;
+
+        /* Indicate the I/O queues are flushed */
+        phba->hba_flag |= HBA_FCP_IOQ_FLUSH;
         spin_unlock_irq(&phba->hbalock);
 
         /* Flush the txq */
@@ -3877,6 +3885,7 @@ lpfc_sli4_brdreset(struct lpfc_hba *phba)
 {
         struct lpfc_sli *psli = &phba->sli;
         uint16_t cfg_value;
+        int rc;
 
         /* Reset HBA */
         lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
@@ -3905,12 +3914,12 @@ lpfc_sli4_brdreset(struct lpfc_hba *phba)
 
         /* Perform FCoE PCI function reset */
         lpfc_sli4_queue_destroy(phba);
-        lpfc_pci_function_reset(phba);
+        rc = lpfc_pci_function_reset(phba);
 
         /* Restore PCI cmd register */
         pci_write_config_word(phba->pcidev, PCI_COMMAND, cfg_value);
 
-        return 0;
+        return rc;
 }
 
 /**
@@ -4002,6 +4011,7 @@ lpfc_sli_brdrestart_s4(struct lpfc_hba *phba)
 {
         struct lpfc_sli *psli = &phba->sli;
         uint32_t hba_aer_enabled;
+        int rc;
 
         /* Restart HBA */
         lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
@@ -4011,7 +4021,7 @@ lpfc_sli_brdrestart_s4(struct lpfc_hba *phba)
         /* Take PCIe device Advanced Error Reporting (AER) state */
         hba_aer_enabled = phba->hba_flag & HBA_AER_ENABLED;
 
-        lpfc_sli4_brdreset(phba);
+        rc = lpfc_sli4_brdreset(phba);
 
         spin_lock_irq(&phba->hbalock);
         phba->pport->stopped = 0;
@@ -4028,7 +4038,7 @@ lpfc_sli_brdrestart_s4(struct lpfc_hba *phba)
 
         lpfc_hba_down_post(phba);
 
-        return 0;
+        return rc;
 }
 
 /**
@@ -4967,7 +4977,12 @@ lpfc_sli4_get_avail_extnt_rsrc(struct lpfc_hba *phba, uint16_t type,
                               &rsrc_info->u.rsp);
         *extnt_size = bf_get(lpfc_mbx_get_rsrc_extent_info_size,
                              &rsrc_info->u.rsp);
- err_exit:
+
+        lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
+                        "3162 Retrieved extents type-%d from port: count:%d, "
+                        "size:%d\n", type, *extnt_count, *extnt_size);
+
+err_exit:
         mempool_free(mbox, phba->mbox_mem_pool);
         return rc;
 }
@@ -5051,7 +5066,7 @@ lpfc_sli4_chk_avail_extnt_rsrc(struct lpfc_hba *phba, uint16_t type)
  *   0: if successful
  **/
 static int
-lpfc_sli4_cfg_post_extnts(struct lpfc_hba *phba, uint16_t *extnt_cnt,
+lpfc_sli4_cfg_post_extnts(struct lpfc_hba *phba, uint16_t extnt_cnt,
                           uint16_t type, bool *emb, LPFC_MBOXQ_t *mbox)
 {
         int rc = 0;
@@ -5060,7 +5075,7 @@ lpfc_sli4_cfg_post_extnts(struct lpfc_hba *phba, uint16_t *extnt_cnt,
         uint32_t alloc_len, mbox_tmo;
 
         /* Calculate the total requested length of the dma memory */
-        req_len = *extnt_cnt * sizeof(uint16_t);
+        req_len = extnt_cnt * sizeof(uint16_t);
 
         /*
          * Calculate the size of an embedded mailbox.  The uint32_t
@@ -5075,7 +5090,7 @@ lpfc_sli4_cfg_post_extnts(struct lpfc_hba *phba, uint16_t *extnt_cnt,
          */
         *emb = LPFC_SLI4_MBX_EMBED;
         if (req_len > emb_len) {
-                req_len = *extnt_cnt * sizeof(uint16_t) +
+                req_len = extnt_cnt * sizeof(uint16_t) +
                         sizeof(union lpfc_sli4_cfg_shdr) +
                         sizeof(uint32_t);
                 *emb = LPFC_SLI4_MBX_NEMBED;
@@ -5091,7 +5106,7 @@ lpfc_sli4_cfg_post_extnts(struct lpfc_hba *phba, uint16_t *extnt_cnt,
                         "size (x%x)\n", alloc_len, req_len);
                 return -ENOMEM;
         }
-        rc = lpfc_sli4_mbox_rsrc_extent(phba, mbox, *extnt_cnt, type, *emb);
+        rc = lpfc_sli4_mbox_rsrc_extent(phba, mbox, extnt_cnt, type, *emb);
         if (unlikely(rc))
                 return -EIO;
 
@@ -5149,17 +5164,15 @@ lpfc_sli4_alloc_extent(struct lpfc_hba *phba, uint16_t type)
                 return -ENOMEM;
         }
 
-        lpfc_printf_log(phba, KERN_INFO, LOG_MBOX | LOG_INIT,
-                        "2903 Available Resource Extents "
-                        "for resource type 0x%x: Count: 0x%x, "
-                        "Size 0x%x\n", type, rsrc_cnt,
-                        rsrc_size);
+        lpfc_printf_log(phba, KERN_INFO, LOG_MBOX | LOG_INIT | LOG_SLI,
+                        "2903 Post resource extents type-0x%x: "
+                        "count:%d, size %d\n", type, rsrc_cnt, rsrc_size);
 
         mbox = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
         if (!mbox)
                 return -ENOMEM;
 
-        rc = lpfc_sli4_cfg_post_extnts(phba, &rsrc_cnt, type, &emb, mbox);
+        rc = lpfc_sli4_cfg_post_extnts(phba, rsrc_cnt, type, &emb, mbox);
         if (unlikely(rc)) {
                 rc = -EIO;
                 goto err_exit;
@@ -5250,6 +5263,7 @@ lpfc_sli4_alloc_extent(struct lpfc_hba *phba, uint16_t type)
                         rc = -ENOMEM;
                         goto err_exit;
                 }
+                phba->sli4_hba.max_cfg_param.xri_used = 0;
                 phba->sli4_hba.xri_ids = kzalloc(rsrc_id_cnt *
                                                  sizeof(uint16_t),
                                                  GFP_KERNEL);
@@ -5420,7 +5434,6 @@ lpfc_sli4_dealloc_extent(struct lpfc_hba *phba, uint16_t type)
         case LPFC_RSC_TYPE_FCOE_XRI:
                 kfree(phba->sli4_hba.xri_bmask);
                 kfree(phba->sli4_hba.xri_ids);
-                bf_set(lpfc_xri_rsrc_rdy, &phba->sli4_hba.sli4_flags, 0);
                 list_for_each_entry_safe(rsrc_blk, rsrc_blk_next,
                                     &phba->sli4_hba.lpfc_xri_blk_list, list) {
                         list_del_init(&rsrc_blk->list);
@@ -5612,7 +5625,6 @@ lpfc_sli4_alloc_resource_identifiers(struct lpfc_hba *phba)
                         goto free_vpi_ids;
                 }
                 phba->sli4_hba.max_cfg_param.xri_used = 0;
-                phba->sli4_hba.xri_count = 0;
                 phba->sli4_hba.xri_ids = kzalloc(count *
                                                  sizeof(uint16_t),
                                                  GFP_KERNEL);
@@ -5694,7 +5706,6 @@ lpfc_sli4_dealloc_resource_identifiers(struct lpfc_hba *phba)
                 bf_set(lpfc_vpi_rsrc_rdy, &phba->sli4_hba.sli4_flags, 0);
                 kfree(phba->sli4_hba.xri_bmask);
                 kfree(phba->sli4_hba.xri_ids);
-                bf_set(lpfc_xri_rsrc_rdy, &phba->sli4_hba.sli4_flags, 0);
                 kfree(phba->sli4_hba.vfi_bmask);
                 kfree(phba->sli4_hba.vfi_ids);
                 bf_set(lpfc_vfi_rsrc_rdy, &phba->sli4_hba.sli4_flags, 0);
@@ -5853,6 +5864,149 @@ lpfc_sli4_get_allocated_extnts(struct lpfc_hba *phba, uint16_t type,
 }
 
 /**
+ * lpfc_sli4_repost_els_sgl_list - Repsot the els buffers sgl pages as block
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine walks the list of els buffers that have been allocated and
+ * repost them to the port by using SGL block post. This is needed after a
+ * pci_function_reset/warm_start or start. It attempts to construct blocks
+ * of els buffer sgls which contains contiguous xris and uses the non-embedded
+ * SGL block post mailbox commands to post them to the port. For single els
+ * buffer sgl with non-contiguous xri, if any, it shall use embedded SGL post
+ * mailbox command for posting.
+ *
+ * Returns: 0 = success, non-zero failure.
+ **/
+static int
+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 last_xritag = NO_XRI;
+        LIST_HEAD(prep_sgl_list);
+        LIST_HEAD(blck_sgl_list);
+        LIST_HEAD(allc_sgl_list);
+        LIST_HEAD(post_sgl_list);
+        LIST_HEAD(free_sgl_list);
+
+        spin_lock(&phba->hbalock);
+        list_splice_init(&phba->sli4_hba.lpfc_sgl_list, &allc_sgl_list);
+        spin_unlock(&phba->hbalock);
+
+        list_for_each_entry_safe(sglq_entry, sglq_entry_next,
+                                 &allc_sgl_list, list) {
+                list_del_init(&sglq_entry->list);
+                block_cnt++;
+                if ((last_xritag != NO_XRI) &&
+                    (sglq_entry->sli4_xritag != last_xritag + 1)) {
+                        /* a hole in xri block, form a sgl posting block */
+                        list_splice_init(&prep_sgl_list, &blck_sgl_list);
+                        post_cnt = block_cnt - 1;
+                        /* prepare list for next posting block */
+                        list_add_tail(&sglq_entry->list, &prep_sgl_list);
+                        block_cnt = 1;
+                } else {
+                        /* prepare list for next posting block */
+                        list_add_tail(&sglq_entry->list, &prep_sgl_list);
+                        /* enough sgls for non-embed sgl mbox command */
+                        if (block_cnt == LPFC_NEMBED_MBOX_SGL_CNT) {
+                                list_splice_init(&prep_sgl_list,
+                                                 &blck_sgl_list);
+                                post_cnt = block_cnt;
+                                block_cnt = 0;
+                        }
+                }
+                num_posted++;
+
+                /* keep track of last sgl's xritag */
+                last_xritag = sglq_entry->sli4_xritag;
+
+                /* end of repost sgl list condition for els buffers */
+                if (num_posted == phba->sli4_hba.els_xri_cnt) {
+                        if (post_cnt == 0) {
+                                list_splice_init(&prep_sgl_list,
+                                                 &blck_sgl_list);
+                                post_cnt = block_cnt;
+                        } else if (block_cnt == 1) {
+                                status = lpfc_sli4_post_sgl(phba,
+                                                sglq_entry->phys, 0,
+                                                sglq_entry->sli4_xritag);
+                                if (!status) {
+                                        /* successful, put sgl to posted list */
+                                        list_add_tail(&sglq_entry->list,
+                                                      &post_sgl_list);
+                                } else {
+                                        /* Failure, put sgl to free list */
+                                        lpfc_printf_log(phba, KERN_WARNING,
+                                                LOG_SLI,
+                                                "3159 Failed to post els "
+                                                "sgl, xritag:x%x\n",
+                                                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);
+                                }
+                        }
+                }
+
+                /* continue until a nembed page worth of sgls */
+                if (post_cnt == 0)
+                        continue;
+
+                /* post the els buffer list sgls as a block */
+                status = lpfc_sli4_post_els_sgl_list(phba, &blck_sgl_list,
+                                                     post_cnt);
+
+                if (!status) {
+                        /* success, put sgl list to posted sgl list */
+                        list_splice_init(&blck_sgl_list, &post_sgl_list);
+                } else {
+                        /* Failure, put sgl list to free sgl list */
+                        sglq_entry_first = list_first_entry(&blck_sgl_list,
+                                                            struct lpfc_sglq,
+                                                            list);
+                        lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
+                                        "3160 Failed to post els sgl-list, "
+                                        "xritag:x%x-x%x\n",
+                                        sglq_entry_first->sli4_xritag,
+                                        (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);
+                }
+
+                /* don't reset xirtag due to hole in xri block */
+                if (block_cnt == 0)
+                        last_xritag = NO_XRI;
+
+                /* reset els sgl post count for next round of posting */
+                post_cnt = 0;
+        }
+
+        /* free the els sgls failed to post */
+        lpfc_free_sgl_list(phba, &free_sgl_list);
+
+        /* push els sgls posted to the availble list */
+        if (!list_empty(&post_sgl_list)) {
+                spin_lock(&phba->hbalock);
+                list_splice_init(&post_sgl_list,
+                                 &phba->sli4_hba.lpfc_sgl_list);
+                spin_unlock(&phba->hbalock);
+        } else {
+                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                                "3161 Failure to post els sgl to port.\n");
+                return -EIO;
+        }
+        return 0;
+}
+
+/**
  * lpfc_sli4_hba_setup - SLI4 device intialization PCI function
  * @phba: Pointer to HBA context object.
  *
@@ -5923,6 +6077,8 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
         else
                 phba->hba_flag &= ~HBA_FIP_SUPPORT;
 
+        phba->hba_flag &= ~HBA_FCP_IOQ_FLUSH;
+
         if (phba->sli_rev != LPFC_SLI_REV4) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
                         "0376 READ_REV Error. SLI Level %d "
@@ -6063,8 +6219,6 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
                                 "rc = x%x\n", rc);
                 goto out_free_mbox;
         }
-        /* update physical xri mappings in the scsi buffers */
-        lpfc_scsi_buf_update(phba);
 
         /* Read the port's service parameters. */
         rc = lpfc_read_sparam(phba, mboxq, vport->vpi);
@@ -6105,28 +6259,26 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
         fc_host_node_name(shost) = wwn_to_u64(vport->fc_nodename.u.wwn);
         fc_host_port_name(shost) = wwn_to_u64(vport->fc_portname.u.wwn);
 
-        /* Register SGL pool to the device using non-embedded mailbox command */
-        if (!phba->sli4_hba.extents_in_use) {
-                rc = lpfc_sli4_post_els_sgl_list(phba);
-                if (unlikely(rc)) {
-                        lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
-                                        "0582 Error %d during els sgl post "
-                                        "operation\n", rc);
-                        rc = -ENODEV;
-                        goto out_free_mbox;
-                }
-        } else {
-                rc = lpfc_sli4_post_els_sgl_list_ext(phba);
-                if (unlikely(rc)) {
-                        lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
-                                        "2560 Error %d during els sgl post "
-                                        "operation\n", rc);
-                        rc = -ENODEV;
-                        goto out_free_mbox;
-                }
+        /* update host els and scsi xri-sgl sizes and mappings */
+        rc = lpfc_sli4_xri_sgl_update(phba);
+        if (unlikely(rc)) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+                                "1400 Failed to update xri-sgl size and "
+                                "mapping: %d\n", rc);
+                goto out_free_mbox;
         }
 
-        /* Register SCSI SGL pool to the device */
+        /* register the els sgl pool to the port */
+        rc = lpfc_sli4_repost_els_sgl_list(phba);
+        if (unlikely(rc)) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+                                "0582 Error %d during els sgl post "
+                                "operation\n", rc);
+                rc = -ENODEV;
+                goto out_free_mbox;
+        }
+
+        /* register the allocated scsi sgl pool to the port */
         rc = lpfc_sli4_repost_scsi_sgl_list(phba);
         if (unlikely(rc)) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
@@ -7060,14 +7212,19 @@ lpfc_sli_issue_mbox_s4(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq,
                 if (rc != MBX_SUCCESS)
                         lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX | LOG_SLI,
                                         "(%d):2541 Mailbox command x%x "
-                                        "(x%x/x%x) cannot issue Data: "
-                                        "x%x x%x\n",
+                                        "(x%x/x%x) failure: "
+                                        "mqe_sta: x%x mcqe_sta: x%x/x%x "
+                                        "Data: x%x x%x\n,",
                                         mboxq->vport ? mboxq->vport->vpi : 0,
                                         mboxq->u.mb.mbxCommand,
                                         lpfc_sli_config_mbox_subsys_get(phba,
                                                                         mboxq),
                                         lpfc_sli_config_mbox_opcode_get(phba,
                                                                         mboxq),
+                                        bf_get(lpfc_mqe_status, &mboxq->u.mqe),
+                                        bf_get(lpfc_mcqe_status, &mboxq->mcqe),
+                                        bf_get(lpfc_mcqe_ext_status,
+                                               &mboxq->mcqe),
                                         psli->sli_flag, flag);
                 return rc;
         } else if (flag == MBX_POLL) {
@@ -7086,18 +7243,22 @@ lpfc_sli_issue_mbox_s4(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq,
                         /* Successfully blocked, now issue sync mbox cmd */
                         rc = lpfc_sli4_post_sync_mbox(phba, mboxq);
                         if (rc != MBX_SUCCESS)
-                                lpfc_printf_log(phba, KERN_ERR,
+                                lpfc_printf_log(phba, KERN_WARNING,
                                         LOG_MBOX | LOG_SLI,
-                                        "(%d):2597 Mailbox command "
-                                        "x%x (x%x/x%x) cannot issue "
-                                        "Data: x%x x%x\n",
-                                        mboxq->vport ?
-                                        mboxq->vport->vpi : 0,
+                                        "(%d):2597 Sync Mailbox command "
+                                        "x%x (x%x/x%x) failure: "
+                                        "mqe_sta: x%x mcqe_sta: x%x/x%x "
+                                        "Data: x%x x%x\n,",
+                                        mboxq->vport ? mboxq->vport->vpi : 0,
                                         mboxq->u.mb.mbxCommand,
                                         lpfc_sli_config_mbox_subsys_get(phba,
                                                                         mboxq),
                                         lpfc_sli_config_mbox_opcode_get(phba,
                                                                         mboxq),
+                                        bf_get(lpfc_mqe_status, &mboxq->u.mqe),
+                                        bf_get(lpfc_mcqe_status, &mboxq->mcqe),
+                                        bf_get(lpfc_mcqe_ext_status,
+                                               &mboxq->mcqe),
                                         psli->sli_flag, flag);
                         /* Unblock the async mailbox posting afterward */
                         lpfc_sli4_async_mbox_unblock(phba);
@@ -7712,7 +7873,10 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
 
         switch (iocbq->iocb.ulpCommand) {
         case CMD_ELS_REQUEST64_CR:
-                ndlp = (struct lpfc_nodelist *)iocbq->context1;
+                if (iocbq->iocb_flag & LPFC_IO_LIBDFC)
+                        ndlp = iocbq->context_un.ndlp;
+                else
+                        ndlp = (struct lpfc_nodelist *)iocbq->context1;
                 if (!iocbq->iocb.ulpLe) {
                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                 "2007 Only Limited Edition cmd Format"
@@ -7751,9 +7915,13 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                                 bf_set(els_req64_sp, &wqe->els_req, 1);
                                 bf_set(els_req64_sid, &wqe->els_req,
                                         iocbq->vport->fc_myDID);
+                                if ((*pcmd == ELS_CMD_FLOGI) &&
+                                        !(phba->fc_topology ==
+                                                LPFC_TOPOLOGY_LOOP))
+                                        bf_set(els_req64_sid, &wqe->els_req, 0);
                                 bf_set(wqe_ct, &wqe->els_req.wqe_com, 1);
                                 bf_set(wqe_ctxt_tag, &wqe->els_req.wqe_com,
-                                        phba->vpi_ids[phba->pport->vpi]);
+                                        phba->vpi_ids[iocbq->vport->vpi]);
                         } else if (pcmd && iocbq->context1) {
                                 bf_set(wqe_ct, &wqe->els_req.wqe_com, 0);
                                 bf_set(wqe_ctxt_tag, &wqe->els_req.wqe_com,
@@ -7908,11 +8076,25 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 /* words0-2 BDE memcpy */
                 /* word3 iocb=iotag32 wqe=response_payload_len */
                 wqe->xmit_els_rsp.response_payload_len = xmit_len;
-                /* word4 iocb=did wge=rsvd. */
-                wqe->xmit_els_rsp.rsvd4 = 0;
+                /* word4 */
+                wqe->xmit_els_rsp.word4 = 0;
                 /* word5 iocb=rsvd wge=did */
                 bf_set(wqe_els_did, &wqe->xmit_els_rsp.wqe_dest,
-                         iocbq->iocb.un.elsreq64.remoteID);
+                         iocbq->iocb.un.xseq64.xmit_els_remoteID);
+
+                if_type = bf_get(lpfc_sli_intf_if_type,
+                                        &phba->sli4_hba.sli_intf);
+                if (if_type == LPFC_SLI_INTF_IF_TYPE_2) {
+                        if (iocbq->vport->fc_flag & FC_PT2PT) {
+                                bf_set(els_rsp64_sp, &wqe->xmit_els_rsp, 1);
+                                bf_set(els_rsp64_sid, &wqe->xmit_els_rsp,
+                                        iocbq->vport->fc_myDID);
+                                if (iocbq->vport->fc_myDID == Fabric_DID) {
+                                        bf_set(wqe_els_did,
+                                                &wqe->xmit_els_rsp.wqe_dest, 0);
+                                }
+                        }
+                }
                 bf_set(wqe_ct, &wqe->xmit_els_rsp.wqe_com,
                        ((iocbq->iocb.ulpCt_h << 1) | iocbq->iocb.ulpCt_l));
                 bf_set(wqe_pu, &wqe->xmit_els_rsp.wqe_com, iocbq->iocb.ulpPU);
@@ -7932,11 +8114,11 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 pcmd = (uint32_t *) (((struct lpfc_dmabuf *)
                                         iocbq->context2)->virt);
                 if (phba->fc_topology == LPFC_TOPOLOGY_LOOP) {
-                                bf_set(els_req64_sp, &wqe->els_req, 1);
-                                bf_set(els_req64_sid, &wqe->els_req,
+                                bf_set(els_rsp64_sp, &wqe->xmit_els_rsp, 1);
+                                bf_set(els_rsp64_sid, &wqe->xmit_els_rsp,
                                         iocbq->vport->fc_myDID);
-                                bf_set(wqe_ct, &wqe->els_req.wqe_com, 1);
-                                bf_set(wqe_ctxt_tag, &wqe->els_req.wqe_com,
+                                bf_set(wqe_ct, &wqe->xmit_els_rsp.wqe_com, 1);
+                                bf_set(wqe_ctxt_tag, &wqe->xmit_els_rsp.wqe_com,
                                         phba->vpi_ids[phba->pport->vpi]);
                 }
                 command_type = OTHER_COMMAND;
@@ -13080,9 +13262,7 @@ lpfc_sli4_alloc_xri(struct lpfc_hba *phba)
         } else {
                 set_bit(xri, phba->sli4_hba.xri_bmask);
                 phba->sli4_hba.max_cfg_param.xri_used++;
-                phba->sli4_hba.xri_count++;
         }
-
         spin_unlock_irq(&phba->hbalock);
         return xri;
 }
@@ -13098,7 +13278,6 @@ void
 __lpfc_sli4_free_xri(struct lpfc_hba *phba, int xri)
 {
         if (test_and_clear_bit(xri, phba->sli4_hba.xri_bmask)) {
-                phba->sli4_hba.xri_count--;
                 phba->sli4_hba.max_cfg_param.xri_used--;
         }
 }
@@ -13134,46 +13313,45 @@ lpfc_sli4_next_xritag(struct lpfc_hba *phba)
         uint16_t xri_index;
 
         xri_index = lpfc_sli4_alloc_xri(phba);
-        if (xri_index != NO_XRI)
-                return xri_index;
-
-        lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
-                        "2004 Failed to allocate XRI.last XRITAG is %d"
-                        " Max XRI is %d, Used XRI is %d\n",
-                        xri_index,
-                        phba->sli4_hba.max_cfg_param.max_xri,
-                        phba->sli4_hba.max_cfg_param.xri_used);
-        return NO_XRI;
+        if (xri_index == NO_XRI)
+                lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
+                                "2004 Failed to allocate XRI.last XRITAG is %d"
+                                " Max XRI is %d, Used XRI is %d\n",
+                                xri_index,
+                                phba->sli4_hba.max_cfg_param.max_xri,
+                                phba->sli4_hba.max_cfg_param.xri_used);
+        return xri_index;
 }
 
 /**
  * lpfc_sli4_post_els_sgl_list - post a block of ELS sgls to the port.
  * @phba: pointer to lpfc hba data structure.
+ * @post_sgl_list: pointer to els sgl entry list.
+ * @count: number of els sgl entries on the list.
  *
  * This routine is invoked to post a block of driver's sgl pages to the
  * HBA using non-embedded mailbox command. No Lock is held. This routine
  * is only called when the driver is loading and after all IO has been
  * stopped.
  **/
-int
-lpfc_sli4_post_els_sgl_list(struct lpfc_hba *phba)
+static int
+lpfc_sli4_post_els_sgl_list(struct lpfc_hba *phba,
+                            struct list_head *post_sgl_list,
+                            int post_cnt)
 {
-        struct lpfc_sglq *sglq_entry;
+        struct lpfc_sglq *sglq_entry = NULL, *sglq_next = NULL;
         struct lpfc_mbx_post_uembed_sgl_page1 *sgl;
         struct sgl_page_pairs *sgl_pg_pairs;
         void *viraddr;
         LPFC_MBOXQ_t *mbox;
         uint32_t reqlen, alloclen, pg_pairs;
         uint32_t mbox_tmo;
-        uint16_t xritag_start = 0, lxri = 0;
-        int els_xri_cnt, rc = 0;
+        uint16_t xritag_start = 0;
+        int rc = 0;
         uint32_t shdr_status, shdr_add_status;
         union lpfc_sli4_cfg_shdr *shdr;
 
-        /* The number of sgls to be posted */
-        els_xri_cnt = lpfc_sli4_get_els_iocb_cnt(phba);
-
-        reqlen = els_xri_cnt * sizeof(struct sgl_page_pairs) +
+        reqlen = phba->sli4_hba.els_xri_cnt * sizeof(struct sgl_page_pairs) +
                  sizeof(union lpfc_sli4_cfg_shdr) + sizeof(uint32_t);
         if (reqlen > SLI4_PAGE_SIZE) {
                 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
@@ -13203,25 +13381,8 @@ lpfc_sli4_post_els_sgl_list(struct lpfc_hba *phba)
         sgl = (struct lpfc_mbx_post_uembed_sgl_page1 *)viraddr;
         sgl_pg_pairs = &sgl->sgl_pg_pairs;
 
-        for (pg_pairs = 0; pg_pairs < els_xri_cnt; pg_pairs++) {
-                sglq_entry = phba->sli4_hba.lpfc_els_sgl_array[pg_pairs];
-
-                /*
-                 * Assign the sglq a physical xri only if the driver has not
-                 * initialized those resources.  A port reset only needs
-                 * the sglq's posted.
-                 */
-                if (bf_get(lpfc_xri_rsrc_rdy, &phba->sli4_hba.sli4_flags) !=
-                    LPFC_XRI_RSRC_RDY) {
-                        lxri = lpfc_sli4_next_xritag(phba);
-                        if (lxri == NO_XRI) {
-                                lpfc_sli4_mbox_cmd_free(phba, mbox);
-                                return -ENOMEM;
-                        }
-                        sglq_entry->sli4_lxritag = lxri;
-                        sglq_entry->sli4_xritag = phba->sli4_hba.xri_ids[lxri];
-                }
-
+        pg_pairs = 0;
+        list_for_each_entry_safe(sglq_entry, sglq_next, post_sgl_list, list) {
                 /* Set up the sge entry */
                 sgl_pg_pairs->sgl_pg0_addr_lo =
                                 cpu_to_le32(putPaddrLow(sglq_entry->phys));
@@ -13236,11 +13397,12 @@ lpfc_sli4_post_els_sgl_list(struct lpfc_hba *phba)
                 if (pg_pairs == 0)
                         xritag_start = sglq_entry->sli4_xritag;
                 sgl_pg_pairs++;
+                pg_pairs++;
         }
 
         /* Complete initialization and perform endian conversion. */
         bf_set(lpfc_post_sgl_pages_xri, sgl, xritag_start);
-        bf_set(lpfc_post_sgl_pages_xricnt, sgl, els_xri_cnt);
+        bf_set(lpfc_post_sgl_pages_xricnt, sgl, phba->sli4_hba.els_xri_cnt);
         sgl->word0 = cpu_to_le32(sgl->word0);
         if (!phba->sli4_hba.intr_enable)
                 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
@@ -13260,183 +13422,6 @@ lpfc_sli4_post_els_sgl_list(struct lpfc_hba *phba)
                                 shdr_status, shdr_add_status, rc);
                 rc = -ENXIO;
         }
-
-        if (rc == 0)
-                bf_set(lpfc_xri_rsrc_rdy, &phba->sli4_hba.sli4_flags,
-                       LPFC_XRI_RSRC_RDY);
-        return rc;
-}
-
-/**
- * lpfc_sli4_post_els_sgl_list_ext - post a block of ELS sgls to the port.
- * @phba: pointer to lpfc hba data structure.
- *
- * This routine is invoked to post a block of driver's sgl pages to the
- * HBA using non-embedded mailbox command. No Lock is held. This routine
- * is only called when the driver is loading and after all IO has been
- * stopped.
- **/
-int
-lpfc_sli4_post_els_sgl_list_ext(struct lpfc_hba *phba)
-{
-        struct lpfc_sglq *sglq_entry;
-        struct lpfc_mbx_post_uembed_sgl_page1 *sgl;
-        struct sgl_page_pairs *sgl_pg_pairs;
-        void *viraddr;
-        LPFC_MBOXQ_t *mbox;
-        uint32_t reqlen, alloclen, index;
-        uint32_t mbox_tmo;
-        uint16_t rsrc_start, rsrc_size, els_xri_cnt, post_els_xri_cnt;
-        uint16_t xritag_start = 0, lxri = 0;
-        struct lpfc_rsrc_blks *rsrc_blk;
-        int cnt, ttl_cnt, rc = 0;
-        int loop_cnt;
-        uint32_t shdr_status, shdr_add_status;
-        union lpfc_sli4_cfg_shdr *shdr;
-
-        /* The number of sgls to be posted */
-        els_xri_cnt = lpfc_sli4_get_els_iocb_cnt(phba);
-
-        reqlen = els_xri_cnt * sizeof(struct sgl_page_pairs) +
-                 sizeof(union lpfc_sli4_cfg_shdr) + sizeof(uint32_t);
-        if (reqlen > SLI4_PAGE_SIZE) {
-                lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
-                                "2989 Block sgl registration required DMA "
-                                "size (%d) great than a page\n", reqlen);
-                return -ENOMEM;
-        }
-
-        cnt = 0;
-        ttl_cnt = 0;
-        post_els_xri_cnt = els_xri_cnt;
-        list_for_each_entry(rsrc_blk, &phba->sli4_hba.lpfc_xri_blk_list,
-                            list) {
-                rsrc_start = rsrc_blk->rsrc_start;
-                rsrc_size = rsrc_blk->rsrc_size;
-
-                lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
-                                "3014 Working ELS Extent start %d, cnt %d\n",
-                                rsrc_start, rsrc_size);
-
-                loop_cnt = min(post_els_xri_cnt, rsrc_size);
-                if (loop_cnt < post_els_xri_cnt) {
-                        post_els_xri_cnt -= loop_cnt;
-                        ttl_cnt += loop_cnt;
-                } else
-                        ttl_cnt += post_els_xri_cnt;
-
-                mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
-                if (!mbox)
-                        return -ENOMEM;
-                /*
-                 * Allocate DMA memory and set up the non-embedded mailbox
-                 * command.
-                 */
-                alloclen = lpfc_sli4_config(phba, mbox,
-                                        LPFC_MBOX_SUBSYSTEM_FCOE,
-                                        LPFC_MBOX_OPCODE_FCOE_POST_SGL_PAGES,
-                                        reqlen, LPFC_SLI4_MBX_NEMBED);
-                if (alloclen < reqlen) {
-                        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
-                                        "2987 Allocated DMA memory size (%d) "
-                                        "is less than the requested DMA memory "
-                                        "size (%d)\n", alloclen, reqlen);
-                        lpfc_sli4_mbox_cmd_free(phba, mbox);
-                        return -ENOMEM;
-                }
-
-                /* Set up the SGL pages in the non-embedded DMA pages */
-                viraddr = mbox->sge_array->addr[0];
-                sgl = (struct lpfc_mbx_post_uembed_sgl_page1 *)viraddr;
-                sgl_pg_pairs = &sgl->sgl_pg_pairs;
-
-                /*
-                 * The starting resource may not begin at zero. Control
-                 * the loop variants via the block resource parameters,
-                 * but handle the sge pointers with a zero-based index
-                 * that doesn't get reset per loop pass.
-                 */
-                for (index = rsrc_start;
-                     index < rsrc_start + loop_cnt;
-                     index++) {
-                        sglq_entry = phba->sli4_hba.lpfc_els_sgl_array[cnt];
-
-                        /*
-                         * Assign the sglq a physical xri only if the driver
-                         * has not initialized those resources.  A port reset
-                         * only needs the sglq's posted.
-                         */
-                        if (bf_get(lpfc_xri_rsrc_rdy,
-                                   &phba->sli4_hba.sli4_flags) !=
-                                   LPFC_XRI_RSRC_RDY) {
-                                lxri = lpfc_sli4_next_xritag(phba);
-                                if (lxri == NO_XRI) {
-                                        lpfc_sli4_mbox_cmd_free(phba, mbox);
-                                        rc = -ENOMEM;
-                                        goto err_exit;
-                                }
-                                sglq_entry->sli4_lxritag = lxri;
-                                sglq_entry->sli4_xritag =
-                                                phba->sli4_hba.xri_ids[lxri];
-                        }
-
-                        /* Set up the sge entry */
-                        sgl_pg_pairs->sgl_pg0_addr_lo =
-                                cpu_to_le32(putPaddrLow(sglq_entry->phys));
-                        sgl_pg_pairs->sgl_pg0_addr_hi =
-                                cpu_to_le32(putPaddrHigh(sglq_entry->phys));
-                        sgl_pg_pairs->sgl_pg1_addr_lo =
-                                cpu_to_le32(putPaddrLow(0));
-                        sgl_pg_pairs->sgl_pg1_addr_hi =
-                                cpu_to_le32(putPaddrHigh(0));
-
-                        /* Track the starting physical XRI for the mailbox. */
-                        if (index == rsrc_start)
-                                xritag_start = sglq_entry->sli4_xritag;
-                        sgl_pg_pairs++;
-                        cnt++;
-                }
-
-                /* Complete initialization and perform endian conversion. */
-                rsrc_blk->rsrc_used += loop_cnt;
-                bf_set(lpfc_post_sgl_pages_xri, sgl, xritag_start);
-                bf_set(lpfc_post_sgl_pages_xricnt, sgl, loop_cnt);
-                sgl->word0 = cpu_to_le32(sgl->word0);
-
-                lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
-                                "3015 Post ELS Extent SGL, start %d, "
-                                "cnt %d, used %d\n",
-                                xritag_start, loop_cnt, rsrc_blk->rsrc_used);
-                if (!phba->sli4_hba.intr_enable)
-                        rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
-                else {
-                        mbox_tmo = lpfc_mbox_tmo_val(phba, mbox);
-                        rc = lpfc_sli_issue_mbox_wait(phba, mbox, mbox_tmo);
-                }
-                shdr = (union lpfc_sli4_cfg_shdr *) &sgl->cfg_shdr;
-                shdr_status = bf_get(lpfc_mbox_hdr_status,
-                                     &shdr->response);
-                shdr_add_status = bf_get(lpfc_mbox_hdr_add_status,
-                                         &shdr->response);
-                if (rc != MBX_TIMEOUT)
-                        lpfc_sli4_mbox_cmd_free(phba, mbox);
-                if (shdr_status || shdr_add_status || rc) {
-                        lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
-                                        "2988 POST_SGL_BLOCK mailbox "
-                                        "command failed status x%x "
-                                        "add_status x%x mbx status x%x\n",
-                                        shdr_status, shdr_add_status, rc);
-                        rc = -ENXIO;
-                        goto err_exit;
-                }
-                if (ttl_cnt >= els_xri_cnt)
-                        break;
-        }
-
- err_exit:
-        if (rc == 0)
-                bf_set(lpfc_xri_rsrc_rdy, &phba->sli4_hba.sli4_flags,
-                       LPFC_XRI_RSRC_RDY);
         return rc;
 }
 
@@ -13452,8 +13437,9 @@ lpfc_sli4_post_els_sgl_list_ext(struct lpfc_hba *phba)
  *
  **/
 int
-lpfc_sli4_post_scsi_sgl_block(struct lpfc_hba *phba, struct list_head *sblist,
-                              int cnt)
+lpfc_sli4_post_scsi_sgl_block(struct lpfc_hba *phba,
+                              struct list_head *sblist,
+                              int count)
 {
         struct lpfc_scsi_buf *psb;
         struct lpfc_mbx_post_uembed_sgl_page1 *sgl;
@@ -13469,7 +13455,7 @@ lpfc_sli4_post_scsi_sgl_block(struct lpfc_hba *phba, struct list_head *sblist,
         union lpfc_sli4_cfg_shdr *shdr;
 
         /* Calculate the requested length of the dma memory */
-        reqlen = cnt * sizeof(struct sgl_page_pairs) +
+        reqlen = count * sizeof(struct sgl_page_pairs) +
                  sizeof(union lpfc_sli4_cfg_shdr) + sizeof(uint32_t);
         if (reqlen > SLI4_PAGE_SIZE) {
                 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
@@ -13553,169 +13539,6 @@ lpfc_sli4_post_scsi_sgl_block(struct lpfc_hba *phba, struct list_head *sblist,
 }
 
 /**
- * lpfc_sli4_post_scsi_sgl_blk_ext - post a block of scsi sgls to the port.
- * @phba: pointer to lpfc hba data structure.
- * @sblist: pointer to scsi buffer list.
- * @count: number of scsi buffers on the list.
- *
- * This routine is invoked to post a block of @count scsi sgl pages from a
- * SCSI buffer list @sblist to the HBA using non-embedded mailbox command.
- * No Lock is held.
- *
- **/
-int
-lpfc_sli4_post_scsi_sgl_blk_ext(struct lpfc_hba *phba, struct list_head *sblist,
-                                int cnt)
-{
-        struct lpfc_scsi_buf *psb = NULL;
-        struct lpfc_mbx_post_uembed_sgl_page1 *sgl;
-        struct sgl_page_pairs *sgl_pg_pairs;
-        void *viraddr;
-        LPFC_MBOXQ_t *mbox;
-        uint32_t reqlen, alloclen, pg_pairs;
-        uint32_t mbox_tmo;
-        uint16_t xri_start = 0, scsi_xri_start;
-        uint16_t rsrc_range;
-        int rc = 0, avail_cnt;
-        uint32_t shdr_status, shdr_add_status;
-        dma_addr_t pdma_phys_bpl1;
-        union lpfc_sli4_cfg_shdr *shdr;
-        struct lpfc_rsrc_blks *rsrc_blk;
-        uint32_t xri_cnt = 0;
-
-        /* Calculate the total requested length of the dma memory */
-        reqlen = cnt * sizeof(struct sgl_page_pairs) +
-                 sizeof(union lpfc_sli4_cfg_shdr) + sizeof(uint32_t);
-        if (reqlen > SLI4_PAGE_SIZE) {
-                lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
-                                "2932 Block sgl registration required DMA "
-                                "size (%d) great than a page\n", reqlen);
-                return -ENOMEM;
-        }
-
-        /*
-         * The use of extents requires the driver to post the sgl headers
-         * in multiple postings to meet the contiguous resource assignment.
-         */
-        psb = list_prepare_entry(psb, sblist, list);
-        scsi_xri_start = phba->sli4_hba.scsi_xri_start;
-        list_for_each_entry(rsrc_blk, &phba->sli4_hba.lpfc_xri_blk_list,
-                            list) {
-                rsrc_range = rsrc_blk->rsrc_start + rsrc_blk->rsrc_size;
-                if (rsrc_range < scsi_xri_start)
-                        continue;
-                else if (rsrc_blk->rsrc_used >= rsrc_blk->rsrc_size)
-                        continue;
-                else
-                        avail_cnt = rsrc_blk->rsrc_size - rsrc_blk->rsrc_used;
-
-                reqlen = (avail_cnt * sizeof(struct sgl_page_pairs)) +
-                        sizeof(union lpfc_sli4_cfg_shdr) + sizeof(uint32_t);
-                /*
-                 * Allocate DMA memory and set up the non-embedded mailbox
-                 * command. The mbox is used to post an SGL page per loop
-                 * but the DMA memory has a use-once semantic so the mailbox
-                 * is used and freed per loop pass.
-                 */
-                mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
-                if (!mbox) {
-                        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
-                                        "2933 Failed to allocate mbox cmd "
-                                        "memory\n");
-                        return -ENOMEM;
-                }
-                alloclen = lpfc_sli4_config(phba, mbox,
-                                        LPFC_MBOX_SUBSYSTEM_FCOE,
-                                        LPFC_MBOX_OPCODE_FCOE_POST_SGL_PAGES,
-                                        reqlen,
-                                        LPFC_SLI4_MBX_NEMBED);
-                if (alloclen < reqlen) {
-                        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
-                                        "2934 Allocated DMA memory size (%d) "
-                                        "is less than the requested DMA memory "
-                                        "size (%d)\n", alloclen, reqlen);
-                        lpfc_sli4_mbox_cmd_free(phba, mbox);
-                        return -ENOMEM;
-                }
-
-                /* Get the first SGE entry from the non-embedded DMA memory */
-                viraddr = mbox->sge_array->addr[0];
-
-                /* Set up the SGL pages in the non-embedded DMA pages */
-                sgl = (struct lpfc_mbx_post_uembed_sgl_page1 *)viraddr;
-                sgl_pg_pairs = &sgl->sgl_pg_pairs;
-
-                /* pg_pairs tracks posted SGEs per loop iteration. */
-                pg_pairs = 0;
-                list_for_each_entry_continue(psb, sblist, list) {
-                        /* Set up the sge entry */
-                        sgl_pg_pairs->sgl_pg0_addr_lo =
-                                cpu_to_le32(putPaddrLow(psb->dma_phys_bpl));
-                        sgl_pg_pairs->sgl_pg0_addr_hi =
-                                cpu_to_le32(putPaddrHigh(psb->dma_phys_bpl));
-                        if (phba->cfg_sg_dma_buf_size > SGL_PAGE_SIZE)
-                                pdma_phys_bpl1 = psb->dma_phys_bpl +
-                                        SGL_PAGE_SIZE;
-                        else
-                                pdma_phys_bpl1 = 0;
-                        sgl_pg_pairs->sgl_pg1_addr_lo =
-                                cpu_to_le32(putPaddrLow(pdma_phys_bpl1));
-                        sgl_pg_pairs->sgl_pg1_addr_hi =
-                                cpu_to_le32(putPaddrHigh(pdma_phys_bpl1));
-                        /* Keep the first xri for this extent. */
-                        if (pg_pairs == 0)
-                                xri_start = psb->cur_iocbq.sli4_xritag;
-                        sgl_pg_pairs++;
-                        pg_pairs++;
-                        xri_cnt++;
-
-                        /*
-                         * Track two exit conditions - the loop has constructed
-                         * all of the caller's SGE pairs or all available
-                         * resource IDs in this extent are consumed.
-                         */
-                        if ((xri_cnt == cnt) || (pg_pairs >= avail_cnt))
-                                break;
-                }
-                rsrc_blk->rsrc_used += pg_pairs;
-                bf_set(lpfc_post_sgl_pages_xri, sgl, xri_start);
-                bf_set(lpfc_post_sgl_pages_xricnt, sgl, pg_pairs);
-
-                lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
-                                "3016 Post SCSI Extent SGL, start %d, cnt %d "
-                                "blk use %d\n",
-                                xri_start, pg_pairs, rsrc_blk->rsrc_used);
-                /* Perform endian conversion if necessary */
-                sgl->word0 = cpu_to_le32(sgl->word0);
-                if (!phba->sli4_hba.intr_enable)
-                        rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
-                else {
-                        mbox_tmo = lpfc_mbox_tmo_val(phba, mbox);
-                        rc = lpfc_sli_issue_mbox_wait(phba, mbox, mbox_tmo);
-                }
-                shdr = (union lpfc_sli4_cfg_shdr *) &sgl->cfg_shdr;
-                shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
-                shdr_add_status = bf_get(lpfc_mbox_hdr_add_status,
-                                         &shdr->response);
-                if (rc != MBX_TIMEOUT)
-                        lpfc_sli4_mbox_cmd_free(phba, mbox);
-                if (shdr_status || shdr_add_status || rc) {
-                        lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
-                                        "2935 POST_SGL_BLOCK mailbox command "
-                                        "failed status x%x add_status x%x "
-                                        "mbx status x%x\n",
-                                        shdr_status, shdr_add_status, rc);
-                        return -ENXIO;
-                }
-
-                /* Post only what is requested. */
-                if (xri_cnt >= cnt)
-                        break;
-        }
-        return rc;
-}
-
-/**
  * lpfc_fc_frame_check - Check that this frame is a valid frame to handle
  * @phba: pointer to lpfc_hba struct that the frame was received on
  * @fc_hdr: A pointer to the FC Header data (In Big Endian Format)
@@ -13839,8 +13662,13 @@ lpfc_fc_frame_to_vport(struct lpfc_hba *phba, struct fc_frame_header *fc_hdr,
         uint32_t did = (fc_hdr->fh_d_id[0] << 16 |
                         fc_hdr->fh_d_id[1] << 8 |
                         fc_hdr->fh_d_id[2]);
+
         if (did == Fabric_DID)
                 return phba->pport;
+        if ((phba->pport->fc_flag & FC_PT2PT) &&
+                !(phba->link_state == LPFC_HBA_READY))
+                return phba->pport;
+
         vports = lpfc_create_vport_work_array(phba);
         if (vports != NULL)
                 for (i = 0; i <= phba->max_vpi && vports[i] != NULL; i++) {
@@ -14133,7 +13961,6 @@ lpfc_sli4_xri_inrange(struct lpfc_hba *phba,
         return NO_XRI;
 }
 
-
 /**
  * lpfc_sli4_seq_abort_rsp - bls rsp to sequence abort
  * @phba: Pointer to HBA context object.
@@ -14148,7 +13975,7 @@ lpfc_sli4_seq_abort_rsp(struct lpfc_hba *phba,
 {
         struct lpfc_iocbq *ctiocb = NULL;
         struct lpfc_nodelist *ndlp;
-        uint16_t oxid, rxid;
+        uint16_t oxid, rxid, xri, lxri;
         uint32_t sid, fctl;
         IOCB_t *icmd;
         int rc;
@@ -14167,8 +13994,6 @@ lpfc_sli4_seq_abort_rsp(struct lpfc_hba *phba,
                                 "SID:x%x\n", oxid, sid);
                 return;
         }
-        if (lpfc_sli4_xri_inrange(phba, rxid))
-                lpfc_set_rrq_active(phba, ndlp, rxid, oxid, 0);
 
         /* Allocate buffer for rsp iocb */
         ctiocb = lpfc_sli_get_iocbq(phba);
@@ -14199,13 +14024,24 @@ lpfc_sli4_seq_abort_rsp(struct lpfc_hba *phba,
         ctiocb->sli4_lxritag = NO_XRI;
         ctiocb->sli4_xritag = NO_XRI;
 
+        if (fctl & FC_FC_EX_CTX)
+                /* Exchange responder sent the abort so we
+                 * own the oxid.
+                 */
+                xri = oxid;
+        else
+                xri = rxid;
+        lxri = lpfc_sli4_xri_inrange(phba, xri);
+        if (lxri != NO_XRI)
+                lpfc_set_rrq_active(phba, ndlp, lxri,
+                        (xri == oxid) ? rxid : oxid, 0);
         /* If the oxid maps to the FCP XRI range or if it is out of range,
          * send a BLS_RJT.  The driver no longer has that exchange.
          * Override the IOCB for a BA_RJT.
          */
-        if (oxid > (phba->sli4_hba.max_cfg_param.max_xri +
+        if (xri > (phba->sli4_hba.max_cfg_param.max_xri +
                     phba->sli4_hba.max_cfg_param.xri_base) ||
-            oxid > (lpfc_sli4_get_els_iocb_cnt(phba) +
+            xri > (lpfc_sli4_get_els_iocb_cnt(phba) +
                     phba->sli4_hba.max_cfg_param.xri_base)) {
                 icmd->un.xseq64.w5.hcsw.Rctl = FC_RCTL_BA_RJT;
                 bf_set(lpfc_vndr_code, &icmd->un.bls_rsp, 0);
@@ -14377,7 +14213,15 @@ lpfc_prep_seq(struct lpfc_vport *vport, struct hbq_dmabuf *seq_dmabuf)
                 /* Initialize the first IOCB. */
                 first_iocbq->iocb.unsli3.rcvsli3.acc_len = 0;
                 first_iocbq->iocb.ulpStatus = IOSTAT_SUCCESS;
-                first_iocbq->iocb.ulpCommand = CMD_IOCB_RCV_SEQ64_CX;
+
+                /* Check FC Header to see what TYPE of frame we are rcv'ing */
+                if (sli4_type_from_fc_hdr(fc_hdr) == FC_TYPE_ELS) {
+                        first_iocbq->iocb.ulpCommand = CMD_IOCB_RCV_ELS64_CX;
+                        first_iocbq->iocb.un.rcvels.parmRo =
+                                sli4_did_from_fc_hdr(fc_hdr);
+                        first_iocbq->iocb.ulpPU = PARM_NPIV_DID;
+                } else
+                        first_iocbq->iocb.ulpCommand = CMD_IOCB_RCV_SEQ64_CX;
                 first_iocbq->iocb.ulpContext = NO_XRI;
                 first_iocbq->iocb.unsli3.rcvsli3.ox_id =
                         be16_to_cpu(fc_hdr->fh_ox_id);
@@ -14507,6 +14351,7 @@ lpfc_sli4_handle_received_buffer(struct lpfc_hba *phba,
         struct fc_frame_header *fc_hdr;
         struct lpfc_vport *vport;
         uint32_t fcfi;
+        uint32_t did;
 
         /* Process each received buffer */
         fc_hdr = (struct fc_frame_header *)dmabuf->hbuf.virt;
@@ -14522,12 +14367,32 @@ lpfc_sli4_handle_received_buffer(struct lpfc_hba *phba,
         else
                 fcfi = bf_get(lpfc_rcqe_fcf_id,
                               &dmabuf->cq_event.cqe.rcqe_cmpl);
+
         vport = lpfc_fc_frame_to_vport(phba, fc_hdr, fcfi);
-        if (!vport || !(vport->vpi_state & LPFC_VPI_REGISTERED)) {
+        if (!vport) {
                 /* throw out the frame */
                 lpfc_in_buf_free(phba, &dmabuf->dbuf);
                 return;
         }
+
+        /* d_id this frame is directed to */
+        did = sli4_did_from_fc_hdr(fc_hdr);
+
+        /* vport is registered unless we rcv a FLOGI directed to Fabric_DID */
+        if (!(vport->vpi_state & LPFC_VPI_REGISTERED) &&
+                (did != Fabric_DID)) {
+                /*
+                 * Throw out the frame if we are not pt2pt.
+                 * The pt2pt protocol allows for discovery frames
+                 * to be received without a registered VPI.
+                 */
+                if (!(vport->fc_flag & FC_PT2PT) ||
+                        (phba->link_state == LPFC_HBA_READY)) {
+                        lpfc_in_buf_free(phba, &dmabuf->dbuf);
+                        return;
+                }
+        }
+
         /* Handle the basic abort sequence (BA_ABTS) event */
         if (fc_hdr->fh_r_ctl == FC_RCTL_BA_ABTS) {
                 lpfc_sli4_handle_unsol_abort(vport, dmabuf);
diff --git a/drivers/scsi/lpfc/lpfc_sli.h b/drivers/scsi/lpfc/lpfc_sli.h
index 3290b8e7ab65..2626f58c0747 100644
--- a/drivers/scsi/lpfc/lpfc_sli.h
+++ b/drivers/scsi/lpfc/lpfc_sli.h
@@ -68,7 +68,7 @@ struct lpfc_iocbq {
 #define LPFC_EXCHANGE_BUSY      0x40    /* SLI4 hba reported XB in response */
 #define LPFC_USE_FCPWQIDX       0x80    /* Submit to specified FCPWQ index */
 #define DSS_SECURITY_OP         0x100   /* security IO */
-#define LPFC_IO_ON_Q            0x200   /* The IO is still on the TXCMPLQ */
+#define LPFC_IO_ON_TXCMPLQ      0x200   /* The IO is still on the TXCMPLQ */
 #define LPFC_IO_DIF             0x400   /* T10 DIF IO */
 
 #define LPFC_FIP_ELS_ID_MASK    0xc000  /* ELS_ID range 0-3, non-shifted mask */
diff --git a/drivers/scsi/lpfc/lpfc_sli4.h b/drivers/scsi/lpfc/lpfc_sli4.h
index c19d139618b7..a4a77080091b 100644
--- a/drivers/scsi/lpfc/lpfc_sli4.h
+++ b/drivers/scsi/lpfc/lpfc_sli4.h
@@ -75,11 +75,19 @@
          (fc_hdr)->fh_s_id[1] <<  8 | \
          (fc_hdr)->fh_s_id[2])
 
+#define sli4_did_from_fc_hdr(fc_hdr)  \
+        ((fc_hdr)->fh_d_id[0] << 16 | \
+         (fc_hdr)->fh_d_id[1] <<  8 | \
+         (fc_hdr)->fh_d_id[2])
+
 #define sli4_fctl_from_fc_hdr(fc_hdr)  \
         ((fc_hdr)->fh_f_ctl[0] << 16 | \
          (fc_hdr)->fh_f_ctl[1] <<  8 | \
          (fc_hdr)->fh_f_ctl[2])
 
+#define sli4_type_from_fc_hdr(fc_hdr)  \
+        ((fc_hdr)->fh_type)
+
 #define LPFC_FW_RESET_MAXIMUM_WAIT_10MS_CNT 12000
 
 enum lpfc_sli4_queue_type {
@@ -493,14 +501,12 @@ struct lpfc_sli4_hba {
         uint16_t next_rpi;
         uint16_t scsi_xri_max;
         uint16_t scsi_xri_cnt;
+        uint16_t els_xri_cnt;
         uint16_t scsi_xri_start;
         struct list_head lpfc_free_sgl_list;
         struct list_head lpfc_sgl_list;
-        struct lpfc_sglq **lpfc_els_sgl_array;
         struct list_head lpfc_abts_els_sgl_list;
-        struct lpfc_scsi_buf **lpfc_scsi_psb_array;
         struct list_head lpfc_abts_scsi_buf_list;
-        uint32_t total_sglq_bufs;
         struct lpfc_sglq **lpfc_sglq_active_list;
         struct list_head lpfc_rpi_hdr_list;
         unsigned long *rpi_bmask;
@@ -509,7 +515,6 @@ struct lpfc_sli4_hba {
         struct list_head lpfc_rpi_blk_list;
         unsigned long *xri_bmask;
         uint16_t *xri_ids;
-        uint16_t xri_count;
         struct list_head lpfc_xri_blk_list;
         unsigned long *vfi_bmask;
         uint16_t *vfi_ids;
@@ -614,11 +619,7 @@ int lpfc_sli4_post_sgl(struct lpfc_hba *, dma_addr_t, dma_addr_t, uint16_t);
 int lpfc_sli4_repost_scsi_sgl_list(struct lpfc_hba *);
 uint16_t lpfc_sli4_next_xritag(struct lpfc_hba *);
 int lpfc_sli4_post_async_mbox(struct lpfc_hba *);
-int lpfc_sli4_post_els_sgl_list(struct lpfc_hba *phba);
-int lpfc_sli4_post_els_sgl_list_ext(struct lpfc_hba *phba);
 int lpfc_sli4_post_scsi_sgl_block(struct lpfc_hba *, struct list_head *, int);
-int lpfc_sli4_post_scsi_sgl_blk_ext(struct lpfc_hba *, struct list_head *,
-                                    int);
 struct lpfc_cq_event *__lpfc_sli4_cq_event_alloc(struct lpfc_hba *);
 struct lpfc_cq_event *lpfc_sli4_cq_event_alloc(struct lpfc_hba *);
 void __lpfc_sli4_cq_event_release(struct lpfc_hba *, struct lpfc_cq_event *);
diff --git a/drivers/scsi/lpfc/lpfc_version.h b/drivers/scsi/lpfc/lpfc_version.h
index 25cefc254b76..59c57a409981 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.30"
+#define LPFC_DRIVER_VERSION "8.3.31"
 #define LPFC_DRIVER_NAME                "lpfc"
 #define LPFC_SP_DRIVER_HANDLER_NAME     "lpfc:sp"
 #define LPFC_FP_DRIVER_HANDLER_NAME     "lpfc:fp"
diff --git a/drivers/scsi/megaraid/megaraid_sas.h b/drivers/scsi/megaraid/megaraid_sas.h
index e5f416f8042d..e8f892647681 100644
--- a/drivers/scsi/megaraid/megaraid_sas.h
+++ b/drivers/scsi/megaraid/megaraid_sas.h
@@ -33,9 +33,9 @@
 /*
  * MegaRAID SAS Driver meta data
  */
-#define MEGASAS_VERSION                         "00.00.06.14-rc1"
-#define MEGASAS_RELDATE                         "Jan. 6, 2012"
-#define MEGASAS_EXT_VERSION                     "Fri. Jan. 6 17:00:00 PDT 2012"
+#define MEGASAS_VERSION                         "00.00.06.15-rc1"
+#define MEGASAS_RELDATE                         "Mar. 19, 2012"
+#define MEGASAS_EXT_VERSION                     "Mon. Mar. 19 17:00:00 PDT 2012"
 
 /*
  * Device IDs
diff --git a/drivers/scsi/megaraid/megaraid_sas_base.c b/drivers/scsi/megaraid/megaraid_sas_base.c
index 8b300be44284..dc27598785e5 100644
--- a/drivers/scsi/megaraid/megaraid_sas_base.c
+++ b/drivers/scsi/megaraid/megaraid_sas_base.c
@@ -18,7 +18,7 @@
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  *
  *  FILE: megaraid_sas_base.c
- *  Version : v00.00.06.14-rc1
+ *  Version : v00.00.06.15-rc1
  *
  *  Authors: LSI Corporation
  *           Sreenivas Bagalkote
diff --git a/drivers/scsi/megaraid/megaraid_sas_fp.c b/drivers/scsi/megaraid/megaraid_sas_fp.c
index 294abb0defa6..e3d251a2e26a 100644
--- a/drivers/scsi/megaraid/megaraid_sas_fp.c
+++ b/drivers/scsi/megaraid/megaraid_sas_fp.c
@@ -362,15 +362,20 @@ MR_BuildRaidContext(struct megasas_instance *instance,
         /* assume this IO needs the full row - we'll adjust if not true */
         regSize             = stripSize;
 
-        /* If IO spans more than 1 strip, fp is not possible
-           FP is not possible for writes on non-0 raid levels
-           FP is not possible if LD is not capable */
-        if (num_strips > 1 || (!isRead && raid->level != 0) ||
-            !raid->capability.fpCapable) {
+        /* Check if we can send this I/O via FastPath */
+        if (raid->capability.fpCapable) {
+                if (isRead)
+                        io_info->fpOkForIo = (raid->capability.fpReadCapable &&
+                                              ((num_strips == 1) ||
+                                               raid->capability.
+                                               fpReadAcrossStripe));
+                else
+                        io_info->fpOkForIo = (raid->capability.fpWriteCapable &&
+                                              ((num_strips == 1) ||
+                                               raid->capability.
+                                               fpWriteAcrossStripe));
+        } else
                 io_info->fpOkForIo = FALSE;
-        } else {
-                io_info->fpOkForIo = TRUE;
-        }
 
         if (numRows == 1) {
                 /* single-strip IOs can always lock only the data needed */
diff --git a/drivers/scsi/megaraid/megaraid_sas_fusion.c b/drivers/scsi/megaraid/megaraid_sas_fusion.c
index bfd87fab39aa..a610cf1d4847 100644
--- a/drivers/scsi/megaraid/megaraid_sas_fusion.c
+++ b/drivers/scsi/megaraid/megaraid_sas_fusion.c
@@ -634,9 +634,7 @@ megasas_ioc_init_fusion(struct megasas_instance *instance)
                 fusion->reply_frames_desc_phys;
         IOCInitMessage->SystemRequestFrameBaseAddress =
                 fusion->io_request_frames_phys;
-        /* Set to 0 for none or 1 MSI-X vectors */
-        IOCInitMessage->HostMSIxVectors = (instance->msix_vectors > 0 ?
-                                           instance->msix_vectors : 0);
+        IOCInitMessage->HostMSIxVectors = instance->msix_vectors;
         init_frame = (struct megasas_init_frame *)cmd->frame;
         memset(init_frame, 0, MEGAMFI_FRAME_SIZE);
 
diff --git a/drivers/scsi/mpt2sas/mpi/mpi2.h b/drivers/scsi/mpt2sas/mpi/mpi2.h
index a01f0aa66f20..a80f3220c641 100644
--- a/drivers/scsi/mpt2sas/mpi/mpi2.h
+++ b/drivers/scsi/mpt2sas/mpi/mpi2.h
@@ -8,7 +8,7 @@
  *                  scatter/gather formats.
  *  Creation Date:  June 21, 2006
  *
- *  mpi2.h Version:  02.00.22
+ *  mpi2.h Version:  02.00.23
  *
  *  Version History
  *  ---------------
@@ -71,6 +71,7 @@
  *  03-09-11  02.00.20  Bumped MPI2_HEADER_VERSION_UNIT.
  *  05-25-11  02.00.21  Bumped MPI2_HEADER_VERSION_UNIT.
  *  08-24-11  02.00.22  Bumped MPI2_HEADER_VERSION_UNIT.
+ *  11-18-11  02.00.23  Bumped MPI2_HEADER_VERSION_UNIT.
  *  --------------------------------------------------------------------------
  */
 
@@ -96,7 +97,7 @@
 #define MPI2_VERSION_02_00                  (0x0200)
 
 /* versioning for this MPI header set */
-#define MPI2_HEADER_VERSION_UNIT            (0x16)
+#define MPI2_HEADER_VERSION_UNIT            (0x17)
 #define MPI2_HEADER_VERSION_DEV             (0x00)
 #define MPI2_HEADER_VERSION_UNIT_MASK       (0xFF00)
 #define MPI2_HEADER_VERSION_UNIT_SHIFT      (8)
@@ -480,7 +481,7 @@ typedef union _MPI2_REPLY_DESCRIPTORS_UNION
     MPI2_RAID_ACCELERATOR_SUCCESS_REPLY_DESCRIPTOR  RAIDAcceleratorSuccess;
     U64                                             Words;
 } MPI2_REPLY_DESCRIPTORS_UNION, MPI2_POINTER PTR_MPI2_REPLY_DESCRIPTORS_UNION,
-  Mpi2ReplyDescriptorsUnion_t, MPI2_POINTER pMpi2ReplyDescriptorsUnion_t;
+Mpi2ReplyDescriptorsUnion_t, MPI2_POINTER pMpi2ReplyDescriptorsUnion_t;
 
 
 
diff --git a/drivers/scsi/mpt2sas/mpi/mpi2_cnfg.h b/drivers/scsi/mpt2sas/mpi/mpi2_cnfg.h
index 3a023dad77a1..737fa8cfb54a 100644
--- a/drivers/scsi/mpt2sas/mpi/mpi2_cnfg.h
+++ b/drivers/scsi/mpt2sas/mpi/mpi2_cnfg.h
@@ -6,7 +6,7 @@
  *          Title:  MPI Configuration messages and pages
  *  Creation Date:  November 10, 2006
  *
- *    mpi2_cnfg.h Version:  02.00.21
+ *    mpi2_cnfg.h Version:  02.00.22
  *
  *  Version History
  *  ---------------
@@ -146,7 +146,9 @@
  *                      Added SpinupFlags field containing a Disable Spin-up
  *                      bit to the MPI2_SAS_IOUNIT4_SPINUP_GROUP fields of
  *                      SAS IO Unit Page 4.
-
+ *  11-18-11  02.00.22  Added define MPI2_IOCPAGE6_CAP_FLAGS_4K_SECTORS_SUPPORT.
+ *                      Added UEFIVersion field to BIOS Page 1 and defined new
+ *                      BiosOptions bits.
  *  --------------------------------------------------------------------------
  */
 
@@ -1131,9 +1133,10 @@ typedef struct _MPI2_CONFIG_PAGE_IOC_6
 } MPI2_CONFIG_PAGE_IOC_6, MPI2_POINTER PTR_MPI2_CONFIG_PAGE_IOC_6,
   Mpi2IOCPage6_t, MPI2_POINTER pMpi2IOCPage6_t;
 
-#define MPI2_IOCPAGE6_PAGEVERSION                       (0x04)
+#define MPI2_IOCPAGE6_PAGEVERSION                       (0x05)
 
 /* defines for IOC Page 6 CapabilitiesFlags */
+#define MPI2_IOCPAGE6_CAP_FLAGS_4K_SECTORS_SUPPORT      (0x00000020)
 #define MPI2_IOCPAGE6_CAP_FLAGS_RAID10_SUPPORT          (0x00000010)
 #define MPI2_IOCPAGE6_CAP_FLAGS_RAID1_SUPPORT           (0x00000008)
 #define MPI2_IOCPAGE6_CAP_FLAGS_RAID1E_SUPPORT          (0x00000004)
@@ -1204,24 +1207,29 @@ typedef struct _MPI2_CONFIG_PAGE_IOC_8
 
 typedef struct _MPI2_CONFIG_PAGE_BIOS_1
 {
-    MPI2_CONFIG_PAGE_HEADER Header;                     /* 0x00 */
-    U32                     BiosOptions;                /* 0x04 */
-    U32                     IOCSettings;                /* 0x08 */
-    U32                     Reserved1;                  /* 0x0C */
-    U32                     DeviceSettings;             /* 0x10 */
-    U16                     NumberOfDevices;            /* 0x14 */
-    U16                     Reserved2;                  /* 0x16 */
-    U16                     IOTimeoutBlockDevicesNonRM; /* 0x18 */
-    U16                     IOTimeoutSequential;        /* 0x1A */
-    U16                     IOTimeoutOther;             /* 0x1C */
-    U16                     IOTimeoutBlockDevicesRM;    /* 0x1E */
+        MPI2_CONFIG_PAGE_HEADER Header;                     /* 0x00 */
+        U32                     BiosOptions;                /* 0x04 */
+        U32                     IOCSettings;                /* 0x08 */
+        U32                     Reserved1;                  /* 0x0C */
+        U32                     DeviceSettings;             /* 0x10 */
+        U16                     NumberOfDevices;            /* 0x14 */
+        U16                     UEFIVersion;                /* 0x16 */
+        U16                     IOTimeoutBlockDevicesNonRM; /* 0x18 */
+        U16                     IOTimeoutSequential;        /* 0x1A */
+        U16                     IOTimeoutOther;             /* 0x1C */
+        U16                     IOTimeoutBlockDevicesRM;    /* 0x1E */
 } MPI2_CONFIG_PAGE_BIOS_1, MPI2_POINTER PTR_MPI2_CONFIG_PAGE_BIOS_1,
   Mpi2BiosPage1_t, MPI2_POINTER pMpi2BiosPage1_t;
 
-#define MPI2_BIOSPAGE1_PAGEVERSION                      (0x04)
+#define MPI2_BIOSPAGE1_PAGEVERSION                      (0x05)
 
 /* values for BIOS Page 1 BiosOptions field */
-#define MPI2_BIOSPAGE1_OPTIONS_DISABLE_BIOS             (0x00000001)
+#define MPI2_BIOSPAGE1_OPTIONS_MASK_UEFI_HII_REGISTRATION   (0x00000006)
+#define MPI2_BIOSPAGE1_OPTIONS_ENABLE_UEFI_HII              (0x00000000)
+#define MPI2_BIOSPAGE1_OPTIONS_DISABLE_UEFI_HII             (0x00000002)
+#define MPI2_BIOSPAGE1_OPTIONS_VERSION_CHECK_UEFI_HII       (0x00000004)
+
+#define MPI2_BIOSPAGE1_OPTIONS_DISABLE_BIOS                 (0x00000001)
 
 /* values for BIOS Page 1 IOCSettings field */
 #define MPI2_BIOSPAGE1_IOCSET_MASK_BOOT_PREFERENCE      (0x00030000)
@@ -1248,6 +1256,13 @@ typedef struct _MPI2_CONFIG_PAGE_BIOS_1
 #define MPI2_BIOSPAGE1_DEVSET_DISABLE_NON_RM_LUN        (0x00000002)
 #define MPI2_BIOSPAGE1_DEVSET_DISABLE_OTHER_LUN         (0x00000001)
 
+/* defines for BIOS Page 1 UEFIVersion field */
+#define MPI2_BIOSPAGE1_UEFI_VER_MAJOR_MASK              (0xFF00)
+#define MPI2_BIOSPAGE1_UEFI_VER_MAJOR_SHIFT             (8)
+#define MPI2_BIOSPAGE1_UEFI_VER_MINOR_MASK              (0x00FF)
+#define MPI2_BIOSPAGE1_UEFI_VER_MINOR_SHIFT             (0)
+
+
 
 /* BIOS Page 2 */
 
@@ -2216,6 +2231,27 @@ typedef struct _MPI2_CONFIG_PAGE_SASIOUNIT_8 {
 
 
 
+/* SAS IO Unit Page 16 */
+
+typedef struct _MPI2_CONFIG_PAGE_SASIOUNIT16 {
+        MPI2_CONFIG_EXTENDED_PAGE_HEADER  Header;                  /* 0x00 */
+        U64                         TimeStamp;                     /* 0x08 */
+        U32                         Reserved1;                     /* 0x10 */
+        U32                         Reserved2;                     /* 0x14 */
+        U32                         FastPathPendedRequests;        /* 0x18 */
+        U32                         FastPathUnPendedRequests;      /* 0x1C */
+        U32                         FastPathHostRequestStarts;     /* 0x20 */
+        U32                         FastPathFirmwareRequestStarts; /* 0x24 */
+        U32                         FastPathHostCompletions;       /* 0x28 */
+        U32                         FastPathFirmwareCompletions;   /* 0x2C */
+        U32                         NonFastPathRequestStarts;      /* 0x30 */
+        U32                         NonFastPathHostCompletions;    /* 0x30 */
+} MPI2_CONFIG_PAGE_SASIOUNIT16,
+MPI2_POINTER PTR_MPI2_CONFIG_PAGE_SASIOUNIT16,
+Mpi2SasIOUnitPage16_t, MPI2_POINTER pMpi2SasIOUnitPage16_t;
+
+#define MPI2_SASIOUNITPAGE16_PAGEVERSION    (0x00)
+
 
 /****************************************************************************
 *   SAS Expander Config Pages
diff --git a/drivers/scsi/mpt2sas/mpt2sas_base.c b/drivers/scsi/mpt2sas/mpt2sas_base.c
index 8a59a772fdf2..6102ef2cb2d8 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_base.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_base.c
@@ -699,6 +699,11 @@ _base_display_reply_info(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
         u16 ioc_status;
 
         mpi_reply = mpt2sas_base_get_reply_virt_addr(ioc, reply);
+        if (unlikely(!mpi_reply)) {
+                printk(MPT2SAS_ERR_FMT "mpi_reply not valid at %s:%d/%s()!\n",
+                        ioc->name, __FILE__, __LINE__, __func__);
+                return;
+        }
         ioc_status = le16_to_cpu(mpi_reply->IOCStatus);
 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
         if ((ioc_status & MPI2_IOCSTATUS_MASK) &&
@@ -930,16 +935,18 @@ _base_interrupt(int irq, void *bus_id)
                 else if (request_desript_type ==
                     MPI2_RPY_DESCRIPT_FLAGS_TARGETASSIST_SUCCESS)
                         goto next;
-                if (smid)
+                if (smid) {
                         cb_idx = _base_get_cb_idx(ioc, smid);
-                if (smid && cb_idx != 0xFF) {
-                        rc = mpt_callbacks[cb_idx](ioc, smid, msix_index,
-                            reply);
+                if ((likely(cb_idx < MPT_MAX_CALLBACKS))
+                            && (likely(mpt_callbacks[cb_idx] != NULL))) {
+                                rc = mpt_callbacks[cb_idx](ioc, smid,
+                                    msix_index, reply);
                         if (reply)
-                                _base_display_reply_info(ioc, smid, msix_index,
-                                    reply);
+                                _base_display_reply_info(ioc, smid,
+                                    msix_index, reply);
                         if (rc)
                                 mpt2sas_base_free_smid(ioc, smid);
+                        }
                 }
                 if (!smid)
                         _base_async_event(ioc, msix_index, reply);
@@ -3343,7 +3350,7 @@ _base_get_port_facts(struct MPT2SAS_ADAPTER *ioc, int port, int sleep_flag)
         }
 
         pfacts = &ioc->pfacts[port];
-        memset(pfacts, 0, sizeof(Mpi2PortFactsReply_t));
+        memset(pfacts, 0, sizeof(struct mpt2sas_port_facts));
         pfacts->PortNumber = mpi_reply.PortNumber;
         pfacts->VP_ID = mpi_reply.VP_ID;
         pfacts->VF_ID = mpi_reply.VF_ID;
@@ -3385,7 +3392,7 @@ _base_get_ioc_facts(struct MPT2SAS_ADAPTER *ioc, int sleep_flag)
         }
 
         facts = &ioc->facts;
-        memset(facts, 0, sizeof(Mpi2IOCFactsReply_t));
+        memset(facts, 0, sizeof(struct mpt2sas_facts));
         facts->MsgVersion = le16_to_cpu(mpi_reply.MsgVersion);
         facts->HeaderVersion = le16_to_cpu(mpi_reply.HeaderVersion);
         facts->VP_ID = mpi_reply.VP_ID;
@@ -4153,7 +4160,8 @@ _base_make_ioc_operational(struct MPT2SAS_ADAPTER *ioc, int sleep_flag)
         if (ioc->is_driver_loading) {
                 if (ioc->is_warpdrive && ioc->manu_pg10.OEMIdentifier
                     == 0x80) {
-                        hide_flag = (u8) (ioc->manu_pg10.OEMSpecificFlags0 &
+                        hide_flag = (u8) (
+                            le32_to_cpu(ioc->manu_pg10.OEMSpecificFlags0) &
                             MFG_PAGE10_HIDE_SSDS_MASK);
                         if (hide_flag != MFG_PAGE10_HIDE_SSDS_MASK)
                                 ioc->mfg_pg10_hide_flag = hide_flag;
@@ -4262,7 +4270,7 @@ mpt2sas_base_attach(struct MPT2SAS_ADAPTER *ioc)
                 goto out_free_resources;
 
         ioc->pfacts = kcalloc(ioc->facts.NumberOfPorts,
-            sizeof(Mpi2PortFactsReply_t), GFP_KERNEL);
+            sizeof(struct mpt2sas_port_facts), GFP_KERNEL);
         if (!ioc->pfacts) {
                 r = -ENOMEM;
                 goto out_free_resources;
@@ -4279,7 +4287,6 @@ mpt2sas_base_attach(struct MPT2SAS_ADAPTER *ioc)
                 goto out_free_resources;
 
         init_waitqueue_head(&ioc->reset_wq);
-
         /* allocate memory pd handle bitmask list */
         ioc->pd_handles_sz = (ioc->facts.MaxDevHandle / 8);
         if (ioc->facts.MaxDevHandle % 8)
@@ -4290,7 +4297,12 @@ mpt2sas_base_attach(struct MPT2SAS_ADAPTER *ioc)
                 r = -ENOMEM;
                 goto out_free_resources;
         }
-
+        ioc->blocking_handles = kzalloc(ioc->pd_handles_sz,
+            GFP_KERNEL);
+        if (!ioc->blocking_handles) {
+                r = -ENOMEM;
+                goto out_free_resources;
+        }
         ioc->fwfault_debug = mpt2sas_fwfault_debug;
 
         /* base internal command bits */
@@ -4377,6 +4389,7 @@ mpt2sas_base_attach(struct MPT2SAS_ADAPTER *ioc)
         if (ioc->is_warpdrive)
                 kfree(ioc->reply_post_host_index);
         kfree(ioc->pd_handles);
+        kfree(ioc->blocking_handles);
         kfree(ioc->tm_cmds.reply);
         kfree(ioc->transport_cmds.reply);
         kfree(ioc->scsih_cmds.reply);
@@ -4418,6 +4431,7 @@ mpt2sas_base_detach(struct MPT2SAS_ADAPTER *ioc)
         if (ioc->is_warpdrive)
                 kfree(ioc->reply_post_host_index);
         kfree(ioc->pd_handles);
+        kfree(ioc->blocking_handles);
         kfree(ioc->pfacts);
         kfree(ioc->ctl_cmds.reply);
         kfree(ioc->ctl_cmds.sense);
diff --git a/drivers/scsi/mpt2sas/mpt2sas_base.h b/drivers/scsi/mpt2sas/mpt2sas_base.h
index c7459fdc06cc..b6dd3a5de7f9 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_base.h
+++ b/drivers/scsi/mpt2sas/mpt2sas_base.h
@@ -69,8 +69,8 @@
 #define MPT2SAS_DRIVER_NAME             "mpt2sas"
 #define MPT2SAS_AUTHOR  "LSI Corporation <DL-MPTFusionLinux@lsi.com>"
 #define MPT2SAS_DESCRIPTION     "LSI MPT Fusion SAS 2.0 Device Driver"
-#define MPT2SAS_DRIVER_VERSION          "12.100.00.00"
-#define MPT2SAS_MAJOR_VERSION           12
+#define MPT2SAS_DRIVER_VERSION          "13.100.00.00"
+#define MPT2SAS_MAJOR_VERSION           13
 #define MPT2SAS_MINOR_VERSION           100
 #define MPT2SAS_BUILD_VERSION           00
 #define MPT2SAS_RELEASE_VERSION         00
@@ -720,6 +720,7 @@ typedef void (*MPT2SAS_FLUSH_RUNNING_CMDS)(struct MPT2SAS_ADAPTER *ioc);
  * @io_missing_delay: time for IO completed by fw when PDR enabled
  * @device_missing_delay: time for device missing by fw when PDR enabled
  * @sas_id : used for setting volume target IDs
+ * @blocking_handles: bitmask used to identify which devices need blocking
  * @pd_handles : bitmask for PD handles
  * @pd_handles_sz : size of pd_handle bitmask
  * @config_page_sz: config page size
@@ -889,7 +890,7 @@ struct MPT2SAS_ADAPTER {
         u8              io_missing_delay;
         u16             device_missing_delay;
         int             sas_id;
-
+        void            *blocking_handles;
         void            *pd_handles;
         u16             pd_handles_sz;
 
@@ -1058,7 +1059,8 @@ int mpt2sas_scsih_issue_tm(struct MPT2SAS_ADAPTER *ioc, u16 handle,
 void mpt2sas_scsih_set_tm_flag(struct MPT2SAS_ADAPTER *ioc, u16 handle);
 void mpt2sas_scsih_clear_tm_flag(struct MPT2SAS_ADAPTER *ioc, u16 handle);
 void mpt2sas_expander_remove(struct MPT2SAS_ADAPTER *ioc, u64 sas_address);
-void mpt2sas_device_remove(struct MPT2SAS_ADAPTER *ioc, u64 sas_address);
+void mpt2sas_device_remove_by_sas_address(struct MPT2SAS_ADAPTER *ioc,
+                u64 sas_address);
 struct _sas_node *mpt2sas_scsih_expander_find_by_handle(struct MPT2SAS_ADAPTER *ioc,
     u16 handle);
 struct _sas_node *mpt2sas_scsih_expander_find_by_sas_address(struct MPT2SAS_ADAPTER
diff --git a/drivers/scsi/mpt2sas/mpt2sas_ctl.c b/drivers/scsi/mpt2sas/mpt2sas_ctl.c
index 3b9a28efea82..49bdd2dc8452 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_ctl.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_ctl.c
@@ -620,11 +620,10 @@ _ctl_set_task_mid(struct MPT2SAS_ADAPTER *ioc, struct mpt2_ioctl_command *karg,
  * @ioc: per adapter object
  * @karg - (struct mpt2_ioctl_command)
  * @mf - pointer to mf in user space
- * @state - NON_BLOCKING or BLOCKING
  */
 static long
-_ctl_do_mpt_command(struct MPT2SAS_ADAPTER *ioc,
-    struct mpt2_ioctl_command karg, void __user *mf, enum block_state state)
+_ctl_do_mpt_command(struct MPT2SAS_ADAPTER *ioc, struct mpt2_ioctl_command karg,
+        void __user *mf)
 {
         MPI2RequestHeader_t *mpi_request = NULL, *request;
         MPI2DefaultReply_t *mpi_reply;
@@ -647,11 +646,6 @@ _ctl_do_mpt_command(struct MPT2SAS_ADAPTER *ioc,
 
         issue_reset = 0;
 
-        if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
-                return -EAGAIN;
-        else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
-                return -ERESTARTSYS;
-
         if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) {
                 printk(MPT2SAS_ERR_FMT "%s: ctl_cmd in use\n",
                     ioc->name, __func__);
@@ -871,8 +865,16 @@ _ctl_do_mpt_command(struct MPT2SAS_ADAPTER *ioc,
                 if (smp_request->PassthroughFlags &
                     MPI2_SMP_PT_REQ_PT_FLAGS_IMMEDIATE)
                         data = (u8 *)&smp_request->SGL;
-                else
+                else {
+                        if (unlikely(data_out == NULL)) {
+                                printk(KERN_ERR "failure at %s:%d/%s()!\n",
+                                    __FILE__, __LINE__, __func__);
+                                mpt2sas_base_free_smid(ioc, smid);
+                                ret = -EINVAL;
+                                goto out;
+                        }
                         data = data_out;
+                }
 
                 if (data[1] == 0x91 && (data[10] == 1 || data[10] == 2)) {
                         ioc->ioc_link_reset_in_progress = 1;
@@ -985,7 +987,8 @@ _ctl_do_mpt_command(struct MPT2SAS_ADAPTER *ioc,
                 ret = -ENODATA;
                 if ((mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST ||
                     mpi_request->Function ==
-                    MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) {
+                    MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH ||
+                    mpi_request->Function == MPI2_FUNCTION_SATA_PASSTHROUGH)) {
                         printk(MPT2SAS_INFO_FMT "issue target reset: handle "
                             "= (0x%04x)\n", ioc->name,
                             le16_to_cpu(mpi_request->FunctionDependent1));
@@ -1013,27 +1016,24 @@ _ctl_do_mpt_command(struct MPT2SAS_ADAPTER *ioc,
 
         kfree(mpi_request);
         ioc->ctl_cmds.status = MPT2_CMD_NOT_USED;
-        mutex_unlock(&ioc->ctl_cmds.mutex);
         return ret;
 }
 
 /**
  * _ctl_getiocinfo - main handler for MPT2IOCINFO opcode
+ * @ioc: per adapter object
  * @arg - user space buffer containing ioctl content
  */
 static long
-_ctl_getiocinfo(void __user *arg)
+_ctl_getiocinfo(struct MPT2SAS_ADAPTER *ioc, void __user *arg)
 {
         struct mpt2_ioctl_iocinfo karg;
-        struct MPT2SAS_ADAPTER *ioc;
 
         if (copy_from_user(&karg, arg, sizeof(karg))) {
                 printk(KERN_ERR "failure at %s:%d/%s()!\n",
                     __FILE__, __LINE__, __func__);
                 return -EFAULT;
         }
-        if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
-                return -ENODEV;
 
         dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name,
             __func__));
@@ -1069,21 +1069,19 @@ _ctl_getiocinfo(void __user *arg)
 
 /**
  * _ctl_eventquery - main handler for MPT2EVENTQUERY opcode
+ * @ioc: per adapter object
  * @arg - user space buffer containing ioctl content
  */
 static long
-_ctl_eventquery(void __user *arg)
+_ctl_eventquery(struct MPT2SAS_ADAPTER *ioc, void __user *arg)
 {
         struct mpt2_ioctl_eventquery karg;
-        struct MPT2SAS_ADAPTER *ioc;
 
         if (copy_from_user(&karg, arg, sizeof(karg))) {
                 printk(KERN_ERR "failure at %s:%d/%s()!\n",
                     __FILE__, __LINE__, __func__);
                 return -EFAULT;
         }
-        if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
-                return -ENODEV;
 
         dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name,
             __func__));
@@ -1102,21 +1100,19 @@ _ctl_eventquery(void __user *arg)
 
 /**
  * _ctl_eventenable - main handler for MPT2EVENTENABLE opcode
+ * @ioc: per adapter object
  * @arg - user space buffer containing ioctl content
  */
 static long
-_ctl_eventenable(void __user *arg)
+_ctl_eventenable(struct MPT2SAS_ADAPTER *ioc, void __user *arg)
 {
         struct mpt2_ioctl_eventenable karg;
-        struct MPT2SAS_ADAPTER *ioc;
 
         if (copy_from_user(&karg, arg, sizeof(karg))) {
                 printk(KERN_ERR "failure at %s:%d/%s()!\n",
                     __FILE__, __LINE__, __func__);
                 return -EFAULT;
         }
-        if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
-                return -ENODEV;
 
         dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name,
             __func__));
@@ -1142,13 +1138,13 @@ _ctl_eventenable(void __user *arg)
 
 /**
  * _ctl_eventreport - main handler for MPT2EVENTREPORT opcode
+ * @ioc: per adapter object
  * @arg - user space buffer containing ioctl content
  */
 static long
-_ctl_eventreport(void __user *arg)
+_ctl_eventreport(struct MPT2SAS_ADAPTER *ioc, void __user *arg)
 {
         struct mpt2_ioctl_eventreport karg;
-        struct MPT2SAS_ADAPTER *ioc;
         u32 number_bytes, max_events, max;
         struct mpt2_ioctl_eventreport __user *uarg = arg;
 
@@ -1157,8 +1153,6 @@ _ctl_eventreport(void __user *arg)
                     __FILE__, __LINE__, __func__);
                 return -EFAULT;
         }
-        if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
-                return -ENODEV;
 
         dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter\n", ioc->name,
             __func__));
@@ -1188,13 +1182,13 @@ _ctl_eventreport(void __user *arg)
 
 /**
  * _ctl_do_reset - main handler for MPT2HARDRESET opcode
+ * @ioc: per adapter object
  * @arg - user space buffer containing ioctl content
  */
 static long
-_ctl_do_reset(void __user *arg)
+_ctl_do_reset(struct MPT2SAS_ADAPTER *ioc, void __user *arg)
 {
         struct mpt2_ioctl_diag_reset karg;
-        struct MPT2SAS_ADAPTER *ioc;
         int retval;
 
         if (copy_from_user(&karg, arg, sizeof(karg))) {
@@ -1202,8 +1196,6 @@ _ctl_do_reset(void __user *arg)
                     __FILE__, __LINE__, __func__);
                 return -EFAULT;
         }
-        if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
-                return -ENODEV;
 
         if (ioc->shost_recovery || ioc->pci_error_recovery ||
                 ioc->is_driver_loading)
@@ -1292,13 +1284,13 @@ _ctl_btdh_search_raid_device(struct MPT2SAS_ADAPTER *ioc,
 
 /**
  * _ctl_btdh_mapping - main handler for MPT2BTDHMAPPING opcode
+ * @ioc: per adapter object
  * @arg - user space buffer containing ioctl content
  */
 static long
-_ctl_btdh_mapping(void __user *arg)
+_ctl_btdh_mapping(struct MPT2SAS_ADAPTER *ioc, void __user *arg)
 {
         struct mpt2_ioctl_btdh_mapping karg;
-        struct MPT2SAS_ADAPTER *ioc;
         int rc;
 
         if (copy_from_user(&karg, arg, sizeof(karg))) {
@@ -1306,8 +1298,6 @@ _ctl_btdh_mapping(void __user *arg)
                     __FILE__, __LINE__, __func__);
                 return -EFAULT;
         }
-        if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
-                return -ENODEV;
 
         dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
             __func__));
@@ -1576,17 +1566,16 @@ mpt2sas_enable_diag_buffer(struct MPT2SAS_ADAPTER *ioc, u8 bits_to_register)
 
 /**
  * _ctl_diag_register - application register with driver
+ * @ioc: per adapter object
  * @arg - user space buffer containing ioctl content
- * @state - NON_BLOCKING or BLOCKING
  *
  * This will allow the driver to setup any required buffers that will be
  * needed by firmware to communicate with the driver.
  */
 static long
-_ctl_diag_register(void __user *arg, enum block_state state)
+_ctl_diag_register(struct MPT2SAS_ADAPTER *ioc, void __user *arg)
 {
         struct mpt2_diag_register karg;
-        struct MPT2SAS_ADAPTER *ioc;
         long rc;
 
         if (copy_from_user(&karg, arg, sizeof(karg))) {
@@ -1594,30 +1583,23 @@ _ctl_diag_register(void __user *arg, enum block_state state)
                     __FILE__, __LINE__, __func__);
                 return -EFAULT;
         }
-        if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
-                return -ENODEV;
 
-        if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
-                return -EAGAIN;
-        else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
-                return -ERESTARTSYS;
         rc = _ctl_diag_register_2(ioc, &karg);
-        mutex_unlock(&ioc->ctl_cmds.mutex);
         return rc;
 }
 
 /**
  * _ctl_diag_unregister - application unregister with driver
+ * @ioc: per adapter object
  * @arg - user space buffer containing ioctl content
  *
  * This will allow the driver to cleanup any memory allocated for diag
  * messages and to free up any resources.
  */
 static long
-_ctl_diag_unregister(void __user *arg)
+_ctl_diag_unregister(struct MPT2SAS_ADAPTER *ioc, void __user *arg)
 {
         struct mpt2_diag_unregister karg;
-        struct MPT2SAS_ADAPTER *ioc;
         void *request_data;
         dma_addr_t request_data_dma;
         u32 request_data_sz;
@@ -1628,8 +1610,6 @@ _ctl_diag_unregister(void __user *arg)
                     __FILE__, __LINE__, __func__);
                 return -EFAULT;
         }
-        if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
-                return -ENODEV;
 
         dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
             __func__));
@@ -1678,6 +1658,7 @@ _ctl_diag_unregister(void __user *arg)
 
 /**
  * _ctl_diag_query - query relevant info associated with diag buffers
+ * @ioc: per adapter object
  * @arg - user space buffer containing ioctl content
  *
  * The application will send only buffer_type and unique_id.  Driver will
@@ -1685,10 +1666,9 @@ _ctl_diag_unregister(void __user *arg)
  * 0x00, the driver will return info specified by Buffer Type.
  */
 static long
-_ctl_diag_query(void __user *arg)
+_ctl_diag_query(struct MPT2SAS_ADAPTER *ioc, void __user *arg)
 {
         struct mpt2_diag_query karg;
-        struct MPT2SAS_ADAPTER *ioc;
         void *request_data;
         int i;
         u8 buffer_type;
@@ -1698,8 +1678,6 @@ _ctl_diag_query(void __user *arg)
                     __FILE__, __LINE__, __func__);
                 return -EFAULT;
         }
-        if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
-                return -ENODEV;
 
         dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
             __func__));
@@ -1866,17 +1844,15 @@ _ctl_send_release(struct MPT2SAS_ADAPTER *ioc, u8 buffer_type, u8 *issue_reset)
 /**
  * _ctl_diag_release - request to send Diag Release Message to firmware
  * @arg - user space buffer containing ioctl content
- * @state - NON_BLOCKING or BLOCKING
  *
  * This allows ownership of the specified buffer to returned to the driver,
  * allowing an application to read the buffer without fear that firmware is
  * overwritting information in the buffer.
  */
 static long
-_ctl_diag_release(void __user *arg, enum block_state state)
+_ctl_diag_release(struct MPT2SAS_ADAPTER *ioc, void __user *arg)
 {
         struct mpt2_diag_release karg;
-        struct MPT2SAS_ADAPTER *ioc;
         void *request_data;
         int rc;
         u8 buffer_type;
@@ -1887,8 +1863,6 @@ _ctl_diag_release(void __user *arg, enum block_state state)
                     __FILE__, __LINE__, __func__);
                 return -EFAULT;
         }
-        if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
-                return -ENODEV;
 
         dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
             __func__));
@@ -1942,32 +1916,25 @@ _ctl_diag_release(void __user *arg, enum block_state state)
                 return 0;
         }
 
-        if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
-                return -EAGAIN;
-        else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
-                return -ERESTARTSYS;
-
         rc = _ctl_send_release(ioc, buffer_type, &issue_reset);
 
         if (issue_reset)
                 mpt2sas_base_hard_reset_handler(ioc, CAN_SLEEP,
                     FORCE_BIG_HAMMER);
 
-        mutex_unlock(&ioc->ctl_cmds.mutex);
         return rc;
 }
 
 /**
  * _ctl_diag_read_buffer - request for copy of the diag buffer
+ * @ioc: per adapter object
  * @arg - user space buffer containing ioctl content
- * @state - NON_BLOCKING or BLOCKING
  */
 static long
-_ctl_diag_read_buffer(void __user *arg, enum block_state state)
+_ctl_diag_read_buffer(struct MPT2SAS_ADAPTER *ioc, void __user *arg)
 {
         struct mpt2_diag_read_buffer karg;
         struct mpt2_diag_read_buffer __user *uarg = arg;
-        struct MPT2SAS_ADAPTER *ioc;
         void *request_data, *diag_data;
         Mpi2DiagBufferPostRequest_t *mpi_request;
         Mpi2DiagBufferPostReply_t *mpi_reply;
@@ -1983,8 +1950,6 @@ _ctl_diag_read_buffer(void __user *arg, enum block_state state)
                     __FILE__, __LINE__, __func__);
                 return -EFAULT;
         }
-        if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 || !ioc)
-                return -ENODEV;
 
         dctlprintk(ioc, printk(MPT2SAS_INFO_FMT "%s\n", ioc->name,
             __func__));
@@ -2055,10 +2020,6 @@ _ctl_diag_read_buffer(void __user *arg, enum block_state state)
         }
         /* Get a free request frame and save the message context.
         */
-        if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
-                return -EAGAIN;
-        else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
-                return -ERESTARTSYS;
 
         if (ioc->ctl_cmds.status != MPT2_CMD_NOT_USED) {
                 printk(MPT2SAS_ERR_FMT "%s: ctl_cmd in use\n",
@@ -2139,115 +2100,170 @@ _ctl_diag_read_buffer(void __user *arg, enum block_state state)
  out:
 
         ioc->ctl_cmds.status = MPT2_CMD_NOT_USED;
-        mutex_unlock(&ioc->ctl_cmds.mutex);
         return rc;
 }
 
+
+#ifdef CONFIG_COMPAT
+/**
+ * _ctl_compat_mpt_command - convert 32bit pointers to 64bit.
+ * @ioc: per adapter object
+ * @cmd - ioctl opcode
+ * @arg - (struct mpt2_ioctl_command32)
+ *
+ * MPT2COMMAND32 - Handle 32bit applications running on 64bit os.
+ */
+static long
+_ctl_compat_mpt_command(struct MPT2SAS_ADAPTER *ioc, unsigned cmd,
+        void __user *arg)
+{
+        struct mpt2_ioctl_command32 karg32;
+        struct mpt2_ioctl_command32 __user *uarg;
+        struct mpt2_ioctl_command karg;
+
+        if (_IOC_SIZE(cmd) != sizeof(struct mpt2_ioctl_command32))
+                return -EINVAL;
+
+        uarg = (struct mpt2_ioctl_command32 __user *) arg;
+
+        if (copy_from_user(&karg32, (char __user *)arg, sizeof(karg32))) {
+                printk(KERN_ERR "failure at %s:%d/%s()!\n",
+                    __FILE__, __LINE__, __func__);
+                return -EFAULT;
+        }
+
+        memset(&karg, 0, sizeof(struct mpt2_ioctl_command));
+        karg.hdr.ioc_number = karg32.hdr.ioc_number;
+        karg.hdr.port_number = karg32.hdr.port_number;
+        karg.hdr.max_data_size = karg32.hdr.max_data_size;
+        karg.timeout = karg32.timeout;
+        karg.max_reply_bytes = karg32.max_reply_bytes;
+        karg.data_in_size = karg32.data_in_size;
+        karg.data_out_size = karg32.data_out_size;
+        karg.max_sense_bytes = karg32.max_sense_bytes;
+        karg.data_sge_offset = karg32.data_sge_offset;
+        karg.reply_frame_buf_ptr = compat_ptr(karg32.reply_frame_buf_ptr);
+        karg.data_in_buf_ptr = compat_ptr(karg32.data_in_buf_ptr);
+        karg.data_out_buf_ptr = compat_ptr(karg32.data_out_buf_ptr);
+        karg.sense_data_ptr = compat_ptr(karg32.sense_data_ptr);
+        return _ctl_do_mpt_command(ioc, karg, &uarg->mf);
+}
+#endif
+
 /**
  * _ctl_ioctl_main - main ioctl entry point
  * @file - (struct file)
  * @cmd - ioctl opcode
  * @arg -
+ * compat - handles 32 bit applications in 64bit os
  */
 static long
-_ctl_ioctl_main(struct file *file, unsigned int cmd, void __user *arg)
+_ctl_ioctl_main(struct file *file, unsigned int cmd, void __user *arg,
+        u8 compat)
 {
+        struct MPT2SAS_ADAPTER *ioc;
+        struct mpt2_ioctl_header ioctl_header;
         enum block_state state;
         long ret = -EINVAL;
 
-        state = (file->f_flags & O_NONBLOCK) ? NON_BLOCKING :
-            BLOCKING;
+        /* get IOCTL header */
+        if (copy_from_user(&ioctl_header, (char __user *)arg,
+            sizeof(struct mpt2_ioctl_header))) {
+                printk(KERN_ERR "failure at %s:%d/%s()!\n",
+                    __FILE__, __LINE__, __func__);
+                return -EFAULT;
+        }
+
+        if (_ctl_verify_adapter(ioctl_header.ioc_number, &ioc) == -1 || !ioc)
+                return -ENODEV;
+        if (ioc->shost_recovery || ioc->pci_error_recovery ||
+            ioc->is_driver_loading)
+                return -EAGAIN;
+
+        state = (file->f_flags & O_NONBLOCK) ? NON_BLOCKING : BLOCKING;
+        if (state == NON_BLOCKING && !mutex_trylock(&ioc->ctl_cmds.mutex))
+                return -EAGAIN;
+        else if (mutex_lock_interruptible(&ioc->ctl_cmds.mutex))
+                return -ERESTARTSYS;
 
         switch (cmd) {
         case MPT2IOCINFO:
                 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_iocinfo))
-                        ret = _ctl_getiocinfo(arg);
+                        ret = _ctl_getiocinfo(ioc, arg);
                 break;
+#ifdef CONFIG_COMPAT
+        case MPT2COMMAND32:
+#endif
         case MPT2COMMAND:
         {
-                struct mpt2_ioctl_command karg;
                 struct mpt2_ioctl_command __user *uarg;
-                struct MPT2SAS_ADAPTER *ioc;
-
+                struct mpt2_ioctl_command karg;
+#ifdef CONFIG_COMPAT
+                if (compat) {
+                        ret = _ctl_compat_mpt_command(ioc, cmd, arg);
+                        break;
+                }
+#endif
                 if (copy_from_user(&karg, arg, sizeof(karg))) {
                         printk(KERN_ERR "failure at %s:%d/%s()!\n",
                             __FILE__, __LINE__, __func__);
-                        return -EFAULT;
+                        ret = -EFAULT;
+                        break;
                 }
 
-                if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 ||
-                    !ioc)
-                        return -ENODEV;
-
-                if (ioc->shost_recovery || ioc->pci_error_recovery ||
-                                ioc->is_driver_loading)
-                        return -EAGAIN;
-
                 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_command)) {
                         uarg = arg;
-                        ret = _ctl_do_mpt_command(ioc, karg, &uarg->mf, state);
+                        ret = _ctl_do_mpt_command(ioc, karg, &uarg->mf);
                 }
                 break;
         }
         case MPT2EVENTQUERY:
                 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_eventquery))
-                        ret = _ctl_eventquery(arg);
+                        ret = _ctl_eventquery(ioc, arg);
                 break;
         case MPT2EVENTENABLE:
                 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_eventenable))
-                        ret = _ctl_eventenable(arg);
+                        ret = _ctl_eventenable(ioc, arg);
                 break;
         case MPT2EVENTREPORT:
-                ret = _ctl_eventreport(arg);
+                ret = _ctl_eventreport(ioc, arg);
                 break;
         case MPT2HARDRESET:
                 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_diag_reset))
-                        ret = _ctl_do_reset(arg);
+                        ret = _ctl_do_reset(ioc, arg);
                 break;
         case MPT2BTDHMAPPING:
                 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_ioctl_btdh_mapping))
-                        ret = _ctl_btdh_mapping(arg);
+                        ret = _ctl_btdh_mapping(ioc, arg);
                 break;
         case MPT2DIAGREGISTER:
                 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_register))
-                        ret = _ctl_diag_register(arg, state);
+                        ret = _ctl_diag_register(ioc, arg);
                 break;
         case MPT2DIAGUNREGISTER:
                 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_unregister))
-                        ret = _ctl_diag_unregister(arg);
+                        ret = _ctl_diag_unregister(ioc, arg);
                 break;
         case MPT2DIAGQUERY:
                 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_query))
-                        ret = _ctl_diag_query(arg);
+                        ret = _ctl_diag_query(ioc, arg);
                 break;
         case MPT2DIAGRELEASE:
                 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_release))
-                        ret = _ctl_diag_release(arg, state);
+                        ret = _ctl_diag_release(ioc, arg);
                 break;
         case MPT2DIAGREADBUFFER:
                 if (_IOC_SIZE(cmd) == sizeof(struct mpt2_diag_read_buffer))
-                        ret = _ctl_diag_read_buffer(arg, state);
+                        ret = _ctl_diag_read_buffer(ioc, arg);
                 break;
         default:
-        {
-                struct mpt2_ioctl_command karg;
-                struct MPT2SAS_ADAPTER *ioc;
-
-                if (copy_from_user(&karg, arg, sizeof(karg))) {
-                        printk(KERN_ERR "failure at %s:%d/%s()!\n",
-                            __FILE__, __LINE__, __func__);
-                        return -EFAULT;
-                }
-
-                if (_ctl_verify_adapter(karg.hdr.ioc_number, &ioc) == -1 ||
-                    !ioc)
-                        return -ENODEV;
 
                 dctlprintk(ioc, printk(MPT2SAS_INFO_FMT
                     "unsupported ioctl opcode(0x%08x)\n", ioc->name, cmd));
                 break;
         }
-        }
+
+        mutex_unlock(&ioc->ctl_cmds.mutex);
         return ret;
 }
 
@@ -2262,66 +2278,11 @@ _ctl_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         long ret;
 
-        mutex_lock(&_ctl_mutex);
-        ret = _ctl_ioctl_main(file, cmd, (void __user *)arg);
-        mutex_unlock(&_ctl_mutex);
+        ret = _ctl_ioctl_main(file, cmd, (void __user *)arg, 0);
         return ret;
 }
-
 #ifdef CONFIG_COMPAT
 /**
- * _ctl_compat_mpt_command - convert 32bit pointers to 64bit.
- * @file - (struct file)
- * @cmd - ioctl opcode
- * @arg - (struct mpt2_ioctl_command32)
- *
- * MPT2COMMAND32 - Handle 32bit applications running on 64bit os.
- */
-static long
-_ctl_compat_mpt_command(struct file *file, unsigned cmd, unsigned long arg)
-{
-        struct mpt2_ioctl_command32 karg32;
-        struct mpt2_ioctl_command32 __user *uarg;
-        struct mpt2_ioctl_command karg;
-        struct MPT2SAS_ADAPTER *ioc;
-        enum block_state state;
-
-        if (_IOC_SIZE(cmd) != sizeof(struct mpt2_ioctl_command32))
-                return -EINVAL;
-
-        uarg = (struct mpt2_ioctl_command32 __user *) arg;
-
-        if (copy_from_user(&karg32, (char __user *)arg, sizeof(karg32))) {
-                printk(KERN_ERR "failure at %s:%d/%s()!\n",
-                    __FILE__, __LINE__, __func__);
-                return -EFAULT;
-        }
-        if (_ctl_verify_adapter(karg32.hdr.ioc_number, &ioc) == -1 || !ioc)
-                return -ENODEV;
-
-        if (ioc->shost_recovery || ioc->pci_error_recovery ||
-                        ioc->is_driver_loading)
-                return -EAGAIN;
-
-        memset(&karg, 0, sizeof(struct mpt2_ioctl_command));
-        karg.hdr.ioc_number = karg32.hdr.ioc_number;
-        karg.hdr.port_number = karg32.hdr.port_number;
-        karg.hdr.max_data_size = karg32.hdr.max_data_size;
-        karg.timeout = karg32.timeout;
-        karg.max_reply_bytes = karg32.max_reply_bytes;
-        karg.data_in_size = karg32.data_in_size;
-        karg.data_out_size = karg32.data_out_size;
-        karg.max_sense_bytes = karg32.max_sense_bytes;
-        karg.data_sge_offset = karg32.data_sge_offset;
-        karg.reply_frame_buf_ptr = compat_ptr(karg32.reply_frame_buf_ptr);
-        karg.data_in_buf_ptr = compat_ptr(karg32.data_in_buf_ptr);
-        karg.data_out_buf_ptr = compat_ptr(karg32.data_out_buf_ptr);
-        karg.sense_data_ptr = compat_ptr(karg32.sense_data_ptr);
-        state = (file->f_flags & O_NONBLOCK) ? NON_BLOCKING : BLOCKING;
-        return _ctl_do_mpt_command(ioc, karg, &uarg->mf, state);
-}
-
-/**
  * _ctl_ioctl_compat - main ioctl entry point (compat)
  * @file -
  * @cmd -
@@ -2334,12 +2295,7 @@ _ctl_ioctl_compat(struct file *file, unsigned cmd, unsigned long arg)
 {
         long ret;
 
-        mutex_lock(&_ctl_mutex);
-        if (cmd == MPT2COMMAND32)
-                ret = _ctl_compat_mpt_command(file, cmd, arg);
-        else
-                ret = _ctl_ioctl_main(file, cmd, (void __user *)arg);
-        mutex_unlock(&_ctl_mutex);
+        ret = _ctl_ioctl_main(file, cmd, (void __user *)arg, 1);
         return ret;
 }
 #endif
@@ -2884,7 +2840,7 @@ _ctl_host_trace_buffer_enable_store(struct device *cdev,
         struct mpt2_diag_register diag_register;
         u8 issue_reset = 0;
 
-        if (sscanf(buf, "%s", str) != 1)
+        if (sscanf(buf, "%9s", str) != 1)
                 return -EINVAL;
 
         if (!strcmp(str, "post")) {
diff --git a/drivers/scsi/mpt2sas/mpt2sas_scsih.c b/drivers/scsi/mpt2sas/mpt2sas_scsih.c
index d953a57e779d..76973e8ca4ba 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_scsih.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_scsih.c
@@ -579,14 +579,12 @@ _scsih_sas_device_remove(struct MPT2SAS_ADAPTER *ioc,
                 return;
 
         spin_lock_irqsave(&ioc->sas_device_lock, flags);
-        if (mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
-            sas_device->sas_address)) {
-                list_del(&sas_device->list);
-                kfree(sas_device);
-        }
+        list_del(&sas_device->list);
+        kfree(sas_device);
         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 }
 
+
 /**
  * _scsih_sas_device_add - insert sas_device to the list.
  * @ioc: per adapter object
@@ -645,8 +643,8 @@ _scsih_sas_device_init_add(struct MPT2SAS_ADAPTER *ioc,
 
         spin_lock_irqsave(&ioc->sas_device_lock, flags);
         list_add_tail(&sas_device->list, &ioc->sas_device_init_list);
-        spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
         _scsih_determine_boot_device(ioc, sas_device, 0);
+        spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 }
 
 /**
@@ -755,7 +753,6 @@ _scsih_raid_device_add(struct MPT2SAS_ADAPTER *ioc,
  * @ioc: per adapter object
  * @raid_device: raid_device object
  *
- * This is removed from the raid_device_list link list.
  */
 static void
 _scsih_raid_device_remove(struct MPT2SAS_ADAPTER *ioc,
@@ -765,7 +762,6 @@ _scsih_raid_device_remove(struct MPT2SAS_ADAPTER *ioc,
 
         spin_lock_irqsave(&ioc->raid_device_lock, flags);
         list_del(&raid_device->list);
-        memset(raid_device, 0, sizeof(struct _raid_device));
         kfree(raid_device);
         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
 }
@@ -1199,10 +1195,10 @@ _scsih_adjust_queue_depth(struct scsi_device *sdev, int qdepth)
         spin_lock_irqsave(&ioc->sas_device_lock, flags);
         sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
            sas_device_priv_data->sas_target->sas_address);
-        spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
         if (sas_device && sas_device->device_info &
             MPI2_SAS_DEVICE_INFO_SATA_DEVICE)
                 max_depth = MPT2SAS_SATA_QUEUE_DEPTH;
+        spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 
  not_sata:
 
@@ -1299,7 +1295,8 @@ _scsih_target_alloc(struct scsi_target *starget)
                         sas_target_priv_data->handle = raid_device->handle;
                         sas_target_priv_data->sas_address = raid_device->wwid;
                         sas_target_priv_data->flags |= MPT_TARGET_FLAGS_VOLUME;
-                        sas_target_priv_data->raid_device = raid_device;
+                        if (ioc->is_warpdrive)
+                                sas_target_priv_data->raid_device = raid_device;
                         raid_device->starget = starget;
                 }
                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
@@ -1465,12 +1462,12 @@ _scsih_slave_destroy(struct scsi_device *sdev)
 /**
  * _scsih_display_sata_capabilities - sata capabilities
  * @ioc: per adapter object
- * @sas_device: the sas_device object
+ * @handle: device handle
  * @sdev: scsi device struct
  */
 static void
 _scsih_display_sata_capabilities(struct MPT2SAS_ADAPTER *ioc,
-    struct _sas_device *sas_device, struct scsi_device *sdev)
+        u16 handle, struct scsi_device *sdev)
 {
         Mpi2ConfigReply_t mpi_reply;
         Mpi2SasDevicePage0_t sas_device_pg0;
@@ -1479,7 +1476,7 @@ _scsih_display_sata_capabilities(struct MPT2SAS_ADAPTER *ioc,
         u32 device_info;
 
         if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
-            MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, sas_device->handle))) {
+            MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) {
                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
                     ioc->name, __FILE__, __LINE__, __func__);
                 return;
@@ -1537,27 +1534,40 @@ _scsih_get_resync(struct device *dev)
         Mpi2RaidVolPage0_t vol_pg0;
         Mpi2ConfigReply_t mpi_reply;
         u32 volume_status_flags;
-        u8 percent_complete = 0;
+        u8 percent_complete;
+        u16 handle;
+
+        percent_complete = 0;
+        handle = 0;
+        if (ioc->is_warpdrive)
+                goto out;
 
         spin_lock_irqsave(&ioc->raid_device_lock, flags);
         raid_device = _scsih_raid_device_find_by_id(ioc, sdev->id,
             sdev->channel);
+        if (raid_device) {
+                handle = raid_device->handle;
+                percent_complete = raid_device->percent_complete;
+        }
         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
 
-        if (!raid_device || ioc->is_warpdrive)
+        if (!handle)
                 goto out;
 
         if (mpt2sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0,
-             MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, raid_device->handle,
+             MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
              sizeof(Mpi2RaidVolPage0_t))) {
                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
                     ioc->name, __FILE__, __LINE__, __func__);
+                percent_complete = 0;
                 goto out;
         }
 
         volume_status_flags = le32_to_cpu(vol_pg0.VolumeStatusFlags);
-        if (volume_status_flags & MPI2_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS)
-                percent_complete = raid_device->percent_complete;
+        if (!(volume_status_flags &
+            MPI2_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS))
+                percent_complete = 0;
+
  out:
         raid_set_resync(mpt2sas_raid_template, dev, percent_complete);
 }
@@ -1577,17 +1587,20 @@ _scsih_get_state(struct device *dev)
         Mpi2ConfigReply_t mpi_reply;
         u32 volstate;
         enum raid_state state = RAID_STATE_UNKNOWN;
+        u16 handle = 0;
 
         spin_lock_irqsave(&ioc->raid_device_lock, flags);
         raid_device = _scsih_raid_device_find_by_id(ioc, sdev->id,
             sdev->channel);
+        if (raid_device)
+                handle = raid_device->handle;
         spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
 
         if (!raid_device)
                 goto out;
 
         if (mpt2sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0,
-             MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, raid_device->handle,
+             MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle,
              sizeof(Mpi2RaidVolPage0_t))) {
                 printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
                     ioc->name, __FILE__, __LINE__, __func__);
@@ -1620,14 +1633,14 @@ _scsih_get_state(struct device *dev)
 /**
  * _scsih_set_level - set raid level
  * @sdev: scsi device struct
- * @raid_device: raid_device object
+ * @volume_type: volume type
  */
 static void
-_scsih_set_level(struct scsi_device *sdev, struct _raid_device *raid_device)
+_scsih_set_level(struct scsi_device *sdev, u8 volume_type)
 {
         enum raid_level level = RAID_LEVEL_UNKNOWN;
 
-        switch (raid_device->volume_type) {
+        switch (volume_type) {
         case MPI2_RAID_VOL_TYPE_RAID0:
                 level = RAID_LEVEL_0;
                 break;
@@ -1722,6 +1735,7 @@ _scsih_disable_ddio(struct MPT2SAS_ADAPTER *ioc)
         struct _raid_device *raid_device;
         u16 handle;
         u16 ioc_status;
+        unsigned long flags;
 
         handle = 0xFFFF;
         while (!(mpt2sas_config_get_raid_volume_pg1(ioc, &mpi_reply,
@@ -1731,9 +1745,11 @@ _scsih_disable_ddio(struct MPT2SAS_ADAPTER *ioc)
                 if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)
                         break;
                 handle = le16_to_cpu(vol_pg1.DevHandle);
+                spin_lock_irqsave(&ioc->raid_device_lock, flags);
                 raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
                 if (raid_device)
                         raid_device->direct_io_enabled = 0;
+                spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
         }
         return;
 }
@@ -1838,7 +1854,8 @@ _scsih_init_warpdrive_properties(struct MPT2SAS_ADAPTER *ioc,
                 if (mpt2sas_config_get_phys_disk_pg0(ioc, &mpi_reply,
                     &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_PHYSDISKNUM,
                     vol_pg0->PhysDisk[count].PhysDiskNum) ||
-                    pd_pg0.DevHandle == MPT2SAS_INVALID_DEVICE_HANDLE) {
+                     le16_to_cpu(pd_pg0.DevHandle) ==
+                    MPT2SAS_INVALID_DEVICE_HANDLE) {
                         printk(MPT2SAS_INFO_FMT "WarpDrive : Direct IO is "
                             "disabled for the drive with handle(0x%04x) member"
                             "handle retrieval failed for member number=%d\n",
@@ -1968,19 +1985,21 @@ _scsih_slave_configure(struct scsi_device *sdev)
         u8 ssp_target = 0;
         char *ds = "";
         char *r_level = "";
+        u16 handle, volume_handle = 0;
+        u64 volume_wwid = 0;
 
         qdepth = 1;
         sas_device_priv_data = sdev->hostdata;
         sas_device_priv_data->configured_lun = 1;
         sas_device_priv_data->flags &= ~MPT_DEVICE_FLAGS_INIT;
         sas_target_priv_data = sas_device_priv_data->sas_target;
+        handle = sas_target_priv_data->handle;
 
         /* raid volume handling */
         if (sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME) {
 
                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
-                raid_device = _scsih_raid_device_find_by_handle(ioc,
-                     sas_target_priv_data->handle);
+                raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
                 if (!raid_device) {
                         dfailprintk(ioc, printk(MPT2SAS_WARN_FMT
@@ -1989,8 +2008,6 @@ _scsih_slave_configure(struct scsi_device *sdev)
                         return 1;
                 }
 
-                _scsih_get_volume_capabilities(ioc, raid_device);
-
                 if (_scsih_get_volume_capabilities(ioc, raid_device)) {
                         dfailprintk(ioc, printk(MPT2SAS_WARN_FMT
                             "failure at %s:%d/%s()!\n", ioc->name, __FILE__,
@@ -2058,68 +2075,67 @@ _scsih_slave_configure(struct scsi_device *sdev)
                 _scsih_change_queue_depth(sdev, qdepth, SCSI_QDEPTH_DEFAULT);
                 /* raid transport support */
                 if (!ioc->is_warpdrive)
-                        _scsih_set_level(sdev, raid_device);
+                        _scsih_set_level(sdev, raid_device->volume_type);
                 return 0;
         }
 
         /* non-raid handling */
-        spin_lock_irqsave(&ioc->sas_device_lock, flags);
-        sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
-           sas_device_priv_data->sas_target->sas_address);
-        spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
-        if (sas_device) {
-                if (sas_target_priv_data->flags &
-                    MPT_TARGET_FLAGS_RAID_COMPONENT) {
-                        if (mpt2sas_config_get_volume_handle(ioc,
-                            sas_device->handle, &sas_device->volume_handle)) {
-                                dfailprintk(ioc, printk(MPT2SAS_WARN_FMT
-                                    "failure at %s:%d/%s()!\n", ioc->name,
-                                    __FILE__, __LINE__, __func__));
-                                return 1;
-                        }
-                        if (sas_device->volume_handle &&
-                            mpt2sas_config_get_volume_wwid(ioc,
-                            sas_device->volume_handle,
-                            &sas_device->volume_wwid)) {
-                                dfailprintk(ioc, printk(MPT2SAS_WARN_FMT
-                                    "failure at %s:%d/%s()!\n", ioc->name,
-                                    __FILE__, __LINE__, __func__));
-                                return 1;
-                        }
+        if (sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT) {
+                if (mpt2sas_config_get_volume_handle(ioc, handle,
+                    &volume_handle)) {
+                        dfailprintk(ioc, printk(MPT2SAS_WARN_FMT
+                            "failure at %s:%d/%s()!\n", ioc->name,
+                            __FILE__, __LINE__, __func__));
+                        return 1;
                 }
-                if (sas_device->device_info & MPI2_SAS_DEVICE_INFO_SSP_TARGET) {
-                        qdepth = MPT2SAS_SAS_QUEUE_DEPTH;
-                        ssp_target = 1;
-                        ds = "SSP";
-                } else {
-                        qdepth = MPT2SAS_SATA_QUEUE_DEPTH;
-                        if (sas_device->device_info &
-                            MPI2_SAS_DEVICE_INFO_STP_TARGET)
-                                ds = "STP";
-                        else if (sas_device->device_info &
-                            MPI2_SAS_DEVICE_INFO_SATA_DEVICE)
-                                ds = "SATA";
+                if (volume_handle && mpt2sas_config_get_volume_wwid(ioc,
+                    volume_handle, &volume_wwid)) {
+                        dfailprintk(ioc, printk(MPT2SAS_WARN_FMT
+                            "failure at %s:%d/%s()!\n", ioc->name,
+                            __FILE__, __LINE__, __func__));
+                        return 1;
                 }
+        }
 
-                sdev_printk(KERN_INFO, sdev, "%s: handle(0x%04x), "
-                    "sas_addr(0x%016llx), phy(%d), device_name(0x%016llx)\n",
-                    ds, sas_device->handle,
-                    (unsigned long long)sas_device->sas_address,
-                    sas_device->phy,
-                    (unsigned long long)sas_device->device_name);
-                sdev_printk(KERN_INFO, sdev, "%s: "
-                    "enclosure_logical_id(0x%016llx), slot(%d)\n", ds,
-                    (unsigned long long) sas_device->enclosure_logical_id,
-                    sas_device->slot);
-
-                if (!ssp_target)
-                        _scsih_display_sata_capabilities(ioc, sas_device, sdev);
-        } else {
+        spin_lock_irqsave(&ioc->sas_device_lock, flags);
+        sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
+           sas_device_priv_data->sas_target->sas_address);
+        if (!sas_device) {
+                spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
                 dfailprintk(ioc, printk(MPT2SAS_WARN_FMT
-                    "failure at %s:%d/%s()!\n", ioc->name, __FILE__, __LINE__,
-                    __func__));
+                        "failure at %s:%d/%s()!\n", ioc->name, __FILE__,
+                        __LINE__, __func__));
                 return 1;
         }
+        sas_device->volume_handle = volume_handle;
+        sas_device->volume_wwid = volume_wwid;
+        if (sas_device->device_info & MPI2_SAS_DEVICE_INFO_SSP_TARGET) {
+                qdepth = MPT2SAS_SAS_QUEUE_DEPTH;
+                ssp_target = 1;
+                ds = "SSP";
+        } else {
+                qdepth = MPT2SAS_SATA_QUEUE_DEPTH;
+                if (sas_device->device_info & MPI2_SAS_DEVICE_INFO_STP_TARGET)
+                        ds = "STP";
+                else if (sas_device->device_info &
+                    MPI2_SAS_DEVICE_INFO_SATA_DEVICE)
+                        ds = "SATA";
+        }
+        sdev_printk(KERN_INFO, sdev, "%s: handle(0x%04x), "
+            "sas_addr(0x%016llx), phy(%d), device_name(0x%016llx)\n",
+            ds, sas_device->handle,
+            (unsigned long long)sas_device->sas_address,
+            sas_device->phy,
+            (unsigned long long)sas_device->device_name);
+        sdev_printk(KERN_INFO, sdev, "%s: "
+            "enclosure_logical_id(0x%016llx), slot(%d)\n", ds,
+            (unsigned long long) sas_device->enclosure_logical_id,
+            sas_device->slot);
+
+        spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
+        if (!ssp_target)
+                _scsih_display_sata_capabilities(ioc, handle, sdev);
+
 
         _scsih_change_queue_depth(sdev, qdepth, SCSI_QDEPTH_DEFAULT);
 
@@ -2899,7 +2915,7 @@ _scsih_ublock_io_all_device(struct MPT2SAS_ADAPTER *ioc)
  * During device pull we need to appropiately set the sdev state.
  */
 static void
-_scsih_ublock_io_device(struct MPT2SAS_ADAPTER *ioc, u16 handle)
+_scsih_ublock_io_device(struct MPT2SAS_ADAPTER *ioc, u64 sas_address)
 {
         struct MPT2SAS_DEVICE *sas_device_priv_data;
         struct scsi_device *sdev;
@@ -2910,10 +2926,12 @@ _scsih_ublock_io_device(struct MPT2SAS_ADAPTER *ioc, u16 handle)
                         continue;
                 if (!sas_device_priv_data->block)
                         continue;
-                if (sas_device_priv_data->sas_target->handle == handle) {
+                if (sas_device_priv_data->sas_target->sas_address ==
+                                                                sas_address) {
                         dewtprintk(ioc, sdev_printk(KERN_INFO, sdev,
                             MPT2SAS_INFO_FMT "SDEV_RUNNING: "
-                            "handle(0x%04x)\n", ioc->name, handle));
+                            "sas address(0x%016llx)\n", ioc->name,
+                                (unsigned long long)sas_address));
                         sas_device_priv_data->block = 0;
                         scsi_internal_device_unblock(sdev);
                 }
@@ -3006,10 +3024,10 @@ _scsih_block_io_to_children_attached_to_ex(struct MPT2SAS_ADAPTER *ioc,
                         sas_device =
                             mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
                            mpt2sas_port->remote_identify.sas_address);
+                        if (sas_device)
+                                set_bit(sas_device->handle,
+                                    ioc->blocking_handles);
                         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
-                        if (!sas_device)
-                                continue;
-                        _scsih_block_io_device(ioc, sas_device->handle);
                 }
         }
 
@@ -3020,12 +3038,9 @@ _scsih_block_io_to_children_attached_to_ex(struct MPT2SAS_ADAPTER *ioc,
                     SAS_EDGE_EXPANDER_DEVICE ||
                     mpt2sas_port->remote_identify.device_type ==
                     SAS_FANOUT_EXPANDER_DEVICE) {
-
-                        spin_lock_irqsave(&ioc->sas_node_lock, flags);
                         expander_sibling =
                             mpt2sas_scsih_expander_find_by_sas_address(
                             ioc, mpt2sas_port->remote_identify.sas_address);
-                        spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
                         _scsih_block_io_to_children_attached_to_ex(ioc,
                             expander_sibling);
                 }
@@ -3124,7 +3139,7 @@ _scsih_tm_tr_send(struct MPT2SAS_ADAPTER *ioc, u16 handle)
                 dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "setting delete flag: "
                 "handle(0x%04x), sas_addr(0x%016llx)\n", ioc->name, handle,
                         (unsigned long long)sas_address));
-                _scsih_ublock_io_device(ioc, handle);
+                _scsih_ublock_io_device(ioc, sas_address);
                 sas_target_priv_data->handle = MPT2SAS_INVALID_DEVICE_HANDLE;
         }
 
@@ -3174,16 +3189,19 @@ static u8
 _scsih_sas_control_complete(struct MPT2SAS_ADAPTER *ioc, u16 smid,
     u8 msix_index, u32 reply)
 {
-#ifdef CONFIG_SCSI_MPT2SAS_LOGGING
         Mpi2SasIoUnitControlReply_t *mpi_reply =
             mpt2sas_base_get_reply_virt_addr(ioc, reply);
-#endif
-        dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
-            "sc_complete:handle(0x%04x), (open) "
-            "smid(%d), ioc_status(0x%04x), loginfo(0x%08x)\n",
-            ioc->name, le16_to_cpu(mpi_reply->DevHandle), smid,
-            le16_to_cpu(mpi_reply->IOCStatus),
-            le32_to_cpu(mpi_reply->IOCLogInfo)));
+        if (likely(mpi_reply)) {
+                dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
+                "sc_complete:handle(0x%04x), (open) "
+                "smid(%d), ioc_status(0x%04x), loginfo(0x%08x)\n",
+                ioc->name, le16_to_cpu(mpi_reply->DevHandle), smid,
+                le16_to_cpu(mpi_reply->IOCStatus),
+                le32_to_cpu(mpi_reply->IOCLogInfo)));
+        } else {
+                printk(MPT2SAS_ERR_FMT "mpi_reply not valid at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+        }
         return 1;
 }
 
@@ -3262,7 +3280,11 @@ _scsih_tm_volume_tr_complete(struct MPT2SAS_ADAPTER *ioc, u16 smid,
                    "progress!\n", __func__, ioc->name));
                 return 1;
         }
-
+        if (unlikely(!mpi_reply)) {
+                printk(MPT2SAS_ERR_FMT "mpi_reply not valid at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+                return 1;
+        }
         mpi_request_tm = mpt2sas_base_get_msg_frame(ioc, smid);
         handle = le16_to_cpu(mpi_request_tm->DevHandle);
         if (handle != le16_to_cpu(mpi_reply->DevHandle)) {
@@ -3325,7 +3347,11 @@ _scsih_tm_tr_complete(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index,
                     "operational\n", __func__, ioc->name));
                 return 1;
         }
-
+        if (unlikely(!mpi_reply)) {
+                printk(MPT2SAS_ERR_FMT "mpi_reply not valid at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+                return 1;
+        }
         mpi_request_tm = mpt2sas_base_get_msg_frame(ioc, smid);
         handle = le16_to_cpu(mpi_request_tm->DevHandle);
         if (handle != le16_to_cpu(mpi_reply->DevHandle)) {
@@ -3441,14 +3467,20 @@ _scsih_check_topo_delete_events(struct MPT2SAS_ADAPTER *ioc,
                 _scsih_block_io_to_children_attached_directly(ioc, event_data);
                 return;
         }
-
-        if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_DELAY_NOT_RESPONDING
-         || event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING) {
+        if (event_data->ExpStatus ==
+            MPI2_EVENT_SAS_TOPO_ES_DELAY_NOT_RESPONDING) {
+                /* put expander attached devices into blocking state */
                 spin_lock_irqsave(&ioc->sas_node_lock, flags);
                 sas_expander = mpt2sas_scsih_expander_find_by_handle(ioc,
                     expander_handle);
-                spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
                 _scsih_block_io_to_children_attached_to_ex(ioc, sas_expander);
+                spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
+                do {
+                        handle = find_first_bit(ioc->blocking_handles,
+                            ioc->facts.MaxDevHandle);
+                        if (handle < ioc->facts.MaxDevHandle)
+                                _scsih_block_io_device(ioc, handle);
+                } while (test_and_clear_bit(handle, ioc->blocking_handles));
         } else if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_RESPONDING)
                 _scsih_block_io_to_children_attached_directly(ioc, event_data);
 
@@ -4446,8 +4478,8 @@ _scsih_io_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
             != MPI2_IOCSTATUS_SCSI_TASK_TERMINATED)) {
                 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags);
                 ioc->scsi_lookup[smid - 1].scmd = scmd;
-                spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
                 _scsih_scsi_direct_io_set(ioc, smid, 0);
+                spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags);
                 memcpy(mpi_request->CDB.CDB32, scmd->cmnd, scmd->cmd_len);
                 mpi_request->DevHandle =
                     cpu_to_le16(sas_device_priv_data->sas_target->handle);
@@ -5020,13 +5052,11 @@ mpt2sas_expander_remove(struct MPT2SAS_ADAPTER *ioc, u64 sas_address)
         spin_lock_irqsave(&ioc->sas_node_lock, flags);
         sas_expander = mpt2sas_scsih_expander_find_by_sas_address(ioc,
             sas_address);
-        if (!sas_expander) {
-                spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
-                return;
-        }
-        list_del(&sas_expander->list);
+        if (sas_expander)
+                list_del(&sas_expander->list);
         spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
-        _scsih_expander_node_remove(ioc, sas_expander);
+        if (sas_expander)
+                _scsih_expander_node_remove(ioc, sas_expander);
 }
 
 /**
@@ -5106,6 +5136,7 @@ _scsih_check_device(struct MPT2SAS_ADAPTER *ioc, u16 handle)
         struct MPT2SAS_TARGET *sas_target_priv_data;
         u32 device_info;
 
+
         if ((mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0,
             MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle)))
                 return;
@@ -5139,21 +5170,24 @@ _scsih_check_device(struct MPT2SAS_ADAPTER *ioc, u16 handle)
                 sas_target_priv_data->handle = handle;
                 sas_device->handle = handle;
         }
-        spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 
         /* check if device is present */
         if (!(le16_to_cpu(sas_device_pg0.Flags) &
             MPI2_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)) {
                 printk(MPT2SAS_ERR_FMT "device is not present "
                     "handle(0x%04x), flags!!!\n", ioc->name, handle);
+                spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
                 return;
         }
 
         /* check if there were any issues with discovery */
         if (_scsih_check_access_status(ioc, sas_address, handle,
-            sas_device_pg0.AccessStatus))
+            sas_device_pg0.AccessStatus)) {
+                spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
                 return;
-        _scsih_ublock_io_device(ioc, handle);
+        }
+        spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
+        _scsih_ublock_io_device(ioc, sas_address);
 
 }
 
@@ -5280,54 +5314,71 @@ static void
 _scsih_remove_device(struct MPT2SAS_ADAPTER *ioc,
     struct _sas_device *sas_device)
 {
-        struct _sas_device sas_device_backup;
         struct MPT2SAS_TARGET *sas_target_priv_data;
 
-        if (!sas_device)
-                return;
-
-        memcpy(&sas_device_backup, sas_device, sizeof(struct _sas_device));
-        _scsih_sas_device_remove(ioc, sas_device);
-
         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: enter: "
             "handle(0x%04x), sas_addr(0x%016llx)\n", ioc->name, __func__,
-            sas_device_backup.handle, (unsigned long long)
-            sas_device_backup.sas_address));
+                sas_device->handle, (unsigned long long)
+            sas_device->sas_address));
 
-        if (sas_device_backup.starget && sas_device_backup.starget->hostdata) {
-                sas_target_priv_data = sas_device_backup.starget->hostdata;
+        if (sas_device->starget && sas_device->starget->hostdata) {
+                sas_target_priv_data = sas_device->starget->hostdata;
                 sas_target_priv_data->deleted = 1;
-                _scsih_ublock_io_device(ioc, sas_device_backup.handle);
+                _scsih_ublock_io_device(ioc, sas_device->sas_address);
                 sas_target_priv_data->handle =
                      MPT2SAS_INVALID_DEVICE_HANDLE;
         }
 
-        _scsih_ublock_io_device(ioc, sas_device_backup.handle);
-
         if (!ioc->hide_drives)
                 mpt2sas_transport_port_remove(ioc,
-                    sas_device_backup.sas_address,
-                    sas_device_backup.sas_address_parent);
+                    sas_device->sas_address,
+                    sas_device->sas_address_parent);
 
         printk(MPT2SAS_INFO_FMT "removing handle(0x%04x), sas_addr"
-            "(0x%016llx)\n", ioc->name, sas_device_backup.handle,
-            (unsigned long long) sas_device_backup.sas_address);
+            "(0x%016llx)\n", ioc->name, sas_device->handle,
+            (unsigned long long) sas_device->sas_address);
 
         dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "%s: exit: "
             "handle(0x%04x), sas_addr(0x%016llx)\n", ioc->name, __func__,
-            sas_device_backup.handle, (unsigned long long)
-            sas_device_backup.sas_address));
+            sas_device->handle, (unsigned long long)
+            sas_device->sas_address));
+        kfree(sas_device);
+}
+/**
+ * _scsih_device_remove_by_handle - removing device object by handle
+ * @ioc: per adapter object
+ * @handle: device handle
+ *
+ * Return nothing.
+ */
+static void
+_scsih_device_remove_by_handle(struct MPT2SAS_ADAPTER *ioc, u16 handle)
+{
+        struct _sas_device *sas_device;
+        unsigned long flags;
+
+        if (ioc->shost_recovery)
+                return;
+
+        spin_lock_irqsave(&ioc->sas_device_lock, flags);
+        sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
+        if (sas_device)
+                list_del(&sas_device->list);
+        spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
+        if (sas_device)
+                _scsih_remove_device(ioc, sas_device);
 }
 
 /**
- * mpt2sas_device_remove - removing device object
+ * mpt2sas_device_remove_by_sas_address - removing device object by sas address
  * @ioc: per adapter object
- * @sas_address: expander sas_address
+ * @sas_address: device sas_address
  *
  * Return nothing.
  */
 void
-mpt2sas_device_remove(struct MPT2SAS_ADAPTER *ioc, u64 sas_address)
+mpt2sas_device_remove_by_sas_address(struct MPT2SAS_ADAPTER *ioc,
+        u64 sas_address)
 {
         struct _sas_device *sas_device;
         unsigned long flags;
@@ -5338,14 +5389,12 @@ mpt2sas_device_remove(struct MPT2SAS_ADAPTER *ioc, u64 sas_address)
         spin_lock_irqsave(&ioc->sas_device_lock, flags);
         sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
             sas_address);
-        if (!sas_device) {
-                spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
-                return;
-        }
+        if (sas_device)
+                list_del(&sas_device->list);
         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
-        _scsih_remove_device(ioc, sas_device);
+        if (sas_device)
+                _scsih_remove_device(ioc, sas_device);
 }
-
 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
 /**
  * _scsih_sas_topology_change_event_debug - debug for topology event
@@ -5442,7 +5491,6 @@ _scsih_sas_topology_change_event(struct MPT2SAS_ADAPTER *ioc,
         u16 reason_code;
         u8 phy_number, max_phys;
         struct _sas_node *sas_expander;
-        struct _sas_device *sas_device;
         u64 sas_address;
         unsigned long flags;
         u8 link_rate, prev_link_rate;
@@ -5477,15 +5525,17 @@ _scsih_sas_topology_change_event(struct MPT2SAS_ADAPTER *ioc,
         spin_lock_irqsave(&ioc->sas_node_lock, flags);
         sas_expander = mpt2sas_scsih_expander_find_by_handle(ioc,
             parent_handle);
-        spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
         if (sas_expander) {
                 sas_address = sas_expander->sas_address;
                 max_phys = sas_expander->num_phys;
         } else if (parent_handle < ioc->sas_hba.num_phys) {
                 sas_address = ioc->sas_hba.sas_address;
                 max_phys = ioc->sas_hba.num_phys;
-        } else
+        } else {
+        spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
                 return;
+        }
+        spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
 
         /* handle siblings events */
         for (i = 0; i < event_data->NumEntries; i++) {
@@ -5540,16 +5590,7 @@ _scsih_sas_topology_change_event(struct MPT2SAS_ADAPTER *ioc,
                         break;
                 case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING:
 
-                        spin_lock_irqsave(&ioc->sas_device_lock, flags);
-                        sas_device = _scsih_sas_device_find_by_handle(ioc,
-                            handle);
-                        if (!sas_device) {
-                                spin_unlock_irqrestore(&ioc->sas_device_lock,
-                                    flags);
-                                break;
-                        }
-                        spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
-                        _scsih_remove_device(ioc, sas_device);
+                        _scsih_device_remove_by_handle(ioc, handle);
                         break;
                 }
         }
@@ -5672,20 +5713,24 @@ _scsih_sas_device_status_change_event(struct MPT2SAS_ADAPTER *ioc,
         sas_address = le64_to_cpu(event_data->SASAddress);
         sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
             sas_address);
-        spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 
-        if (!sas_device || !sas_device->starget)
+        if (!sas_device || !sas_device->starget) {
+                spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
                 return;
+        }
 
         target_priv_data = sas_device->starget->hostdata;
-        if (!target_priv_data)
+        if (!target_priv_data) {
+                spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
                 return;
+        }
 
         if (event_data->ReasonCode ==
             MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET)
                 target_priv_data->tm_busy = 1;
         else
                 target_priv_data->tm_busy = 0;
+        spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 }
 
 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
@@ -5950,30 +5995,6 @@ _scsih_reprobe_lun(struct scsi_device *sdev, void *no_uld_attach)
 }
 
 /**
- * _scsih_reprobe_target - reprobing target
- * @starget: scsi target struct
- * @no_uld_attach: sdev->no_uld_attach flag setting
- *
- * Note: no_uld_attach flag determines whether the disk device is attached
- * to block layer. A value of `1` means to not attach.
- **/
-static void
-_scsih_reprobe_target(struct scsi_target *starget, int no_uld_attach)
-{
-        struct MPT2SAS_TARGET *sas_target_priv_data;
-
-        if (starget == NULL)
-                return;
-        sas_target_priv_data = starget->hostdata;
-        if (no_uld_attach)
-                sas_target_priv_data->flags |= MPT_TARGET_FLAGS_RAID_COMPONENT;
-        else
-                sas_target_priv_data->flags &= ~MPT_TARGET_FLAGS_RAID_COMPONENT;
-
-        starget_for_each_device(starget, no_uld_attach ? (void *)1 : NULL,
-            _scsih_reprobe_lun);
-}
-/**
  * _scsih_sas_volume_add - add new volume
  * @ioc: per adapter object
  * @element: IR config element data
@@ -6024,8 +6045,11 @@ _scsih_sas_volume_add(struct MPT2SAS_ADAPTER *ioc,
                     raid_device->id, 0);
                 if (rc)
                         _scsih_raid_device_remove(ioc, raid_device);
-        } else
+        } else {
+                spin_lock_irqsave(&ioc->raid_device_lock, flags);
                 _scsih_determine_boot_device(ioc, raid_device, 1);
+                spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
+        }
 }
 
 /**
@@ -6042,21 +6066,25 @@ _scsih_sas_volume_delete(struct MPT2SAS_ADAPTER *ioc, u16 handle)
         struct _raid_device *raid_device;
         unsigned long flags;
         struct MPT2SAS_TARGET *sas_target_priv_data;
+        struct scsi_target *starget = NULL;
 
         spin_lock_irqsave(&ioc->raid_device_lock, flags);
         raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
-        spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
-        if (!raid_device)
-                return;
-        if (raid_device->starget) {
-                sas_target_priv_data = raid_device->starget->hostdata;
-                sas_target_priv_data->deleted = 1;
-                scsi_remove_target(&raid_device->starget->dev);
+        if (raid_device) {
+                if (raid_device->starget) {
+                        starget = raid_device->starget;
+                        sas_target_priv_data = starget->hostdata;
+                        sas_target_priv_data->deleted = 1;
+                }
+                printk(MPT2SAS_INFO_FMT "removing handle(0x%04x), wwid"
+                    "(0x%016llx)\n", ioc->name,  raid_device->handle,
+                    (unsigned long long) raid_device->wwid);
+                list_del(&raid_device->list);
+                kfree(raid_device);
         }
-        printk(MPT2SAS_INFO_FMT "removing handle(0x%04x), wwid"
-            "(0x%016llx)\n", ioc->name,  raid_device->handle,
-            (unsigned long long) raid_device->wwid);
-        _scsih_raid_device_remove(ioc, raid_device);
+        spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
+        if (starget)
+                scsi_remove_target(&starget->dev);
 }
 
 /**
@@ -6072,20 +6100,31 @@ _scsih_sas_pd_expose(struct MPT2SAS_ADAPTER *ioc,
     Mpi2EventIrConfigElement_t *element)
 {
         struct _sas_device *sas_device;
+        struct scsi_target *starget = NULL;
+        struct MPT2SAS_TARGET *sas_target_priv_data;
         unsigned long flags;
         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
 
         spin_lock_irqsave(&ioc->sas_device_lock, flags);
         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
+        if (sas_device) {
+                sas_device->volume_handle = 0;
+                sas_device->volume_wwid = 0;
+                clear_bit(handle, ioc->pd_handles);
+                if (sas_device->starget && sas_device->starget->hostdata) {
+                        starget = sas_device->starget;
+                        sas_target_priv_data = starget->hostdata;
+                        sas_target_priv_data->flags &=
+                            ~MPT_TARGET_FLAGS_RAID_COMPONENT;
+                }
+        }
         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
         if (!sas_device)
                 return;
 
         /* exposing raid component */
-        sas_device->volume_handle = 0;
-        sas_device->volume_wwid = 0;
-        clear_bit(handle, ioc->pd_handles);
-        _scsih_reprobe_target(sas_device->starget, 0);
+        if (starget)
+                starget_for_each_device(starget, NULL, _scsih_reprobe_lun);
 }
 
 /**
@@ -6101,23 +6140,38 @@ _scsih_sas_pd_hide(struct MPT2SAS_ADAPTER *ioc,
     Mpi2EventIrConfigElement_t *element)
 {
         struct _sas_device *sas_device;
+        struct scsi_target *starget = NULL;
+        struct MPT2SAS_TARGET *sas_target_priv_data;
         unsigned long flags;
         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
+        u16 volume_handle = 0;
+        u64 volume_wwid = 0;
+
+        mpt2sas_config_get_volume_handle(ioc, handle, &volume_handle);
+        if (volume_handle)
+                mpt2sas_config_get_volume_wwid(ioc, volume_handle,
+                    &volume_wwid);
 
         spin_lock_irqsave(&ioc->sas_device_lock, flags);
         sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
+        if (sas_device) {
+                set_bit(handle, ioc->pd_handles);
+                if (sas_device->starget && sas_device->starget->hostdata) {
+                        starget = sas_device->starget;
+                        sas_target_priv_data = starget->hostdata;
+                        sas_target_priv_data->flags |=
+                            MPT_TARGET_FLAGS_RAID_COMPONENT;
+                        sas_device->volume_handle = volume_handle;
+                        sas_device->volume_wwid = volume_wwid;
+                }
+        }
         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
         if (!sas_device)
                 return;
 
         /* hiding raid component */
-        mpt2sas_config_get_volume_handle(ioc, handle,
-            &sas_device->volume_handle);
-        mpt2sas_config_get_volume_wwid(ioc, sas_device->volume_handle,
-            &sas_device->volume_wwid);
-        set_bit(handle, ioc->pd_handles);
-        _scsih_reprobe_target(sas_device->starget, 1);
-
+        if (starget)
+                starget_for_each_device(starget, (void *)1, _scsih_reprobe_lun);
 }
 
 /**
@@ -6132,16 +6186,9 @@ static void
 _scsih_sas_pd_delete(struct MPT2SAS_ADAPTER *ioc,
     Mpi2EventIrConfigElement_t *element)
 {
-        struct _sas_device *sas_device;
-        unsigned long flags;
         u16 handle = le16_to_cpu(element->PhysDiskDevHandle);
 
-        spin_lock_irqsave(&ioc->sas_device_lock, flags);
-        sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
-        spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
-        if (!sas_device)
-                return;
-        _scsih_remove_device(ioc, sas_device);
+        _scsih_device_remove_by_handle(ioc, handle);
 }
 
 /**
@@ -6583,18 +6630,13 @@ _scsih_sas_ir_operation_status_event(struct MPT2SAS_ADAPTER *ioc,
         /* code added for raid transport support */
         if (event_data->RAIDOperation == MPI2_EVENT_IR_RAIDOP_RESYNC) {
 
-                handle = le16_to_cpu(event_data->VolDevHandle);
-
                 spin_lock_irqsave(&ioc->raid_device_lock, flags);
+                handle = le16_to_cpu(event_data->VolDevHandle);
                 raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
-                spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
-
-                if (!raid_device)
-                        return;
-
-                if (event_data->RAIDOperation == MPI2_EVENT_IR_RAIDOP_RESYNC)
+                if (raid_device)
                         raid_device->percent_complete =
                             event_data->PercentComplete;
+                spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
         }
 }
 
@@ -6761,13 +6803,18 @@ _scsih_mark_responding_raid_device(struct MPT2SAS_ADAPTER *ioc, u64 wwid,
                          * required data for Direct IO
                          */
                         _scsih_init_warpdrive_properties(ioc, raid_device);
-                        if (raid_device->handle == handle)
+                        spin_lock_irqsave(&ioc->raid_device_lock, flags);
+                        if (raid_device->handle == handle) {
+                                spin_unlock_irqrestore(&ioc->raid_device_lock,
+                                    flags);
                                 return;
+                        }
                         printk(KERN_INFO "\thandle changed from(0x%04x)!!!\n",
                             raid_device->handle);
                         raid_device->handle = handle;
                         if (sas_target_priv_data)
                                 sas_target_priv_data->handle = handle;
+                        spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
                         return;
                 }
         }
@@ -6939,58 +6986,56 @@ static void
 _scsih_remove_unresponding_sas_devices(struct MPT2SAS_ADAPTER *ioc)
 {
         struct _sas_device *sas_device, *sas_device_next;
-        struct _sas_node *sas_expander;
+        struct _sas_node *sas_expander, *sas_expander_next;
         struct _raid_device *raid_device, *raid_device_next;
+        struct list_head tmp_list;
+        unsigned long flags;
 
         printk(MPT2SAS_INFO_FMT "removing unresponding devices: start\n",
             ioc->name);
 
+        /* removing unresponding end devices */
+        printk(MPT2SAS_INFO_FMT "removing unresponding devices: end-devices\n",
+            ioc->name);
         list_for_each_entry_safe(sas_device, sas_device_next,
             &ioc->sas_device_list, list) {
-                if (sas_device->responding) {
+                if (!sas_device->responding)
+                        mpt2sas_device_remove_by_sas_address(ioc,
+                                sas_device->sas_address);
+                else
                         sas_device->responding = 0;
-                        continue;
-                }
-                if (sas_device->starget)
-                        starget_printk(KERN_INFO, sas_device->starget,
-                            "removing: handle(0x%04x), sas_addr(0x%016llx), "
-                            "enclosure logical id(0x%016llx), slot(%d)\n",
-                            sas_device->handle,
-                            (unsigned long long)sas_device->sas_address,
-                            (unsigned long long)
-                            sas_device->enclosure_logical_id,
-                            sas_device->slot);
-                _scsih_remove_device(ioc, sas_device);
         }
 
-        if (!ioc->ir_firmware)
-                goto retry_expander_search;
-
-        list_for_each_entry_safe(raid_device, raid_device_next,
-            &ioc->raid_device_list, list) {
-                if (raid_device->responding) {
-                        raid_device->responding = 0;
-                        continue;
-                }
-                if (raid_device->starget) {
-                        starget_printk(KERN_INFO, raid_device->starget,
-                            "removing: handle(0x%04x), wwid(0x%016llx)\n",
-                              raid_device->handle,
-                            (unsigned long long)raid_device->wwid);
-                        scsi_remove_target(&raid_device->starget->dev);
+        /* removing unresponding volumes */
+        if (ioc->ir_firmware) {
+                printk(MPT2SAS_INFO_FMT "removing unresponding devices: "
+                    "volumes\n", ioc->name);
+                list_for_each_entry_safe(raid_device, raid_device_next,
+                    &ioc->raid_device_list, list) {
+                        if (!raid_device->responding)
+                                _scsih_sas_volume_delete(ioc,
+                                    raid_device->handle);
+                        else
+                                raid_device->responding = 0;
                 }
-                _scsih_raid_device_remove(ioc, raid_device);
         }
-
- retry_expander_search:
-        sas_expander = NULL;
-        list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) {
-                if (sas_expander->responding) {
+        /* removing unresponding expanders */
+        printk(MPT2SAS_INFO_FMT "removing unresponding devices: expanders\n",
+            ioc->name);
+        spin_lock_irqsave(&ioc->sas_node_lock, flags);
+        INIT_LIST_HEAD(&tmp_list);
+        list_for_each_entry_safe(sas_expander, sas_expander_next,
+            &ioc->sas_expander_list, list) {
+                if (!sas_expander->responding)
+                        list_move_tail(&sas_expander->list, &tmp_list);
+                else
                         sas_expander->responding = 0;
-                        continue;
-                }
-                mpt2sas_expander_remove(ioc, sas_expander->sas_address);
-                goto retry_expander_search;
+        }
+        spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
+        list_for_each_entry_safe(sas_expander, sas_expander_next, &tmp_list,
+            list) {
+                list_del(&sas_expander->list);
+                _scsih_expander_node_remove(ioc, sas_expander);
         }
         printk(MPT2SAS_INFO_FMT "removing unresponding devices: complete\n",
             ioc->name);
@@ -7043,6 +7088,7 @@ _scsih_scan_for_devices_after_reset(struct MPT2SAS_ADAPTER *ioc)
         struct _sas_device *sas_device;
         struct _sas_node *expander_device;
         static struct _raid_device *raid_device;
+        unsigned long flags;
 
         printk(MPT2SAS_INFO_FMT "scan devices: start\n", ioc->name);
 
@@ -7057,8 +7103,10 @@ _scsih_scan_for_devices_after_reset(struct MPT2SAS_ADAPTER *ioc)
                 if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)
                         break;
                 handle = le16_to_cpu(expander_pg0.DevHandle);
+                spin_lock_irqsave(&ioc->sas_node_lock, flags);
                 expander_device = mpt2sas_scsih_expander_find_by_sas_address(
                     ioc, le64_to_cpu(expander_pg0.SASAddress));
+                spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
                 if (expander_device)
                         _scsih_refresh_expander_links(ioc, expander_device,
                             handle);
@@ -7080,7 +7128,9 @@ _scsih_scan_for_devices_after_reset(struct MPT2SAS_ADAPTER *ioc)
                         break;
                 phys_disk_num = pd_pg0.PhysDiskNum;
                 handle = le16_to_cpu(pd_pg0.DevHandle);
+                spin_lock_irqsave(&ioc->sas_device_lock, flags);
                 sas_device = _scsih_sas_device_find_by_handle(ioc, handle);
+                spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
                 if (sas_device)
                         continue;
                 if (mpt2sas_config_get_sas_device_pg0(ioc, &mpi_reply,
@@ -7107,8 +7157,10 @@ _scsih_scan_for_devices_after_reset(struct MPT2SAS_ADAPTER *ioc)
                 if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE)
                         break;
                 handle = le16_to_cpu(volume_pg1.DevHandle);
+                spin_lock_irqsave(&ioc->raid_device_lock, flags);
                 raid_device = _scsih_raid_device_find_by_wwid(ioc,
                     le64_to_cpu(volume_pg1.WWID));
+                spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
                 if (raid_device)
                         continue;
                 if (mpt2sas_config_get_raid_volume_pg0(ioc, &mpi_reply,
@@ -7140,8 +7192,10 @@ _scsih_scan_for_devices_after_reset(struct MPT2SAS_ADAPTER *ioc)
                 if (!(_scsih_is_end_device(
                     le32_to_cpu(sas_device_pg0.DeviceInfo))))
                         continue;
+                spin_lock_irqsave(&ioc->sas_device_lock, flags);
                 sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
                     le64_to_cpu(sas_device_pg0.SASAddress));
+                spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
                 if (sas_device)
                         continue;
                 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle);
@@ -7235,7 +7289,7 @@ _firmware_event_work(struct work_struct *work)
 
         switch (fw_event->event) {
         case MPT2SAS_REMOVE_UNRESPONDING_DEVICES:
-                while (scsi_host_in_recovery(ioc->shost))
+                while (scsi_host_in_recovery(ioc->shost) || ioc->shost_recovery)
                         ssleep(1);
                 _scsih_remove_unresponding_sas_devices(ioc);
                 _scsih_scan_for_devices_after_reset(ioc);
@@ -7313,6 +7367,13 @@ mpt2sas_scsih_event_callback(struct MPT2SAS_ADAPTER *ioc, u8 msix_index,
                 return 1;
 
         mpi_reply = mpt2sas_base_get_reply_virt_addr(ioc, reply);
+
+        if (unlikely(!mpi_reply)) {
+                printk(MPT2SAS_ERR_FMT "mpi_reply not valid at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+                return 1;
+        }
+
         event = le16_to_cpu(mpi_reply->Event);
 
         switch (event) {
@@ -7353,14 +7414,14 @@ mpt2sas_scsih_event_callback(struct MPT2SAS_ADAPTER *ioc, u8 msix_index,
         case MPI2_EVENT_LOG_ENTRY_ADDED:
         {
                 Mpi2EventDataLogEntryAdded_t *log_entry;
-                u32 *log_code;
+                __le32 *log_code;
 
                 if (!ioc->is_warpdrive)
                         break;
 
                 log_entry = (Mpi2EventDataLogEntryAdded_t *)
                     mpi_reply->EventData;
-                log_code = (u32 *)log_entry->LogData;
+                log_code = (__le32 *)log_entry->LogData;
 
                 if (le16_to_cpu(log_entry->LogEntryQualifier)
                     != MPT2_WARPDRIVE_LOGENTRY)
@@ -7487,7 +7548,7 @@ _scsih_expander_node_remove(struct MPT2SAS_ADAPTER *ioc,
                         return;
                 if (mpt2sas_port->remote_identify.device_type ==
                     SAS_END_DEVICE)
-                        mpt2sas_device_remove(ioc,
+                        mpt2sas_device_remove_by_sas_address(ioc,
                             mpt2sas_port->remote_identify.sas_address);
                 else if (mpt2sas_port->remote_identify.device_type ==
                     SAS_EDGE_EXPANDER_DEVICE ||
@@ -7661,7 +7722,7 @@ _scsih_remove(struct pci_dev *pdev)
            &ioc->sas_hba.sas_port_list, port_list) {
                 if (mpt2sas_port->remote_identify.device_type ==
                     SAS_END_DEVICE)
-                        mpt2sas_device_remove(ioc,
+                        mpt2sas_device_remove_by_sas_address(ioc,
                             mpt2sas_port->remote_identify.sas_address);
                 else if (mpt2sas_port->remote_identify.device_type ==
                     SAS_EDGE_EXPANDER_DEVICE ||
@@ -7733,11 +7794,11 @@ _scsih_probe_boot_devices(struct MPT2SAS_ADAPTER *ioc)
                 if (rc)
                         _scsih_raid_device_remove(ioc, raid_device);
         } else {
+                spin_lock_irqsave(&ioc->sas_device_lock, flags);
                 sas_device = device;
                 handle = sas_device->handle;
                 sas_address_parent = sas_device->sas_address_parent;
                 sas_address = sas_device->sas_address;
-                spin_lock_irqsave(&ioc->sas_device_lock, flags);
                 list_move_tail(&sas_device->list, &ioc->sas_device_list);
                 spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 
@@ -8061,8 +8122,8 @@ _scsih_probe(struct pci_dev *pdev, const struct pci_device_id *id)
  out_thread_fail:
         list_del(&ioc->list);
         scsi_remove_host(shost);
-        scsi_host_put(shost);
  out_add_shost_fail:
+        scsi_host_put(shost);
         return -ENODEV;
 }
 
diff --git a/drivers/scsi/mpt2sas/mpt2sas_transport.c b/drivers/scsi/mpt2sas/mpt2sas_transport.c
index 831047466a5a..c6cf20f60720 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_transport.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_transport.c
@@ -163,12 +163,15 @@ _transport_set_identify(struct MPT2SAS_ADAPTER *ioc, u16 handle,
                 return -EIO;
         }
 
-        memset(identify, 0, sizeof(*identify));
+        memset(identify, 0, sizeof(struct sas_identify));
         device_info = le32_to_cpu(sas_device_pg0.DeviceInfo);
 
         /* sas_address */
         identify->sas_address = le64_to_cpu(sas_device_pg0.SASAddress);
 
+        /* phy number of the parent device this device is linked to */
+        identify->phy_identifier = sas_device_pg0.PhyNum;
+
         /* device_type */
         switch (device_info & MPI2_SAS_DEVICE_INFO_MASK_DEVICE_TYPE) {
         case MPI2_SAS_DEVICE_INFO_NO_DEVICE:
@@ -484,7 +487,7 @@ _transport_delete_port(struct MPT2SAS_ADAPTER *ioc,
 
         ioc->logging_level |= MPT_DEBUG_TRANSPORT;
         if (device_type == SAS_END_DEVICE)
-                mpt2sas_device_remove(ioc, sas_address);
+                mpt2sas_device_remove_by_sas_address(ioc, sas_address);
         else if (device_type == SAS_EDGE_EXPANDER_DEVICE ||
             device_type == SAS_FANOUT_EXPANDER_DEVICE)
                 mpt2sas_expander_remove(ioc, sas_address);
@@ -792,9 +795,10 @@ mpt2sas_transport_port_remove(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
         spin_lock_irqsave(&ioc->sas_node_lock, flags);
         sas_node = _transport_sas_node_find_by_sas_address(ioc,
             sas_address_parent);
-        spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
-        if (!sas_node)
+        if (!sas_node) {
+                spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
                 return;
+        }
         list_for_each_entry_safe(mpt2sas_port, next, &sas_node->sas_port_list,
             port_list) {
                 if (mpt2sas_port->remote_identify.sas_address != sas_address)
@@ -804,8 +808,10 @@ mpt2sas_transport_port_remove(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
                 goto out;
         }
  out:
-        if (!found)
+        if (!found) {
+                spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
                 return;
+        }
 
         for (i = 0; i < sas_node->num_phys; i++) {
                 if (sas_node->phy[i].remote_identify.sas_address == sas_address)
@@ -813,6 +819,7 @@ mpt2sas_transport_port_remove(struct MPT2SAS_ADAPTER *ioc, u64 sas_address,
                             sizeof(struct sas_identify));
         }
 
+        spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
         list_for_each_entry_safe(mpt2sas_phy, next_phy,
             &mpt2sas_port->phy_list, port_siblings) {
                 if ((ioc->logging_level & MPT_DEBUG_TRANSPORT))
@@ -986,12 +993,14 @@ mpt2sas_transport_update_links(struct MPT2SAS_ADAPTER *ioc,
 
         spin_lock_irqsave(&ioc->sas_node_lock, flags);
         sas_node = _transport_sas_node_find_by_sas_address(ioc, sas_address);
-        spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
-        if (!sas_node)
+        if (!sas_node) {
+                spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
                 return;
+        }
 
         mpt2sas_phy = &sas_node->phy[phy_number];
         mpt2sas_phy->attached_handle = handle;
+        spin_unlock_irqrestore(&ioc->sas_node_lock, flags);
         if (handle && (link_rate >= MPI2_SAS_NEG_LINK_RATE_1_5)) {
                 _transport_set_identify(ioc, handle,
                     &mpt2sas_phy->remote_identify);
@@ -1310,17 +1319,20 @@ _transport_get_enclosure_identifier(struct sas_rphy *rphy, u64 *identifier)
         struct MPT2SAS_ADAPTER *ioc = rphy_to_ioc(rphy);
         struct _sas_device *sas_device;
         unsigned long flags;
+        int rc;
 
         spin_lock_irqsave(&ioc->sas_device_lock, flags);
         sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
             rphy->identify.sas_address);
+        if (sas_device) {
+                *identifier = sas_device->enclosure_logical_id;
+                rc = 0;
+        } else {
+                *identifier = 0;
+                rc = -ENXIO;
+        }
         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
-
-        if (!sas_device)
-                return -ENXIO;
-
-        *identifier = sas_device->enclosure_logical_id;
-        return 0;
+        return rc;
 }
 
 /**
@@ -1335,16 +1347,17 @@ _transport_get_bay_identifier(struct sas_rphy *rphy)
         struct MPT2SAS_ADAPTER *ioc = rphy_to_ioc(rphy);
         struct _sas_device *sas_device;
         unsigned long flags;
+        int rc;
 
         spin_lock_irqsave(&ioc->sas_device_lock, flags);
         sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
             rphy->identify.sas_address);
+        if (sas_device)
+                rc = sas_device->slot;
+        else
+                rc = -ENXIO;
         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
-
-        if (!sas_device)
-                return -ENXIO;
-
-        return sas_device->slot;
+        return rc;
 }
 
 /* phy control request structure */
@@ -1629,11 +1642,13 @@ _transport_phy_enable(struct sas_phy *phy, int enable)
 {
         struct MPT2SAS_ADAPTER *ioc = phy_to_ioc(phy);
         Mpi2SasIOUnitPage1_t *sas_iounit_pg1 = NULL;
+        Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL;
         Mpi2ConfigReply_t mpi_reply;
         u16 ioc_status;
         u16 sz;
         int rc = 0;
         unsigned long flags;
+        int i, discovery_active;
 
         spin_lock_irqsave(&ioc->sas_node_lock, flags);
         if (_transport_sas_node_find_by_sas_address(ioc,
@@ -1651,7 +1666,50 @@ _transport_phy_enable(struct sas_phy *phy, int enable)
 
         /* handle hba phys */
 
-        /* sas_iounit page 1 */
+        /* read sas_iounit page 0 */
+        sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys *
+            sizeof(Mpi2SasIOUnit0PhyData_t));
+        sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL);
+        if (!sas_iounit_pg0) {
+                printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+                rc = -ENOMEM;
+                goto out;
+        }
+        if ((mpt2sas_config_get_sas_iounit_pg0(ioc, &mpi_reply,
+            sas_iounit_pg0, sz))) {
+                printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+                rc = -ENXIO;
+                goto out;
+        }
+        ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
+            MPI2_IOCSTATUS_MASK;
+        if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
+                printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+                rc = -EIO;
+                goto out;
+        }
+
+        /* unable to enable/disable phys when when discovery is active */
+        for (i = 0, discovery_active = 0; i < ioc->sas_hba.num_phys ; i++) {
+                if (sas_iounit_pg0->PhyData[i].PortFlags &
+                    MPI2_SASIOUNIT0_PORTFLAGS_DISCOVERY_IN_PROGRESS) {
+                        printk(MPT2SAS_ERR_FMT "discovery is active on "
+                            "port = %d, phy = %d: unable to enable/disable "
+                            "phys, try again later!\n", ioc->name,
+                            sas_iounit_pg0->PhyData[i].Port, i);
+                        discovery_active = 1;
+                }
+        }
+
+        if (discovery_active) {
+                rc = -EAGAIN;
+                goto out;
+        }
+
+        /* read sas_iounit page 1 */
         sz = offsetof(Mpi2SasIOUnitPage1_t, PhyData) + (ioc->sas_hba.num_phys *
             sizeof(Mpi2SasIOUnit1PhyData_t));
         sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL);
@@ -1676,7 +1734,18 @@ _transport_phy_enable(struct sas_phy *phy, int enable)
                 rc = -EIO;
                 goto out;
         }
-
+        /* copy Port/PortFlags/PhyFlags from page 0 */
+        for (i = 0; i < ioc->sas_hba.num_phys ; i++) {
+                sas_iounit_pg1->PhyData[i].Port =
+                    sas_iounit_pg0->PhyData[i].Port;
+                sas_iounit_pg1->PhyData[i].PortFlags =
+                    (sas_iounit_pg0->PhyData[i].PortFlags &
+                    MPI2_SASIOUNIT0_PORTFLAGS_AUTO_PORT_CONFIG);
+                sas_iounit_pg1->PhyData[i].PhyFlags =
+                    (sas_iounit_pg0->PhyData[i].PhyFlags &
+                    (MPI2_SASIOUNIT0_PHYFLAGS_ZONING_ENABLED +
+                    MPI2_SASIOUNIT0_PHYFLAGS_PHY_DISABLED));
+        }
         if (enable)
                 sas_iounit_pg1->PhyData[phy->number].PhyFlags
                     &= ~MPI2_SASIOUNIT1_PHYFLAGS_PHY_DISABLE;
@@ -1692,6 +1761,7 @@ _transport_phy_enable(struct sas_phy *phy, int enable)
 
  out:
         kfree(sas_iounit_pg1);
+        kfree(sas_iounit_pg0);
         return rc;
 }
 
@@ -1828,7 +1898,7 @@ _transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
         struct MPT2SAS_ADAPTER *ioc = shost_priv(shost);
         Mpi2SmpPassthroughRequest_t *mpi_request;
         Mpi2SmpPassthroughReply_t *mpi_reply;
-        int rc;
+        int rc, i;
         u16 smid;
         u32 ioc_state;
         unsigned long timeleft;
@@ -1837,24 +1907,20 @@ _transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
         u8 issue_reset = 0;
         dma_addr_t dma_addr_in = 0;
         dma_addr_t dma_addr_out = 0;
+        dma_addr_t pci_dma_in = 0;
+        dma_addr_t pci_dma_out = 0;
+        void *pci_addr_in = NULL;
+        void *pci_addr_out = NULL;
         u16 wait_state_count;
         struct request *rsp = req->next_rq;
+        struct bio_vec *bvec = NULL;
 
         if (!rsp) {
                 printk(MPT2SAS_ERR_FMT "%s: the smp response space is "
                     "missing\n", ioc->name, __func__);
                 return -EINVAL;
         }
-
-        /* do we need to support multiple segments? */
-        if (req->bio->bi_vcnt > 1 || rsp->bio->bi_vcnt > 1) {
-                printk(MPT2SAS_ERR_FMT "%s: multiple segments req %u %u, "
-                    "rsp %u %u\n", ioc->name, __func__, req->bio->bi_vcnt,
-                    blk_rq_bytes(req), rsp->bio->bi_vcnt, blk_rq_bytes(rsp));
-                return -EINVAL;
-        }
-
-        if (ioc->shost_recovery) {
+        if (ioc->shost_recovery || ioc->pci_error_recovery) {
                 printk(MPT2SAS_INFO_FMT "%s: host reset in progress!\n",
                     __func__, ioc->name);
                 return -EFAULT;
@@ -1872,6 +1938,59 @@ _transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
         }
         ioc->transport_cmds.status = MPT2_CMD_PENDING;
 
+        /* Check if the request is split across multiple segments */
+        if (req->bio->bi_vcnt > 1) {
+                u32 offset = 0;
+
+                /* Allocate memory and copy the request */
+                pci_addr_out = pci_alloc_consistent(ioc->pdev,
+                    blk_rq_bytes(req), &pci_dma_out);
+                if (!pci_addr_out) {
+                        printk(MPT2SAS_INFO_FMT "%s(): PCI Addr out = NULL\n",
+                            ioc->name, __func__);
+                        rc = -ENOMEM;
+                        goto out;
+                }
+
+                bio_for_each_segment(bvec, req->bio, i) {
+                        memcpy(pci_addr_out + offset,
+                            page_address(bvec->bv_page) + bvec->bv_offset,
+                            bvec->bv_len);
+                        offset += bvec->bv_len;
+                }
+        } else {
+                dma_addr_out = pci_map_single(ioc->pdev, bio_data(req->bio),
+                    blk_rq_bytes(req), PCI_DMA_BIDIRECTIONAL);
+                if (!dma_addr_out) {
+                        printk(MPT2SAS_INFO_FMT "%s(): DMA Addr out = NULL\n",
+                            ioc->name, __func__);
+                        rc = -ENOMEM;
+                        goto free_pci;
+                }
+        }
+
+        /* Check if the response needs to be populated across
+         * multiple segments */
+        if (rsp->bio->bi_vcnt > 1) {
+                pci_addr_in = pci_alloc_consistent(ioc->pdev, blk_rq_bytes(rsp),
+                    &pci_dma_in);
+                if (!pci_addr_in) {
+                        printk(MPT2SAS_INFO_FMT "%s(): PCI Addr in = NULL\n",
+                            ioc->name, __func__);
+                        rc = -ENOMEM;
+                        goto unmap;
+                }
+        } else {
+                dma_addr_in =  pci_map_single(ioc->pdev, bio_data(rsp->bio),
+                    blk_rq_bytes(rsp), PCI_DMA_BIDIRECTIONAL);
+                if (!dma_addr_in) {
+                        printk(MPT2SAS_INFO_FMT "%s(): DMA Addr in = NULL\n",
+                            ioc->name, __func__);
+                        rc = -ENOMEM;
+                        goto unmap;
+                }
+        }
+
         wait_state_count = 0;
         ioc_state = mpt2sas_base_get_iocstate(ioc, 1);
         while (ioc_state != MPI2_IOC_STATE_OPERATIONAL) {
@@ -1880,7 +1999,7 @@ _transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
                             "%s: failed due to ioc not operational\n",
                             ioc->name, __func__);
                         rc = -EFAULT;
-                        goto out;
+                        goto unmap;
                 }
                 ssleep(1);
                 ioc_state = mpt2sas_base_get_iocstate(ioc, 1);
@@ -1897,7 +2016,7 @@ _transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
                 printk(MPT2SAS_ERR_FMT "%s: failed obtaining a smid\n",
                     ioc->name, __func__);
                 rc = -EAGAIN;
-                goto out;
+                goto unmap;
         }
 
         rc = 0;
@@ -1919,16 +2038,14 @@ _transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
         sgl_flags = (MPI2_SGE_FLAGS_SIMPLE_ELEMENT |
             MPI2_SGE_FLAGS_END_OF_BUFFER | MPI2_SGE_FLAGS_HOST_TO_IOC);
         sgl_flags = sgl_flags << MPI2_SGE_FLAGS_SHIFT;
-        dma_addr_out = pci_map_single(ioc->pdev, bio_data(req->bio),
-                blk_rq_bytes(req), PCI_DMA_BIDIRECTIONAL);
-        if (!dma_addr_out) {
-                mpt2sas_base_free_smid(ioc, smid);
-                goto unmap;
+        if (req->bio->bi_vcnt > 1) {
+                ioc->base_add_sg_single(psge, sgl_flags |
+                    (blk_rq_bytes(req) - 4), pci_dma_out);
+        } else {
+                ioc->base_add_sg_single(psge, sgl_flags |
+                    (blk_rq_bytes(req) - 4), dma_addr_out);
         }
 
-        ioc->base_add_sg_single(psge, sgl_flags | (blk_rq_bytes(req) - 4),
-            dma_addr_out);
-
         /* incr sgel */
         psge += ioc->sge_size;
 
@@ -1937,16 +2054,14 @@ _transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
             MPI2_SGE_FLAGS_LAST_ELEMENT | MPI2_SGE_FLAGS_END_OF_BUFFER |
             MPI2_SGE_FLAGS_END_OF_LIST);
         sgl_flags = sgl_flags << MPI2_SGE_FLAGS_SHIFT;
-        dma_addr_in = pci_map_single(ioc->pdev, bio_data(rsp->bio),
-                                     blk_rq_bytes(rsp), PCI_DMA_BIDIRECTIONAL);
-        if (!dma_addr_in) {
-                mpt2sas_base_free_smid(ioc, smid);
-                goto unmap;
+        if (rsp->bio->bi_vcnt > 1) {
+                ioc->base_add_sg_single(psge, sgl_flags |
+                    (blk_rq_bytes(rsp) + 4), pci_dma_in);
+        } else {
+                ioc->base_add_sg_single(psge, sgl_flags |
+                    (blk_rq_bytes(rsp) + 4), dma_addr_in);
         }
 
-        ioc->base_add_sg_single(psge, sgl_flags | (blk_rq_bytes(rsp) + 4),
-            dma_addr_in);
-
         dtransportprintk(ioc, printk(MPT2SAS_INFO_FMT "%s - "
             "sending smp request\n", ioc->name, __func__));
 
@@ -1982,6 +2097,27 @@ _transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
                 req->resid_len = 0;
                 rsp->resid_len -=
                     le16_to_cpu(mpi_reply->ResponseDataLength);
+                /* check if the resp needs to be copied from the allocated
+                 * pci mem */
+                if (rsp->bio->bi_vcnt > 1) {
+                        u32 offset = 0;
+                        u32 bytes_to_copy =
+                            le16_to_cpu(mpi_reply->ResponseDataLength);
+                        bio_for_each_segment(bvec, rsp->bio, i) {
+                                if (bytes_to_copy <= bvec->bv_len) {
+                                        memcpy(page_address(bvec->bv_page) +
+                                            bvec->bv_offset, pci_addr_in +
+                                            offset, bytes_to_copy);
+                                        break;
+                                } else {
+                                        memcpy(page_address(bvec->bv_page) +
+                                            bvec->bv_offset, pci_addr_in +
+                                            offset, bvec->bv_len);
+                                        bytes_to_copy -= bvec->bv_len;
+                                }
+                                offset += bvec->bv_len;
+                        }
+                }
         } else {
                 dtransportprintk(ioc, printk(MPT2SAS_INFO_FMT
                     "%s - no reply\n", ioc->name, __func__));
@@ -2003,6 +2139,15 @@ _transport_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy,
                 pci_unmap_single(ioc->pdev, dma_addr_in, blk_rq_bytes(rsp),
                     PCI_DMA_BIDIRECTIONAL);
 
+ free_pci:
+        if (pci_addr_out)
+                pci_free_consistent(ioc->pdev, blk_rq_bytes(req), pci_addr_out,
+                    pci_dma_out);
+
+        if (pci_addr_in)
+                pci_free_consistent(ioc->pdev, blk_rq_bytes(rsp), pci_addr_in,
+                    pci_dma_in);
+
  out:
         ioc->transport_cmds.status = MPT2_CMD_NOT_USED;
         mutex_unlock(&ioc->transport_cmds.mutex);
diff --git a/drivers/scsi/pm8001/pm8001_defs.h b/drivers/scsi/pm8001/pm8001_defs.h
index 944afada61ee..c3d20c8d4abe 100644
--- a/drivers/scsi/pm8001/pm8001_defs.h
+++ b/drivers/scsi/pm8001/pm8001_defs.h
@@ -66,9 +66,10 @@ enum port_type {
 
 /* driver compile-time configuration */
 #define PM8001_MAX_CCB           512    /* max ccbs supported */
+#define PM8001_MPI_QUEUE         1024   /* maximum mpi queue entries */
 #define PM8001_MAX_INB_NUM       1
 #define PM8001_MAX_OUTB_NUM      1
-#define PM8001_CAN_QUEUE         128    /* SCSI Queue depth */
+#define PM8001_CAN_QUEUE         508    /* SCSI Queue depth */
 
 /* unchangeable hardware details */
 #define PM8001_MAX_PHYS          8      /* max. possible phys */
diff --git a/drivers/scsi/pm8001/pm8001_hwi.c b/drivers/scsi/pm8001/pm8001_hwi.c
index 9d82ee5c10de..bf54aafc2d71 100644
--- a/drivers/scsi/pm8001/pm8001_hwi.c
+++ b/drivers/scsi/pm8001/pm8001_hwi.c
@@ -192,7 +192,7 @@ init_default_table_values(struct pm8001_hba_info *pm8001_ha)
         pm8001_ha->main_cfg_tbl.fatal_err_interrupt             = 0x01;
         for (i = 0; i < qn; i++) {
                 pm8001_ha->inbnd_q_tbl[i].element_pri_size_cnt  =
-                        0x00000100 | (0x00000040 << 16) | (0x00<<30);
+                        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->inbnd_q_tbl[i].lower_base_addr       =
@@ -218,7 +218,7 @@ init_default_table_values(struct pm8001_hba_info *pm8001_ha)
         }
         for (i = 0; i < qn; i++) {
                 pm8001_ha->outbnd_q_tbl[i].element_size_cnt     =
-                        256 | (64 << 16) | (1<<30);
+                        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->outbnd_q_tbl[i].lower_base_addr      =
@@ -1245,7 +1245,7 @@ static int mpi_msg_free_get(struct inbound_queue_table *circularQ,
         /* Stores the new consumer index */
         consumer_index = pm8001_read_32(circularQ->ci_virt);
         circularQ->consumer_index = cpu_to_le32(consumer_index);
-        if (((circularQ->producer_idx + bcCount) % 256) ==
+        if (((circularQ->producer_idx + bcCount) % PM8001_MPI_QUEUE) ==
                 le32_to_cpu(circularQ->consumer_index)) {
                 *messagePtr = NULL;
                 return -1;
@@ -1253,7 +1253,8 @@ static int mpi_msg_free_get(struct inbound_queue_table *circularQ,
         /* get memory IOMB buffer address */
         offset = circularQ->producer_idx * 64;
         /* increment to next bcCount element */
-        circularQ->producer_idx = (circularQ->producer_idx + bcCount) % 256;
+        circularQ->producer_idx = (circularQ->producer_idx + bcCount)
+                                % PM8001_MPI_QUEUE;
         /* Adds that distance to the base of the region virtual address plus
         the message header size*/
         msgHeader = (struct mpi_msg_hdr *)(circularQ->base_virt + offset);
@@ -1326,7 +1327,8 @@ static u32 mpi_msg_free_set(struct pm8001_hba_info *pm8001_ha, void *pMsg,
                 return 0;
         }
         /* free the circular queue buffer elements associated with the message*/
-        circularQ->consumer_idx = (circularQ->consumer_idx + bc) % 256;
+        circularQ->consumer_idx = (circularQ->consumer_idx + bc)
+                                % PM8001_MPI_QUEUE;
         /* update the CI of outbound queue */
         pm8001_cw32(pm8001_ha, circularQ->ci_pci_bar, circularQ->ci_offset,
                 circularQ->consumer_idx);
@@ -1383,7 +1385,8 @@ static u32 mpi_msg_consume(struct pm8001_hba_info *pm8001_ha,
                                         circularQ->consumer_idx =
                                                 (circularQ->consumer_idx +
                                                 ((le32_to_cpu(msgHeader_tmp)
-                                                >> 24) & 0x1f)) % 256;
+                                                 >> 24) & 0x1f))
+                                                        % PM8001_MPI_QUEUE;
                                         msgHeader_tmp = 0;
                                         pm8001_write_32(msgHeader, 0, 0);
                                         /* update the CI of outbound queue */
@@ -1396,7 +1399,7 @@ static u32 mpi_msg_consume(struct pm8001_hba_info *pm8001_ha,
                                 circularQ->consumer_idx =
                                         (circularQ->consumer_idx +
                                         ((le32_to_cpu(msgHeader_tmp) >> 24) &
-                                        0x1f)) % 256;
+                                        0x1f)) % PM8001_MPI_QUEUE;
                                 msgHeader_tmp = 0;
                                 pm8001_write_32(msgHeader, 0, 0);
                                 /* update the CI of outbound queue */
@@ -3357,7 +3360,7 @@ mpi_fw_flash_update_resp(struct pm8001_hba_info *pm8001_ha, void *piomb)
         struct fw_control_ex    fw_control_context;
         struct fw_flash_Update_resp *ppayload =
                 (struct fw_flash_Update_resp *)(piomb + 4);
-        u32 tag = ppayload->tag;
+        u32 tag = le32_to_cpu(ppayload->tag);
         struct pm8001_ccb_info *ccb = &pm8001_ha->ccb_info[tag];
         status = le32_to_cpu(ppayload->status);
         memcpy(&fw_control_context,
@@ -3703,8 +3706,8 @@ static int mpi_hw_event(struct pm8001_hba_info *pm8001_ha, void* piomb)
  */
 static void process_one_iomb(struct pm8001_hba_info *pm8001_ha, void *piomb)
 {
-        u32 pHeader = (u32)*(u32 *)piomb;
-        u8 opc = (u8)(pHeader & 0xFFF);
+        __le32 pHeader = *(__le32 *)piomb;
+        u8 opc = (u8)((le32_to_cpu(pHeader)) & 0xFFF);
 
         PM8001_MSG_DBG(pm8001_ha, pm8001_printk("process_one_iomb:"));
 
diff --git a/drivers/scsi/pm8001/pm8001_hwi.h b/drivers/scsi/pm8001/pm8001_hwi.h
index 1a4611eb0321..d437309cb1e1 100644
--- a/drivers/scsi/pm8001/pm8001_hwi.h
+++ b/drivers/scsi/pm8001/pm8001_hwi.h
@@ -599,7 +599,7 @@ struct fw_flash_Update_req {
  *
  */
 struct fw_flash_Update_resp {
-        dma_addr_t      tag;
+        __le32  tag;
         __le32  status;
         u32     reserved[13];
 } __attribute__((packed, aligned(4)));
diff --git a/drivers/scsi/pm8001/pm8001_init.c b/drivers/scsi/pm8001/pm8001_init.c
index 36efaa7c3a54..0267c22f8741 100644
--- a/drivers/scsi/pm8001/pm8001_init.c
+++ b/drivers/scsi/pm8001/pm8001_init.c
@@ -235,15 +235,15 @@ static int __devinit pm8001_alloc(struct pm8001_hba_info *pm8001_ha)
         pm8001_ha->memoryMap.region[PI].alignment = 4;
 
         /* MPI Memory region 5 inbound queues */
-        pm8001_ha->memoryMap.region[IB].num_elements = 256;
+        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 = 256 * 64;
+        pm8001_ha->memoryMap.region[IB].total_len = PM8001_MPI_QUEUE * 64;
         pm8001_ha->memoryMap.region[IB].alignment = 64;
 
-        /* MPI Memory region 6 inbound queues */
-        pm8001_ha->memoryMap.region[OB].num_elements = 256;
+        /* 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 = 256 * 64;
+        pm8001_ha->memoryMap.region[OB].total_len = PM8001_MPI_QUEUE * 64;
         pm8001_ha->memoryMap.region[OB].alignment = 64;
 
         /* Memory region write DMA*/
diff --git a/drivers/scsi/scsi.c b/drivers/scsi/scsi.c
index 07322ecff90d..61c82a345f82 100644
--- a/drivers/scsi/scsi.c
+++ b/drivers/scsi/scsi.c
@@ -90,6 +90,12 @@ unsigned int scsi_logging_level;
 EXPORT_SYMBOL(scsi_logging_level);
 #endif
 
+#if IS_ENABLED(CONFIG_PM) || IS_ENABLED(CONFIG_BLK_DEV_SD)
+/* sd and scsi_pm need to coordinate flushing async actions */
+LIST_HEAD(scsi_sd_probe_domain);
+EXPORT_SYMBOL(scsi_sd_probe_domain);
+#endif
+
 /* NB: These are exposed through /proc/scsi/scsi and form part of the ABI.
  * You may not alter any existing entry (although adding new ones is
  * encouraged once assigned by ANSI/INCITS T10
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 5dfd7495d1a1..62ddfd31d4ce 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -2348,10 +2348,14 @@ EXPORT_SYMBOL(scsi_device_quiesce);
  *
  *      Must be called with user context, may sleep.
  */
-void
-scsi_device_resume(struct scsi_device *sdev)
+void scsi_device_resume(struct scsi_device *sdev)
 {
-        if(scsi_device_set_state(sdev, SDEV_RUNNING))
+        /* check if the device state was mutated prior to resume, and if
+         * so assume the state is being managed elsewhere (for example
+         * device deleted during suspend)
+         */
+        if (sdev->sdev_state != SDEV_QUIESCE ||
+            scsi_device_set_state(sdev, SDEV_RUNNING))
                 return;
         scsi_run_queue(sdev->request_queue);
 }
diff --git a/drivers/scsi/scsi_pm.c b/drivers/scsi/scsi_pm.c
index c4670642d023..f661a41fa4c6 100644
--- a/drivers/scsi/scsi_pm.c
+++ b/drivers/scsi/scsi_pm.c
@@ -97,7 +97,7 @@ static int scsi_bus_prepare(struct device *dev)
 {
         if (scsi_is_sdev_device(dev)) {
                 /* sd probing uses async_schedule.  Wait until it finishes. */
-                async_synchronize_full();
+                async_synchronize_full_domain(&scsi_sd_probe_domain);
 
         } else if (scsi_is_host_device(dev)) {
                 /* Wait until async scanning is finished */
diff --git a/drivers/scsi/scsi_priv.h b/drivers/scsi/scsi_priv.h
index be4fa6d179b1..07ce3f51701d 100644
--- a/drivers/scsi/scsi_priv.h
+++ b/drivers/scsi/scsi_priv.h
@@ -163,6 +163,8 @@ static inline int scsi_autopm_get_host(struct Scsi_Host *h) { return 0; }
 static inline void scsi_autopm_put_host(struct Scsi_Host *h) {}
 #endif /* CONFIG_PM_RUNTIME */
 
+extern struct list_head scsi_sd_probe_domain;
+
 /* 
  * internal scsi timeout functions: for use by mid-layer and transport
  * classes.
diff --git a/drivers/scsi/scsi_transport_fc.c b/drivers/scsi/scsi_transport_fc.c
index 80fbe2ac0b47..579760420d53 100644
--- a/drivers/scsi/scsi_transport_fc.c
+++ b/drivers/scsi/scsi_transport_fc.c
@@ -2808,17 +2808,20 @@ fc_remote_port_add(struct Scsi_Host *shost, int channel,
                                                   FC_RPORT_DEVLOSS_PENDING |
                                                   FC_RPORT_DEVLOSS_CALLBK_DONE);
 
+                                spin_unlock_irqrestore(shost->host_lock, flags);
+
                                 /* if target, initiate a scan */
                                 if (rport->scsi_target_id != -1) {
+                                        scsi_target_unblock(&rport->dev);
+
+                                        spin_lock_irqsave(shost->host_lock,
+                                                          flags);
                                         rport->flags |= FC_RPORT_SCAN_PENDING;
                                         scsi_queue_work(shost,
                                                         &rport->scan_work);
                                         spin_unlock_irqrestore(shost->host_lock,
                                                         flags);
-                                        scsi_target_unblock(&rport->dev);
-                                } else
-                                        spin_unlock_irqrestore(shost->host_lock,
-                                                        flags);
+                                }
 
                                 fc_bsg_goose_queue(rport);
 
@@ -2876,16 +2879,17 @@ fc_remote_port_add(struct Scsi_Host *shost, int channel,
                         if (fci->f->dd_fcrport_size)
                                 memset(rport->dd_data, 0,
                                                 fci->f->dd_fcrport_size);
+                        spin_unlock_irqrestore(shost->host_lock, flags);
+
+                        if (ids->roles & FC_PORT_ROLE_FCP_TARGET) {
+                                scsi_target_unblock(&rport->dev);
 
-                        if (rport->roles & FC_PORT_ROLE_FCP_TARGET) {
                                 /* initiate a scan of the target */
+                                spin_lock_irqsave(shost->host_lock, flags);
                                 rport->flags |= FC_RPORT_SCAN_PENDING;
                                 scsi_queue_work(shost, &rport->scan_work);
                                 spin_unlock_irqrestore(shost->host_lock, flags);
-                                scsi_target_unblock(&rport->dev);
-                        } else
-                                spin_unlock_irqrestore(shost->host_lock, flags);
-
+                        }
                         return rport;
                 }
         }
@@ -3083,12 +3087,12 @@ fc_remote_port_rolechg(struct fc_rport  *rport, u32 roles)
                 /* ensure any stgt delete functions are done */
                 fc_flush_work(shost);
 
+                scsi_target_unblock(&rport->dev);
                 /* initiate a scan of the target */
                 spin_lock_irqsave(shost->host_lock, flags);
                 rport->flags |= FC_RPORT_SCAN_PENDING;
                 scsi_queue_work(shost, &rport->scan_work);
                 spin_unlock_irqrestore(shost->host_lock, flags);
-                scsi_target_unblock(&rport->dev);
         }
 }
 EXPORT_SYMBOL(fc_remote_port_rolechg);
diff --git a/drivers/scsi/scsi_transport_spi.c b/drivers/scsi/scsi_transport_spi.c
index a2715c31e754..cf08071a9b6e 100644
--- a/drivers/scsi/scsi_transport_spi.c
+++ b/drivers/scsi/scsi_transport_spi.c
@@ -1010,10 +1010,10 @@ spi_dv_device(struct scsi_device *sdev)
         u8 *buffer;
         const int len = SPI_MAX_ECHO_BUFFER_SIZE*2;
 
-        if (unlikely(scsi_device_get(sdev)))
+        if (unlikely(spi_dv_in_progress(starget)))
                 return;
 
-        if (unlikely(spi_dv_in_progress(starget)))
+        if (unlikely(scsi_device_get(sdev)))
                 return;
         spi_dv_in_progress(starget) = 1;
 
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 5ba5c2a9e8e9..6f0a4c612b3b 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -65,6 +65,7 @@
 #include <scsi/scsicam.h>
 
 #include "sd.h"
+#include "scsi_priv.h"
 #include "scsi_logging.h"
 
 MODULE_AUTHOR("Eric Youngdale");
@@ -2722,7 +2723,7 @@ static int sd_probe(struct device *dev)
         dev_set_drvdata(dev, sdkp);
 
         get_device(&sdkp->dev); /* prevent release before async_schedule */
-        async_schedule(sd_probe_async, sdkp);
+        async_schedule_domain(sd_probe_async, sdkp, &scsi_sd_probe_domain);
 
         return 0;
 
@@ -2756,7 +2757,7 @@ static int sd_remove(struct device *dev)
         sdkp = dev_get_drvdata(dev);
         scsi_autopm_get_device(sdkp->device);
 
-        async_synchronize_full();
+        async_synchronize_full_domain(&scsi_sd_probe_domain);
         blk_queue_prep_rq(sdkp->device->request_queue, scsi_prep_fn);
         blk_queue_unprep_rq(sdkp->device->request_queue, NULL);
         device_del(&sdkp->dev);
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index eacd46bb36b9..9c5c5f2b3962 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -104,7 +104,7 @@ static int scatter_elem_sz_prev = SG_SCATTER_SZ;
 static int sg_add(struct device *, struct class_interface *);
 static void sg_remove(struct device *, struct class_interface *);
 
-static DEFINE_MUTEX(sg_mutex);
+static DEFINE_SPINLOCK(sg_open_exclusive_lock);
 
 static DEFINE_IDR(sg_index_idr);
 static DEFINE_RWLOCK(sg_index_lock);    /* Also used to lock
@@ -137,13 +137,15 @@ typedef struct sg_request {	/* SG_MAX_QUEUE requests outstanding per file */
         char res_used;          /* 1 -> using reserve buffer, 0 -> not ... */
         char orphan;            /* 1 -> drop on sight, 0 -> normal */
         char sg_io_owned;       /* 1 -> packet belongs to SG_IO */
-        volatile char done;     /* 0->before bh, 1->before read, 2->read */
+        /* done protected by rq_list_lock */
+        char done;              /* 0->before bh, 1->before read, 2->read */
         struct request *rq;
         struct bio *bio;
         struct execute_work ew;
 } Sg_request;
 
 typedef struct sg_fd {          /* holds the state of a file descriptor */
+        /* sfd_siblings is protected by sg_index_lock */
         struct list_head sfd_siblings;
         struct sg_device *parentdp;     /* owning device */
         wait_queue_head_t read_wait;    /* queue read until command done */
@@ -157,7 +159,6 @@ typedef struct sg_fd {		/* holds the state of a file descriptor */
         Sg_request req_arr[SG_MAX_QUEUE];       /* used as singly-linked list */
         char low_dma;           /* as in parent but possibly overridden to 1 */
         char force_packid;      /* 1 -> pack_id input to read(), 0 -> ignored */
-        volatile char closed;   /* 1 -> fd closed but request(s) outstanding */
         char cmd_q;             /* 1 -> allow command queuing, 0 -> don't */
         char next_cmd_len;      /* 0 -> automatic (def), >0 -> use on next write() */
         char keep_orphan;       /* 0 -> drop orphan (def), 1 -> keep for read() */
@@ -171,9 +172,11 @@ typedef struct sg_device { /* holds the state of each scsi generic device */
         wait_queue_head_t o_excl_wait;  /* queue open() when O_EXCL in use */
         int sg_tablesize;       /* adapter's max scatter-gather table size */
         u32 index;              /* device index number */
+        /* sfds is protected by sg_index_lock */
         struct list_head sfds;
         volatile char detached; /* 0->attached, 1->detached pending removal */
-        volatile char exclude;  /* opened for exclusive access */
+        /* exclude protected by sg_open_exclusive_lock */
+        char exclude;           /* opened for exclusive access */
         char sgdebug;           /* 0->off, 1->sense, 9->dump dev, 10-> all devs */
         struct gendisk *disk;
         struct cdev * cdev;     /* char_dev [sysfs: /sys/cdev/major/sg<n>] */
@@ -221,6 +224,38 @@ static int sg_allow_access(struct file *filp, unsigned char *cmd)
         return blk_verify_command(cmd, filp->f_mode & FMODE_WRITE);
 }
 
+static int get_exclude(Sg_device *sdp)
+{
+        unsigned long flags;
+        int ret;
+
+        spin_lock_irqsave(&sg_open_exclusive_lock, flags);
+        ret = sdp->exclude;
+        spin_unlock_irqrestore(&sg_open_exclusive_lock, flags);
+        return ret;
+}
+
+static int set_exclude(Sg_device *sdp, char val)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&sg_open_exclusive_lock, flags);
+        sdp->exclude = val;
+        spin_unlock_irqrestore(&sg_open_exclusive_lock, flags);
+        return val;
+}
+
+static int sfds_list_empty(Sg_device *sdp)
+{
+        unsigned long flags;
+        int ret;
+
+        read_lock_irqsave(&sg_index_lock, flags);
+        ret = list_empty(&sdp->sfds);
+        read_unlock_irqrestore(&sg_index_lock, flags);
+        return ret;
+}
+
 static int
 sg_open(struct inode *inode, struct file *filp)
 {
@@ -232,7 +267,6 @@ sg_open(struct inode *inode, struct file *filp)
         int res;
         int retval;
 
-        mutex_lock(&sg_mutex);
         nonseekable_open(inode, filp);
         SCSI_LOG_TIMEOUT(3, printk("sg_open: dev=%d, flags=0x%x\n", dev, flags));
         sdp = sg_get_dev(dev);
@@ -264,25 +298,22 @@ sg_open(struct inode *inode, struct file *filp)
                         retval = -EPERM; /* Can't lock it with read only access */
                         goto error_out;
                 }
-                if (!list_empty(&sdp->sfds) && (flags & O_NONBLOCK)) {
+                if (!sfds_list_empty(sdp) && (flags & O_NONBLOCK)) {
                         retval = -EBUSY;
                         goto error_out;
                 }
-                res = 0;
-                __wait_event_interruptible(sdp->o_excl_wait,
-                                           ((!list_empty(&sdp->sfds) || sdp->exclude) ? 0 : (sdp->exclude = 1)), res);
+                res = wait_event_interruptible(sdp->o_excl_wait,
+                                           ((!sfds_list_empty(sdp) || get_exclude(sdp)) ? 0 : set_exclude(sdp, 1)));
                 if (res) {
                         retval = res;   /* -ERESTARTSYS because signal hit process */
                         goto error_out;
                 }
-        } else if (sdp->exclude) {      /* some other fd has an exclusive lock on dev */
+        } else if (get_exclude(sdp)) {  /* some other fd has an exclusive lock on dev */
                 if (flags & O_NONBLOCK) {
                         retval = -EBUSY;
                         goto error_out;
                 }
-                res = 0;
-                __wait_event_interruptible(sdp->o_excl_wait, (!sdp->exclude),
-                                           res);
+                res = wait_event_interruptible(sdp->o_excl_wait, !get_exclude(sdp));
                 if (res) {
                         retval = res;   /* -ERESTARTSYS because signal hit process */
                         goto error_out;
@@ -292,7 +323,7 @@ sg_open(struct inode *inode, struct file *filp)
                 retval = -ENODEV;
                 goto error_out;
         }
-        if (list_empty(&sdp->sfds)) {   /* no existing opens on this device */
+        if (sfds_list_empty(sdp)) {     /* no existing opens on this device */
                 sdp->sgdebug = 0;
                 q = sdp->device->request_queue;
                 sdp->sg_tablesize = queue_max_segments(q);
@@ -301,7 +332,7 @@ sg_open(struct inode *inode, struct file *filp)
                 filp->private_data = sfp;
         else {
                 if (flags & O_EXCL) {
-                        sdp->exclude = 0;       /* undo if error */
+                        set_exclude(sdp, 0);    /* undo if error */
                         wake_up_interruptible(&sdp->o_excl_wait);
                 }
                 retval = -ENOMEM;
@@ -317,7 +348,6 @@ sdp_put:
 sg_put:
         if (sdp)
                 sg_put_dev(sdp);
-        mutex_unlock(&sg_mutex);
         return retval;
 }
 
@@ -332,9 +362,7 @@ sg_release(struct inode *inode, struct file *filp)
                 return -ENXIO;
         SCSI_LOG_TIMEOUT(3, printk("sg_release: %s\n", sdp->disk->disk_name));
 
-        sfp->closed = 1;
-
-        sdp->exclude = 0;
+        set_exclude(sdp, 0);
         wake_up_interruptible(&sdp->o_excl_wait);
 
         scsi_autopm_put_device(sdp->device);
@@ -398,19 +426,14 @@ sg_read(struct file *filp, char __user *buf, size_t count, loff_t * ppos)
                         retval = -EAGAIN;
                         goto free_old_hdr;
                 }
-                while (1) {
-                        retval = 0; /* following macro beats race condition */
-                        __wait_event_interruptible(sfp->read_wait,
-                                (sdp->detached ||
-                                (srp = sg_get_rq_mark(sfp, req_pack_id))), 
-                                retval);
-                        if (sdp->detached) {
-                                retval = -ENODEV;
-                                goto free_old_hdr;
-                        }
-                        if (0 == retval)
-                                break;
-
+                retval = wait_event_interruptible(sfp->read_wait,
+                        (sdp->detached ||
+                        (srp = sg_get_rq_mark(sfp, req_pack_id))));
+                if (sdp->detached) {
+                        retval = -ENODEV;
+                        goto free_old_hdr;
+                }
+                if (retval) {
                         /* -ERESTARTSYS as signal hit process */
                         goto free_old_hdr;
                 }
@@ -771,7 +794,18 @@ sg_common_write(Sg_fd * sfp, Sg_request * srp,
         return 0;
 }
 
-static int
+static int srp_done(Sg_fd *sfp, Sg_request *srp)
+{
+        unsigned long flags;
+        int ret;
+
+        read_lock_irqsave(&sfp->rq_list_lock, flags);
+        ret = srp->done;
+        read_unlock_irqrestore(&sfp->rq_list_lock, flags);
+        return ret;
+}
+
+static long
 sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
 {
         void __user *p = (void __user *)arg;
@@ -791,40 +825,30 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
 
         switch (cmd_in) {
         case SG_IO:
-                {
-                        int blocking = 1;       /* ignore O_NONBLOCK flag */
-
-                        if (sdp->detached)
-                                return -ENODEV;
-                        if (!scsi_block_when_processing_errors(sdp->device))
-                                return -ENXIO;
-                        if (!access_ok(VERIFY_WRITE, p, SZ_SG_IO_HDR))
-                                return -EFAULT;
-                        result =
-                            sg_new_write(sfp, filp, p, SZ_SG_IO_HDR,
-                                         blocking, read_only, 1, &srp);
-                        if (result < 0)
-                                return result;
-                        while (1) {
-                                result = 0;     /* following macro to beat race condition */
-                                __wait_event_interruptible(sfp->read_wait,
-                                        (srp->done || sdp->detached),
-                                        result);
-                                if (sdp->detached)
-                                        return -ENODEV;
-                                write_lock_irq(&sfp->rq_list_lock);
-                                if (srp->done) {
-                                        srp->done = 2;
-                                        write_unlock_irq(&sfp->rq_list_lock);
-                                        break;
-                                }
-                                srp->orphan = 1;
-                                write_unlock_irq(&sfp->rq_list_lock);
-                                return result;  /* -ERESTARTSYS because signal hit process */
-                        }
+                if (sdp->detached)
+                        return -ENODEV;
+                if (!scsi_block_when_processing_errors(sdp->device))
+                        return -ENXIO;
+                if (!access_ok(VERIFY_WRITE, p, SZ_SG_IO_HDR))
+                        return -EFAULT;
+                result = sg_new_write(sfp, filp, p, SZ_SG_IO_HDR,
+                                 1, read_only, 1, &srp);
+                if (result < 0)
+                        return result;
+                result = wait_event_interruptible(sfp->read_wait,
+                        (srp_done(sfp, srp) || sdp->detached));
+                if (sdp->detached)
+                        return -ENODEV;
+                write_lock_irq(&sfp->rq_list_lock);
+                if (srp->done) {
+                        srp->done = 2;
+                        write_unlock_irq(&sfp->rq_list_lock);
                         result = sg_new_read(sfp, p, SZ_SG_IO_HDR, srp);
                         return (result < 0) ? result : 0;
                 }
+                srp->orphan = 1;
+                write_unlock_irq(&sfp->rq_list_lock);
+                return result;  /* -ERESTARTSYS because signal hit process */
         case SG_SET_TIMEOUT:
                 result = get_user(val, ip);
                 if (result)
@@ -1091,18 +1115,6 @@ sg_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
         }
 }
 
-static long
-sg_unlocked_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
-{
-        int ret;
-
-        mutex_lock(&sg_mutex);
-        ret = sg_ioctl(filp, cmd_in, arg);
-        mutex_unlock(&sg_mutex);
-
-        return ret;
-}
-
 #ifdef CONFIG_COMPAT
 static long sg_compat_ioctl(struct file *filp, unsigned int cmd_in, unsigned long arg)
 {
@@ -1136,8 +1148,11 @@ sg_poll(struct file *filp, poll_table * wait)
         int count = 0;
         unsigned long iflags;
 
-        if ((!(sfp = (Sg_fd *) filp->private_data)) || (!(sdp = sfp->parentdp))
-            || sfp->closed)
+        sfp = filp->private_data;
+        if (!sfp)
+                return POLLERR;
+        sdp = sfp->parentdp;
+        if (!sdp)
                 return POLLERR;
         poll_wait(filp, &sfp->read_wait, wait);
         read_lock_irqsave(&sfp->rq_list_lock, iflags);
@@ -1347,7 +1362,7 @@ static const struct file_operations sg_fops = {
         .read = sg_read,
         .write = sg_write,
         .poll = sg_poll,
-        .unlocked_ioctl = sg_unlocked_ioctl,
+        .unlocked_ioctl = sg_ioctl,
 #ifdef CONFIG_COMPAT
         .compat_ioctl = sg_compat_ioctl,
 #endif
@@ -2312,7 +2327,7 @@ struct sg_proc_leaf {
         const struct file_operations * fops;
 };
 
-static struct sg_proc_leaf sg_proc_leaf_arr[] = {
+static const struct sg_proc_leaf sg_proc_leaf_arr[] = {
         {"allow_dio", &adio_fops},
         {"debug", &debug_fops},
         {"def_reserved_size", &dressz_fops},
@@ -2332,7 +2347,7 @@ sg_proc_init(void)
         if (!sg_proc_sgp)
                 return 1;
         for (k = 0; k < num_leaves; ++k) {
-                struct sg_proc_leaf *leaf = &sg_proc_leaf_arr[k];
+                const struct sg_proc_leaf *leaf = &sg_proc_leaf_arr[k];
                 umode_t mask = leaf->fops->write ? S_IRUGO | S_IWUSR : S_IRUGO;
                 proc_create(leaf->name, mask, sg_proc_sgp, leaf->fops);
         }
@@ -2533,9 +2548,9 @@ static void sg_proc_debug_helper(struct seq_file *s, Sg_device * sdp)
                            fp->reserve.bufflen,
                            (int) fp->reserve.k_use_sg,
                            (int) fp->low_dma);
-                seq_printf(s, "   cmd_q=%d f_packid=%d k_orphan=%d closed=%d\n",
+                seq_printf(s, "   cmd_q=%d f_packid=%d k_orphan=%d closed=0\n",
                            (int) fp->cmd_q, (int) fp->force_packid,
-                           (int) fp->keep_orphan, (int) fp->closed);
+                           (int) fp->keep_orphan);
                 for (m = 0, srp = fp->headrp;
                                 srp != NULL;
                                 ++m, srp = srp->nextrp) {
@@ -2612,7 +2627,7 @@ static int sg_proc_seq_show_debug(struct seq_file *s, void *v)
                              scsidp->lun,
                              scsidp->host->hostt->emulated);
                 seq_printf(s, " sg_tablesize=%d excl=%d\n",
-                           sdp->sg_tablesize, sdp->exclude);
+                           sdp->sg_tablesize, get_exclude(sdp));
                 sg_proc_debug_helper(s, sdp);
         }
         read_unlock_irqrestore(&sg_index_lock, iflags);
diff --git a/drivers/scsi/st.h b/drivers/scsi/st.h
index ea35632b986c..b548923785ed 100644
--- a/drivers/scsi/st.h
+++ b/drivers/scsi/st.h
@@ -35,8 +35,8 @@ struct st_request {
 /* The tape buffer descriptor. */
 struct st_buffer {
         unsigned char dma;      /* DMA-able buffer */
-        unsigned char do_dio;   /* direct i/o set up? */
         unsigned char cleared;  /* internal buffer cleared after open? */
+        unsigned short do_dio;  /* direct i/o set up? */
         int buffer_size;
         int buffer_blocks;
         int buffer_bytes;
diff --git a/drivers/scsi/storvsc_drv.c b/drivers/scsi/storvsc_drv.c
index 83a1972a1999..528d52beaa1c 100644
--- a/drivers/scsi/storvsc_drv.c
+++ b/drivers/scsi/storvsc_drv.c
@@ -785,12 +785,22 @@ static void storvsc_command_completion(struct storvsc_cmd_request *cmd_request)
         /*
          * If there is an error; offline the device since all
          * error recovery strategies would have already been
-         * deployed on the host side.
+         * deployed on the host side. However, if the command
+         * were a pass-through command deal with it appropriately.
          */
-        if (vm_srb->srb_status == SRB_STATUS_ERROR)
-                scmnd->result = DID_TARGET_FAILURE << 16;
-        else
-                scmnd->result = vm_srb->scsi_status;
+        scmnd->result = vm_srb->scsi_status;
+
+        if (vm_srb->srb_status == SRB_STATUS_ERROR) {
+                switch (scmnd->cmnd[0]) {
+                case ATA_16:
+                case ATA_12:
+                        set_host_byte(scmnd, DID_PASSTHROUGH);
+                        break;
+                default:
+                        set_host_byte(scmnd, DID_TARGET_FAILURE);
+                }
+        }
+
 
         /*
          * If the LUN is invalid; remove the device.
diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
index 52b96e8bf92e..4e010b727818 100644
--- a/drivers/scsi/ufs/ufshcd.c
+++ b/drivers/scsi/ufs/ufshcd.c
@@ -1032,11 +1032,11 @@ static int ufshcd_initialize_hba(struct ufs_hba *hba)
                 return -EIO;
 
         /* Configure UTRL and UTMRL base address registers */
-        writel(hba->utrdl_dma_addr,
-               (hba->mmio_base + REG_UTP_TRANSFER_REQ_LIST_BASE_L));
         writel(lower_32_bits(hba->utrdl_dma_addr),
+               (hba->mmio_base + REG_UTP_TRANSFER_REQ_LIST_BASE_L));
+        writel(upper_32_bits(hba->utrdl_dma_addr),
                (hba->mmio_base + REG_UTP_TRANSFER_REQ_LIST_BASE_H));
-        writel(hba->utmrdl_dma_addr,
+        writel(lower_32_bits(hba->utmrdl_dma_addr),
                (hba->mmio_base + REG_UTP_TASK_REQ_LIST_BASE_L));
         writel(upper_32_bits(hba->utmrdl_dma_addr),
                (hba->mmio_base + REG_UTP_TASK_REQ_LIST_BASE_H));
@@ -1160,7 +1160,7 @@ static int ufshcd_task_req_compl(struct ufs_hba *hba, u32 index)
                 task_result = be32_to_cpu(task_rsp_upiup->header.dword_1);
                 task_result = ((task_result & MASK_TASK_RESPONSE) >> 8);
 
-                if (task_result != UPIU_TASK_MANAGEMENT_FUNC_COMPL ||
+                if (task_result != UPIU_TASK_MANAGEMENT_FUNC_COMPL &&
                     task_result != UPIU_TASK_MANAGEMENT_FUNC_SUCCEEDED)
                         task_result = FAILED;
         } else {
diff --git a/include/scsi/iscsi_proto.h b/include/scsi/iscsi_proto.h
index 988ba06b3ad6..c1260d80ef30 100644
--- a/include/scsi/iscsi_proto.h
+++ b/include/scsi/iscsi_proto.h
@@ -661,6 +661,8 @@ struct iscsi_reject {
 
 #define ISCSI_DEF_TIME2WAIT                     2
 
+#define ISCSI_NAME_LEN                          224
+
 /************************* RFC 3720 End *****************************/
 
 #endif /* ISCSI_PROTO_H */
diff --git a/include/scsi/sas.h b/include/scsi/sas.h
index a577a833603d..be3eb0bf1ac0 100644
--- a/include/scsi/sas.h
+++ b/include/scsi/sas.h
@@ -103,6 +103,7 @@ enum sas_dev_type {
 };
 
 enum sas_protocol {
+        SAS_PROTOCOL_NONE               = 0,
         SAS_PROTOCOL_SATA               = 0x01,
         SAS_PROTOCOL_SMP                = 0x02,
         SAS_PROTOCOL_STP                = 0x04,