Patched in Tegra support.

24 files changed, 4143 insertions, 3946 deletions

diff --git a/drivers/scsi/isci/host.c b/drivers/scsi/isci/host.c
index 609dafd661d..6981b773a88 100644
--- a/drivers/scsi/isci/host.c
+++ b/drivers/scsi/isci/host.c
@@ -58,6 +58,7 @@
 #include "host.h"
 #include "isci.h"
 #include "port.h"
+#include "host.h"
 #include "probe_roms.h"
 #include "remote_device.h"
 #include "request.h"
@@ -192,27 +193,22 @@ 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);
 
-        /* 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)) {
+                /*
+                 * 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. */
                 writel(0xFF000000, &ihost->smu_registers->interrupt_mask);
                 writel(0, &ihost->smu_registers->interrupt_mask);
         }
-        spin_unlock(&ihost->scic_lock);
 
         return false;
 }
@@ -492,7 +488,7 @@ static void sci_controller_process_completions(struct isci_host *ihost)
         u32 event_cycle;
 
         dev_dbg(&ihost->pdev->dev,
-                "%s: completion queue beginning get:0x%08x\n",
+                "%s: completion queue begining get:0x%08x\n",
                 __func__,
                 ihost->completion_queue_get);
 
@@ -647,21 +643,29 @@ 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);
 }
 
 int isci_host_scan_finished(struct Scsi_Host *shost, unsigned long time)
 {
-        struct sas_ha_struct *ha = SHOST_TO_SAS_HA(shost);
-        struct isci_host *ihost = ha->lldd_ha;
+        struct isci_host *ihost = SHOST_TO_SAS_HA(shost)->lldd_ha;
 
         if (test_bit(IHOST_START_PENDING, &ihost->flags))
                 return 0;
 
-        sas_drain_work(ha);
+        /* todo: use sas_flush_discovery once it is upstream */
+        scsi_flush_work(shost);
+
+        scsi_flush_work(shost);
+
+        dev_dbg(&ihost->pdev->dev,
+                "%s: ihost->status = %d, time = %ld\n",
+                 __func__, isci_host_get_state(ihost), time);
 
         return 1;
+
 }
 
 /**
@@ -703,15 +707,14 @@ static u32 sci_controller_get_suggested_start_timeout(struct isci_host *ihost)
 
 static void sci_controller_enable_interrupts(struct isci_host *ihost)
 {
-        set_bit(IHOST_IRQ_ENABLED, &ihost->flags);
+        BUG_ON(ihost->smu_registers == NULL);
         writel(0, &ihost->smu_registers->interrupt_mask);
 }
 
 void sci_controller_disable_interrupts(struct isci_host *ihost)
 {
-        clear_bit(IHOST_IRQ_ENABLED, &ihost->flags);
+        BUG_ON(ihost->smu_registers == NULL);
         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 +825,7 @@ static void sci_controller_initialize_unsolicited_frame_queue(struct isci_host *
                &ihost->scu_registers->sdma.unsolicited_frame_put_pointer);
 }
 
-void sci_controller_transition_to_ready(struct isci_host *ihost, enum sci_status status)
+static void sci_controller_transition_to_ready(struct isci_host *ihost, enum sci_status status)
 {
         if (ihost->sm.current_state_id == SCIC_STARTING) {
                 /*
@@ -849,7 +852,6 @@ 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;
@@ -858,39 +860,6 @@ 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
@@ -911,7 +880,35 @@ static enum sci_status sci_controller_start_next_phy(struct isci_host *ihost)
                 return status;
 
         if (ihost->next_phy_to_start >= SCI_MAX_PHYS) {
-                if (is_controller_start_complete(ihost)) {
+                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))) {
+                                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) {
                         sci_controller_transition_to_ready(ihost, SCI_SUCCESS);
                         sci_del_timer(&ihost->phy_timer);
                         ihost->phy_startup_timer_pending = false;
@@ -992,8 +989,9 @@ 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, "%s invalid state: %d\n",
-                         __func__, ihost->sm.current_state_id);
+                dev_warn(&ihost->pdev->dev,
+                         "SCIC Controller start operation requested in "
+                         "invalid state\n");
                 return SCI_FAILURE_INVALID_STATE;
         }
 
@@ -1044,7 +1042,7 @@ static enum sci_status sci_controller_start(struct isci_host *ihost,
         return SCI_SUCCESS;
 }
 
-void isci_host_start(struct Scsi_Host *shost)
+void isci_host_scan_start(struct Scsi_Host *shost)
 {
         struct isci_host *ihost = SHOST_TO_SAS_HA(shost)->lldd_ha;
         unsigned long tmo = sci_controller_get_suggested_start_timeout(ihost);
@@ -1057,8 +1055,9 @@ void isci_host_start(struct Scsi_Host *shost)
         spin_unlock_irq(&ihost->scic_lock);
 }
 
-static void isci_host_stop_complete(struct isci_host *ihost)
+static void isci_host_stop_complete(struct isci_host *ihost, enum sci_status completion_status)
 {
+        isci_host_change_state(ihost, isci_stopped);
         sci_controller_disable_interrupts(ihost);
         clear_bit(IHOST_STOP_PENDING, &ihost->flags);
         wake_up(&ihost->eventq);
@@ -1077,34 +1076,6 @@ 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)
-{
-        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->lldd_task = NULL;
-                        task->task_done(task);
-                } else {
-                        dev_dbg(&ihost->pdev->dev,
-                                "%s: Error - ireq/task = %p/%p\n",
-                                __func__, ireq, task);
-                        if (sas_protocol_ata(task->task_proto))
-                                task->lldd_task = NULL;
-                        sas_task_abort(task);
-                }
-        } else
-                task->lldd_task = NULL;
-
-        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
@@ -1113,25 +1084,111 @@ void ireq_done(struct isci_host *ihost, struct isci_request *ireq, struct sas_ta
  * @data: This parameter specifies the ISCI host object
  *
  */
-void isci_host_completion_routine(unsigned long data)
+static 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);
 
-        /*
-         * we subtract SCI_MAX_PORTS to account for the number of dummy TCs
-         * issued for hardware issue workaround
-         */
-        active = isci_tci_active(ihost) - SCI_MAX_PORTS;
+        /* Process any completions in the lists. */
+        list_for_each_safe(current_position, next_position,
+                           &completed_request_list) {
 
-        /*
-         * the coalesence timeout doubles at each encoding step, so
+                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
          */
+        active = isci_tci_active(ihost);
         writel(SMU_ICC_GEN_VAL(NUMBER, active) |
                SMU_ICC_GEN_VAL(TIMER, ISCI_COALESCE_BASE + ilog2(active)),
                &ihost->smu_registers->interrupt_coalesce_control);
@@ -1158,8 +1215,9 @@ 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, "%s invalid state: %d\n",
-                         __func__, ihost->sm.current_state_id);
+                dev_warn(&ihost->pdev->dev,
+                         "SCIC Controller stop operation requested in "
+                         "invalid state\n");
                 return SCI_FAILURE_INVALID_STATE;
         }
 
@@ -1185,7 +1243,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_STOPPING:
+        case SCIC_STOPPED:
         case SCIC_FAILED:
                 /*
                  * The reset operation is not a graceful cleanup, just
@@ -1194,58 +1252,28 @@ 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, "%s invalid state: %d\n",
-                         __func__, ihost->sm.current_state_id);
+                dev_warn(&ihost->pdev->dev,
+                         "SCIC Controller reset operation requested in "
+                         "invalid state\n");
                 return SCI_FAILURE_INVALID_STATE;
         }
 }
 
-static enum sci_status sci_controller_stop_phys(struct isci_host *ihost)
+void isci_host_deinit(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]);
+        int i;
 
-                if (phy_status != SCI_SUCCESS &&
-                    phy_status != SCI_FAILURE_INVALID_STATE) {
-                        status = SCI_FAILURE;
+        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;
 
-                        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);
+                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);
                 }
         }
 
-        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;
-
-        /* disable output data selects */
-        for (i = 0; i < isci_gpio_count(ihost); i++)
-                writel(SGPIO_HW_CONTROL, &ihost->scu_registers->peg0.sgpio.output_data_select[i]);
-
         set_bit(IHOST_STOP_PENDING, &ihost->flags);
 
         spin_lock_irq(&ihost->scic_lock);
@@ -1253,22 +1281,7 @@ void isci_host_deinit(struct isci_host *ihost)
         spin_unlock_irq(&ihost->scic_lock);
 
         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++) {
@@ -1307,6 +1320,29 @@ 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_number_concurrent_device_spin_up = 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);
@@ -1444,15 +1480,6 @@ sci_controller_set_interrupt_coalescence(struct isci_host *ihost,
 static void sci_controller_ready_state_enter(struct sci_base_state_machine *sm)
 {
         struct isci_host *ihost = container_of(sm, typeof(*ihost), sm);
-        u32 val;
-
-        /* enable clock gating for power control of the scu unit */
-        val = readl(&ihost->smu_registers->clock_gating_control);
-        val &= ~(SMU_CGUCR_GEN_BIT(REGCLK_ENABLE) |
-                 SMU_CGUCR_GEN_BIT(TXCLK_ENABLE) |
-                 SMU_CGUCR_GEN_BIT(XCLK_ENABLE));
-        val |= SMU_CGUCR_GEN_BIT(IDLE_ENABLE);
-        writel(val, &ihost->smu_registers->clock_gating_control);
 
         /* set the default interrupt coalescence number and timeout value. */
         sci_controller_set_interrupt_coalescence(ihost, 0, 0);
@@ -1466,6 +1493,32 @@ 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;
@@ -1525,11 +1578,10 @@ static void sci_controller_stopping_state_enter(struct sci_base_state_machine *s
 {
         struct isci_host *ihost = container_of(sm, typeof(*ihost), sm);
 
-        sci_controller_stop_devices(ihost);
+        /* Stop all of the components for this controller */
+        sci_controller_stop_phys(ihost);
         sci_controller_stop_ports(ihost);
-
-        if (!sci_controller_has_remote_devices_stopping(ihost))
-                isci_host_stop_complete(ihost);
+        sci_controller_stop_devices(ihost);
 }
 
 static void sci_controller_stopping_state_exit(struct sci_base_state_machine *sm)
@@ -1555,9 +1607,6 @@ 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)
@@ -1589,9 +1638,55 @@ 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_concurrent_dev_spin_up = 1;
+
+        /* Default to no SSC operation. */
+        ihost->oem_parameters.controller.do_enable_ssc = false;
+
+        /* 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 6G (i.e. Gen 3) for now. */
+                ihost->user_parameters.phys[index].max_speed_generation = 3;
+
+                /* 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 = 20;
+}
+
 static void controller_timeout(unsigned long data)
 {
         struct sci_timer *tmr = (struct sci_timer *)data;
@@ -1608,7 +1703,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);
+                isci_host_stop_complete(ihost, SCI_FAILURE_TIMEOUT);
         } 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 "
@@ -1648,10 +1743,13 @@ 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);
 }
 
-int sci_oem_parameters_validate(struct sci_oem_params *oem, u8 version)
+int sci_oem_parameters_validate(struct sci_oem_params *oem)
 {
         int i;
 
@@ -1679,62 +1777,27 @@ int sci_oem_parameters_validate(struct sci_oem_params *oem, u8 version)
         } else
                 return -EINVAL;
 
-        if (oem->controller.max_concurr_spin_up > MAX_CONCURRENT_DEVICE_SPIN_UP_COUNT ||
-            oem->controller.max_concurr_spin_up < 1)
+        if (oem->controller.max_concurrent_dev_spin_up > MAX_CONCURRENT_DEVICE_SPIN_UP_COUNT)
                 return -EINVAL;
 
-        if (oem->controller.do_enable_ssc) {
-                if (version < ISCI_ROM_VER_1_1 && oem->controller.do_enable_ssc != 1)
-                        return -EINVAL;
+        return 0;
+}
 
-                if (version >= ISCI_ROM_VER_1_1) {
-                        u8 test = oem->controller.ssc_sata_tx_spread_level;
+static enum sci_status sci_oem_parameters_set(struct isci_host *ihost)
+{
+        u32 state = ihost->sm.current_state_id;
 
-                        switch (test) {
-                        case 0:
-                        case 2:
-                        case 3:
-                        case 6:
-                        case 7:
-                                break;
-                        default:
-                                return -EINVAL;
-                        }
+        if (state == SCIC_RESET ||
+            state == SCIC_INITIALIZING ||
+            state == SCIC_INITIALIZED) {
 
-                        test = oem->controller.ssc_sas_tx_spread_level;
-                        if (oem->controller.ssc_sas_tx_type == 0) {
-                                switch (test) {
-                                case 0:
-                                case 2:
-                                case 3:
-                                        break;
-                                default:
-                                        return -EINVAL;
-                                }
-                        } else if (oem->controller.ssc_sas_tx_type == 1) {
-                                switch (test) {
-                                case 0:
-                                case 3:
-                                case 6:
-                                        break;
-                                default:
-                                        return -EINVAL;
-                                }
-                        }
-                }
-        }
+                if (sci_oem_parameters_validate(&ihost->oem_parameters))
+                        return SCI_FAILURE_INVALID_PARAMETER_VALUE;
 
-        return 0;
-}
+                return SCI_SUCCESS;
+        }
 
-static u8 max_spin_up(struct isci_host *ihost)
-{
-        if (ihost->user_parameters.max_concurr_spinup)
-                return min_t(u8, ihost->user_parameters.max_concurr_spinup,
-                             MAX_CONCURRENT_DEVICE_SPIN_UP_COUNT);
-        else
-                return min_t(u8, ihost->oem_parameters.controller.max_concurr_spin_up,
-                             MAX_CONCURRENT_DEVICE_SPIN_UP_COUNT);
+        return SCI_FAILURE_INVALID_STATE;
 }
 
 static void power_control_timeout(unsigned long data)
@@ -1766,38 +1829,14 @@ static void power_control_timeout(unsigned long data)
                 if (iphy == NULL)
                         continue;
 
-                if (ihost->power_control.phys_granted_power >= max_spin_up(ihost))
+                if (ihost->power_control.phys_granted_power >=
+                    ihost->oem_parameters.controller.max_concurrent_dev_spin_up)
                         break;
 
                 ihost->power_control.requesters[i] = NULL;
                 ihost->power_control.phys_waiting--;
                 ihost->power_control.phys_granted_power++;
                 sci_phy_consume_power_handler(iphy);
-
-                if (iphy->protocol == SAS_PROTOCOL_SSP) {
-                        u8 j;
-
-                        for (j = 0; j < SCI_MAX_PHYS; j++) {
-                                struct isci_phy *requester = ihost->power_control.requesters[j];
-
-                                /*
-                                 * Search the power_control queue to see if there are other phys
-                                 * attached to the same remote device. If found, take all of
-                                 * them out of await_sas_power state.
-                                 */
-                                if (requester != NULL && requester != iphy) {
-                                        u8 other = memcmp(requester->frame_rcvd.iaf.sas_addr,
-                                                          iphy->frame_rcvd.iaf.sas_addr,
-                                                          sizeof(requester->frame_rcvd.iaf.sas_addr));
-
-                                        if (other == 0) {
-                                                ihost->power_control.requesters[j] = NULL;
-                                                ihost->power_control.phys_waiting--;
-                                                sci_phy_consume_power_handler(requester);
-                                        }
-                                }
-                        }
-                }
         }
 
         /*
@@ -1816,7 +1855,8 @@ void sci_controller_power_control_queue_insert(struct isci_host *ihost,
 {
         BUG_ON(iphy == NULL);
 
-        if (ihost->power_control.phys_granted_power < max_spin_up(ihost)) {
+        if (ihost->power_control.phys_granted_power <
+            ihost->oem_parameters.controller.max_concurrent_dev_spin_up) {
                 ihost->power_control.phys_granted_power++;
                 sci_phy_consume_power_handler(iphy);
 
@@ -1832,34 +1872,9 @@ void sci_controller_power_control_queue_insert(struct isci_host *ihost,
                 ihost->power_control.timer_started = true;
 
         } else {
-                /*
-                 * There are phys, attached to the same sas address as this phy, are
-                 * already in READY state, this phy don't need wait.
-                 */
-                u8 i;
-                struct isci_phy *current_phy;
-
-                for (i = 0; i < SCI_MAX_PHYS; i++) {
-                        u8 other;
-                        current_phy = &ihost->phys[i];
-
-                        other = memcmp(current_phy->frame_rcvd.iaf.sas_addr,
-                                       iphy->frame_rcvd.iaf.sas_addr,
-                                       sizeof(current_phy->frame_rcvd.iaf.sas_addr));
-
-                        if (current_phy->sm.current_state_id == SCI_PHY_READY &&
-                            current_phy->protocol == SAS_PROTOCOL_SSP &&
-                            other == 0) {
-                                sci_phy_consume_power_handler(iphy);
-                                break;
-                        }
-                }
-
-                if (i == SCI_MAX_PHYS) {
-                        /* Add the phy in the waiting list */
-                        ihost->power_control.requesters[iphy->phy_index] = iphy;
-                        ihost->power_control.phys_waiting++;
-                }
+                /* Add the phy in the waiting list */
+                ihost->power_control.requesters[iphy->phy_index] = iphy;
+                ihost->power_control.phys_waiting++;
         }
 }
 
@@ -1874,250 +1889,162 @@ void sci_controller_power_control_queue_remove(struct isci_host *ihost,
         ihost->power_control.requesters[iphy->phy_index] = NULL;
 }
 
-static int is_long_cable(int phy, unsigned char selection_byte)
-{
-        return !!(selection_byte & (1 << phy));
-}
-
-static int is_medium_cable(int phy, unsigned char selection_byte)
-{
-        return !!(selection_byte & (1 << (phy + 4)));
-}
-
-static enum cable_selections decode_selection_byte(
-        int phy,
-        unsigned char selection_byte)
-{
-        return ((selection_byte & (1 << phy)) ? 1 : 0)
-                + (selection_byte & (1 << (phy + 4)) ? 2 : 0);
-}
-
-static unsigned char *to_cable_select(struct isci_host *ihost)
-{
-        if (is_cable_select_overridden())
-                return ((unsigned char *)&cable_selection_override)
-                        + ihost->id;
-        else
-                return &ihost->oem_parameters.controller.cable_selection_mask;
-}
-
-enum cable_selections decode_cable_selection(struct isci_host *ihost, int phy)
-{
-        return decode_selection_byte(phy, *to_cable_select(ihost));
-}
-
-char *lookup_cable_names(enum cable_selections selection)
-{
-        static char *cable_names[] = {
-                [short_cable]     = "short",
-                [long_cable]      = "long",
-                [medium_cable]    = "medium",
-                [undefined_cable] = "<undefined, assumed long>" /* bit 0==1 */
-        };
-        return (selection <= undefined_cable) ? cable_names[selection]
-                                              : cable_names[undefined_cable];
-}
-
 #define AFE_REGISTER_WRITE_DELAY 10
 
+/* Initialize the AFE for this phy index. We need to read the AFE setup from
+ * the OEM parameters
+ */
 static void sci_controller_afe_initialization(struct isci_host *ihost)
 {
-        struct scu_afe_registers __iomem *afe = &ihost->scu_registers->afe;
         const struct sci_oem_params *oem = &ihost->oem_parameters;
         struct pci_dev *pdev = ihost->pdev;
         u32 afe_status;
         u32 phy_id;
-        unsigned char cable_selection_mask = *to_cable_select(ihost);
 
         /* Clear DFX Status registers */
-        writel(0x0081000f, &afe->afe_dfx_master_control0);
+        writel(0x0081000f, &ihost->scu_registers->afe.afe_dfx_master_control0);
         udelay(AFE_REGISTER_WRITE_DELAY);
 
-        if (is_b0(pdev) || is_c0(pdev) || is_c1(pdev)) {
+        if (is_b0(pdev)) {
                 /* PM Rx Equalization Save, PM SPhy Rx Acknowledgement
-                 * Timer, PM Stagger Timer
-                 */
-                writel(0x0007FFFF, &afe->afe_pmsn_master_control2);
+                 * Timer, PM Stagger Timer */
+                writel(0x0007BFFF, &ihost->scu_registers->afe.afe_pmsn_master_control2);
                 udelay(AFE_REGISTER_WRITE_DELAY);
         }
 
         /* Configure bias currents to normal */
         if (is_a2(pdev))
-                writel(0x00005A00, &afe->afe_bias_control);
+                writel(0x00005A00, &ihost->scu_registers->afe.afe_bias_control);
         else if (is_b0(pdev) || is_c0(pdev))
-                writel(0x00005F00, &afe->afe_bias_control);
-        else if (is_c1(pdev))
-                writel(0x00005500, &afe->afe_bias_control);
+                writel(0x00005F00, &ihost->scu_registers->afe.afe_bias_control);
 
         udelay(AFE_REGISTER_WRITE_DELAY);
 
         /* Enable PLL */
-        if (is_a2(pdev))
-                writel(0x80040908, &afe->afe_pll_control0);
-        else if (is_b0(pdev) || is_c0(pdev))
-                writel(0x80040A08, &afe->afe_pll_control0);
-        else if (is_c1(pdev)) {
-                writel(0x80000B08, &afe->afe_pll_control0);
-                udelay(AFE_REGISTER_WRITE_DELAY);
-                writel(0x00000B08, &afe->afe_pll_control0);
-                udelay(AFE_REGISTER_WRITE_DELAY);
-                writel(0x80000B08, &afe->afe_pll_control0);
-        }
+        if (is_b0(pdev) || is_c0(pdev))
+                writel(0x80040A08, &ihost->scu_registers->afe.afe_pll_control0);
+        else
+                writel(0x80040908, &ihost->scu_registers->afe.afe_pll_control0);
 
         udelay(AFE_REGISTER_WRITE_DELAY);
 
         /* Wait for the PLL to lock */
         do {
-                afe_status = readl(&afe->afe_common_block_status);
+                afe_status = readl(&ihost->scu_registers->afe.afe_common_block_status);
                 udelay(AFE_REGISTER_WRITE_DELAY);
         } while ((afe_status & 0x00001000) == 0);
 
         if (is_a2(pdev)) {
-                /* Shorten SAS SNW lock time (RxLock timer value from 76
-                 * us to 50 us)
-                 */
-                writel(0x7bcc96ad, &afe->afe_pmsn_master_control0);
+                /* Shorten SAS SNW lock time (RxLock timer value from 76 us to 50 us) */
+                writel(0x7bcc96ad, &ihost->scu_registers->afe.afe_pmsn_master_control0);
                 udelay(AFE_REGISTER_WRITE_DELAY);
         }
 
         for (phy_id = 0; phy_id < SCI_MAX_PHYS; phy_id++) {
-                struct scu_afe_transceiver __iomem *xcvr = &afe->scu_afe_xcvr[phy_id];
                 const struct sci_phy_oem_params *oem_phy = &oem->phys[phy_id];
-                int cable_length_long =
-                        is_long_cable(phy_id, cable_selection_mask);
-                int cable_length_medium =
-                        is_medium_cable(phy_id, cable_selection_mask);
 
-                if (is_a2(pdev)) {
-                        /* All defaults, except the Receive Word
-                         * Alignament/Comma Detect Enable....(0xe800)
-                         */
-                        writel(0x00004512, &xcvr->afe_xcvr_control0);
-                        udelay(AFE_REGISTER_WRITE_DELAY);
-
-                        writel(0x0050100F, &xcvr->afe_xcvr_control1);
-                        udelay(AFE_REGISTER_WRITE_DELAY);
-                } else if (is_b0(pdev)) {
-                        /* Configure transmitter SSC parameters */
-                        writel(0x00030000, &xcvr->afe_tx_ssc_control);
+                if (is_b0(pdev)) {
+                         /* Configure transmitter SSC parameters */
+                        writel(0x00030000, &ihost->scu_registers->afe.scu_afe_xcvr[phy_id].afe_tx_ssc_control);
                         udelay(AFE_REGISTER_WRITE_DELAY);
                 } else if (is_c0(pdev)) {
-                        /* Configure transmitter SSC parameters */
-                        writel(0x00010202, &xcvr->afe_tx_ssc_control);
+                         /* Configure transmitter SSC parameters */
+                        writel(0x0003000, &ihost->scu_registers->afe.scu_afe_xcvr[phy_id].afe_tx_ssc_control);
                         udelay(AFE_REGISTER_WRITE_DELAY);
 
-                        /* All defaults, except the Receive Word
-                         * Alignament/Comma Detect Enable....(0xe800)
-                         */
-                        writel(0x00014500, &xcvr->afe_xcvr_control0);
+                        /*
+                         * All defaults, except the Receive Word Alignament/Comma Detect
+                         * Enable....(0xe800) */
+                        writel(0x00004500, &ihost->scu_registers->afe.scu_afe_xcvr[phy_id].afe_xcvr_control0);
                         udelay(AFE_REGISTER_WRITE_DELAY);
-                } else if (is_c1(pdev)) {
-                        /* Configure transmitter SSC parameters */
-                        writel(0x00010202, &xcvr->afe_tx_ssc_control);
+                } else {
+                        /*
+                         * All defaults, except the Receive Word Alignament/Comma Detect
+                         * Enable....(0xe800) */
+                        writel(0x00004512, &ihost->scu_registers->afe.scu_afe_xcvr[phy_id].afe_xcvr_control0);
                         udelay(AFE_REGISTER_WRITE_DELAY);
 
-                        /* All defaults, except the Receive Word
-                         * Alignament/Comma Detect Enable....(0xe800)
-                         */
-                        writel(0x0001C500, &xcvr->afe_xcvr_control0);
+                        writel(0x0050100F, &ihost->scu_registers->afe.scu_afe_xcvr[phy_id].afe_xcvr_control1);
                         udelay(AFE_REGISTER_WRITE_DELAY);
                 }
 
-                /* Power up TX and RX out from power down (PWRDNTX and
-                 * PWRDNRX) & increase TX int & ext bias 20%....(0xe85c)
-                 */
+                /*
+                 * Power up TX and RX out from power down (PWRDNTX and PWRDNRX)
+                 * & increase TX int & ext bias 20%....(0xe85c) */
                 if (is_a2(pdev))
-                        writel(0x000003F0, &xcvr->afe_channel_control);
+                        writel(0x000003F0, &ihost->scu_registers->afe.scu_afe_xcvr[phy_id].afe_channel_control);
                 else if (is_b0(pdev)) {
-                        writel(0x000003D7, &xcvr->afe_channel_control);
+                         /* Power down TX and RX (PWRDNTX and PWRDNRX) */
+                        writel(0x000003D7, &ihost->scu_registers->afe.scu_afe_xcvr[phy_id].afe_channel_control);
                         udelay(AFE_REGISTER_WRITE_DELAY);
 
-                        writel(0x000003D4, &xcvr->afe_channel_control);
-                } else if (is_c0(pdev)) {
-                        writel(0x000001E7, &xcvr->afe_channel_control);
-                        udelay(AFE_REGISTER_WRITE_DELAY);
-
-                        writel(0x000001E4, &xcvr->afe_channel_control);
-                } else if (is_c1(pdev)) {
-                        writel(cable_length_long ? 0x000002F7 : 0x000001F7,
-                               &xcvr->afe_channel_control);
+                        /*
+                         * Power up TX and RX out from power down (PWRDNTX and PWRDNRX)
+                         * & increase TX int & ext bias 20%....(0xe85c) */
+                        writel(0x000003D4, &ihost->scu_registers->afe.scu_afe_xcvr[phy_id].afe_channel_control);
+                } else {
+                        writel(0x000001E7, &ihost->scu_registers->afe.scu_afe_xcvr[phy_id].afe_channel_control);
                         udelay(AFE_REGISTER_WRITE_DELAY);
 
-                        writel(cable_length_long ? 0x000002F4 : 0x000001F4,
-                               &xcvr->afe_channel_control);
+                        /*
+                         * Power up TX and RX out from power down (PWRDNTX and PWRDNRX)
+                         * & increase TX int & ext bias 20%....(0xe85c) */
+                        writel(0x000001E4, &ihost->scu_registers->afe.scu_afe_xcvr[phy_id].afe_channel_control);
                 }
                 udelay(AFE_REGISTER_WRITE_DELAY);
 
                 if (is_a2(pdev)) {
                         /* Enable TX equalization (0xe824) */
-                        writel(0x00040000, &xcvr->afe_tx_control);
+                        writel(0x00040000, &ihost->scu_registers->afe.scu_afe_xcvr[phy_id].afe_tx_control);
                         udelay(AFE_REGISTER_WRITE_DELAY);
                 }
 
-                if (is_a2(pdev) || is_b0(pdev))
-                        /* RDPI=0x0(RX Power On), RXOOBDETPDNC=0x0,
-                         * TPD=0x0(TX Power On), RDD=0x0(RX Detect
-                         * Enabled) ....(0xe800)
-                         */
-                        writel(0x00004100, &xcvr->afe_xcvr_control0);
-                else if (is_c0(pdev))
-                        writel(0x00014100, &xcvr->afe_xcvr_control0);
-                else if (is_c1(pdev))
-                        writel(0x0001C100, &xcvr->afe_xcvr_control0);
+                /*
+                 * RDPI=0x0(RX Power On), RXOOBDETPDNC=0x0, TPD=0x0(TX Power On),
+                 * RDD=0x0(RX Detect Enabled) ....(0xe800) */
+                writel(0x00004100, &ihost->scu_registers->afe.scu_afe_xcvr[phy_id].afe_xcvr_control0);
                 udelay(AFE_REGISTER_WRITE_DELAY);
 
                 /* Leave DFE/FFE on */
                 if (is_a2(pdev))
-                        writel(0x3F11103F, &xcvr->afe_rx_ssc_control0);
+                        writel(0x3F11103F, &ihost->scu_registers->afe.scu_afe_xcvr[phy_id].afe_rx_ssc_control0);
                 else if (is_b0(pdev)) {
-                        writel(0x3F11103F, &xcvr->afe_rx_ssc_control0);
+                        writel(0x3F11103F, &ihost->scu_registers->afe.scu_afe_xcvr[phy_id].afe_rx_ssc_control0);
                         udelay(AFE_REGISTER_WRITE_DELAY);
                         /* Enable TX equalization (0xe824) */
-                        writel(0x00040000, &xcvr->afe_tx_control);
-                } else if (is_c0(pdev)) {
-                        writel(0x01400C0F, &xcvr->afe_rx_ssc_control1);
-                        udelay(AFE_REGISTER_WRITE_DELAY);
-
-                        writel(0x3F6F103F, &xcvr->afe_rx_ssc_control0);
-                        udelay(AFE_REGISTER_WRITE_DELAY);
-
-                        /* Enable TX equalization (0xe824) */
-                        writel(0x00040000, &xcvr->afe_tx_control);
-                } else if (is_c1(pdev)) {
-                        writel(cable_length_long ? 0x01500C0C :
-                               cable_length_medium ? 0x01400C0D : 0x02400C0D,
-                               &xcvr->afe_xcvr_control1);
-                        udelay(AFE_REGISTER_WRITE_DELAY);
-
-                        writel(0x000003E0, &xcvr->afe_dfx_rx_control1);
+                        writel(0x00040000, &ihost->scu_registers->afe.scu_afe_xcvr[phy_id].afe_tx_control);
+                } else {
+                        writel(0x0140DF0F, &ihost->scu_registers->afe.scu_afe_xcvr[phy_id].afe_rx_ssc_control1);
                         udelay(AFE_REGISTER_WRITE_DELAY);
 
-                        writel(cable_length_long ? 0x33091C1F :
-                               cable_length_medium ? 0x3315181F : 0x2B17161F,
-                               &xcvr->afe_rx_ssc_control0);
+                        writel(0x3F6F103F, &ihost->scu_registers->afe.scu_afe_xcvr[phy_id].afe_rx_ssc_control0);
                         udelay(AFE_REGISTER_WRITE_DELAY);
 
                         /* Enable TX equalization (0xe824) */
-                        writel(0x00040000, &xcvr->afe_tx_control);
+                        writel(0x00040000, &ihost->scu_registers->afe.scu_afe_xcvr[phy_id].afe_tx_control);
                 }
 
                 udelay(AFE_REGISTER_WRITE_DELAY);
 
-                writel(oem_phy->afe_tx_amp_control0, &xcvr->afe_tx_amp_control0);
+                writel(oem_phy->afe_tx_amp_control0,
+                        &ihost->scu_registers->afe.scu_afe_xcvr[phy_id].afe_tx_amp_control0);
                 udelay(AFE_REGISTER_WRITE_DELAY);
 
-                writel(oem_phy->afe_tx_amp_control1, &xcvr->afe_tx_amp_control1);
+                writel(oem_phy->afe_tx_amp_control1,
+                        &ihost->scu_registers->afe.scu_afe_xcvr[phy_id].afe_tx_amp_control1);
                 udelay(AFE_REGISTER_WRITE_DELAY);
 
-                writel(oem_phy->afe_tx_amp_control2, &xcvr->afe_tx_amp_control2);
+                writel(oem_phy->afe_tx_amp_control2,
+                        &ihost->scu_registers->afe.scu_afe_xcvr[phy_id].afe_tx_amp_control2);
                 udelay(AFE_REGISTER_WRITE_DELAY);
 
-                writel(oem_phy->afe_tx_amp_control3, &xcvr->afe_tx_amp_control3);
+                writel(oem_phy->afe_tx_amp_control3,
+                        &ihost->scu_registers->afe.scu_afe_xcvr[phy_id].afe_tx_amp_control3);
                 udelay(AFE_REGISTER_WRITE_DELAY);
         }
 
         /* Transfer control to the PEs */
-        writel(0x00010f00, &afe->afe_dfx_master_control0);
+        writel(0x00010f00, &ihost->scu_registers->afe.afe_dfx_master_control0);
         udelay(AFE_REGISTER_WRITE_DELAY);
 }
 
@@ -2139,8 +2066,9 @@ 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, "%s invalid state: %d\n",
-                         __func__, ihost->sm.current_state_id);
+                dev_warn(&ihost->pdev->dev,
+                         "SCIC Controller initialize operation requested "
+                         "in invalid state\n");
                 return SCI_FAILURE_INVALID_STATE;
         }
 
@@ -2243,76 +2171,96 @@ static enum sci_status sci_controller_initialize(struct isci_host *ihost)
         return result;
 }
 
-static int sci_controller_dma_alloc(struct isci_host *ihost)
+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)
 {
         struct device *dev = &ihost->pdev->dev;
+        dma_addr_t dma;
         size_t size;
-        int i;
-
-        /* detect re-initialization */
-        if (ihost->completion_queue)
-                return 0;
+        int err;
 
         size = SCU_MAX_COMPLETION_QUEUE_ENTRIES * sizeof(u32);
-        ihost->completion_queue = dmam_alloc_coherent(dev, size, &ihost->cq_dma,
-                                                      GFP_KERNEL);
+        ihost->completion_queue = dmam_alloc_coherent(dev, size, &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, &ihost->rnc_dma,
+        ihost->remote_node_context_table = dmam_alloc_coherent(dev, size, &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, &ihost->tc_dma,
-                                                        GFP_KERNEL);
+        ihost->task_context_table = dmam_alloc_coherent(dev, size, &dma, GFP_KERNEL);
         if (!ihost->task_context_table)
                 return -ENOMEM;
 
-        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);
+        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);
 
+        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.
@@ -2330,22 +2278,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 i, err;
+        int err = 0, i;
         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",
@@ -2354,6 +2302,48 @@ 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);
@@ -2369,11 +2359,36 @@ int isci_host_init(struct isci_host *ihost)
         if (err)
                 return err;
 
-        /* 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_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);
+
+        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;
 }
@@ -2420,7 +2435,7 @@ void sci_controller_link_down(struct isci_host *ihost, struct isci_port *iport,
         }
 }
 
-bool sci_controller_has_remote_devices_stopping(struct isci_host *ihost)
+static bool sci_controller_has_remote_devices_stopping(struct isci_host *ihost)
 {
         u32 index;
 
@@ -2446,7 +2461,7 @@ void sci_controller_remote_device_stopped(struct isci_host *ihost,
         }
 
         if (!sci_controller_has_remote_devices_stopping(ihost))
-                isci_host_stop_complete(ihost);
+                sci_change_state(&ihost->sm, SCIC_STOPPED);
 }
 
 void sci_controller_post_request(struct isci_host *ihost, u32 request)
@@ -2608,8 +2623,7 @@ 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, "%s invalid state: %d\n",
-                         __func__, ihost->sm.current_state_id);
+                dev_warn(&ihost->pdev->dev, "invalid state to start I/O");
                 return SCI_FAILURE_INVALID_STATE;
         }
 
@@ -2633,26 +2647,22 @@ 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, "%s invalid state: %d\n",
-                         __func__, ihost->sm.current_state_id);
+                dev_warn(&ihost->pdev->dev,
+                         "invalid state to terminate request\n");
                 return SCI_FAILURE_INVALID_STATE;
         }
-        status = sci_io_request_terminate(ireq);
 
-        dev_dbg(&ihost->pdev->dev, "%s: status=%d; ireq=%p; flags=%lx\n",
-                __func__, status, ireq, ireq->flags);
+        status = sci_io_request_terminate(ireq);
+        if (status != SCI_SUCCESS)
+                return status;
 
-        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;
+        /*
+         * 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;
 }
 
 /**
@@ -2686,8 +2696,7 @@ 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, "%s invalid state: %d\n",
-                         __func__, ihost->sm.current_state_id);
+                dev_warn(&ihost->pdev->dev, "invalid state to complete I/O");
                 return SCI_FAILURE_INVALID_STATE;
         }
 
@@ -2698,8 +2707,7 @@ 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, "%s invalid state: %d\n",
-                         __func__, ihost->sm.current_state_id);
+                dev_warn(&ihost->pdev->dev, "invalid state to continue I/O");
                 return SCI_FAILURE_INVALID_STATE;
         }
 
@@ -2752,56 +2760,3 @@ enum sci_task_status sci_controller_start_task(struct isci_host *ihost,
 
         return status;
 }
-
-static int sci_write_gpio_tx_gp(struct isci_host *ihost, u8 reg_index, u8 reg_count, u8 *write_data)
-{
-        int d;
-
-        /* no support for TX_GP_CFG */
-        if (reg_index == 0)
-                return -EINVAL;
-
-        for (d = 0; d < isci_gpio_count(ihost); d++) {
-                u32 val = 0x444; /* all ODx.n clear */
-                int i;
-
-                for (i = 0; i < 3; i++) {
-                        int bit = (i << 2) + 2;
-
-                        bit = try_test_sas_gpio_gp_bit(to_sas_gpio_od(d, i),
-                                                       write_data, reg_index,
-                                                       reg_count);
-                        if (bit < 0)
-                                break;
-
-                        /* if od is set, clear the 'invert' bit */
-                        val &= ~(bit << ((i << 2) + 2));
-                }
-
-                if (i < 3)
-                        break;
-                writel(val, &ihost->scu_registers->peg0.sgpio.output_data_select[d]);
-        }
-
-        /* unless reg_index is > 1, we should always be able to write at
-         * least one register
-         */
-        return d > 0;
-}
-
-int isci_gpio_write(struct sas_ha_struct *sas_ha, u8 reg_type, u8 reg_index,
-                    u8 reg_count, u8 *write_data)
-{
-        struct isci_host *ihost = sas_ha->lldd_ha;
-        int written;
-
-        switch (reg_type) {
-        case SAS_GPIO_REG_TX_GP:
-                written = sci_write_gpio_tx_gp(ihost, reg_index, reg_count, write_data);
-                break;
-        default:
-                written = -EINVAL;
-        }
-
-        return written;
-}
diff --git a/drivers/scsi/isci/host.h b/drivers/scsi/isci/host.h
index 4911310a38f..9f33831a2f0 100644
--- a/drivers/scsi/isci/host.h
+++ b/drivers/scsi/isci/host.h
@@ -55,7 +55,6 @@
 #ifndef _SCI_HOST_H_
 #define _SCI_HOST_H_
 
-#include <scsi/sas_ata.h>
 #include "remote_device.h"
 #include "phy.h"
 #include "isci.h"
@@ -109,8 +108,6 @@ 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;
@@ -160,17 +157,13 @@ 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 tc_dma;
+        dma_addr_t task_context_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 */
@@ -194,16 +187,19 @@ struct isci_host {
         int id; /* unique within a given pci device */
         struct isci_phy phys[SCI_MAX_PHYS];
         struct isci_port ports[SCI_MAX_PORTS + 1]; /* includes dummy port */
-        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];
@@ -277,6 +273,13 @@ 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.
@@ -305,16 +308,32 @@ 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));
@@ -340,11 +359,6 @@ 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
 
@@ -363,7 +377,8 @@ static inline int sci_remote_device_node_count(struct isci_remote_device *idev)
 {
         struct domain_device *dev = idev->domain_dev;
 
-        if (dev_is_sata(dev) && dev->parent)
+        if ((dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP)) &&
+            !idev->is_direct_attached)
                 return SCU_STP_REMOTE_NODE_COUNT;
         return SCU_SSP_REMOTE_NODE_COUNT;
 }
@@ -378,6 +393,24 @@ static inline int sci_remote_device_node_count(struct isci_remote_device *idev)
 #define sci_controller_clear_invalid_phy(controller, phy) \
         ((controller)->invalid_phy_mask &= ~(1 << (phy)->phy_index))
 
+static inline struct device *sciphy_to_dev(struct isci_phy *iphy)
+{
+
+        if (!iphy || !iphy->isci_port || !iphy->isci_port->isci_host)
+                return NULL;
+
+        return &iphy->isci_port->isci_host->pdev->dev;
+}
+
+static inline struct device *sciport_to_dev(struct isci_port *iport)
+{
+
+        if (!iport || !iport->isci_host)
+                return NULL;
+
+        return &iport->isci_host->pdev->dev;
+}
+
 static inline struct device *scirdev_to_dev(struct isci_remote_device *idev)
 {
         if (!idev || !idev->isci_port || !idev->isci_port->isci_host)
@@ -402,48 +435,11 @@ static inline bool is_b0(struct pci_dev *pdev)
 
 static inline bool is_c0(struct pci_dev *pdev)
 {
-        if (pdev->revision == 5)
-                return true;
-        return false;
-}
-
-static inline bool is_c1(struct pci_dev *pdev)
-{
-        if (pdev->revision >= 6)
+        if (pdev->revision >= 5)
                 return true;
         return false;
 }
 
-enum cable_selections {
-        short_cable     = 0,
-        long_cable      = 1,
-        medium_cable    = 2,
-        undefined_cable = 3
-};
-
-#define CABLE_OVERRIDE_DISABLED (0x10000)
-
-static inline int is_cable_select_overridden(void)
-{
-        return cable_selection_override < CABLE_OVERRIDE_DISABLED;
-}
-
-enum cable_selections decode_cable_selection(struct isci_host *ihost, int phy);
-void validate_cable_selections(struct isci_host *ihost);
-char *lookup_cable_names(enum cable_selections);
-
-/* set hw control for 'activity', even though active enclosures seem to drive
- * the activity led on their own.  Skip setting FSENG control on 'status' due
- * to unexpected operation and 'error' due to not being a supported automatic
- * FSENG output
- */
-#define SGPIO_HW_CONTROL 0x00000443
-
-static inline int isci_gpio_count(struct isci_host *ihost)
-{
-        return ARRAY_SIZE(ihost->scu_registers->peg0.sgpio.output_data_select);
-}
-
 void sci_controller_post_request(struct isci_host *ihost,
                                       u32 request);
 void sci_controller_release_frame(struct isci_host *ihost,
@@ -459,32 +455,66 @@ 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);
+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);
 
 enum sci_status sci_controller_continue_io(struct isci_request *ireq);
 int isci_host_scan_finished(struct Scsi_Host *, unsigned long);
-void isci_host_start(struct Scsi_Host *);
+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_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);
+
+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);
 
 enum sci_status sci_controller_start_io(
         struct isci_host *ihost,
@@ -512,7 +542,4 @@ void sci_port_configuration_agent_construct(
 enum sci_status sci_port_configuration_agent_initialize(
         struct isci_host *ihost,
         struct sci_port_configuration_agent *port_agent);
-
-int isci_gpio_write(struct sas_ha_struct *, u8 reg_type, u8 reg_index,
-                    u8 reg_count, u8 *write_data);
 #endif
diff --git a/drivers/scsi/isci/init.c b/drivers/scsi/isci/init.c
index d73fdcfeb45..29aa34efb0f 100644
--- a/drivers/scsi/isci/init.c
+++ b/drivers/scsi/isci/init.c
@@ -60,13 +60,12 @@
 #include <linux/efi.h>
 #include <asm/string.h>
 #include <scsi/scsi_host.h>
-#include "host.h"
 #include "isci.h"
 #include "task.h"
 #include "probe_roms.h"
 
 #define MAJ 1
-#define MIN 1
+#define MIN 0
 #define BUILD 0
 #define DRV_VERSION __stringify(MAJ) "." __stringify(MIN) "." \
         __stringify(BUILD)
@@ -95,7 +94,7 @@ MODULE_DEVICE_TABLE(pci, isci_id_table);
 
 /* linux isci specific settings */
 
-unsigned char no_outbound_task_to = 2;
+unsigned char no_outbound_task_to = 20;
 module_param(no_outbound_task_to, byte, 0);
 MODULE_PARM_DESC(no_outbound_task_to, "No Outbound Task Timeout (1us incr)");
 
@@ -115,22 +114,14 @@ u16 stp_inactive_to = 5;
 module_param(stp_inactive_to, ushort, 0);
 MODULE_PARM_DESC(stp_inactive_to, "STP inactivity timeout (100us incr)");
 
-unsigned char phy_gen = SCIC_SDS_PARM_GEN2_SPEED;
+unsigned char phy_gen = 3;
 module_param(phy_gen, byte, 0);
 MODULE_PARM_DESC(phy_gen, "PHY generation (1: 1.5Gbps 2: 3.0Gbps 3: 6.0Gbps)");
 
-unsigned char max_concurr_spinup;
+unsigned char max_concurr_spinup = 1;
 module_param(max_concurr_spinup, byte, 0);
 MODULE_PARM_DESC(max_concurr_spinup, "Max concurrent device spinup");
 
-uint cable_selection_override = CABLE_OVERRIDE_DISABLED;
-module_param(cable_selection_override, uint, 0);
-
-MODULE_PARM_DESC(cable_selection_override,
-                 "This field indicates length of the SAS/SATA cable between "
-                 "host and device. If any bits > 15 are set (default) "
-                 "indicates \"use platform defaults\"");
-
 static ssize_t isci_show_id(struct device *dev, struct device_attribute *attr, char *buf)
 {
         struct Scsi_Host *shost = container_of(dev, typeof(*shost), shost_dev);
@@ -155,8 +146,9 @@ static struct scsi_host_template isci_sht = {
         .queuecommand                   = sas_queuecommand,
         .target_alloc                   = sas_target_alloc,
         .slave_configure                = sas_slave_configure,
+        .slave_destroy                  = sas_slave_destroy,
         .scan_finished                  = isci_host_scan_finished,
-        .scan_start                     = isci_host_start,
+        .scan_start                     = isci_host_scan_start,
         .change_queue_depth             = sas_change_queue_depth,
         .change_queue_type              = sas_change_queue_type,
         .bios_param                     = sas_bios_param,
@@ -166,9 +158,9 @@ static struct scsi_host_template isci_sht = {
         .sg_tablesize                   = SG_ALL,
         .max_sectors                    = SCSI_DEFAULT_MAX_SECTORS,
         .use_clustering                 = ENABLE_CLUSTERING,
-        .eh_abort_handler               = sas_eh_abort_handler,
-        .eh_device_reset_handler        = sas_eh_device_reset_handler,
-        .eh_bus_reset_handler           = sas_eh_bus_reset_handler,
+        .eh_device_reset_handler        = sas_eh_device_reset_handler,
+        .eh_bus_reset_handler           = isci_bus_reset_handler,
+        .slave_alloc                    = sas_slave_alloc,
         .target_destroy                 = sas_target_destroy,
         .ioctl                          = sas_ioctl,
         .shost_attrs                    = isci_host_attrs,
@@ -194,18 +186,12 @@ static struct sas_domain_function_template isci_transport_ops  = {
         .lldd_lu_reset          = isci_task_lu_reset,
         .lldd_query_task        = isci_task_query_task,
 
-        /* ata recovery called from ata-eh */
-        .lldd_ata_check_ready   = isci_ata_check_ready,
-
         /* Port and Adapter management */
         .lldd_clear_nexus_port  = isci_task_clear_nexus_port,
         .lldd_clear_nexus_ha    = isci_task_clear_nexus_ha,
 
         /* Phy management */
         .lldd_control_phy       = isci_phy_control,
-
-        /* GPIO support */
-        .lldd_write_gpio        = isci_gpio_write,
 };
 
 
@@ -222,7 +208,7 @@ static struct sas_domain_function_template isci_transport_ops  = {
  * @isci_host: This parameter specifies the lldd specific wrapper for the
  *    libsas sas_ha struct.
  *
- * This method returns an error code indicating success or failure. The user
+ * This method returns an error code indicating sucess or failure. The user
  * should check for possible memory allocation error return otherwise, a zero
  * indicates success.
  */
@@ -245,13 +231,18 @@ static int isci_register_sas_ha(struct isci_host *isci_host)
         if (!sas_ports)
                 return -ENOMEM;
 
+        /*----------------- Libsas Initialization Stuff----------------------
+         * Set various fields in the sas_ha struct:
+         */
+
         sas_ha->sas_ha_name = DRV_NAME;
         sas_ha->lldd_module = THIS_MODULE;
         sas_ha->sas_addr    = &isci_host->phys[0].sas_addr[0];
 
+        /* set the array of phy and port structs.  */
         for (i = 0; i < SCI_MAX_PHYS; i++) {
                 sas_phys[i] = &isci_host->phys[i].sas_phy;
-                sas_ports[i] = &isci_host->sas_ports[i];
+                sas_ports[i] = &isci_host->ports[i].sas_port;
         }
 
         sas_ha->sas_phy  = sas_phys;
@@ -274,15 +265,16 @@ static void isci_unregister(struct isci_host *isci_host)
         if (!isci_host)
                 return;
 
+        shost = isci_host->shost;
+
         sas_unregister_ha(&isci_host->sas_ha);
 
-        shost = to_shost(isci_host);
-        sas_remove_host(shost);
-        scsi_remove_host(shost);
-        scsi_host_put(shost);
+        sas_remove_host(isci_host->shost);
+        scsi_remove_host(isci_host->shost);
+        scsi_host_put(isci_host->shost);
 }
 
-static int isci_pci_init(struct pci_dev *pdev)
+static int __devinit isci_pci_init(struct pci_dev *pdev)
 {
         int err, bar_num, bar_mask = 0;
         void __iomem * const *iomap;
@@ -399,199 +391,30 @@ 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_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 isci_host *isci_host;
         struct Scsi_Host *shost;
-        int err, i;
-
-        ihost = devm_kzalloc(&pdev->dev, sizeof(*ihost), GFP_KERNEL);
-        if (!ihost)
-                return NULL;
-
-        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;
-        }
+        int err;
 
-        /* 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");
+        isci_host = devm_kzalloc(&pdev->dev, sizeof(*isci_host), GFP_KERNEL);
+        if (!isci_host)
                 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);
-        }
+        isci_host->pdev = pdev;
+        isci_host->id = id;
 
         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() ? "* " : ""), 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(ihost);
+        err = isci_host_init(isci_host);
         if (err)
                 goto err_shost;
 
-        SHOST_TO_SAS_HA(shost) = &ihost->sas_ha;
-        ihost->sas_ha.core.shost = shost;
+        SHOST_TO_SAS_HA(shost) = &isci_host->sas_ha;
+        isci_host->sas_ha.core.shost = shost;
         shost->transportt = isci_transport_template;
 
         shost->max_id = ~0;
@@ -602,11 +425,11 @@ static struct isci_host *isci_host_alloc(struct pci_dev *pdev, int id)
         if (err)
                 goto err_shost;
 
-        err = isci_register_sas_ha(ihost);
+        err = isci_register_sas_ha(isci_host);
         if (err)
                 goto err_shost_remove;
 
-        return ihost;
+        return isci_host;
 
  err_shost_remove:
         scsi_remove_host(shost);
@@ -616,7 +439,7 @@ static struct isci_host *isci_host_alloc(struct pci_dev *pdev, int id)
         return NULL;
 }
 
-static int isci_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
+static int __devinit isci_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
 {
         struct isci_pci_info *pci_info;
         int err, i;
@@ -639,11 +462,11 @@ static int isci_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         if (!orom)
                 orom = isci_request_oprom(pdev);
 
-        for (i = 0; orom && i < num_controllers(pdev); i++) {
-                if (sci_oem_parameters_validate(&orom->ctrl[i],
-                                                orom->hdr.version)) {
+        for (i = 0; orom && i < ARRAY_SIZE(orom->ctrl); i++) {
+                if (sci_oem_parameters_validate(&orom->ctrl[i])) {
                         dev_warn(&pdev->dev,
                                  "[%d]: invalid oem parameters detected, falling back to firmware\n", i);
+                        devm_kfree(&pdev->dev, orom);
                         orom = NULL;
                         break;
                 }
@@ -685,13 +508,6 @@ static int isci_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
                         goto err_host_alloc;
                 }
                 pci_info->hosts[i] = h;
-
-                /* turn on DIF support */
-                scsi_host_set_prot(to_shost(h),
-                                   SHOST_DIF_TYPE1_PROTECTION |
-                                   SHOST_DIF_TYPE2_PROTECTION |
-                                   SHOST_DIF_TYPE3_PROTECTION);
-                scsi_host_set_guard(to_shost(h), SHOST_DIX_GUARD_CRC);
         }
 
         err = isci_setup_interrupts(pdev);
@@ -699,7 +515,7 @@ static int isci_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
                 goto err_host_alloc;
 
         for_each_isci_host(i, isci_host, pdev)
-                scsi_scan_host(to_shost(isci_host));
+                scsi_scan_host(isci_host->shost);
 
         return 0;
 
@@ -709,79 +525,23 @@ static int isci_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         return err;
 }
 
-static void isci_pci_remove(struct pci_dev *pdev)
+static void __devexit isci_pci_remove(struct pci_dev *pdev)
 {
         struct isci_host *ihost;
         int i;
 
         for_each_isci_host(i, ihost, pdev) {
-                wait_for_start(ihost);
                 isci_unregister(ihost);
                 isci_host_deinit(ihost);
+                sci_controller_disable_interrupts(ihost);
         }
 }
 
-#ifdef CONFIG_PM
-static int isci_suspend(struct device *dev)
-{
-        struct pci_dev *pdev = to_pci_dev(dev);
-        struct isci_host *ihost;
-        int i;
-
-        for_each_isci_host(i, ihost, pdev) {
-                sas_suspend_ha(&ihost->sas_ha);
-                isci_host_deinit(ihost);
-        }
-
-        pci_save_state(pdev);
-        pci_disable_device(pdev);
-        pci_set_power_state(pdev, PCI_D3hot);
-
-        return 0;
-}
-
-static int isci_resume(struct device *dev)
-{
-        struct pci_dev *pdev = to_pci_dev(dev);
-        struct isci_host *ihost;
-        int rc, i;
-
-        pci_set_power_state(pdev, PCI_D0);
-        pci_restore_state(pdev);
-
-        rc = pcim_enable_device(pdev);
-        if (rc) {
-                dev_err(&pdev->dev,
-                        "enabling device failure after resume(%d)\n", rc);
-                return rc;
-        }
-
-        pci_set_master(pdev);
-
-        for_each_isci_host(i, ihost, pdev) {
-                sas_prep_resume_ha(&ihost->sas_ha);
-
-                isci_host_init(ihost);
-                isci_host_start(ihost->sas_ha.core.shost);
-                wait_for_start(ihost);
-
-                sas_resume_ha(&ihost->sas_ha);
-        }
-
-        return 0;
-}
-
-static SIMPLE_DEV_PM_OPS(isci_pm_ops, isci_suspend, isci_resume);
-#endif
-
 static struct pci_driver isci_pci_driver = {
         .name           = DRV_NAME,
         .id_table       = isci_id_table,
         .probe          = isci_pci_probe,
-        .remove         = isci_pci_remove,
-#ifdef CONFIG_PM
-        .driver.pm      = &isci_pm_ops,
-#endif
+        .remove         = __devexit_p(isci_pci_remove),
 };
 
 static __init int isci_init(void)
diff --git a/drivers/scsi/isci/isci.h b/drivers/scsi/isci/isci.h
index 234ab46fce3..8efeb6b0832 100644
--- a/drivers/scsi/isci/isci.h
+++ b/drivers/scsi/isci/isci.h
@@ -480,7 +480,6 @@ extern u16 ssp_inactive_to;
 extern u16 stp_inactive_to;
 extern unsigned char phy_gen;
 extern unsigned char max_concurr_spinup;
-extern uint cable_selection_override;
 
 irqreturn_t isci_msix_isr(int vec, void *data);
 irqreturn_t isci_intx_isr(int vec, void *data);
diff --git a/drivers/scsi/isci/phy.c b/drivers/scsi/isci/phy.c
index cb87b2ef7c9..430fc8ff014 100644
--- a/drivers/scsi/isci/phy.c
+++ b/drivers/scsi/isci/phy.c
@@ -59,16 +59,6 @@
 #include "scu_event_codes.h"
 #include "probe_roms.h"
 
-#undef C
-#define C(a) (#a)
-static const char *phy_state_name(enum sci_phy_states state)
-{
-        static const char * const strings[] = PHY_STATES;
-
-        return strings[state];
-}
-#undef C
-
 /* Maximum arbitration wait time in micro-seconds */
 #define SCIC_SDS_PHY_MAX_ARBITRATION_WAIT_TIME  (700)
 
@@ -77,19 +67,6 @@ enum sas_linkrate sci_phy_linkrate(struct isci_phy *iphy)
         return iphy->max_negotiated_speed;
 }
 
-static struct isci_host *phy_to_host(struct isci_phy *iphy)
-{
-        struct isci_phy *table = iphy - iphy->phy_index;
-        struct isci_host *ihost = container_of(table, typeof(*ihost), phys[0]);
-
-        return ihost;
-}
-
-static struct device *sciphy_to_dev(struct isci_phy *iphy)
-{
-        return &phy_to_host(iphy)->pdev->dev;
-}
-
 static enum sci_status
 sci_phy_transport_layer_initialization(struct isci_phy *iphy,
                                        struct scu_transport_layer_registers __iomem *reg)
@@ -114,23 +91,22 @@ sci_phy_transport_layer_initialization(struct isci_phy *iphy,
 
 static enum sci_status
 sci_phy_link_layer_initialization(struct isci_phy *iphy,
-                                  struct scu_link_layer_registers __iomem *llr)
+                                  struct scu_link_layer_registers __iomem *reg)
 {
         struct isci_host *ihost = iphy->owning_port->owning_controller;
-        struct sci_phy_user_params *phy_user;
-        struct sci_phy_oem_params *phy_oem;
         int phy_idx = iphy->phy_index;
-        struct sci_phy_cap phy_cap;
+        struct sci_phy_user_params *phy_user = &ihost->user_parameters.phys[phy_idx];
+        struct sci_phy_oem_params *phy_oem =
+                &ihost->oem_parameters.phys[phy_idx];
         u32 phy_configuration;
+        struct sci_phy_cap phy_cap;
         u32 parity_check = 0;
         u32 parity_count = 0;
         u32 llctl, link_rate;
         u32 clksm_value = 0;
         u32 sp_timeouts = 0;
 
-        phy_user = &ihost->user_parameters.phys[phy_idx];
-        phy_oem = &ihost->oem_parameters.phys[phy_idx];
-        iphy->link_layer_registers = llr;
+        iphy->link_layer_registers = reg;
 
         /* Set our IDENTIFY frame data */
         #define SCI_END_DEVICE 0x01
@@ -140,26 +116,32 @@ sci_phy_link_layer_initialization(struct isci_phy *iphy,
                SCU_SAS_TIID_GEN_BIT(STP_INITIATOR) |
                SCU_SAS_TIID_GEN_BIT(DA_SATA_HOST) |
                SCU_SAS_TIID_GEN_VAL(DEVICE_TYPE, SCI_END_DEVICE),
-               &llr->transmit_identification);
+               &iphy->link_layer_registers->transmit_identification);
 
         /* Write the device SAS Address */
-        writel(0xFEDCBA98, &llr->sas_device_name_high);
-        writel(phy_idx, &llr->sas_device_name_low);
+        writel(0xFEDCBA98,
+               &iphy->link_layer_registers->sas_device_name_high);
+        writel(phy_idx, &iphy->link_layer_registers->sas_device_name_low);
 
         /* Write the source SAS Address */
-        writel(phy_oem->sas_address.high, &llr->source_sas_address_high);
-        writel(phy_oem->sas_address.low, &llr->source_sas_address_low);
+        writel(phy_oem->sas_address.high,
+                &iphy->link_layer_registers->source_sas_address_high);
+        writel(phy_oem->sas_address.low,
+                &iphy->link_layer_registers->source_sas_address_low);
 
         /* Clear and Set the PHY Identifier */
-        writel(0, &llr->identify_frame_phy_id);
-        writel(SCU_SAS_TIPID_GEN_VALUE(ID, phy_idx), &llr->identify_frame_phy_id);
+        writel(0, &iphy->link_layer_registers->identify_frame_phy_id);
+        writel(SCU_SAS_TIPID_GEN_VALUE(ID, phy_idx),
+                &iphy->link_layer_registers->identify_frame_phy_id);
 
         /* Change the initial state of the phy configuration register */
-        phy_configuration = readl(&llr->phy_configuration);
+        phy_configuration =
+                readl(&iphy->link_layer_registers->phy_configuration);
 
         /* Hold OOB state machine in reset */
         phy_configuration |=  SCU_SAS_PCFG_GEN_BIT(OOB_RESET);
-        writel(phy_configuration, &llr->phy_configuration);
+        writel(phy_configuration,
+                &iphy->link_layer_registers->phy_configuration);
 
         /* Configure the SNW capabilities */
         phy_cap.all = 0;
@@ -167,64 +149,15 @@ sci_phy_link_layer_initialization(struct isci_phy *iphy,
         phy_cap.gen3_no_ssc = 1;
         phy_cap.gen2_no_ssc = 1;
         phy_cap.gen1_no_ssc = 1;
-        if (ihost->oem_parameters.controller.do_enable_ssc) {
-                struct scu_afe_registers __iomem *afe = &ihost->scu_registers->afe;
-                struct scu_afe_transceiver __iomem *xcvr = &afe->scu_afe_xcvr[phy_idx];
-                struct isci_pci_info *pci_info = to_pci_info(ihost->pdev);
-                bool en_sas = false;
-                bool en_sata = false;
-                u32 sas_type = 0;
-                u32 sata_spread = 0x2;
-                u32 sas_spread = 0x2;
-
+        if (ihost->oem_parameters.controller.do_enable_ssc == true) {
                 phy_cap.gen3_ssc = 1;
                 phy_cap.gen2_ssc = 1;
                 phy_cap.gen1_ssc = 1;
-
-                if (pci_info->orom->hdr.version < ISCI_ROM_VER_1_1)
-                        en_sas = en_sata = true;
-                else {
-                        sata_spread = ihost->oem_parameters.controller.ssc_sata_tx_spread_level;
-                        sas_spread = ihost->oem_parameters.controller.ssc_sas_tx_spread_level;
-
-                        if (sata_spread)
-                                en_sata = true;
-
-                        if (sas_spread) {
-                                en_sas = true;
-                                sas_type = ihost->oem_parameters.controller.ssc_sas_tx_type;
-                        }
-
-                }
-
-                if (en_sas) {
-                        u32 reg;
-
-                        reg = readl(&xcvr->afe_xcvr_control0);
-                        reg |= (0x00100000 | (sas_type << 19));
-                        writel(reg, &xcvr->afe_xcvr_control0);
-
-                        reg = readl(&xcvr->afe_tx_ssc_control);
-                        reg |= sas_spread << 8;
-                        writel(reg, &xcvr->afe_tx_ssc_control);
-                }
-
-                if (en_sata) {
-                        u32 reg;
-
-                        reg = readl(&xcvr->afe_tx_ssc_control);
-                        reg |= sata_spread;
-                        writel(reg, &xcvr->afe_tx_ssc_control);
-
-                        reg = readl(&llr->stp_control);
-                        reg |= 1 << 12;
-                        writel(reg, &llr->stp_control);
-                }
         }
 
-        /* The SAS specification indicates that the phy_capabilities that
-         * are transmitted shall have an even parity.  Calculate the parity.
-         */
+        /*
+         * The SAS specification indicates that the phy_capabilities that
+         * are transmitted shall have an even parity.  Calculate the parity. */
         parity_check = phy_cap.all;
         while (parity_check != 0) {
                 if (parity_check & 0x1)
@@ -232,20 +165,20 @@ sci_phy_link_layer_initialization(struct isci_phy *iphy,
                 parity_check >>= 1;
         }
 
-        /* If parity indicates there are an odd number of bits set, then
-         * set the parity bit to 1 in the phy capabilities.
-         */
+        /*
+         * If parity indicates there are an odd number of bits set, then
+         * set the parity bit to 1 in the phy capabilities. */
         if ((parity_count % 2) != 0)
                 phy_cap.parity = 1;
 
-        writel(phy_cap.all, &llr->phy_capabilities);
+        writel(phy_cap.all, &iphy->link_layer_registers->phy_capabilities);
 
         /* Set the enable spinup period but disable the ability to send
          * notify enable spinup
          */
         writel(SCU_ENSPINUP_GEN_VAL(COUNT,
                         phy_user->notify_enable_spin_up_insertion_frequency),
-                &llr->notify_enable_spinup_control);
+                &iphy->link_layer_registers->notify_enable_spinup_control);
 
         /* Write the ALIGN Insertion Ferequency for connected phy and
          * inpendent of connected state
@@ -256,13 +189,11 @@ sci_phy_link_layer_initialization(struct isci_phy *iphy,
         clksm_value |= SCU_ALIGN_INSERTION_FREQUENCY_GEN_VAL(GENERAL,
                         phy_user->align_insertion_frequency);
 
-        writel(clksm_value, &llr->clock_skew_management);
+        writel(clksm_value, &iphy->link_layer_registers->clock_skew_management);
 
-        if (is_c0(ihost->pdev) || is_c1(ihost->pdev)) {
-                writel(0x04210400, &llr->afe_lookup_table_control);
-                writel(0x020A7C05, &llr->sas_primitive_timeout);
-        } else
-                writel(0x02108421, &llr->afe_lookup_table_control);
+        /* @todo Provide a way to write this register correctly */
+        writel(0x02108421,
+                &iphy->link_layer_registers->afe_lookup_table_control);
 
         llctl = SCU_SAS_LLCTL_GEN_VAL(NO_OUTBOUND_TASK_TIMEOUT,
                 (u8)ihost->user_parameters.no_outbound_task_timeout);
@@ -279,9 +210,9 @@ sci_phy_link_layer_initialization(struct isci_phy *iphy,
                 break;
         }
         llctl |= SCU_SAS_LLCTL_GEN_VAL(MAX_LINK_RATE, link_rate);
-        writel(llctl, &llr->link_layer_control);
+        writel(llctl, &iphy->link_layer_registers->link_layer_control);
 
-        sp_timeouts = readl(&llr->sas_phy_timeouts);
+        sp_timeouts = readl(&iphy->link_layer_registers->sas_phy_timeouts);
 
         /* Clear the default 0x36 (54us) RATE_CHANGE timeout value. */
         sp_timeouts &= ~SCU_SAS_PHYTOV_GEN_VAL(RATE_CHANGE, 0xFF);
@@ -291,23 +222,20 @@ sci_phy_link_layer_initialization(struct isci_phy *iphy,
          */
         sp_timeouts |= SCU_SAS_PHYTOV_GEN_VAL(RATE_CHANGE, 0x3B);
 
-        writel(sp_timeouts, &llr->sas_phy_timeouts);
+        writel(sp_timeouts, &iphy->link_layer_registers->sas_phy_timeouts);
 
         if (is_a2(ihost->pdev)) {
-                /* Program the max ARB time for the PHY to 700us so we
-                 * inter-operate with the PMC expander which shuts down
-                 * PHYs if the expander PHY generates too many breaks.
-                 * This time value will guarantee that the initiator PHY
-                 * will generate the break.
+                /* Program the max ARB time for the PHY to 700us so we inter-operate with
+                 * the PMC expander which shuts down PHYs if the expander PHY generates too
+                 * many breaks.  This time value will guarantee that the initiator PHY will
+                 * generate the break.
                  */
                 writel(SCIC_SDS_PHY_MAX_ARBITRATION_WAIT_TIME,
-                       &llr->maximum_arbitration_wait_timer_timeout);
+                        &iphy->link_layer_registers->maximum_arbitration_wait_timer_timeout);
         }
 
-        /* Disable link layer hang detection, rely on the OS timeout for
-         * I/O timeouts.
-         */
-        writel(0, &llr->link_layer_hang_detection_timeout);
+        /* Disable link layer hang detection, rely on the OS timeout for I/O timeouts. */
+        writel(0, &iphy->link_layer_registers->link_layer_hang_detection_timeout);
 
         /* We can exit the initial state to the stopped state */
         sci_change_state(&iphy->sm, SCI_PHY_STOPPED);
@@ -469,8 +397,8 @@ enum sci_status sci_phy_start(struct isci_phy *iphy)
         enum sci_phy_states state = iphy->sm.current_state_id;
 
         if (state != SCI_PHY_STOPPED) {
-                dev_dbg(sciphy_to_dev(iphy), "%s: in wrong state: %s\n",
-                        __func__, phy_state_name(state));
+                dev_dbg(sciphy_to_dev(iphy),
+                         "%s: in wrong state: %d\n", __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
         }
 
@@ -495,8 +423,8 @@ enum sci_status sci_phy_stop(struct isci_phy *iphy)
         case SCI_PHY_READY:
                 break;
         default:
-                dev_dbg(sciphy_to_dev(iphy), "%s: in wrong state: %s\n",
-                        __func__, phy_state_name(state));
+                dev_dbg(sciphy_to_dev(iphy),
+                        "%s: in wrong state: %d\n", __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
         }
 
@@ -509,8 +437,8 @@ enum sci_status sci_phy_reset(struct isci_phy *iphy)
         enum sci_phy_states state = iphy->sm.current_state_id;
 
         if (state != SCI_PHY_READY) {
-                dev_dbg(sciphy_to_dev(iphy), "%s: in wrong state: %s\n",
-                        __func__, phy_state_name(state));
+                dev_dbg(sciphy_to_dev(iphy),
+                        "%s: in wrong state: %d\n", __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
         }
 
@@ -559,8 +487,8 @@ enum sci_status sci_phy_consume_power_handler(struct isci_phy *iphy)
                 return SCI_SUCCESS;
         }
         default:
-                dev_dbg(sciphy_to_dev(iphy), "%s: in wrong state: %s\n",
-                        __func__, phy_state_name(state));
+                dev_dbg(sciphy_to_dev(iphy),
+                        "%s: in wrong state: %d\n", __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
         }
 }
@@ -580,7 +508,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 = SAS_PROTOCOL_SSP;
+        iphy->protocol = SCIC_SDS_PHY_PROTOCOL_SAS;
 }
 
 static void sci_phy_start_sata_link_training(struct isci_phy *iphy)
@@ -591,7 +519,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 = SAS_PROTOCOL_SATA;
+        iphy->protocol = SCIC_SDS_PHY_PROTOCOL_SATA;
 }
 
 /**
@@ -614,73 +542,6 @@ static void sci_phy_complete_link_training(struct isci_phy *iphy,
         sci_change_state(&iphy->sm, next_state);
 }
 
-static const char *phy_event_name(u32 event_code)
-{
-        switch (scu_get_event_code(event_code)) {
-        case SCU_EVENT_PORT_SELECTOR_DETECTED:
-                return "port selector";
-        case SCU_EVENT_SENT_PORT_SELECTION:
-                return "port selection";
-        case SCU_EVENT_HARD_RESET_TRANSMITTED:
-                return "tx hard reset";
-        case SCU_EVENT_HARD_RESET_RECEIVED:
-                return "rx hard reset";
-        case SCU_EVENT_RECEIVED_IDENTIFY_TIMEOUT:
-                return "identify timeout";
-        case SCU_EVENT_LINK_FAILURE:
-                return "link fail";
-        case SCU_EVENT_SATA_SPINUP_HOLD:
-                return "sata spinup hold";
-        case SCU_EVENT_SAS_15_SSC:
-        case SCU_EVENT_SAS_15:
-                return "sas 1.5";
-        case SCU_EVENT_SAS_30_SSC:
-        case SCU_EVENT_SAS_30:
-                return "sas 3.0";
-        case SCU_EVENT_SAS_60_SSC:
-        case SCU_EVENT_SAS_60:
-                return "sas 6.0";
-        case SCU_EVENT_SATA_15_SSC:
-        case SCU_EVENT_SATA_15:
-                return "sata 1.5";
-        case SCU_EVENT_SATA_30_SSC:
-        case SCU_EVENT_SATA_30:
-                return "sata 3.0";
-        case SCU_EVENT_SATA_60_SSC:
-        case SCU_EVENT_SATA_60:
-                return "sata 6.0";
-        case SCU_EVENT_SAS_PHY_DETECTED:
-                return "sas detect";
-        case SCU_EVENT_SATA_PHY_DETECTED:
-                return "sata detect";
-        default:
-                return "unknown";
-        }
-}
-
-#define phy_event_dbg(iphy, state, code) \
-        dev_dbg(sciphy_to_dev(iphy), "phy-%d:%d: %s event: %s (%x)\n", \
-                phy_to_host(iphy)->id, iphy->phy_index, \
-                phy_state_name(state), phy_event_name(code), code)
-
-#define phy_event_warn(iphy, state, code) \
-        dev_warn(sciphy_to_dev(iphy), "phy-%d:%d: %s event: %s (%x)\n", \
-                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;
@@ -696,15 +557,12 @@ 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);
+                        dev_dbg(sciphy_to_dev(iphy),
+                                "%s: PHY starting substate machine received "
+                                "unexpected event_code %x\n",
+                                __func__,
+                                event_code);
                         return SCI_FAILURE;
                 }
                 return SCI_SUCCESS;
@@ -737,21 +595,15 @@ 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);
+                        dev_warn(sciphy_to_dev(iphy),
+                                 "%s: PHY starting substate machine received "
+                                 "unexpected event_code %x\n",
+                                 __func__, event_code);
+
                         return SCI_FAILURE;
                         break;
                 }
@@ -770,43 +622,37 @@ 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);
                         break;
                 default:
-                        phy_event_warn(iphy, state, event_code);
+                        dev_warn(sciphy_to_dev(iphy),
+                                 "%s: PHY starting substate machine received "
+                                 "unexpected event_code %x\n",
+                                 __func__, event_code);
                         return SCI_FAILURE;
                 }
                 return SCI_SUCCESS;
         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;
                 default:
-                        phy_event_warn(iphy, state, event_code);
+                        dev_warn(sciphy_to_dev(iphy),
+                                "%s: PHY starting substate machine received unexpected "
+                                "event_code %x\n",
+                                __func__,
+                                event_code);
                         return SCI_FAILURE;
                 }
                 return SCI_SUCCESS;
         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;
@@ -824,16 +670,17 @@ enum sci_status sci_phy_event_handler(struct isci_phy *iphy, u32 event_code)
                         break;
 
                 default:
-                        phy_event_warn(iphy, state, event_code);
+                        dev_warn(sciphy_to_dev(iphy),
+                                 "%s: PHY starting substate machine received "
+                                 "unexpected event_code %x\n",
+                                 __func__, event_code);
+
                         return SCI_FAILURE;
                 }
                 return SCI_SUCCESS;
         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;
@@ -843,7 +690,7 @@ enum sci_status sci_phy_event_handler(struct isci_phy *iphy, u32 event_code)
                          */
                         break;
                 case SCU_EVENT_SATA_PHY_DETECTED:
-                        iphy->protocol = SAS_PROTOCOL_SATA;
+                        iphy->protocol = SCIC_SDS_PHY_PROTOCOL_SATA;
 
                         /* We have received the SATA PHY notification change state */
                         sci_change_state(&iphy->sm, SCI_PHY_SUB_AWAIT_SATA_SPEED_EN);
@@ -855,8 +702,13 @@ enum sci_status sci_phy_event_handler(struct isci_phy *iphy, u32 event_code)
                         sci_phy_start_sas_link_training(iphy);
                         break;
                 default:
-                        phy_event_warn(iphy, state, event_code);
-                        return SCI_FAILURE;
+                        dev_warn(sciphy_to_dev(iphy),
+                                 "%s: PHY starting substate machine received "
+                                 "unexpected event_code %x\n",
+                                 __func__,
+                                 event_code);
+
+                        return SCI_FAILURE;;
                 }
                 return SCI_SUCCESS;
         case SCI_PHY_SUB_AWAIT_SATA_SPEED_EN:
@@ -882,9 +734,6 @@ 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;
@@ -895,7 +744,11 @@ enum sci_status sci_phy_event_handler(struct isci_phy *iphy, u32 event_code)
                         sci_phy_start_sas_link_training(iphy);
                         break;
                 default:
-                        phy_event_warn(iphy, state, event_code);
+                        dev_warn(sciphy_to_dev(iphy),
+                                 "%s: PHY starting substate machine received "
+                                 "unexpected event_code %x\n",
+                                 __func__, event_code);
+
                         return SCI_FAILURE;
                 }
 
@@ -908,43 +761,38 @@ 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;
 
                 default:
-                        phy_event_warn(iphy, state, event_code);
+                        dev_warn(sciphy_to_dev(iphy),
+                                 "%s: PHY starting substate machine received "
+                                 "unexpected event_code %x\n",
+                                 __func__,
+                                 event_code);
+
                         return SCI_FAILURE;
                 }
                 return SCI_SUCCESS;
         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);
+                        dev_warn(sciphy_to_dev(iphy),
+                                 "%sP SCIC PHY 0x%p ready state machine received "
+                                 "unexpected event_code %x\n",
+                                 __func__, iphy, event_code);
                         return SCI_FAILURE_INVALID_STATE;
                 }
                 return SCI_SUCCESS;
@@ -955,14 +803,18 @@ enum sci_status sci_phy_event_handler(struct isci_phy *iphy, u32 event_code)
                         sci_change_state(&iphy->sm, SCI_PHY_STARTING);
                         break;
                 default:
-                        phy_event_warn(iphy, state, event_code);
+                        dev_warn(sciphy_to_dev(iphy),
+                                 "%s: SCIC PHY 0x%p resetting state machine received "
+                                 "unexpected event_code %x\n",
+                                 __func__, iphy, event_code);
+
                         return SCI_FAILURE_INVALID_STATE;
                         break;
                 }
                 return SCI_SUCCESS;
         default:
-                dev_dbg(sciphy_to_dev(iphy), "%s: in wrong state: %s\n",
-                        __func__, phy_state_name(state));
+                dev_dbg(sciphy_to_dev(iphy),
+                        "%s: in wrong state: %d\n", __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
         }
 }
@@ -1055,8 +907,8 @@ enum sci_status sci_phy_frame_handler(struct isci_phy *iphy, u32 frame_index)
                 return result;
         }
         default:
-                dev_dbg(sciphy_to_dev(iphy), "%s: in wrong state: %s\n",
-                        __func__, phy_state_name(state));
+                dev_dbg(sciphy_to_dev(iphy),
+                        "%s: in wrong state: %d\n", __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
         }
 
@@ -1197,26 +1049,24 @@ static void scu_link_layer_stop_protocol_engine(
         writel(enable_spinup_value, &iphy->link_layer_registers->notify_enable_spinup_control);
 }
 
-static void scu_link_layer_start_oob(struct isci_phy *iphy)
+/**
+ *
+ *
+ * This method will start the OOB/SN state machine for this struct isci_phy object.
+ */
+static void scu_link_layer_start_oob(
+        struct isci_phy *iphy)
 {
-        struct scu_link_layer_registers __iomem *ll = iphy->link_layer_registers;
-        u32 val;
-
-        /** Reset OOB sequence - start */
-        val = readl(&ll->phy_configuration);
-        val &= ~(SCU_SAS_PCFG_GEN_BIT(OOB_RESET) |
-                 SCU_SAS_PCFG_GEN_BIT(OOB_ENABLE) |
-                 SCU_SAS_PCFG_GEN_BIT(HARD_RESET));
-        writel(val, &ll->phy_configuration);
-        readl(&ll->phy_configuration); /* flush */
-        /** Reset OOB sequence - end */
-
-        /** Start OOB sequence - start */
-        val = readl(&ll->phy_configuration);
-        val |= SCU_SAS_PCFG_GEN_BIT(OOB_ENABLE);
-        writel(val, &ll->phy_configuration);
-        readl(&ll->phy_configuration); /* flush */
-        /** Start OOB sequence - end */
+        u32 scu_sas_pcfg_value;
+
+        scu_sas_pcfg_value =
+                readl(&iphy->link_layer_registers->phy_configuration);
+        scu_sas_pcfg_value |= SCU_SAS_PCFG_GEN_BIT(OOB_ENABLE);
+        scu_sas_pcfg_value &=
+                ~(SCU_SAS_PCFG_GEN_BIT(OOB_RESET) |
+                SCU_SAS_PCFG_GEN_BIT(HARD_RESET));
+        writel(scu_sas_pcfg_value,
+               &iphy->link_layer_registers->phy_configuration);
 }
 
 /**
@@ -1237,7 +1087,6 @@ static void scu_link_layer_tx_hard_reset(
          * to the starting state. */
         phy_configuration_value =
                 readl(&iphy->link_layer_registers->phy_configuration);
-        phy_configuration_value &= ~(SCU_SAS_PCFG_GEN_BIT(OOB_ENABLE));
         phy_configuration_value |=
                 (SCU_SAS_PCFG_GEN_BIT(HARD_RESET) |
                  SCU_SAS_PCFG_GEN_BIT(OOB_RESET));
@@ -1279,7 +1128,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 = SAS_PROTOCOL_NONE;
+        iphy->protocol = SCIC_SDS_PHY_PROTOCOL_UNKNOWN;
         iphy->bcn_received_while_port_unassigned = false;
 
         if (iphy->sm.previous_state_id == SCI_PHY_READY)
@@ -1314,7 +1163,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 == SAS_PROTOCOL_SSP) {
+        if (iphy->protocol == SCIC_SDS_PHY_PROTOCOL_SAS) {
                 scu_link_layer_tx_hard_reset(iphy);
         } else {
                 /* The SCU does not need to have a discrete reset state so
@@ -1380,7 +1229,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 = SAS_PROTOCOL_NONE;
+        iphy->protocol = SCIC_SDS_PHY_PROTOCOL_UNKNOWN;
         iphy->link_layer_registers = NULL;
         iphy->max_negotiated_speed = SAS_LINK_RATE_UNKNOWN;
 
@@ -1400,6 +1249,7 @@ void isci_phy_init(struct isci_phy *iphy, struct isci_host *ihost, int index)
         sas_addr = cpu_to_be64(sci_sas_addr);
         memcpy(iphy->sas_addr, &sas_addr, sizeof(sas_addr));
 
+        iphy->isci_port = NULL;
         iphy->sas_phy.enabled = 0;
         iphy->sas_phy.id = index;
         iphy->sas_phy.sas_addr = &iphy->sas_addr[0];
@@ -1433,48 +1283,36 @@ int isci_phy_control(struct asd_sas_phy *sas_phy,
 {
         int ret = 0;
         struct isci_phy *iphy = sas_phy->lldd_phy;
-        struct asd_sas_port *port = sas_phy->port;
+        struct isci_port *iport = iphy->isci_port;
         struct isci_host *ihost = sas_phy->ha->lldd_ha;
         unsigned long flags;
 
         dev_dbg(&ihost->pdev->dev,
                 "%s: phy %p; func %d; buf %p; isci phy %p, port %p\n",
-                __func__, sas_phy, func, buf, iphy, port);
+                __func__, sas_phy, func, buf, iphy, iport);
 
         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);
                 break;
 
         case PHY_FUNC_HARD_RESET:
-                if (!port)
+                if (!iport)
                         return -ENODEV;
 
-                ret = isci_port_perform_hard_reset(ihost, port->lldd_port, iphy);
+                /* Perform the port reset. */
+                ret = isci_port_perform_hard_reset(ihost, iport, iphy);
 
                 break;
-        case PHY_FUNC_GET_EVENTS: {
-                struct scu_link_layer_registers __iomem *r;
-                struct sas_phy *phy = sas_phy->phy;
-
-                r = iphy->link_layer_registers;
-                phy->running_disparity_error_count = readl(&r->running_disparity_error_count);
-                phy->loss_of_dword_sync_count = readl(&r->loss_of_sync_error_count);
-                phy->phy_reset_problem_count = readl(&r->phy_reset_problem_count);
-                phy->invalid_dword_count = readl(&r->invalid_dword_counter);
-                break;
-        }
 
         default:
                 dev_dbg(&ihost->pdev->dev,
diff --git a/drivers/scsi/isci/phy.h b/drivers/scsi/isci/phy.h
index 45fecfa36a9..67699c8e321 100644
--- a/drivers/scsi/isci/phy.h
+++ b/drivers/scsi/isci/phy.h
@@ -76,6 +76,13 @@
  */
 #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:
@@ -88,7 +95,7 @@ struct isci_phy {
         struct sci_base_state_machine sm;
         struct isci_port *owning_port;
         enum sas_linkrate max_negotiated_speed;
-        enum sas_protocol protocol;
+        enum sci_phy_protocol protocol;
         u8 phy_index;
         bool bcn_received_while_port_unassigned;
         bool is_in_link_training;
@@ -96,6 +103,7 @@ struct isci_phy {
         struct scu_transport_layer_registers __iomem *transport_layer_registers;
         struct scu_link_layer_registers __iomem *link_layer_registers;
         struct asd_sas_phy sas_phy;
+        struct isci_port *isci_port;
         u8 sas_addr[SAS_ADDR_SIZE];
         union {
                 struct sas_identify_frame iaf;
@@ -336,65 +344,101 @@ enum sci_phy_counter_id {
         SCIC_PHY_COUNTER_SN_DWORD_SYNC_ERROR
 };
 
-/**
- * enum sci_phy_states - phy state machine states
- * @SCI_PHY_INITIAL: Simply the initial state for the base domain state
- *                   machine.
- * @SCI_PHY_STOPPED: phy has successfully been stopped.  In this state
- *                   no new IO operations are permitted on this phy.
- * @SCI_PHY_STARTING: the phy is in the process of becomming ready.  In
- *                    this state no new IO operations are permitted on
- *                    this phy.
- * @SCI_PHY_SUB_INITIAL: Initial state
- * @SCI_PHY_SUB_AWAIT_OSSP_EN: Wait state for the hardware OSSP event
- *                             type notification
- * @SCI_PHY_SUB_AWAIT_SAS_SPEED_EN: Wait state for the PHY speed
- *                                  notification
- * @SCI_PHY_SUB_AWAIT_IAF_UF: Wait state for the IAF Unsolicited frame
- *                            notification
- * @SCI_PHY_SUB_AWAIT_SAS_POWER: Wait state for the request to consume
- *                               power
- * @SCI_PHY_SUB_AWAIT_SATA_POWER: Wait state for request to consume
- *                                power
- * @SCI_PHY_SUB_AWAIT_SATA_PHY_EN: Wait state for the SATA PHY
- *                                 notification
- * @SCI_PHY_SUB_AWAIT_SATA_SPEED_EN: Wait for the SATA PHY speed
- *                                   notification
- * @SCI_PHY_SUB_AWAIT_SIG_FIS_UF: Wait state for the SIGNATURE FIS
- *                                unsolicited frame notification
- * @SCI_PHY_SUB_FINAL: Exit state for this state machine
- * @SCI_PHY_READY: phy is now ready.  Thus, the user is able to perform
- *                 IO operations utilizing this phy as long as it is
- *                 currently part of a valid port.  This state is
- *                 entered from the STARTING state.
- * @SCI_PHY_RESETTING: phy is in the process of being reset.  In this
- *                     state no new IO operations are permitted on this
- *                     phy.  This state is entered from the READY state.
- * @SCI_PHY_FINAL: Simply the final state for the base phy state
- *                 machine.
- */
-#define PHY_STATES {\
-        C(PHY_INITIAL),\
-        C(PHY_STOPPED),\
-        C(PHY_STARTING),\
-        C(PHY_SUB_INITIAL),\
-        C(PHY_SUB_AWAIT_OSSP_EN),\
-        C(PHY_SUB_AWAIT_SAS_SPEED_EN),\
-        C(PHY_SUB_AWAIT_IAF_UF),\
-        C(PHY_SUB_AWAIT_SAS_POWER),\
-        C(PHY_SUB_AWAIT_SATA_POWER),\
-        C(PHY_SUB_AWAIT_SATA_PHY_EN),\
-        C(PHY_SUB_AWAIT_SATA_SPEED_EN),\
-        C(PHY_SUB_AWAIT_SIG_FIS_UF),\
-        C(PHY_SUB_FINAL),\
-        C(PHY_READY),\
-        C(PHY_RESETTING),\
-        C(PHY_FINAL),\
-        }
-#undef C
-#define C(a) SCI_##a
-enum sci_phy_states PHY_STATES;
-#undef C
+enum sci_phy_states {
+        /**
+         * Simply the initial state for the base domain state machine.
+         */
+        SCI_PHY_INITIAL,
+
+        /**
+         * This state indicates that the phy has successfully been stopped.
+         * In this state no new IO operations are permitted on this phy.
+         * This state is entered from the INITIAL state.
+         * This state is entered from the STARTING state.
+         * This state is entered from the READY state.
+         * This state is entered from the RESETTING state.
+         */
+        SCI_PHY_STOPPED,
+
+        /**
+         * This state indicates that the phy is in the process of becomming
+         * ready.  In this state no new IO operations are permitted on this phy.
+         * This state is entered from the STOPPED state.
+         * This state is entered from the READY state.
+         * This state is entered from the RESETTING state.
+         */
+        SCI_PHY_STARTING,
+
+        /**
+         * Initial state
+         */
+        SCI_PHY_SUB_INITIAL,
+
+        /**
+         * Wait state for the hardware OSSP event type notification
+         */
+        SCI_PHY_SUB_AWAIT_OSSP_EN,
+
+        /**
+         * Wait state for the PHY speed notification
+         */
+        SCI_PHY_SUB_AWAIT_SAS_SPEED_EN,
+
+        /**
+         * Wait state for the IAF Unsolicited frame notification
+         */
+        SCI_PHY_SUB_AWAIT_IAF_UF,
+
+        /**
+         * Wait state for the request to consume power
+         */
+        SCI_PHY_SUB_AWAIT_SAS_POWER,
+
+        /**
+         * Wait state for request to consume power
+         */
+        SCI_PHY_SUB_AWAIT_SATA_POWER,
+
+        /**
+         * Wait state for the SATA PHY notification
+         */
+        SCI_PHY_SUB_AWAIT_SATA_PHY_EN,
+
+        /**
+         * Wait for the SATA PHY speed notification
+         */
+        SCI_PHY_SUB_AWAIT_SATA_SPEED_EN,
+
+        /**
+         * Wait state for the SIGNATURE FIS unsolicited frame notification
+         */
+        SCI_PHY_SUB_AWAIT_SIG_FIS_UF,
+
+        /**
+         * Exit state for this state machine
+         */
+        SCI_PHY_SUB_FINAL,
+
+        /**
+         * This state indicates the the phy is now ready.  Thus, the user
+         * is able to perform IO operations utilizing this phy as long as it
+         * is currently part of a valid port.
+         * This state is entered from the STARTING state.
+         */
+        SCI_PHY_READY,
+
+        /**
+         * This state indicates that the phy is in the process of being reset.
+         * In this state no new IO operations are permitted on this phy.
+         * This state is entered from the READY state.
+         */
+        SCI_PHY_RESETTING,
+
+        /**
+         * Simply the final state for the base phy state machine.
+         */
+        SCI_PHY_FINAL,
+};
 
 void sci_phy_construct(
         struct isci_phy *iphy,
diff --git a/drivers/scsi/isci/port.c b/drivers/scsi/isci/port.c
index 13098b09a82..8f6f9b77e41 100644
--- a/drivers/scsi/isci/port.c
+++ b/drivers/scsi/isci/port.c
@@ -60,29 +60,18 @@
 #define SCIC_SDS_PORT_HARD_RESET_TIMEOUT  (1000)
 #define SCU_DUMMY_INDEX    (0xFFFF)
 
-#undef C
-#define C(a) (#a)
-const char *port_state_name(enum sci_port_states state)
+static void isci_port_change_state(struct isci_port *iport, enum isci_status status)
 {
-        static const char * const strings[] = PORT_STATES;
-
-        return strings[state];
-}
-#undef C
-
-static struct device *sciport_to_dev(struct isci_port *iport)
-{
-        int i = iport->physical_port_index;
-        struct isci_port *table;
-        struct isci_host *ihost;
-
-        if (i == SCIC_SDS_DUMMY_PORT)
-                i = SCI_MAX_PORTS+1;
+        unsigned long flags;
 
-        table = iport - i;
-        ihost = container_of(table, typeof(*ihost), ports[0]);
+        dev_dbg(&iport->isci_host->pdev->dev,
+                "%s: iport = %p, state = 0x%x\n",
+                __func__, iport, status);
 
-        return &ihost->pdev->dev;
+        /* XXX pointless lock */
+        spin_lock_irqsave(&iport->state_lock, flags);
+        iport->status = status;
+        spin_unlock_irqrestore(&iport->state_lock, flags);
 }
 
 static void sci_port_get_protocols(struct isci_port *iport, struct sci_phy_proto *proto)
@@ -125,7 +114,7 @@ static u32 sci_port_get_phys(struct isci_port *iport)
  * value is returned if the specified port is not valid.  When this value is
  * returned, no data is copied to the properties output parameter.
  */
-enum sci_status sci_port_get_properties(struct isci_port *iport,
+static enum sci_status sci_port_get_properties(struct isci_port *iport,
                                                 struct sci_port_properties *prop)
 {
         if (!iport || iport->logical_port_index == SCIC_SDS_DUMMY_PORT)
@@ -156,15 +145,48 @@ static void sci_port_bcn_enable(struct isci_port *iport)
         }
 }
 
+/* called under sci_lock to stabilize phy:port associations */
+void isci_port_bcn_enable(struct isci_host *ihost, struct isci_port *iport)
+{
+        int i;
+
+        clear_bit(IPORT_BCN_BLOCKED, &iport->flags);
+        wake_up(&ihost->eventq);
+
+        if (!test_and_clear_bit(IPORT_BCN_PENDING, &iport->flags))
+                return;
+
+        for (i = 0; i < ARRAY_SIZE(iport->phy_table); i++) {
+                struct isci_phy *iphy = iport->phy_table[i];
+
+                if (!iphy)
+                        continue;
+
+                ihost->sas_ha.notify_port_event(&iphy->sas_phy,
+                                                PORTE_BROADCAST_RCVD);
+                break;
+        }
+}
+
 static void isci_port_bc_change_received(struct isci_host *ihost,
                                          struct isci_port *iport,
                                          struct isci_phy *iphy)
 {
-        dev_dbg(&ihost->pdev->dev,
-                "%s: isci_phy = %p, sas_phy = %p\n",
-                __func__, iphy, &iphy->sas_phy);
+        if (iport && test_bit(IPORT_BCN_BLOCKED, &iport->flags)) {
+                dev_dbg(&ihost->pdev->dev,
+                        "%s: disabled BCN; isci_phy = %p, sas_phy = %p\n",
+                        __func__, iphy, &iphy->sas_phy);
+                set_bit(IPORT_BCN_PENDING, &iport->flags);
+                atomic_inc(&iport->event);
+                wake_up(&ihost->eventq);
+        } else {
+                dev_dbg(&ihost->pdev->dev,
+                        "%s: isci_phy = %p, sas_phy = %p\n",
+                        __func__, iphy, &iphy->sas_phy);
 
-        ihost->sas_ha.notify_port_event(&iphy->sas_phy, PORTE_BROADCAST_RCVD);
+                ihost->sas_ha.notify_port_event(&iphy->sas_phy,
+                                                PORTE_BROADCAST_RCVD);
+        }
         sci_port_bcn_enable(iport);
 }
 
@@ -176,15 +198,21 @@ static void isci_port_link_up(struct isci_host *isci_host,
         struct sci_port_properties properties;
         unsigned long success = true;
 
+        BUG_ON(iphy->isci_port != NULL);
+
+        iphy->isci_port = iport;
+
         dev_dbg(&isci_host->pdev->dev,
                 "%s: isci_port = %p\n",
                 __func__, iport);
 
         spin_lock_irqsave(&iphy->sas_phy.frame_rcvd_lock, flags);
 
+        isci_port_change_state(iphy->isci_port, isci_starting);
+
         sci_port_get_properties(iport, &properties);
 
-        if (iphy->protocol == SAS_PROTOCOL_SATA) {
+        if (iphy->protocol == SCIC_SDS_PHY_PROTOCOL_SATA) {
                 u64 attached_sas_address;
 
                 iphy->sas_phy.oob_mode = SATA_OOB_MODE;
@@ -204,7 +232,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 == SAS_PROTOCOL_SSP) {
+        } else if (iphy->protocol == SCIC_SDS_PHY_PROTOCOL_SAS) {
                 iphy->sas_phy.oob_mode = SAS_OOB_MODE;
                 iphy->sas_phy.frame_rcvd_size = sizeof(struct sas_identify_frame);
 
@@ -212,7 +240,7 @@ static void isci_port_link_up(struct isci_host *isci_host,
                 memcpy(iphy->sas_phy.attached_sas_addr,
                        iphy->frame_rcvd.iaf.sas_addr, SAS_ADDR_SIZE);
         } else {
-                dev_err(&isci_host->pdev->dev, "%s: unknown target\n", __func__);
+                dev_err(&isci_host->pdev->dev, "%s: unkown target\n", __func__);
                 success = false;
         }
 
@@ -250,11 +278,14 @@ static void isci_port_link_down(struct isci_host *isci_host,
                 /* check to see if this is the last phy on this port. */
                 if (isci_phy->sas_phy.port &&
                     isci_phy->sas_phy.port->num_phys == 1) {
+                        atomic_inc(&isci_port->event);
+                        isci_port_bcn_enable(isci_host, isci_port);
+
                         /* 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) {
@@ -264,6 +295,7 @@ static void isci_port_link_down(struct isci_host *isci_host,
                                 set_bit(IDEV_GONE, &isci_device->flags);
                         }
                 }
+                isci_port_change_state(isci_port, isci_stopping);
         }
 
         /* Notify libsas of the borken link, this will trigger calls to our
@@ -273,35 +305,49 @@ static void isci_port_link_down(struct isci_host *isci_host,
         isci_host->sas_ha.notify_phy_event(&isci_phy->sas_phy,
                                            PHYE_LOSS_OF_SIGNAL);
 
+        isci_phy->isci_port = NULL;
+
         dev_dbg(&isci_host->pdev->dev,
                 "%s: isci_port = %p - Done\n", __func__, isci_port);
 }
 
-static bool is_port_ready_state(enum sci_port_states state)
+
+/**
+ * isci_port_ready() - This function is called by the sci core when a link
+ *    becomes ready.
+ * @isci_host: This parameter specifies the isci host object.
+ * @port: This parameter specifies the sci port with the active link.
+ *
+ */
+static void isci_port_ready(struct isci_host *isci_host, struct isci_port *isci_port)
 {
-        switch (state) {
-        case SCI_PORT_READY:
-        case SCI_PORT_SUB_WAITING:
-        case SCI_PORT_SUB_OPERATIONAL:
-        case SCI_PORT_SUB_CONFIGURING:
-                return true;
-        default:
-                return false;
-        }
+        dev_dbg(&isci_host->pdev->dev,
+                "%s: isci_port = %p\n", __func__, isci_port);
+
+        complete_all(&isci_port->start_complete);
+        isci_port_change_state(isci_port, isci_ready);
+        return;
 }
 
-/* flag dummy rnc hanling when exiting a ready state */
-static void port_state_machine_change(struct isci_port *iport,
-                                      enum sci_port_states state)
+/**
+ * isci_port_not_ready() - This function is called by the sci core when a link
+ *    is not ready. All remote devices on this link will be removed if they are
+ *    in the stopping state.
+ * @isci_host: This parameter specifies the isci host object.
+ * @port: This parameter specifies the sci port with the active link.
+ *
+ */
+static void isci_port_not_ready(struct isci_host *isci_host, struct isci_port *isci_port)
 {
-        struct sci_base_state_machine *sm = &iport->sm;
-        enum sci_port_states old_state = sm->current_state_id;
-
-        if (is_port_ready_state(old_state) && !is_port_ready_state(state))
-                iport->ready_exit = true;
+        dev_dbg(&isci_host->pdev->dev,
+                "%s: isci_port = %p\n", __func__, isci_port);
+}
 
-        sci_change_state(sm, state);
-        iport->ready_exit = false;
+static void isci_port_stop_complete(struct isci_host *ihost,
+                                    struct isci_port *iport,
+                                    enum sci_status completion_status)
+{
+        dev_dbg(&ihost->pdev->dev, "Port stop complete\n");
 }
 
 /**
@@ -315,37 +361,14 @@ static void port_state_machine_change(struct isci_port *iport,
 static void isci_port_hard_reset_complete(struct isci_port *isci_port,
                                           enum sci_status completion_status)
 {
-        struct isci_host *ihost = isci_port->owning_controller;
-
-        dev_dbg(&ihost->pdev->dev,
+        dev_dbg(&isci_port->isci_host->pdev->dev,
                 "%s: isci_port = %p, completion_status=%x\n",
                      __func__, isci_port, completion_status);
 
         /* Save the status of the hard reset from the port. */
         isci_port->hard_reset_status = completion_status;
 
-        if (completion_status != SCI_SUCCESS) {
-
-                /* The reset failed.  The port state is now SCI_PORT_FAILED. */
-                if (isci_port->active_phy_mask == 0) {
-                        int phy_idx = isci_port->last_active_phy;
-                        struct isci_phy *iphy = &ihost->phys[phy_idx];
-
-                        /* Generate the link down now to the host, since it
-                         * was intercepted by the hard reset state machine when
-                         * it really happened.
-                         */
-                        isci_port_link_down(ihost, iphy, isci_port);
-                }
-                /* Advance the port state so that link state changes will be
-                 * noticed.
-                 */
-                port_state_machine_change(isci_port, SCI_PORT_SUB_WAITING);
-
-        }
-        clear_bit(IPORT_RESET_PENDING, &isci_port->state);
-        wake_up(&ihost->eventq);
-
+        complete_all(&isci_port->hard_reset_complete);
 }
 
 /* This method will return a true value if the specified phy can be assigned to
@@ -517,7 +540,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 != SAS_PROTOCOL_SATA) {
+                if (iphy->protocol != SCIC_SDS_PHY_PROTOCOL_SATA) {
                         sci_phy_get_attached_sas_address(iphy, sas);
                 } else {
                         sci_phy_get_sas_address(iphy, sas);
@@ -612,26 +635,19 @@ void sci_port_setup_transports(struct isci_port *iport, u32 device_id)
         }
 }
 
-static void sci_port_resume_phy(struct isci_port *iport, struct isci_phy *iphy)
-{
-        sci_phy_resume(iphy);
-        iport->enabled_phy_mask |= 1 << iphy->phy_index;
-}
-
-static void sci_port_activate_phy(struct isci_port *iport,
-                                  struct isci_phy *iphy,
-                                  u8 flags)
+static void sci_port_activate_phy(struct isci_port *iport, struct isci_phy *iphy,
+                                  bool do_notify_user)
 {
         struct isci_host *ihost = iport->owning_controller;
 
-        if (iphy->protocol != SAS_PROTOCOL_SATA && (flags & PF_RESUME))
+        if (iphy->protocol != SCIC_SDS_PHY_PROTOCOL_SATA)
                 sci_phy_resume(iphy);
 
         iport->active_phy_mask |= 1 << iphy->phy_index;
 
         sci_controller_clear_invalid_phy(ihost, iphy);
 
-        if (flags & PF_NOTIFY)
+        if (do_notify_user == true)
                 isci_port_link_up(ihost, iport, iphy);
 }
 
@@ -641,19 +657,12 @@ void sci_port_deactivate_phy(struct isci_port *iport, struct isci_phy *iphy,
         struct isci_host *ihost = iport->owning_controller;
 
         iport->active_phy_mask &= ~(1 << iphy->phy_index);
-        iport->enabled_phy_mask &= ~(1 << iphy->phy_index);
-        if (!iport->active_phy_mask)
-                iport->last_active_phy = iphy->phy_index;
 
         iphy->max_negotiated_speed = SAS_LINK_RATE_UNKNOWN;
 
-        /* Re-assign the phy back to the LP as if it were a narrow port for APC
-         * mode. For MPC mode, the phy will remain in the port.
-         */
-        if (iport->owning_controller->oem_parameters.controller.mode_type ==
-                SCIC_PORT_AUTOMATIC_CONFIGURATION_MODE)
-                writel(iphy->phy_index,
-                        &iport->port_pe_configuration_register[iphy->phy_index]);
+        /* Re-assign the phy back to the LP as if it were a narrow port */
+        writel(iphy->phy_index,
+                &iport->port_pe_configuration_register[iphy->phy_index]);
 
         if (do_notify_user == true)
                 isci_port_link_down(ihost, iphy, iport);
@@ -674,20 +683,49 @@ static void sci_port_invalid_link_up(struct isci_port *iport, struct isci_phy *i
         }
 }
 
+static bool is_port_ready_state(enum sci_port_states state)
+{
+        switch (state) {
+        case SCI_PORT_READY:
+        case SCI_PORT_SUB_WAITING:
+        case SCI_PORT_SUB_OPERATIONAL:
+        case SCI_PORT_SUB_CONFIGURING:
+                return true;
+        default:
+                return false;
+        }
+}
+
+/* flag dummy rnc hanling when exiting a ready state */
+static void port_state_machine_change(struct isci_port *iport,
+                                      enum sci_port_states state)
+{
+        struct sci_base_state_machine *sm = &iport->sm;
+        enum sci_port_states old_state = sm->current_state_id;
+
+        if (is_port_ready_state(old_state) && !is_port_ready_state(state))
+                iport->ready_exit = true;
+
+        sci_change_state(sm, state);
+        iport->ready_exit = false;
+}
+
 /**
  * sci_port_general_link_up_handler - phy can be assigned to port?
  * @sci_port: sci_port object for which has a phy that has gone link up.
  * @sci_phy: This is the struct isci_phy object that has gone link up.
- * @flags: PF_RESUME, PF_NOTIFY to sci_port_activate_phy
+ * @do_notify_user: This parameter specifies whether to inform the user (via
+ *    sci_port_link_up()) as to the fact that a new phy as become ready.
  *
- * Determine if this phy can be assigned to this port . If the phy is
- * not a valid PHY for this port then the function will notify the user.
- * A PHY can only be part of a port if it's attached SAS ADDRESS is the
- * same as all other PHYs in the same port.
+ * Determine if this phy can be assigned to this
+ * port . If the phy is not a valid PHY for
+ * this port then the function will notify the user. A PHY can only be
+ * part of a port if it's attached SAS ADDRESS is the same as all other PHYs in
+ * the same port. none
  */
 static void sci_port_general_link_up_handler(struct isci_port *iport,
-                                             struct isci_phy *iphy,
-                                             u8 flags)
+                                                  struct isci_phy *iphy,
+                                                  bool do_notify_user)
 {
         struct sci_sas_address port_sas_address;
         struct sci_sas_address phy_sas_address;
@@ -705,7 +743,7 @@ static void sci_port_general_link_up_handler(struct isci_port *iport,
             iport->active_phy_mask == 0) {
                 struct sci_base_state_machine *sm = &iport->sm;
 
-                sci_port_activate_phy(iport, iphy, flags);
+                sci_port_activate_phy(iport, iphy, do_notify_user);
                 if (sm->current_state_id == SCI_PORT_RESETTING)
                         port_state_machine_change(iport, SCI_PORT_READY);
         } else
@@ -751,19 +789,16 @@ 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 == SAS_PROTOCOL_SATA)) {
-                if (sci_port_is_wide(iport)) {
-                        sci_port_invalid_link_up(iport, iphy);
-                        return false;
-                } else {
-                        struct isci_host *ihost = iport->owning_controller;
-                        struct isci_port *dst_port = &(ihost->ports[iphy->phy_index]);
-                        writel(iphy->phy_index,
-                               &dst_port->port_pe_configuration_register[iphy->phy_index]);
-                }
+            (iphy->protocol == SCIC_SDS_PHY_PROTOCOL_SATA) &&
+            sci_port_is_wide(iport)) {
+                sci_port_invalid_link_up(iport, iphy);
+
+                return false;
         }
 
         return true;
@@ -798,9 +833,10 @@ static void port_timeout(unsigned long data)
                         __func__,
                         iport);
         } else if (current_state == SCI_PORT_STOPPING) {
-                dev_dbg(sciport_to_dev(iport),
-                        "%s: port%d: stop complete timeout\n",
-                        __func__, iport->physical_port_index);
+                /* if the port is still stopping then the stop has not completed */
+                isci_port_stop_complete(iport->owning_controller,
+                                        iport,
+                                        SCI_FAILURE_TIMEOUT);
         } else {
                 /* The port is in the ready state and we have a timer
                  * reporting a timeout this should not happen.
@@ -952,34 +988,26 @@ static void sci_port_ready_substate_waiting_enter(struct sci_base_state_machine
         }
 }
 
-static void scic_sds_port_ready_substate_waiting_exit(
-                                        struct sci_base_state_machine *sm)
-{
-        struct isci_port *iport = container_of(sm, typeof(*iport), sm);
-        sci_port_resume_port_task_scheduler(iport);
-}
-
 static void sci_port_ready_substate_operational_enter(struct sci_base_state_machine *sm)
 {
         u32 index;
         struct isci_port *iport = container_of(sm, typeof(*iport), sm);
         struct isci_host *ihost = iport->owning_controller;
 
-        dev_dbg(&ihost->pdev->dev, "%s: port%d ready\n",
-                __func__, iport->physical_port_index);
+        isci_port_ready(ihost, iport);
 
         for (index = 0; index < SCI_MAX_PHYS; index++) {
                 if (iport->phy_table[index]) {
                         writel(iport->physical_port_index,
                                 &iport->port_pe_configuration_register[
                                         iport->phy_table[index]->phy_index]);
-                        if (((iport->active_phy_mask^iport->enabled_phy_mask) & (1 << index)) != 0)
-                                sci_port_resume_phy(iport, iport->phy_table[index]);
                 }
         }
 
         sci_port_update_viit_entry(iport);
 
+        sci_port_resume_port_task_scheduler(iport);
+
         /*
          * Post the dummy task for the port so the hardware can schedule
          * io correctly
@@ -1032,8 +1060,7 @@ static void sci_port_ready_substate_operational_exit(struct sci_base_state_machi
          */
         sci_port_abort_dummy_request(iport);
 
-        dev_dbg(&ihost->pdev->dev, "%s: port%d !ready\n",
-                __func__, iport->physical_port_index);
+        isci_port_not_ready(ihost, iport);
 
         if (iport->ready_exit)
                 sci_port_invalidate_dummy_remote_node(iport);
@@ -1045,12 +1072,22 @@ static void sci_port_ready_substate_configuring_enter(struct sci_base_state_mach
         struct isci_host *ihost = iport->owning_controller;
 
         if (iport->active_phy_mask == 0) {
-                dev_dbg(&ihost->pdev->dev, "%s: port%d !ready\n",
-                        __func__, iport->physical_port_index);
+                isci_port_not_ready(ihost, iport);
 
-                port_state_machine_change(iport, SCI_PORT_SUB_WAITING);
-        } else
-                port_state_machine_change(iport, SCI_PORT_SUB_OPERATIONAL);
+                port_state_machine_change(iport,
+                                          SCI_PORT_SUB_WAITING);
+        } else if (iport->started_request_count == 0)
+                port_state_machine_change(iport,
+                                          SCI_PORT_SUB_OPERATIONAL);
+}
+
+static void sci_port_ready_substate_configuring_exit(struct sci_base_state_machine *sm)
+{
+        struct isci_port *iport = container_of(sm, typeof(*iport), sm);
+
+        sci_port_suspend_port_task_scheduler(iport);
+        if (iport->ready_exit)
+                sci_port_invalidate_dummy_remote_node(iport);
 }
 
 enum sci_status sci_port_start(struct isci_port *iport)
@@ -1062,8 +1099,8 @@ enum sci_status sci_port_start(struct isci_port *iport)
 
         state = iport->sm.current_state_id;
         if (state != SCI_PORT_STOPPED) {
-                dev_warn(sciport_to_dev(iport), "%s: in wrong state: %s\n",
-                         __func__, port_state_name(state));
+                dev_warn(sciport_to_dev(iport),
+                         "%s: in wrong state: %d\n", __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
         }
 
@@ -1137,8 +1174,8 @@ enum sci_status sci_port_stop(struct isci_port *iport)
                                           SCI_PORT_STOPPING);
                 return SCI_SUCCESS;
         default:
-                dev_warn(sciport_to_dev(iport), "%s: in wrong state: %s\n",
-                         __func__, port_state_name(state));
+                dev_warn(sciport_to_dev(iport),
+                         "%s: in wrong state: %d\n", __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
         }
 }
@@ -1152,8 +1189,8 @@ static enum sci_status sci_port_hard_reset(struct isci_port *iport, u32 timeout)
 
         state = iport->sm.current_state_id;
         if (state != SCI_PORT_SUB_OPERATIONAL) {
-                dev_warn(sciport_to_dev(iport), "%s: in wrong state: %s\n",
-                         __func__, port_state_name(state));
+                dev_warn(sciport_to_dev(iport),
+                         "%s: in wrong state: %d\n", __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
         }
 
@@ -1199,8 +1236,6 @@ 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: {
@@ -1230,7 +1265,7 @@ enum sci_status sci_port_add_phy(struct isci_port *iport,
                 if (status != SCI_SUCCESS)
                         return status;
 
-                sci_port_general_link_up_handler(iport, iphy, PF_NOTIFY|PF_RESUME);
+                sci_port_general_link_up_handler(iport, iphy, true);
                 iport->not_ready_reason = SCIC_PORT_NOT_READY_RECONFIGURING;
                 port_state_machine_change(iport, SCI_PORT_SUB_CONFIGURING);
 
@@ -1240,7 +1275,7 @@ enum sci_status sci_port_add_phy(struct isci_port *iport,
 
                 if (status != SCI_SUCCESS)
                         return status;
-                sci_port_general_link_up_handler(iport, iphy, PF_NOTIFY);
+                sci_port_general_link_up_handler(iport, iphy, true);
 
                 /* Re-enter the configuring state since this may be the last phy in
                  * the port.
@@ -1249,8 +1284,8 @@ enum sci_status sci_port_add_phy(struct isci_port *iport,
                                           SCI_PORT_SUB_CONFIGURING);
                 return SCI_SUCCESS;
         default:
-                dev_warn(sciport_to_dev(iport), "%s: in wrong state: %s\n",
-                         __func__, port_state_name(state));
+                dev_warn(sciport_to_dev(iport),
+                         "%s: in wrong state: %d\n", __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
         }
 }
@@ -1299,8 +1334,8 @@ enum sci_status sci_port_remove_phy(struct isci_port *iport,
                                           SCI_PORT_SUB_CONFIGURING);
                 return SCI_SUCCESS;
         default:
-                dev_warn(sciport_to_dev(iport), "%s: in wrong state: %s\n",
-                         __func__, port_state_name(state));
+                dev_warn(sciport_to_dev(iport),
+                         "%s: in wrong state: %d\n", __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
         }
 }
@@ -1316,13 +1351,13 @@ enum sci_status sci_port_link_up(struct isci_port *iport,
                 /* Since this is the first phy going link up for the port we
                  * can just enable it and continue
                  */
-                sci_port_activate_phy(iport, iphy, PF_NOTIFY|PF_RESUME);
+                sci_port_activate_phy(iport, iphy, true);
 
                 port_state_machine_change(iport,
                                           SCI_PORT_SUB_OPERATIONAL);
                 return SCI_SUCCESS;
         case SCI_PORT_SUB_OPERATIONAL:
-                sci_port_general_link_up_handler(iport, iphy, PF_NOTIFY|PF_RESUME);
+                sci_port_general_link_up_handler(iport, iphy, true);
                 return SCI_SUCCESS;
         case SCI_PORT_RESETTING:
                 /* TODO We should  make  sure  that  the phy  that  has gone
@@ -1339,11 +1374,11 @@ enum sci_status sci_port_link_up(struct isci_port *iport,
                 /* In the resetting state we don't notify the user regarding
                  * link up and link down notifications.
                  */
-                sci_port_general_link_up_handler(iport, iphy, PF_RESUME);
+                sci_port_general_link_up_handler(iport, iphy, false);
                 return SCI_SUCCESS;
         default:
-                dev_warn(sciport_to_dev(iport), "%s: in wrong state: %s\n",
-                         __func__, port_state_name(state));
+                dev_warn(sciport_to_dev(iport),
+                         "%s: in wrong state: %d\n", __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
         }
 }
@@ -1372,8 +1407,8 @@ enum sci_status sci_port_link_down(struct isci_port *iport,
                 sci_port_deactivate_phy(iport, iphy, false);
                 return SCI_SUCCESS;
         default:
-                dev_warn(sciport_to_dev(iport), "%s: in wrong state: %s\n",
-                         __func__, port_state_name(state));
+                dev_warn(sciport_to_dev(iport),
+                         "%s: in wrong state: %d\n", __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
         }
 }
@@ -1392,8 +1427,8 @@ enum sci_status sci_port_start_io(struct isci_port *iport,
                 iport->started_request_count++;
                 return SCI_SUCCESS;
         default:
-                dev_warn(sciport_to_dev(iport), "%s: in wrong state: %s\n",
-                         __func__, port_state_name(state));
+                dev_warn(sciport_to_dev(iport),
+                         "%s: in wrong state: %d\n", __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
         }
 }
@@ -1407,8 +1442,8 @@ enum sci_status sci_port_complete_io(struct isci_port *iport,
         state = iport->sm.current_state_id;
         switch (state) {
         case SCI_PORT_STOPPED:
-                dev_warn(sciport_to_dev(iport), "%s: in wrong state: %s\n",
-                         __func__, port_state_name(state));
+                dev_warn(sciport_to_dev(iport),
+                         "%s: in wrong state: %d\n", __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
         case SCI_PORT_STOPPING:
                 sci_port_decrement_request_count(iport);
@@ -1514,8 +1549,7 @@ static void sci_port_ready_state_enter(struct sci_base_state_machine *sm)
         if (prev_state  == SCI_PORT_RESETTING)
                 isci_port_hard_reset_complete(iport, SCI_SUCCESS);
         else
-                dev_dbg(&ihost->pdev->dev, "%s: port%d !ready\n",
-                        __func__, iport->physical_port_index);
+                isci_port_not_ready(ihost, iport);
 
         /* Post and suspend the dummy remote node context for this port. */
         sci_port_post_dummy_remote_node(iport);
@@ -1548,29 +1582,6 @@ 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[] = {
@@ -1586,14 +1597,14 @@ static const struct sci_base_state sci_port_state_table[] = {
         },
         [SCI_PORT_SUB_WAITING] = {
                 .enter_state = sci_port_ready_substate_waiting_enter,
-                .exit_state  = scic_sds_port_ready_substate_waiting_exit,
         },
         [SCI_PORT_SUB_OPERATIONAL] = {
                 .enter_state = sci_port_ready_substate_operational_enter,
                 .exit_state  = sci_port_ready_substate_operational_exit
         },
         [SCI_PORT_SUB_CONFIGURING] = {
-                .enter_state = sci_port_ready_substate_configuring_enter
+                .enter_state = sci_port_ready_substate_configuring_enter,
+                .exit_state  = sci_port_ready_substate_configuring_exit
         },
         [SCI_PORT_RESETTING] = {
                 .exit_state  = sci_port_resetting_state_exit
@@ -1611,15 +1622,12 @@ void sci_port_construct(struct isci_port *iport, u8 index,
         iport->logical_port_index  = SCIC_SDS_DUMMY_PORT;
         iport->physical_port_index = index;
         iport->active_phy_mask     = 0;
-        iport->enabled_phy_mask    = 0;
-        iport->last_active_phy     = 0;
-        iport->ready_exit          = false;
+        iport->ready_exit             = false;
 
         iport->owning_controller = ihost;
 
         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;
@@ -1632,6 +1640,29 @@ 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);
+        spin_lock_init(&iport->state_lock);
+        init_completion(&iport->start_complete);
+        iport->isci_host = ihost;
+        isci_port_change_state(iport, isci_freed);
+        atomic_set(&iport->event, 0);
+}
+
+/**
+ * isci_port_get_state() - This function gets the status of the port object.
+ * @isci_port: This parameter points to the isci_port object
+ *
+ * status of the object as a isci_status enum.
+ */
+enum isci_status isci_port_get_state(
+        struct isci_port *isci_port)
+{
+        return isci_port->status;
+}
+
 void sci_port_broadcast_change_received(struct isci_port *iport, struct isci_phy *iphy)
 {
         struct isci_host *ihost = iport->owning_controller;
@@ -1640,23 +1671,19 @@ void sci_port_broadcast_change_received(struct isci_port *iport, struct isci_phy
         isci_port_bc_change_received(ihost, iport, iphy);
 }
 
-static void wait_port_reset(struct isci_host *ihost, struct isci_port *iport)
-{
-        wait_event(ihost->eventq, !test_bit(IPORT_RESET_PENDING, &iport->state));
-}
-
 int isci_port_perform_hard_reset(struct isci_host *ihost, struct isci_port *iport,
                                  struct isci_phy *iphy)
 {
         unsigned long flags;
         enum sci_status status;
-        int ret = TMF_RESP_FUNC_COMPLETE;
+        int idx, ret = TMF_RESP_FUNC_COMPLETE;
 
         dev_dbg(&ihost->pdev->dev, "%s: iport = %p\n",
                 __func__, iport);
 
+        init_completion(&iport->hard_reset_complete);
+
         spin_lock_irqsave(&ihost->scic_lock, flags);
-        set_bit(IPORT_RESET_PENDING, &iport->state);
 
         #define ISCI_PORT_RESET_TIMEOUT SCIC_SDS_SIGNATURE_FIS_TIMEOUT
         status = sci_port_hard_reset(iport, ISCI_PORT_RESET_TIMEOUT);
@@ -1664,22 +1691,15 @@ int isci_port_perform_hard_reset(struct isci_host *ihost, struct isci_port *ipor
         spin_unlock_irqrestore(&ihost->scic_lock, flags);
 
         if (status == SCI_SUCCESS) {
-                wait_port_reset(ihost, iport);
+                wait_for_completion(&iport->hard_reset_complete);
 
                 dev_dbg(&ihost->pdev->dev,
                         "%s: iport = %p; hard reset completion\n",
                         __func__, iport);
 
-                if (iport->hard_reset_status != SCI_SUCCESS) {
+                if (iport->hard_reset_status != SCI_SUCCESS)
                         ret = TMF_RESP_FUNC_FAILED;
-
-                        dev_err(&ihost->pdev->dev,
-                                "%s: iport = %p; hard reset failed (0x%x)\n",
-                                __func__, iport, iport->hard_reset_status);
-                }
         } else {
-                clear_bit(IPORT_RESET_PENDING, &iport->state);
-                wake_up(&ihost->eventq);
                 ret = TMF_RESP_FUNC_FAILED;
 
                 dev_err(&ihost->pdev->dev,
@@ -1688,83 +1708,50 @@ int isci_port_perform_hard_reset(struct isci_host *ihost, struct isci_port *ipor
                         __func__, iport, status);
 
         }
-        return ret;
-}
-
-int isci_ata_check_ready(struct domain_device *dev)
-{
-        struct isci_port *iport = dev->port->lldd_port;
-        struct isci_host *ihost = dev_to_ihost(dev);
-        struct isci_remote_device *idev;
-        unsigned long flags;
-        int rc = 0;
-
-        spin_lock_irqsave(&ihost->scic_lock, flags);
-        idev = isci_lookup_device(dev);
-        spin_unlock_irqrestore(&ihost->scic_lock, flags);
-
-        if (!idev)
-                goto out;
-
-        if (test_bit(IPORT_RESET_PENDING, &iport->state))
-                goto out;
 
-        rc = !!iport->active_phy_mask;
- out:
-        isci_put_device(idev);
+        /* 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) {
 
-        return rc;
+                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);
+
+                /* Down all phys in the port. */
+                spin_lock_irqsave(&ihost->scic_lock, flags);
+                for (idx = 0; idx < SCI_MAX_PHYS; ++idx) {
+                        struct isci_phy *iphy = iport->phy_table[idx];
+
+                        if (!iphy)
+                                continue;
+                        sci_phy_stop(iphy);
+                        sci_phy_start(iphy);
+                }
+                spin_unlock_irqrestore(&ihost->scic_lock, flags);
+        }
+        return ret;
 }
 
+/**
+ * isci_port_deformed() - This function is called by libsas when a port becomes
+ *    inactive.
+ * @phy: This parameter specifies the libsas phy with the inactive port.
+ *
+ */
 void isci_port_deformed(struct asd_sas_phy *phy)
 {
-        struct isci_host *ihost = phy->ha->lldd_ha;
-        struct isci_port *iport = phy->port->lldd_port;
-        unsigned long flags;
-        int i;
-
-        /* we got a port notification on a port that was subsequently
-         * torn down and libsas is just now catching up
-         */
-        if (!iport)
-                return;
-
-        spin_lock_irqsave(&ihost->scic_lock, flags);
-        for (i = 0; i < SCI_MAX_PHYS; i++) {
-                if (iport->active_phy_mask & 1 << i)
-                        break;
-        }
-        spin_unlock_irqrestore(&ihost->scic_lock, flags);
-
-        if (i >= SCI_MAX_PHYS)
-                dev_dbg(&ihost->pdev->dev, "%s: port: %ld\n",
-                        __func__, (long) (iport - &ihost->ports[0]));
+        pr_debug("%s: sas_phy = %p\n", __func__, phy);
 }
 
+/**
+ * isci_port_formed() - This function is called by libsas when a port becomes
+ *    active.
+ * @phy: This parameter specifies the libsas phy with the active port.
+ *
+ */
 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 = NULL;
-        unsigned long flags;
-        int i;
-
-        /* initial ports are formed as the driver is still initializing,
-         * wait for that process to complete
-         */
-        wait_for_start(ihost);
-
-        spin_lock_irqsave(&ihost->scic_lock, flags);
-        for (i = 0; i < SCI_MAX_PORTS; i++) {
-                iport = &ihost->ports[i];
-                if (iport->active_phy_mask & 1 << iphy->phy_index)
-                        break;
-        }
-        spin_unlock_irqrestore(&ihost->scic_lock, flags);
-
-        if (i >= SCI_MAX_PORTS)
-                iport = NULL;
-
-        port->lldd_port = iport;
+        pr_debug("%s: sas_phy = %p, sas_port = %p\n", __func__, phy, phy->port);
 }
diff --git a/drivers/scsi/isci/port.h b/drivers/scsi/isci/port.h
index 861e8f72811..b50ecd4e8f9 100644
--- a/drivers/scsi/isci/port.h
+++ b/drivers/scsi/isci/port.h
@@ -63,9 +63,6 @@
 
 #define SCIC_SDS_DUMMY_PORT   0xFF
 
-#define PF_NOTIFY (1 << 0)
-#define PF_RESUME (1 << 1)
-
 struct isci_phy;
 struct isci_host;
 
@@ -80,14 +77,13 @@ enum isci_status {
 
 /**
  * struct isci_port - isci direct attached sas port object
+ * @event: counts bcns and port stop events (for bcn filtering)
  * @ready_exit: several states constitute 'ready'. When exiting ready we
  *              need to take extra port-teardown actions that are
  *              skipped when exiting to another 'ready' state.
  * @logical_port_index: software port index
  * @physical_port_index: hardware port index
  * @active_phy_mask: identifies phy members
- * @enabled_phy_mask: phy mask for the port
- *                    that are already part of the port
  * @reserved_tag:
  * @reserved_rni: reserver for port task scheduler workaround
  * @started_request_count: reference count for outstanding commands
@@ -95,23 +91,28 @@ enum isci_status {
  * @timer: timeout start/stop operations
  */
 struct isci_port {
+        enum isci_status status;
+        #define IPORT_BCN_BLOCKED 0
+        #define IPORT_BCN_PENDING 1
+        unsigned long flags;
+        atomic_t event;
         struct isci_host *isci_host;
+        struct asd_sas_port sas_port;
         struct list_head remote_dev_list;
-        #define IPORT_RESET_PENDING 0
-        unsigned long state;
+        spinlock_t state_lock;
+        struct list_head domain_dev_list;
+        struct completion start_complete;
+        struct completion hard_reset_complete;
         enum sci_status hard_reset_status;
         struct sci_base_state_machine sm;
         bool ready_exit;
         u8 logical_port_index;
         u8 physical_port_index;
         u8 active_phy_mask;
-        u8 enabled_phy_mask;
-        u8 last_active_phy;
         u16 reserved_rni;
         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;
@@ -144,47 +145,70 @@ struct sci_port_properties {
 };
 
 /**
- * enum sci_port_states - port state machine states
- * @SCI_PORT_STOPPED: port has successfully been stopped.  In this state
- *                    no new IO operations are permitted.  This state is
- *                    entered from the STOPPING state.
- * @SCI_PORT_STOPPING: port is in the process of stopping.  In this
- *                     state no new IO operations are permitted, but
- *                     existing IO operations are allowed to complete.
- *                     This state is entered from the READY state.
- * @SCI_PORT_READY: port is now ready.  Thus, the user is able to
- *                  perform IO operations on this port. This state is
- *                  entered from the STARTING state.
- * @SCI_PORT_SUB_WAITING: port is started and ready but has no active
- *                        phys.
- * @SCI_PORT_SUB_OPERATIONAL: port is started and ready and there is at
- *                            least one phy operational.
- * @SCI_PORT_SUB_CONFIGURING: port is started and there was an
- *                            add/remove phy event.  This state is only
- *                            used in Automatic Port Configuration Mode
- *                            (APC)
- * @SCI_PORT_RESETTING: port is in the process of performing a hard
- *                      reset.  Thus, the user is unable to perform IO
- *                      operations on this port.  This state is entered
- *                      from the READY state.
- * @SCI_PORT_FAILED: port has failed a reset request.  This state is
- *                   entered when a port reset request times out. This
- *                   state is entered from the RESETTING state.
+ * enum sci_port_states - This enumeration depicts all the states for the
+ *    common port state machine.
+ *
+ *
  */
-#define PORT_STATES {\
-        C(PORT_STOPPED),\
-        C(PORT_STOPPING),\
-        C(PORT_READY),\
-        C(PORT_SUB_WAITING),\
-        C(PORT_SUB_OPERATIONAL),\
-        C(PORT_SUB_CONFIGURING),\
-        C(PORT_RESETTING),\
-        C(PORT_FAILED),\
-        }
-#undef C
-#define C(a) SCI_##a
-enum sci_port_states PORT_STATES;
-#undef C
+enum sci_port_states {
+        /**
+         * This state indicates that the port has successfully been stopped.
+         * In this state no new IO operations are permitted.
+         * This state is entered from the STOPPING state.
+         */
+        SCI_PORT_STOPPED,
+
+        /**
+         * This state indicates that the port is in the process of stopping.
+         * In this state no new IO operations are permitted, but existing IO
+         * operations are allowed to complete.
+         * This state is entered from the READY state.
+         */
+        SCI_PORT_STOPPING,
+
+        /**
+         * This state indicates the port is now ready.  Thus, the user is
+         * able to perform IO operations on this port.
+         * This state is entered from the STARTING state.
+         */
+        SCI_PORT_READY,
+
+        /**
+         * The substate where the port is started and ready but has no
+         * active phys.
+         */
+        SCI_PORT_SUB_WAITING,
+
+        /**
+         * The substate where the port is started and ready and there is
+         * at least one phy operational.
+         */
+        SCI_PORT_SUB_OPERATIONAL,
+
+        /**
+         * The substate where the port is started and there was an
+         * add/remove phy event.  This state is only used in Automatic
+         * Port Configuration Mode (APC)
+         */
+        SCI_PORT_SUB_CONFIGURING,
+
+        /**
+         * This state indicates the port is in the process of performing a hard
+         * reset.  Thus, the user is unable to perform IO operations on this
+         * port.
+         * This state is entered from the READY state.
+         */
+        SCI_PORT_RESETTING,
+
+        /**
+         * This state indicates the port has failed a reset request.  This state
+         * is entered when a port reset request times out.
+         * This state is entered from the RESETTING state.
+         */
+        SCI_PORT_FAILED,
+
+
+};
 
 static inline void sci_port_decrement_request_count(struct isci_port *iport)
 {
@@ -230,10 +254,6 @@ bool sci_port_link_detected(
         struct isci_port *iport,
         struct isci_phy *iphy);
 
-enum sci_status sci_port_get_properties(
-        struct isci_port *iport,
-        struct sci_port_properties *prop);
-
 enum sci_status sci_port_link_up(struct isci_port *iport,
                                       struct isci_phy *iphy);
 enum sci_status sci_port_link_down(struct isci_port *iport,
@@ -270,14 +290,17 @@ 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);
+enum isci_status isci_port_get_state(
+        struct isci_port *isci_port);
 
 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);
 #endif /* !defined(_ISCI_PORT_H_) */
diff --git a/drivers/scsi/isci/port_config.c b/drivers/scsi/isci/port_config.c
index cd962da4a57..38a99d28114 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  (1000)
+#define SCIC_SDS_APC_WAIT_LINK_UP_NOTIFICATION  (100)
 
 enum SCIC_SDS_APC_ACTIVITY {
         SCIC_SDS_APC_SKIP_PHY,
@@ -466,19 +466,6 @@ sci_apc_agent_validate_phy_configuration(struct isci_host *ihost,
         return sci_port_configuration_agent_validate_ports(ihost, port_agent);
 }
 
-/*
- * This routine will restart the automatic port configuration timeout
- * timer for the next time period. This could be caused by either a link
- * 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)
-{
-        port_agent->timer_pending = true;
-        sci_mod_timer(&port_agent->timer, timeout);
-}
-
 static void sci_apc_agent_configure_ports(struct isci_host *ihost,
                                                struct sci_port_configuration_agent *port_agent,
                                                struct isci_phy *iphy,
@@ -578,8 +565,17 @@ static void sci_apc_agent_configure_ports(struct isci_host *ihost,
                 break;
 
         case SCIC_SDS_APC_START_TIMER:
-                sci_apc_agent_start_timer(port_agent,
-                                          SCIC_SDS_APC_WAIT_LINK_UP_NOTIFICATION);
+                /*
+                 * This can occur for either a link down event, or a link
+                 * up event where we cannot yet tell the port to which a
+                 * phy belongs.
+                 */
+                if (port_agent->timer_pending)
+                        sci_del_timer(&port_agent->timer);
+
+                port_agent->timer_pending = true;
+                sci_mod_timer(&port_agent->timer,
+                              SCIC_SDS_APC_WAIT_LINK_UP_NOTIFICATION);
                 break;
 
         case SCIC_SDS_APC_SKIP_PHY:
@@ -611,8 +607,7 @@ static void sci_apc_agent_link_up(struct isci_host *ihost,
         if (!iport) {
                 /* the phy is not the part of this port */
                 port_agent->phy_ready_mask |= 1 << phy_index;
-                sci_apc_agent_start_timer(port_agent,
-                                          SCIC_SDS_APC_WAIT_LINK_UP_NOTIFICATION);
+                sci_apc_agent_configure_ports(ihost, port_agent, iphy, true);
         } else {
                 /* the phy is already the part of the port */
                 u32 port_state = iport->sm.current_state_id;
@@ -693,9 +688,6 @@ 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);
 }
@@ -731,11 +723,6 @@ 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 8ac646e5edd..b5f4341de24 100644
--- a/drivers/scsi/isci/probe_roms.c
+++ b/drivers/scsi/isci/probe_roms.c
@@ -104,6 +104,7 @@ struct isci_orom *isci_request_oprom(struct pci_dev *pdev)
 
         if (i >= len) {
                 dev_err(&pdev->dev, "oprom parse error\n");
+                devm_kfree(&pdev->dev, rom);
                 rom = NULL;
         }
         pci_unmap_biosrom(oprom);
@@ -111,6 +112,18 @@ 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;
@@ -134,7 +147,7 @@ struct isci_orom *isci_request_firmware(struct pci_dev *pdev, const struct firmw
 
         memcpy(orom, fw->data, fw->size);
 
-        if (is_c0(pdev) || is_c1(pdev))
+        if (is_c0(pdev))
                 goto out;
 
         /*
diff --git a/drivers/scsi/isci/probe_roms.h b/drivers/scsi/isci/probe_roms.h
index e08b578241f..dc007e692f4 100644
--- a/drivers/scsi/isci/probe_roms.h
+++ b/drivers/scsi/isci/probe_roms.h
@@ -112,7 +112,7 @@ struct sci_user_parameters {
          * This field specifies the maximum number of direct attached devices
          * that can have power supplied to them simultaneously.
          */
-        u8 max_concurr_spinup;
+        u8 max_number_concurrent_device_spin_up;
 
         /**
          * This field specifies the number of seconds to allow a phy to consume
@@ -152,10 +152,12 @@ struct sci_user_parameters {
 #define MAX_CONCURRENT_DEVICE_SPIN_UP_COUNT 4
 
 struct sci_oem_params;
-int sci_oem_parameters_validate(struct sci_oem_params *oem, u8 version);
+int sci_oem_parameters_validate(struct sci_oem_params *oem);
 
 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);
 
@@ -189,11 +191,6 @@ struct isci_oem_hdr {
                         0x1a, 0x04, 0xc6)
 #define ISCI_EFI_VAR_NAME       "RstScuO"
 
-#define ISCI_ROM_VER_1_0        0x10
-#define ISCI_ROM_VER_1_1        0x11
-#define ISCI_ROM_VER_1_3        0x13
-#define ISCI_ROM_VER_LATEST     ISCI_ROM_VER_1_3
-
 /* Allowed PORT configuration modes APC Automatic PORT configuration mode is
  * defined by the OEM configuration parameters providing no PHY_MASK parameters
  * for any PORT. i.e. There are no phys assigned to any of the ports at start.
@@ -222,87 +219,9 @@ struct sci_bios_oem_param_block_hdr {
 struct sci_oem_params {
         struct {
                 uint8_t mode_type;
-                uint8_t max_concurr_spin_up;
-                /*
-                 * This bitfield indicates the OEM's desired default Tx
-                 * Spread Spectrum Clocking (SSC) settings for SATA and SAS.
-                 * NOTE: Default SSC Modulation Frequency is 31.5KHz.
-                 */
-                union {
-                        struct {
-                        /*
-                         * NOTE: Max spread for SATA is +0 / -5000 PPM.
-                         * Down-spreading SSC (only method allowed for SATA):
-                         *  SATA SSC Tx Disabled                    = 0x0
-                         *  SATA SSC Tx at +0 / -1419 PPM Spread    = 0x2
-                         *  SATA SSC Tx at +0 / -2129 PPM Spread    = 0x3
-                         *  SATA SSC Tx at +0 / -4257 PPM Spread    = 0x6
-                         *  SATA SSC Tx at +0 / -4967 PPM Spread    = 0x7
-                         */
-                                uint8_t ssc_sata_tx_spread_level:4;
-                        /*
-                         * SAS SSC Tx Disabled                     = 0x0
-                         *
-                         * NOTE: Max spread for SAS down-spreading +0 /
-                         *       -2300 PPM
-                         * Down-spreading SSC:
-                         *  SAS SSC Tx at +0 / -1419 PPM Spread     = 0x2
-                         *  SAS SSC Tx at +0 / -2129 PPM Spread     = 0x3
-                         *
-                         * NOTE: Max spread for SAS center-spreading +2300 /
-                         *       -2300 PPM
-                         * Center-spreading SSC:
-                         *  SAS SSC Tx at +1064 / -1064 PPM Spread  = 0x3
-                         *  SAS SSC Tx at +2129 / -2129 PPM Spread  = 0x6
-                         */
-                                uint8_t ssc_sas_tx_spread_level:3;
-                        /*
-                         * NOTE: Refer to the SSC section of the SAS 2.x
-                         * Specification for proper setting of this field.
-                         * For standard SAS Initiator SAS PHY operation it
-                         * should be 0 for Down-spreading.
-                         * SAS SSC Tx spread type:
-                         *  Down-spreading SSC      = 0
-                         *  Center-spreading SSC    = 1
-                         */
-                                uint8_t ssc_sas_tx_type:1;
-                        };
-                        uint8_t do_enable_ssc;
-                };
-                /*
-                 * This field indicates length of the SAS/SATA cable between
-                 * host and device.
-                 * This field is used make relationship between analog
-                 * parameters of the phy in the silicon and length of the cable.
-                 * Supported cable attenuation levels:
-                 * "short"- up to 3m, "medium"-3m to 6m, and "long"- more than
-                 * 6m.
-                 *
-                 * This is bit mask field:
-                 *
-                 * BIT:      (MSB) 7     6     5     4
-                 * ASSIGNMENT:   <phy3><phy2><phy1><phy0>  - Medium cable
-                 *                                           length assignment
-                 * BIT:            3     2     1     0  (LSB)
-                 * ASSIGNMENT:   <phy3><phy2><phy1><phy0>  - Long cable length
-                 *                                           assignment
-                 *
-                 * BITS 7-4 are set when the cable length is assigned to medium
-                 * BITS 3-0 are set when the cable length is assigned to long
-                 *
-                 * The BIT positions are clear when the cable length is
-                 * assigned to short.
-                 *
-                 * Setting the bits for both long and medium cable length is
-                 * undefined.
-                 *
-                 * A value of 0x84 would assign
-                 *    phy3 - medium
-                 *    phy2 - long
-                 *    phy1 - short
-                 *    phy0 - short
-                 */
-                uint8_t cable_selection_mask;
+                uint8_t max_concurrent_dev_spin_up;
+                uint8_t do_enable_ssc;
+                uint8_t reserved;
         } controller;
 
         struct {
diff --git a/drivers/scsi/isci/registers.h b/drivers/scsi/isci/registers.h
index 97f3ceb8d72..00afc738bbe 100644
--- a/drivers/scsi/isci/registers.h
+++ b/drivers/scsi/isci/registers.h
@@ -370,27 +370,6 @@ struct scu_iit_entry {
                 >> SMU_DEVICE_CONTEXT_CAPACITY_MAX_RNC_SHIFT \
         )
 
-/* ***************************************************************************** */
-#define SMU_CLOCK_GATING_CONTROL_IDLE_ENABLE_SHIFT    (0)
-#define SMU_CLOCK_GATING_CONTROL_IDLE_ENABLE_MASK     (0x00000001)
-#define SMU_CLOCK_GATING_CONTROL_XCLK_ENABLE_SHIFT    (1)
-#define SMU_CLOCK_GATING_CONTROL_XCLK_ENABLE_MASK     (0x00000002)
-#define SMU_CLOCK_GATING_CONTROL_TXCLK_ENABLE_SHIFT   (2)
-#define SMU_CLOCK_GATING_CONTROL_TXCLK_ENABLE_MASK    (0x00000004)
-#define SMU_CLOCK_GATING_CONTROL_REGCLK_ENABLE_SHIFT  (3)
-#define SMU_CLOCK_GATING_CONTROL_REGCLK_ENABLE_MASK   (0x00000008)
-#define SMU_CLOCK_GATING_CONTROL_IDLE_TIMEOUT_SHIFT   (16)
-#define SMU_CLOCK_GATING_CONTROL_IDLE_TIMEOUT_MASK    (0x000F0000)
-#define SMU_CLOCK_GATING_CONTROL_FORCE_IDLE_SHIFT     (31)
-#define SMU_CLOCK_GATING_CONTROL_FORCE_IDLE_MASK      (0x80000000)
-#define SMU_CLOCK_GATING_CONTROL_RESERVED_MASK        (0x7FF0FFF0)
-
-#define SMU_CGUCR_GEN_VAL(name, value) \
-        SCU_GEN_VALUE(SMU_CLOCK_GATING_CONTROL_##name, value)
-
-#define SMU_CGUCR_GEN_BIT(name) \
-        SCU_GEN_BIT(SMU_CLOCK_GATING_CONTROL_##name)
-
 /* -------------------------------------------------------------------------- */
 
 #define SMU_CONTROL_STATUS_TASK_CONTEXT_RANGE_ENABLE_SHIFT      (0)
@@ -896,6 +875,122 @@ struct scu_iit_entry {
 #define SCU_PTSxSR_GEN_BIT(name) \
         SCU_GEN_BIT(SCU_PTSG_PORT_TASK_SCHEDULER_STATUS_ ## name)
 
+
+/*
+ * *****************************************************************************
+ * * SGPIO Register shift and mask values
+ * ***************************************************************************** */
+#define SCU_SGPIO_CONTROL_SGPIO_ENABLE_SHIFT                    (0)
+#define SCU_SGPIO_CONTROL_SGPIO_ENABLE_MASK                     (0x00000001)
+#define SCU_SGPIO_CONTROL_SGPIO_SERIAL_CLOCK_SELECT_SHIFT       (1)
+#define SCU_SGPIO_CONTROL_SGPIO_SERIAL_CLOCK_SELECT_MASK        (0x00000002)
+#define SCU_SGPIO_CONTROL_SGPIO_SERIAL_SHIFT_WIDTH_SELECT_SHIFT (2)
+#define SCU_SGPIO_CONTROL_SGPIO_SERIAL_SHIFT_WIDTH_SELECT_MASK  (0x00000004)
+#define SCU_SGPIO_CONTROL_SGPIO_TEST_BIT_SHIFT                  (15)
+#define SCU_SGPIO_CONTROL_SGPIO_TEST_BIT_MASK                   (0x00008000)
+#define SCU_SGPIO_CONTROL_SGPIO_RESERVED_MASK                   (0xFFFF7FF8)
+
+#define SCU_SGICRx_GEN_BIT(name) \
+        SCU_GEN_BIT(SCU_SGPIO_CONTROL_SGPIO_ ## name)
+
+#define SCU_SGPIO_PROGRAMMABLE_BLINK_REGISTER_R0_SHIFT      (0)
+#define SCU_SGPIO_PROGRAMMABLE_BLINK_REGISTER_R0_MASK       (0x0000000F)
+#define SCU_SGPIO_PROGRAMMABLE_BLINK_REGISTER_R1_SHIFT      (4)
+#define SCU_SGPIO_PROGRAMMABLE_BLINK_REGISTER_R1_MASK       (0x000000F0)
+#define SCU_SGPIO_PROGRAMMABLE_BLINK_REGISTER_R2_SHIFT      (8)
+#define SCU_SGPIO_PROGRAMMABLE_BLINK_REGISTER_R2_MASK       (0x00000F00)
+#define SCU_SGPIO_PROGRAMMABLE_BLINK_REGISTER_R3_SHIFT      (12)
+#define SCU_SGPIO_PROGRAMMABLE_BLINK_REGISTER_R3_MASK       (0x0000F000)
+#define SCU_SGPIO_PROGRAMMABLE_BLINK_REGISTER_RESERVED_MASK (0xFFFF0000)
+
+#define SCU_SGPBRx_GEN_VAL(name, value) \
+        SCU_GEN_VALUE(SCU_SGPIO_PROGRAMMABLE_BLINK_REGISTER_ ## name, value)
+
+#define SCU_SGPIO_START_DRIVE_LOWER_R0_SHIFT        (0)
+#define SCU_SGPIO_START_DRIVE_LOWER_R0_MASK         (0x00000003)
+#define SCU_SGPIO_START_DRIVE_LOWER_R1_SHIFT        (4)
+#define SCU_SGPIO_START_DRIVE_LOWER_R1_MASK         (0x00000030)
+#define SCU_SGPIO_START_DRIVE_LOWER_R2_SHIFT        (8)
+#define SCU_SGPIO_START_DRIVE_LOWER_R2_MASK         (0x00000300)
+#define SCU_SGPIO_START_DRIVE_LOWER_R3_SHIFT        (12)
+#define SCU_SGPIO_START_DRIVE_LOWER_R3_MASK         (0x00003000)
+#define SCU_SGPIO_START_DRIVE_LOWER_RESERVED_MASK   (0xFFFF8888)
+
+#define SCU_SGSDLRx_GEN_VAL(name, value) \
+        SCU_GEN_VALUE(SCU_SGPIO_START_DRIVE_LOWER_ ## name, value)
+
+#define SCU_SGPIO_START_DRIVE_UPPER_R0_SHIFT        (0)
+#define SCU_SGPIO_START_DRIVE_UPPER_R0_MASK         (0x00000003)
+#define SCU_SGPIO_START_DRIVE_UPPER_R1_SHIFT        (4)
+#define SCU_SGPIO_START_DRIVE_UPPER_R1_MASK         (0x00000030)
+#define SCU_SGPIO_START_DRIVE_UPPER_R2_SHIFT        (8)
+#define SCU_SGPIO_START_DRIVE_UPPER_R2_MASK         (0x00000300)
+#define SCU_SGPIO_START_DRIVE_UPPER_R3_SHIFT        (12)
+#define SCU_SGPIO_START_DRIVE_UPPER_R3_MASK         (0x00003000)
+#define SCU_SGPIO_START_DRIVE_UPPER_RESERVED_MASK   (0xFFFF8888)
+
+#define SCU_SGSDURx_GEN_VAL(name, value) \
+        SCU_GEN_VALUE(SCU_SGPIO_START_DRIVE_LOWER_ ## name, value)
+
+#define SCU_SGPIO_SERIAL_INPUT_DATA_LOWER_D0_SHIFT      (0)
+#define SCU_SGPIO_SERIAL_INPUT_DATA_LOWER_D0_MASK       (0x00000003)
+#define SCU_SGPIO_SERIAL_INPUT_DATA_LOWER_D1_SHIFT      (4)
+#define SCU_SGPIO_SERIAL_INPUT_DATA_LOWER_D1_MASK       (0x00000030)
+#define SCU_SGPIO_SERIAL_INPUT_DATA_LOWER_D2_SHIFT      (8)
+#define SCU_SGPIO_SERIAL_INPUT_DATA_LOWER_D2_MASK       (0x00000300)
+#define SCU_SGPIO_SERIAL_INPUT_DATA_LOWER_D3_SHIFT      (12)
+#define SCU_SGPIO_SERIAL_INPUT_DATA_LOWER_D3_MASK       (0x00003000)
+#define SCU_SGPIO_SERIAL_INPUT_DATA_LOWER_RESERVED_MASK (0xFFFF8888)
+
+#define SCU_SGSIDLRx_GEN_VAL(name, value) \
+        SCU_GEN_VALUE(SCU_SGPIO_SERIAL_INPUT_DATA_LOWER_ ## name, value)
+
+#define SCU_SGPIO_SERIAL_INPUT_DATA_UPPER_D0_SHIFT      (0)
+#define SCU_SGPIO_SERIAL_INPUT_DATA_UPPER_D0_MASK       (0x00000003)
+#define SCU_SGPIO_SERIAL_INPUT_DATA_UPPER_D1_SHIFT      (4)
+#define SCU_SGPIO_SERIAL_INPUT_DATA_UPPER_D1_MASK       (0x00000030)
+#define SCU_SGPIO_SERIAL_INPUT_DATA_UPPER_D2_SHIFT      (8)
+#define SCU_SGPIO_SERIAL_INPUT_DATA_UPPER_D2_MASK       (0x00000300)
+#define SCU_SGPIO_SERIAL_INPUT_DATA_UPPER_D3_SHIFT      (12)
+#define SCU_SGPIO_SERIAL_INPUT_DATA_UPPER_D3_MASK       (0x00003000)
+#define SCU_SGPIO_SERIAL_INPUT_DATA_UPPER_RESERVED_MASK (0xFFFF8888)
+
+#define SCU_SGSIDURx_GEN_VAL(name, value) \
+        SCU_GEN_VALUE(SCU_SGPIO_SERIAL_INPUT_DATA_LOWER_ ## name, value)
+
+#define SCU_SGPIO_VENDOR_SPECIFIC_CODE_SHIFT            (0)
+#define SCU_SGPIO_VENDOR_SPECIFIC_CODE_MASK             (0x0000000F)
+#define SCU_SGPIO_VENDOR_SPECIFIC_CODE_RESERVED_MASK    (0xFFFFFFF0)
+
+#define SCU_SGVSCR_GEN_VAL(value) \
+        SCU_GEN_VALUE(SCU_SGPIO_VENDOR_SPECIFIC_CODE ## name, value)
+
+#define SCU_SGPIO_OUPUT_DATA_SELECT_INPUT_DATA0_SHIFT           (0)
+#define SCU_SGPIO_OUPUT_DATA_SELECT_INPUT_DATA0_MASK            (0x00000003)
+#define SCU_SGPIO_OUPUT_DATA_SELECT_INVERT_INPUT_DATA0_SHIFT    (2)
+#define SCU_SGPIO_OUPUT_DATA_SELECT_INVERT_INPUT_DATA0_MASK     (0x00000004)
+#define SCU_SGPIO_OUPUT_DATA_SELECT_JOG_ENABLE_DATA0_SHIFT      (3)
+#define SCU_SGPIO_OUPUT_DATA_SELECT_JOG_ENABLE_DATA0_MASK       (0x00000008)
+#define SCU_SGPIO_OUPUT_DATA_SELECT_INPUT_DATA1_SHIFT           (4)
+#define SCU_SGPIO_OUPUT_DATA_SELECT_INPUT_DATA1_MASK            (0x00000030)
+#define SCU_SGPIO_OUPUT_DATA_SELECT_INVERT_INPUT_DATA1_SHIFT    (6)
+#define SCU_SGPIO_OUPUT_DATA_SELECT_INVERT_INPUT_DATA1_MASK     (0x00000040)
+#define SCU_SGPIO_OUPUT_DATA_SELECT_JOG_ENABLE_DATA1_SHIFT      (7)
+#define SCU_SGPIO_OUPUT_DATA_SELECT_JOG_ENABLE_DATA1_MASK       (0x00000080)
+#define SCU_SGPIO_OUPUT_DATA_SELECT_INPUT_DATA2_SHIFT           (8)
+#define SCU_SGPIO_OUPUT_DATA_SELECT_INPUT_DATA2_MASK            (0x00000300)
+#define SCU_SGPIO_OUPUT_DATA_SELECT_INVERT_INPUT_DATA2_SHIFT    (10)
+#define SCU_SGPIO_OUPUT_DATA_SELECT_INVERT_INPUT_DATA2_MASK     (0x00000400)
+#define SCU_SGPIO_OUPUT_DATA_SELECT_JOG_ENABLE_DATA2_SHIFT      (11)
+#define SCU_SGPIO_OUPUT_DATA_SELECT_JOG_ENABLE_DATA2_MASK       (0x00000800)
+#define SCU_SGPIO_OUPUT_DATA_SELECT_RESERVED_MASK               (0xFFFFF000)
+
+#define SCU_SGODSR_GEN_VAL(name, value) \
+        SCU_GEN_VALUE(SCU_SGPIO_OUPUT_DATA_SELECT_ ## name, value)
+
+#define SCU_SGODSR_GEN_BIT(name) \
+        SCU_GEN_BIT(SCU_SGPIO_OUPUT_DATA_SELECT_ ## name)
+
 /*
  * *****************************************************************************
  * * SMU Registers
@@ -1013,10 +1108,8 @@ struct smu_registers {
         u32 mmr_address_window;
 /* 0x00A4 SMDW */
         u32 mmr_data_window;
-/* 0x00A8 CGUCR */
-        u32 clock_gating_control;
-/* 0x00AC CGUPC */
-        u32 clock_gating_performance;
+        u32 reserved_A8;
+        u32 reserved_AC;
 /* A whole bunch of reserved space */
         u32 reserved_Bx[4];
         u32 reserved_Cx[4];
@@ -1239,14 +1332,6 @@ 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
@@ -1444,12 +1529,10 @@ struct scu_sgpio_registers {
         u32 serial_input_upper;
 /* 0x0018 SGPIO_SGVSCR */
         u32 vendor_specific_code;
-/* 0x001C Reserved */
-        u32 reserved_001c;
 /* 0x0020 SGPIO_SGODSR */
-        u32 output_data_select[8];
+        u32 ouput_data_select[8];
 /* Remainder of memory space 256 bytes */
-        u32 reserved_1444_14ff[0x30];
+        u32 reserved_1444_14ff[0x31];
 
 };
 
diff --git a/drivers/scsi/isci/remote_device.c b/drivers/scsi/isci/remote_device.c
index c3aa6c5457b..b6e6368c266 100644
--- a/drivers/scsi/isci/remote_device.c
+++ b/drivers/scsi/isci/remote_device.c
@@ -53,7 +53,6 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include <scsi/sas.h>
-#include <linux/bitops.h>
 #include "isci.h"
 #include "port.h"
 #include "remote_device.h"
@@ -62,21 +61,46 @@
 #include "scu_event_codes.h"
 #include "task.h"
 
-#undef C
-#define C(a) (#a)
-const char *dev_state_name(enum sci_remote_device_states state)
+/**
+ * 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)
 {
-        static const char * const strings[] = REMOTE_DEV_STATES;
+        struct isci_request *ireq;
 
-        return strings[state];
-}
-#undef C
+        dev_dbg(&ihost->pdev->dev,
+                "%s: isci_device = %p\n", __func__, idev);
 
-enum sci_status sci_remote_device_suspend(struct isci_remote_device *idev,
-                                          enum sci_remote_node_suspension_reasons reason)
-{
-        return sci_remote_node_context_suspend(&idev->rnc, reason,
-                                               SCI_SOFTWARE_SUSPEND_EXPECTED_EVENT);
+        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;
+        }
 }
 
 /**
@@ -98,29 +122,18 @@ static void isci_remote_device_ready(struct isci_host *ihost, struct isci_remote
                 wake_up(&ihost->eventq);
 }
 
-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)
+/* 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)
 {
-        if (!test_bit(IREQ_ACTIVE, &ireq->flags) ||
-            (ireq->target_device != idev) ||
-            (check_abort && !test_bit(IREQ_PENDING_ABORT, &ireq->flags)))
-                return SCI_SUCCESS;
-
-        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);
+        struct isci_remote_device *idev = _dev;
 
-        return sci_controller_terminate_request(ihost, idev, ireq);
+        BUG_ON(idev->started_request_count != 0);
+        sci_change_state(&idev->sm, SCI_DEV_STOPPED);
 }
 
-static enum sci_status sci_remote_device_terminate_reqs_checkabort(
-        struct isci_remote_device *idev,
-        int chk)
+static enum sci_status sci_remote_device_terminate_requests(struct isci_remote_device *idev)
 {
         struct isci_host *ihost = idev->owning_port->owning_controller;
         enum sci_status status  = SCI_SUCCESS;
@@ -130,210 +143,18 @@ static enum sci_status sci_remote_device_terminate_reqs_checkabort(
                 struct isci_request *ireq = ihost->reqs[i];
                 enum sci_status s;
 
-                s = sci_remote_device_terminate_req(ihost, idev, chk, ireq);
+                if (!test_bit(IREQ_ACTIVE, &ireq->flags) ||
+                    ireq->target_device != idev)
+                        continue;
+
+                s = sci_controller_terminate_request(ihost, idev, 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)
 {
@@ -345,8 +166,8 @@ enum sci_status sci_remote_device_stop(struct isci_remote_device *idev,
         case SCI_DEV_FAILED:
         case SCI_DEV_FINAL:
         default:
-                dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
-                         __func__, dev_state_name(state));
+                dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
+                         __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
         case SCI_DEV_STOPPED:
                 return SCI_SUCCESS;
@@ -369,16 +190,13 @@ 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);
-                else {
-                        sci_remote_device_suspend(
-                                idev, SCI_SW_SUSPEND_LINKHANG_DETECT);
-                        sci_remote_device_terminate_requests(idev);
-                }
-                return SCI_SUCCESS;
+                                                              rnc_destruct_done, idev);
+                        return SCI_SUCCESS;
+                } else
+                        return sci_remote_device_terminate_requests(idev);
+                break;
         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
@@ -407,8 +225,8 @@ enum sci_status sci_remote_device_reset(struct isci_remote_device *idev)
         case SCI_DEV_RESETTING:
         case SCI_DEV_FINAL:
         default:
-                dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
-                         __func__, dev_state_name(state));
+                dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
+                         __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
         case SCI_DEV_READY:
         case SCI_STP_DEV_IDLE:
@@ -427,8 +245,8 @@ enum sci_status sci_remote_device_reset_complete(struct isci_remote_device *idev
         enum sci_remote_device_states state = sm->current_state_id;
 
         if (state != SCI_DEV_RESETTING) {
-                dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
-                         __func__, dev_state_name(state));
+                dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
+                         __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
         }
 
@@ -436,6 +254,22 @@ 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: %d\n",
+                         __func__, 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)
 {
@@ -452,8 +286,8 @@ enum sci_status sci_remote_device_frame_handler(struct isci_remote_device *idev,
         case SCI_SMP_DEV_IDLE:
         case SCI_DEV_FINAL:
         default:
-                dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
-                         __func__, dev_state_name(state));
+                dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
+                         __func__, state);
                 /* Return the frame back to the controller */
                 sci_controller_release_frame(ihost, frame_index);
                 return SCI_FAILURE_INVALID_STATE;
@@ -552,24 +386,12 @@ static bool is_remote_device_ready(struct isci_remote_device *idev)
         }
 }
 
-/*
- * called once the remote node context has transisitioned to a ready
- * state (after suspending RX and/or TX due to early D2H fis)
- */
-static void atapi_remote_device_resume_done(void *_dev)
-{
-        struct isci_remote_device *idev = _dev;
-        struct isci_request *ireq = idev->working_request;
-
-        sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
-}
-
 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:
@@ -582,7 +404,9 @@ enum sci_status sci_remote_device_event_handler(struct isci_remote_device *idev,
                         status = SCI_SUCCESS;
 
                         /* Suspend the associated RNC */
-                        sci_remote_device_suspend(idev, SCI_SW_SUSPEND_NORMAL);
+                        sci_remote_node_context_suspend(&idev->rnc,
+                                                              SCI_SOFTWARE_SUSPENSION,
+                                                              NULL, NULL);
 
                         dev_dbg(scirdev_to_dev(idev),
                                 "%s: device: %p event code: %x: %s\n",
@@ -608,20 +432,6 @@ 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 ||
-                    scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX) {
-                        return sci_remote_node_context_resume(&idev->rnc,
-                                                              atapi_remote_device_resume_done,
-                                                              idev);
-                }
-        }
-
         if (state == SCI_STP_DEV_IDLE) {
 
                 /* We pick up suspension events to handle specifically to this
@@ -669,8 +479,8 @@ enum sci_status sci_remote_device_start_io(struct isci_host *ihost,
         case SCI_DEV_RESETTING:
         case SCI_DEV_FINAL:
         default:
-                dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
-                         __func__, dev_state_name(state));
+                dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
+                         __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
         case SCI_DEV_READY:
                 /* attempt to start an io request for this device object. The remote
@@ -804,8 +614,8 @@ enum sci_status sci_remote_device_complete_io(struct isci_host *ihost,
         case SCI_DEV_FAILED:
         case SCI_DEV_FINAL:
         default:
-                dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
-                         __func__, dev_state_name(state));
+                dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
+                         __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
         case SCI_DEV_READY:
         case SCI_STP_DEV_AWAIT_RESET:
@@ -815,7 +625,6 @@ enum sci_status sci_remote_device_complete_io(struct isci_host *ihost,
         case SCI_STP_DEV_CMD:
         case SCI_STP_DEV_NCQ:
         case SCI_STP_DEV_NCQ_ERROR:
-        case SCI_STP_DEV_ATAPI_ERROR:
                 status = common_complete_io(iport, idev, ireq);
                 if (status != SCI_SUCCESS)
                         break;
@@ -888,8 +697,8 @@ enum sci_status sci_remote_device_start_task(struct isci_host *ihost,
         case SCI_DEV_RESETTING:
         case SCI_DEV_FINAL:
         default:
-                dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
-                         __func__, dev_state_name(state));
+                dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
+                         __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
         case SCI_STP_DEV_IDLE:
         case SCI_STP_DEV_CMD:
@@ -900,6 +709,10 @@ 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;
@@ -918,11 +731,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_device_suspend(idev,
-                                          SCI_SW_SUSPEND_LINKHANG_DETECT);
-
-                status = sci_remote_node_context_start_task(&idev->rnc, ireq,
-                                sci_remote_device_continue_request, idev);
+                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);
 
         out:
                 sci_remote_device_start_request(idev, ireq, status);
@@ -936,9 +749,7 @@ enum sci_status sci_remote_device_start_task(struct isci_host *ihost,
                 if (status != SCI_SUCCESS)
                         return status;
 
-                /* Resume the RNC as needed: */
-                status = sci_remote_node_context_start_task(&idev->rnc, ireq,
-                                                            NULL, NULL);
+                status = sci_remote_node_context_start_task(&idev->rnc, ireq);
                 if (status != SCI_SUCCESS)
                         break;
 
@@ -1018,8 +829,8 @@ static enum sci_status sci_remote_device_destruct(struct isci_remote_device *ide
         struct isci_host *ihost;
 
         if (state != SCI_DEV_STOPPED) {
-                dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
-                         __func__, dev_state_name(state));
+                dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
+                         __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
         }
 
@@ -1047,7 +858,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(idev->started_request_count > 0);
+        BUG_ON(!list_empty(&idev->reqs_in_process));
 
         sci_remote_device_destruct(idev);
         list_del_init(&idev->node);
@@ -1109,21 +920,14 @@ 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;
-
-        dev_dbg(&ihost->pdev->dev,
-                "%s: isci_device = %p\n", __func__, idev);
 
-        sci_remote_device_suspend(idev, SCI_SW_SUSPEND_LINKHANG_DETECT);
+        sci_remote_node_context_suspend(
+                &idev->rnc, SCI_SOFTWARE_SUSPENSION, NULL, NULL);
 }
 
 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);
 }
@@ -1216,7 +1020,6 @@ static const struct sci_base_state sci_remote_device_state_table[] = {
         [SCI_STP_DEV_NCQ_ERROR] = {
                 .enter_state = sci_stp_remote_device_ready_ncq_error_substate_enter,
         },
-        [SCI_STP_DEV_ATAPI_ERROR] = { },
         [SCI_STP_DEV_AWAIT_RESET] = { },
         [SCI_SMP_DEV_IDLE] = {
                 .enter_state = sci_smp_remote_device_ready_idle_substate_enter,
@@ -1274,23 +1077,33 @@ static enum sci_status sci_remote_device_da_construct(struct isci_port *iport,
                                                        struct isci_remote_device *idev)
 {
         enum sci_status status;
-        struct sci_port_properties properties;
+        struct domain_device *dev = idev->domain_dev;
 
         sci_remote_device_construct(iport, idev);
 
-        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);
-
+        /*
+         * 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;
         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);
 
+        /* / @todo Should I assign the port width by reading all of the phys on the port? */
+        idev->device_port_width = 1;
+
         return SCI_SUCCESS;
 }
 
@@ -1320,13 +1133,19 @@ static enum sci_status sci_remote_device_ea_construct(struct isci_port *iport,
         if (status != SCI_SUCCESS)
                 return status;
 
-        /* For SAS-2 the physical link rate is actually a logical link
+        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
          * 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);
 
@@ -1336,105 +1155,6 @@ 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
@@ -1449,20 +1169,21 @@ enum sci_status isci_remote_device_resume_from_abort(
  * 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;
         enum sci_status status;
 
         if (state != SCI_DEV_STOPPED) {
-                dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %s\n",
-                         __func__, dev_state_name(state));
+                dev_warn(scirdev_to_dev(idev), "%s: in wrong state: %d\n",
+                         __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
         }
 
-        status = sci_remote_device_resume(idev, remote_device_resume_done,
-                                          idev);
+        status = sci_remote_node_context_resume(&idev->rnc,
+                                                     remote_device_resume_done,
+                                                     idev);
         if (status != SCI_SUCCESS)
                 return status;
 
@@ -1500,6 +1221,20 @@ 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.
@@ -1524,6 +1259,10 @@ 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;
 
@@ -1541,6 +1280,7 @@ void isci_remote_device_release(struct kref *kref)
         clear_bit(IDEV_STOP_PENDING, &idev->flags);
         clear_bit(IDEV_IO_READY, &idev->flags);
         clear_bit(IDEV_GONE, &idev->flags);
+        clear_bit(IDEV_EH, &idev->flags);
         smp_mb__before_clear_bit();
         clear_bit(IDEV_ALLOCATED, &idev->flags);
         wake_up(&ihost->eventq);
@@ -1565,8 +1305,14 @@ 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);
 
@@ -1576,9 +1322,6 @@ 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;
 }
 
@@ -1610,17 +1353,34 @@ void isci_remote_device_gone(struct domain_device *dev)
  *
  * status, zero indicates success.
  */
-int isci_remote_device_found(struct domain_device *dev)
+int isci_remote_device_found(struct domain_device *domain_dev)
 {
-        struct isci_host *isci_host = dev_to_ihost(dev);
-        struct isci_port *isci_port = dev->port->lldd_port;
+        struct isci_host *isci_host = dev_to_ihost(domain_dev);
+        struct isci_port *isci_port;
+        struct isci_phy *isci_phy;
+        struct asd_sas_port *sas_port;
+        struct asd_sas_phy *sas_phy;
         struct isci_remote_device *isci_device;
         enum sci_status status;
 
         dev_dbg(&isci_host->pdev->dev,
-                "%s: domain_device = %p\n", __func__, dev);
+                "%s: domain_device = %p\n", __func__, domain_dev);
+
+        wait_for_start(isci_host);
+
+        sas_port = domain_dev->port;
+        sas_phy = list_first_entry(&sas_port->phy_list, struct asd_sas_phy,
+                                   port_phy_el);
+        isci_phy = to_iphy(sas_phy);
+        isci_port = isci_phy->isci_port;
 
-        if (!isci_port)
+        /* we are being called for a device on this port,
+         * so it has to come up eventually
+         */
+        wait_for_completion(&isci_port->start_complete);
+
+        if ((isci_stopping == isci_port_get_state(isci_port)) ||
+            (isci_stopped == isci_port_get_state(isci_port)))
                 return -ENODEV;
 
         isci_device = isci_remote_device_alloc(isci_host, isci_port);
@@ -1631,7 +1391,7 @@ int isci_remote_device_found(struct domain_device *dev)
         INIT_LIST_HEAD(&isci_device->node);
 
         spin_lock_irq(&isci_host->scic_lock);
-        isci_device->domain_dev = dev;
+        isci_device->domain_dev = domain_dev;
         isci_device->isci_port = isci_port;
         list_add_tail(&isci_device->node, &isci_port->remote_dev_list);
 
@@ -1644,7 +1404,7 @@ int isci_remote_device_found(struct domain_device *dev)
 
         if (status == SCI_SUCCESS) {
                 /* device came up, advertise it to the world */
-                dev->lldd_dev = isci_device;
+                domain_dev->lldd_dev = isci_device;
         } else
                 isci_put_device(isci_device);
         spin_unlock_irq(&isci_host->scic_lock);
@@ -1654,73 +1414,88 @@ 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)
+/**
+ * isci_device_is_reset_pending() - This function will check if there is any
+ *    pending reset condition on the device.
+ * @request: This parameter is the isci_device object.
+ *
+ * true if there is a reset pending for the device.
+ */
+bool isci_device_is_reset_pending(
+        struct isci_host *isci_host,
+        struct isci_remote_device *isci_device)
 {
+        struct isci_request *isci_request;
+        struct isci_request *tmp_req;
+        bool reset_is_pending = false;
         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);
+        dev_dbg(&isci_host->pdev->dev,
+                "%s: isci_device = %p\n", __func__, isci_device);
 
-        /* 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);
+        spin_lock_irqsave(&isci_host->scic_lock, flags);
 
-        /* NOTE: RNC resumption is left to the caller! */
-        return status;
-}
+        /* Check for reset on all pending requests. */
+        list_for_each_entry_safe(isci_request, tmp_req,
+                                 &isci_device->reqs_in_process, dev_node) {
+                dev_dbg(&isci_host->pdev->dev,
+                        "%s: isci_device = %p request = %p\n",
+                        __func__, isci_device, isci_request);
 
-int isci_remote_device_is_safe_to_abort(
-        struct isci_remote_device *idev)
-{
-        return sci_remote_node_context_is_safe_to_abort(&idev->rnc);
-}
+                if (isci_request->ttype == io_task) {
+                        struct sas_task *task = isci_request_access_task(
+                                isci_request);
 
-enum sci_status sci_remote_device_abort_requests_pending_abort(
-        struct isci_remote_device *idev)
-{
-        return sci_remote_device_terminate_reqs_checkabort(idev, 1);
+                        spin_lock(&task->task_state_lock);
+                        if (task->task_state_flags & SAS_TASK_NEED_DEV_RESET)
+                                reset_is_pending = true;
+                        spin_unlock(&task->task_state_lock);
+                }
+        }
+
+        spin_unlock_irqrestore(&isci_host->scic_lock, flags);
+
+        dev_dbg(&isci_host->pdev->dev,
+                "%s: isci_device = %p reset_is_pending = %d\n",
+                __func__, isci_device, reset_is_pending);
+
+        return reset_is_pending;
 }
 
-enum sci_status isci_remote_device_reset_complete(
-        struct isci_host *ihost,
-        struct isci_remote_device *idev)
+/**
+ * isci_device_clear_reset_pending() - This function will clear if any pending
+ *    reset condition flags on the device.
+ * @request: This parameter is the isci_device object.
+ *
+ * true if there is a reset pending for the device.
+ */
+void isci_device_clear_reset_pending(struct isci_host *ihost, struct isci_remote_device *idev)
 {
-        unsigned long flags;
-        enum sci_status status;
+        struct isci_request *isci_request;
+        struct isci_request *tmp_req;
+        unsigned long flags = 0;
+
+        dev_dbg(&ihost->pdev->dev, "%s: idev=%p, ihost=%p\n",
+                 __func__, idev, ihost);
 
         spin_lock_irqsave(&ihost->scic_lock, flags);
-        status = sci_remote_device_reset_complete(idev);
-        spin_unlock_irqrestore(&ihost->scic_lock, flags);
 
-        return status;
-}
+        /* Clear reset pending on all pending requests. */
+        list_for_each_entry_safe(isci_request, tmp_req,
+                                 &idev->reqs_in_process, dev_node) {
+                dev_dbg(&ihost->pdev->dev, "%s: idev = %p request = %p\n",
+                         __func__, idev, isci_request);
 
-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);
+                if (isci_request->ttype == io_task) {
+
+                        unsigned long flags2;
+                        struct sas_task *task = isci_request_access_task(
+                                isci_request);
+
+                        spin_lock_irqsave(&task->task_state_lock, flags2);
+                        task->task_state_flags &= ~SAS_TASK_NEED_DEV_RESET;
+                        spin_unlock_irqrestore(&task->task_state_lock, flags2);
+                }
         }
+        spin_unlock_irqrestore(&ihost->scic_lock, flags);
 }
diff --git a/drivers/scsi/isci/remote_device.h b/drivers/scsi/isci/remote_device.h
index 7674caae1d8..57ccfc3d6ad 100644
--- a/drivers/scsi/isci/remote_device.h
+++ b/drivers/scsi/isci/remote_device.h
@@ -82,41 +82,31 @@ struct isci_remote_device {
         #define IDEV_START_PENDING 0
         #define IDEV_STOP_PENDING 1
         #define IDEV_ALLOCATED 2
-        #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
+        #define IDEV_EH 3
+        #define IDEV_GONE 4
+        #define IDEV_IO_READY 5
+        #define IDEV_IO_NCQERROR 6
         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;
@@ -142,7 +132,10 @@ void isci_remote_device_nuke_requests(struct isci_host *ihost,
                                       struct isci_remote_device *idev);
 void isci_remote_device_gone(struct domain_device *domain_dev);
 int isci_remote_device_found(struct domain_device *domain_dev);
-
+bool isci_device_is_reset_pending(struct isci_host *ihost,
+                                  struct isci_remote_device *idev);
+void isci_device_clear_reset_pending(struct isci_host *ihost,
+                                     struct isci_remote_device *idev);
 /**
  * sci_remote_device_stop() - This method will stop both transmission and
  *    reception of link activity for the supplied remote device.  This method
@@ -190,101 +183,113 @@ enum sci_status sci_remote_device_reset_complete(
 /**
  * enum sci_remote_device_states - This enumeration depicts all the states
  *    for the common remote device state machine.
- * @SCI_DEV_INITIAL: Simply the initial state for the base remote device
- * state machine.
- *
- * @SCI_DEV_STOPPED: This state indicates that the remote device has
- * successfully been stopped.  In this state no new IO operations are
- * permitted.  This state is entered from the INITIAL state.  This state
- * is entered from the STOPPING state.
- *
- * @SCI_DEV_STARTING: This state indicates the the remote device is in
- * the process of becoming ready (i.e. starting).  In this state no new
- * IO operations are permitted.  This state is entered from the STOPPED
- * state.
- *
- * @SCI_DEV_READY: This state indicates the remote device is now ready.
- * Thus, the user is able to perform IO operations on the remote device.
- * This state is entered from the STARTING state.
- *
- * @SCI_STP_DEV_IDLE: This is the idle substate for the stp remote
- * device.  When there are no active IO for the device it is is in this
- * state.
- *
- * @SCI_STP_DEV_CMD: This is the command state for for the STP remote
- * device.  This state is entered when the device is processing a
- * non-NCQ command.  The device object will fail any new start IO
- * requests until this command is complete.
- *
- * @SCI_STP_DEV_NCQ: This is the NCQ state for the STP remote device.
- * This state is entered when the device is processing an NCQ reuqest.
- * It will remain in this state so long as there is one or more NCQ
- * requests being processed.
- *
- * @SCI_STP_DEV_NCQ_ERROR: This is the NCQ error state for the STP
- * remote device.  This state is entered when an SDB error FIS is
- * received by the device object while in the NCQ state.  The device
- * object will only accept a READ LOG command while in this state.
- *
- * @SCI_STP_DEV_ATAPI_ERROR: This is the ATAPI error state for the STP
- * ATAPI remote device.  This state is entered when ATAPI device sends
- * error status FIS without data while the device object is in CMD
- * state.  A suspension event is expected in this state.  The device
- * object will resume right away.
- *
- * @SCI_STP_DEV_AWAIT_RESET: This is the READY substate indicates the
- * device is waiting for the RESET task coming to be recovered from
- * certain hardware specific error.
- *
- * @SCI_SMP_DEV_IDLE: This is the ready operational substate for the
- * remote device.  This is the normal operational state for a remote
- * device.
- *
- * @SCI_SMP_DEV_CMD: This is the suspended state for the remote device.
- * This is the state that the device is placed in when a RNC suspend is
- * received by the SCU hardware.
- *
- * @SCI_DEV_STOPPING: This state indicates that the remote device is in
- * the process of stopping.  In this state no new IO operations are
- * permitted, but existing IO operations are allowed to complete.  This
- * state is entered from the READY state.  This state is entered from
- * the FAILED state.
- *
- * @SCI_DEV_FAILED: This state indicates that the remote device has
- * failed.  In this state no new IO operations are permitted.  This
- * state is entered from the INITIALIZING state.  This state is entered
- * from the READY state.
  *
- * @SCI_DEV_RESETTING: This state indicates the device is being reset.
- * In this state no new IO operations are permitted.  This state is
- * entered from the READY state.
  *
- * @SCI_DEV_FINAL: Simply the final state for the base remote device
- * state machine.
  */
-#define REMOTE_DEV_STATES {\
-        C(DEV_INITIAL),\
-        C(DEV_STOPPED),\
-        C(DEV_STARTING),\
-        C(DEV_READY),\
-        C(STP_DEV_IDLE),\
-        C(STP_DEV_CMD),\
-        C(STP_DEV_NCQ),\
-        C(STP_DEV_NCQ_ERROR),\
-        C(STP_DEV_ATAPI_ERROR),\
-        C(STP_DEV_AWAIT_RESET),\
-        C(SMP_DEV_IDLE),\
-        C(SMP_DEV_CMD),\
-        C(DEV_STOPPING),\
-        C(DEV_FAILED),\
-        C(DEV_RESETTING),\
-        C(DEV_FINAL),\
-        }
-#undef C
-#define C(a) SCI_##a
-enum sci_remote_device_states REMOTE_DEV_STATES;
-#undef C
-const char *dev_state_name(enum sci_remote_device_states state);
+enum sci_remote_device_states {
+        /**
+         * Simply the initial state for the base remote device state machine.
+         */
+        SCI_DEV_INITIAL,
+
+        /**
+         * This state indicates that the remote device has successfully been
+         * stopped.  In this state no new IO operations are permitted.
+         * This state is entered from the INITIAL state.
+         * This state is entered from the STOPPING state.
+         */
+        SCI_DEV_STOPPED,
+
+        /**
+         * This state indicates the the remote device is in the process of
+         * becoming ready (i.e. starting).  In this state no new IO operations
+         * are permitted.
+         * This state is entered from the STOPPED state.
+         */
+        SCI_DEV_STARTING,
+
+        /**
+         * This state indicates the remote device is now ready.  Thus, the user
+         * is able to perform IO operations on the remote device.
+         * This state is entered from the STARTING state.
+         */
+        SCI_DEV_READY,
+
+        /**
+         * This is the idle substate for the stp remote device.  When there are no
+         * active IO for the device it is is in this state.
+         */
+        SCI_STP_DEV_IDLE,
+
+        /**
+         * This is the command state for for the STP remote device.  This state is
+         * entered when the device is processing a non-NCQ command.  The device object
+         * will fail any new start IO requests until this command is complete.
+         */
+        SCI_STP_DEV_CMD,
+
+        /**
+         * This is the NCQ state for the STP remote device.  This state is entered
+         * when the device is processing an NCQ reuqest.  It will remain in this state
+         * so long as there is one or more NCQ requests being processed.
+         */
+        SCI_STP_DEV_NCQ,
+
+        /**
+         * This is the NCQ error state for the STP remote device.  This state is
+         * entered when an SDB error FIS is received by the device object while in the
+         * NCQ state.  The device object will only accept a READ LOG command while in
+         * this state.
+         */
+        SCI_STP_DEV_NCQ_ERROR,
+
+        /**
+         * This is the READY substate indicates the device is waiting for the RESET task
+         * coming to be recovered from certain hardware specific error.
+         */
+        SCI_STP_DEV_AWAIT_RESET,
+
+        /**
+         * This is the ready operational substate for the remote device.  This is the
+         * normal operational state for a remote device.
+         */
+        SCI_SMP_DEV_IDLE,
+
+        /**
+         * This is the suspended state for the remote device.  This is the state that
+         * the device is placed in when a RNC suspend is received by the SCU hardware.
+         */
+        SCI_SMP_DEV_CMD,
+
+        /**
+         * This state indicates that the remote device is in the process of
+         * stopping.  In this state no new IO operations are permitted, but
+         * existing IO operations are allowed to complete.
+         * This state is entered from the READY state.
+         * This state is entered from the FAILED state.
+         */
+        SCI_DEV_STOPPING,
+
+        /**
+         * This state indicates that the remote device has failed.
+         * In this state no new IO operations are permitted.
+         * This state is entered from the INITIALIZING state.
+         * This state is entered from the READY state.
+         */
+        SCI_DEV_FAILED,
+
+        /**
+         * This state indicates the device is being reset.
+         * In this state no new IO operations are permitted.
+         * This state is entered from the READY state.
+         */
+        SCI_DEV_RESETTING,
+
+        /**
+         * Simply the final state for the base remote device state machine.
+         */
+        SCI_DEV_FINAL,
+};
 
 static inline struct isci_remote_device *rnc_to_dev(struct sci_remote_node_context *rnc)
 {
@@ -313,8 +318,6 @@ 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);
@@ -338,50 +341,12 @@ enum sci_status sci_remote_device_complete_io(
         struct isci_remote_device *idev,
         struct isci_request *ireq);
 
-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(
+enum sci_status sci_remote_device_suspend(
         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);
+        u32 suspend_type);
 
-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,
+void sci_remote_device_post_request(
         struct isci_remote_device *idev,
-        struct isci_request *ireq);
+        u32 request);
 
-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 1910100638a..748e8339d1e 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"
@@ -60,15 +60,18 @@
 #include "scu_event_codes.h"
 #include "scu_task_context.h"
 
-#undef C
-#define C(a) (#a)
-const char *rnc_state_name(enum scis_sds_remote_node_context_states state)
-{
-        static const char * const strings[] = RNC_STATES;
 
-        return strings[state];
-}
-#undef C
+/**
+ *
+ * @sci_rnc: The RNC for which the is posted request is being made.
+ *
+ * This method will return true if the RNC is not in the initial state.  In all
+ * other states the RNC is considered active and this will return true. The
+ * destroy request of the state machine drives the RNC back to the initial
+ * state.  If the state machine changes then this routine will also have to be
+ * changed. bool true if the state machine is not in the initial state false if
+ * the state machine is in the initial state
+ */
 
 /**
  *
@@ -90,15 +93,6 @@ 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 &&
@@ -140,7 +134,7 @@ static void sci_remote_node_context_construct_buffer(struct sci_remote_node_cont
 
         rnc->ssp.arbitration_wait_time = 0;
 
-        if (dev_is_sata(dev)) {
+        if (dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP)) {
                 rnc->ssp.connection_occupancy_timeout =
                         ihost->user_parameters.stp_max_occupancy_timeout;
                 rnc->ssp.connection_inactivity_timeout =
@@ -160,6 +154,7 @@ 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:
@@ -173,30 +168,23 @@ 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,
-        enum sci_remote_node_context_destination_state dest_param)
+        void *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;
-                }
+        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;
         }
 }
 
-static void sci_remote_node_context_setup_to_destroy(
+static void sci_remote_node_context_setup_to_destory(
         struct sci_remote_node_context *sci_rnc,
         scics_sds_remote_node_context_callback callback,
         void *callback_parameter)
 {
-        struct isci_host *ihost = idev_to_ihost(rnc_to_dev(sci_rnc));
-
-        sci_rnc->destination_state = RNC_DEST_FINAL;
+        sci_rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_FINAL;
         sci_rnc->user_callback     = callback;
         sci_rnc->user_cookie       = callback_parameter;
-
-        wake_up(&ihost->eventq);
 }
 
 /**
@@ -218,19 +206,9 @@ static void sci_remote_node_context_notify_user(
 
 static void sci_remote_node_context_continue_state_transitions(struct sci_remote_node_context *rnc)
 {
-        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:
+        if (rnc->destination_state == SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_READY)
                 sci_remote_node_context_resume(rnc, rnc->user_callback,
-                                               rnc->user_cookie);
-                break;
-        default:
-                rnc->destination_state = RNC_DEST_UNSPECIFIED;
-                break;
-        }
+                                                    rnc->user_cookie);
 }
 
 static void sci_remote_node_context_validate_context_buffer(struct sci_remote_node_context *sci_rnc)
@@ -244,12 +222,13 @@ static void sci_remote_node_context_validate_context_buffer(struct sci_remote_no
 
         rnc_buffer->ssp.is_valid = true;
 
-        if (dev_is_sata(dev) && dev->parent) {
+        if (!idev->is_direct_attached &&
+            (dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP))) {
                 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 (!dev->parent)
+                if (idev->is_direct_attached)
                         sci_port_setup_transports(idev->owning_port,
                                                   sci_rnc->remote_node_index);
         }
@@ -272,18 +251,13 @@ 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 = RNC_DEST_UNSPECIFIED;
+                rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_UNSPECIFIED;
                 sci_remote_node_context_notify_user(rnc);
-
-                smp_wmb();
-                wake_up(&ihost->eventq);
         }
 }
 
@@ -298,8 +272,6 @@ 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);
 }
 
@@ -318,8 +290,10 @@ 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_is_sata(dev) && !dev->parent)
-                sci_port_setup_transports(idev->owning_port, rnc->remote_node_index);
+        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);
 
         sci_remote_device_post_request(idev, SCU_CONTEXT_COMMAND_POST_RNC_RESUME);
 }
@@ -327,22 +301,10 @@ 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;
 
-        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);
+        rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_UNSPECIFIED;
 
-                if (dest_select == RNC_DEST_SUSPENDED_RESUME)
-                        tell_user = 0;  /* Wait until ready again. */
-        }
-        if (tell_user)
+        if (rnc->user_callback)
                 sci_remote_node_context_notify_user(rnc);
 }
 
@@ -356,34 +318,10 @@ 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,
@@ -406,9 +344,7 @@ 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] = {
-                .exit_state = sci_remote_node_context_await_suspend_state_exit,
-        },
+        [SCI_RNC_AWAIT_SUSPENSION] = { },
 };
 
 void sci_remote_node_context_construct(struct sci_remote_node_context *rnc,
@@ -417,7 +353,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 = RNC_DEST_UNSPECIFIED;
+        rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_UNSPECIFIED;
 
         sci_init_sm(&rnc->sm, sci_remote_node_context_state_table, SCI_RNC_INITIAL);
 }
@@ -426,7 +362,6 @@ 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) {
@@ -441,18 +376,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 == RNC_DEST_FINAL)
-                                next_state = SCI_RNC_INITIAL;
+                        if (sci_rnc->destination_state == SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_FINAL)
+                                state = SCI_RNC_INITIAL;
                         else
-                                next_state = SCI_RNC_POSTING;
-                        sci_change_state(&sci_rnc->sm, next_state);
+                                state = SCI_RNC_POSTING;
+                        sci_change_state(&sci_rnc->sm, 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_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
+                                dev_dbg(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);
@@ -471,7 +406,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_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
+                                dev_dbg(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);
@@ -485,11 +420,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->suspend_type = scu_get_event_type(event_code);
+                        sci_rnc->suspension_code = scu_get_event_specifier(event_code);
                         break;
                 case SCU_EVENT_TL_RNC_SUSPEND_TX_RX:
                         sci_change_state(&sci_rnc->sm, SCI_RNC_TX_RX_SUSPENDED);
-                        sci_rnc->suspend_type = scu_get_event_type(event_code);
+                        sci_rnc->suspension_code = scu_get_event_specifier(event_code);
                         break;
                 default:
                         goto out;
@@ -498,29 +433,27 @@ 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:
-                        next_state = SCI_RNC_TX_SUSPENDED;
+                        sci_change_state(&sci_rnc->sm, SCI_RNC_TX_SUSPENDED);
+                        sci_rnc->suspension_code = scu_get_event_specifier(event_code);
                         break;
                 case SCU_EVENT_TL_RNC_SUSPEND_TX_RX:
-                        next_state = SCI_RNC_TX_RX_SUSPENDED;
+                        sci_change_state(&sci_rnc->sm, SCI_RNC_TX_RX_SUSPENDED);
+                        sci_rnc->suspension_code = scu_get_event_specifier(event_code);
                         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: %s\n", __func__,
-                         rnc_state_name(state));
+                         "%s: invalid state %d\n", __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
         }
         return SCI_SUCCESS;
 
  out:
         dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
-                 "%s: code: %#x state: %s\n", __func__, event_code,
-                 rnc_state_name(state));
+                 "%s: code: %#x state: %d\n", __func__, event_code, state);
         return SCI_FAILURE;
 
 }
@@ -534,23 +467,20 @@ 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_destroy(sci_rnc, cb_fn, cb_p);
+                sci_remote_node_context_setup_to_destory(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:
-                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);
+                sci_remote_node_context_setup_to_destory(sci_rnc, cb_fn, cb_p);
+                sci_change_state(&sci_rnc->sm, SCI_RNC_INVALIDATING);
                 return SCI_SUCCESS;
         case SCI_RNC_INITIAL:
                 dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
-                         "%s: invalid state: %s\n", __func__,
-                         rnc_state_name(state));
+                         "%s: invalid state %d\n", __func__, 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.
@@ -558,101 +488,35 @@ 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 %s\n", __func__,
-                         rnc_state_name(state));
+                         "%s: invalid state %d\n", __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
         }
 }
 
-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 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 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;
-
-        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;
+        enum scis_sds_remote_node_context_states state;
 
-        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:
+        state = sci_rnc->sm.current_state_id;
+        if (state != SCI_RNC_READY) {
                 dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
-                         "%s: invalid state %s\n", __func__,
-                         rnc_state_name(state));
+                         "%s: invalid state %d\n", __func__, 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;
+        sci_rnc->user_callback   = cb_fn;
+        sci_rnc->user_cookie     = cb_p;
+        sci_rnc->suspension_code = suspend_type;
 
-                wake_up_all(&ihost->eventq); /* Let observers look. */
-                return SCI_SUCCESS;
+        if (suspend_type == SCI_SOFTWARE_SUSPENSION) {
+                sci_remote_device_post_request(rnc_to_dev(sci_rnc),
+                                                    SCU_CONTEXT_COMMAND_POST_RNC_SUSPEND_TX);
         }
-        if ((suspend_reason == SCI_SW_SUSPEND_NORMAL) ||
-            (suspend_reason == SCI_SW_SUSPEND_LINKHANG_DETECT)) {
-
-                if (suspend_reason == SCI_SW_SUSPEND_LINKHANG_DETECT)
-                        isci_dev_set_hang_detection_timeout(idev, 0x00000001);
-
-                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;
 }
 
@@ -661,86 +525,56 @@ 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,
-                                                        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);
-                }
+                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);
                 return SCI_SUCCESS;
-
         case SCI_RNC_POSTING:
         case SCI_RNC_INVALIDATING:
         case SCI_RNC_RESUMING:
-                /* 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;
+                if (sci_rnc->destination_state != SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_READY)
+                        return SCI_FAILURE_INVALID_STATE;
 
-        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);
+                sci_rnc->user_callback = cb_fn;
+                sci_rnc->user_cookie   = cb_p;
+                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);
                         }
-                }
+                } 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, RNC_DEST_SUSPENDED_RESUME);
+                sci_remote_node_context_setup_to_resume(sci_rnc, cb_fn, cb_p);
                 return SCI_SUCCESS;
         default:
                 dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
-                         "%s: invalid state %s\n", __func__,
-                         rnc_state_name(state));
+                         "%s: invalid state %d\n", __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
         }
 }
@@ -759,51 +593,35 @@ 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 %s\n", __func__,
-                         rnc_state_name(state));
+                         "%s: invalid state %d\n", __func__, state);
                 return SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
         default:
-                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;
+                break;
         }
+        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,
-        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 sci_status sci_remote_node_context_start_task(struct sci_remote_node_context *sci_rnc,
+                                                        struct isci_request *ireq)
 {
         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_TX_SUSPENDED:
         case SCI_RNC_AWAIT_SUSPENSION:
-        case SCI_RNC_INITIAL:
-                return 0;
+                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;
         default:
                 dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
                          "%s: invalid state %d\n", __func__, state);
-                return 0;
+                return SCI_FAILURE_INVALID_STATE;
         }
 }
diff --git a/drivers/scsi/isci/remote_node_context.h b/drivers/scsi/isci/remote_node_context.h
index c7ee81d0112..41580ad1252 100644
--- a/drivers/scsi/isci/remote_node_context.h
+++ b/drivers/scsi/isci/remote_node_context.h
@@ -75,13 +75,8 @@
  */
 #define SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX    0x0FFF
 
-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
+#define SCU_HARDWARE_SUSPENSION  (0)
+#define SCI_SOFTWARE_SUSPENSION  (1)
 
 struct isci_request;
 struct isci_remote_device;
@@ -90,50 +85,61 @@ struct sci_remote_node_context;
 typedef void (*scics_sds_remote_node_context_callback)(void *);
 
 /**
- * enum sci_remote_node_context_states
- * @SCI_RNC_INITIAL initial state for a remote node context.  On a resume
- * request the remote node context will transition to the posting state.
- *
- * @SCI_RNC_POSTING: transition state that posts the RNi to the hardware. Once
- * the RNC is posted the remote node context will be made ready.
- *
- * @SCI_RNC_INVALIDATING: transition state that will post an RNC invalidate to
- * the hardware.  Once the invalidate is complete the remote node context will
- * transition to the posting state.
- *
- * @SCI_RNC_RESUMING: transition state that will post an RNC resume to the
- * hardare.  Once the event notification of resume complete is received the
- * remote node context will transition to the ready state.
- *
- * @SCI_RNC_READY: state that the remote node context must be in to accept io
- * request operations.
- *
- * @SCI_RNC_TX_SUSPENDED: state that the remote node context transitions to when
- * it gets a TX suspend notification from the hardware.
- *
- * @SCI_RNC_TX_RX_SUSPENDED: state that the remote node context transitions to
- * when it gets a TX RX suspend notification from the hardware.
- *
- * @SCI_RNC_AWAIT_SUSPENSION: wait state for the remote node context that waits
- * for a suspend notification from the hardware.  This state is entered when
- * either there is a request to supend the remote node context or when there is
- * a TC completion where the remote node will be suspended by the hardware.
+ * This is the enumeration of the remote node context states.
  */
-#define RNC_STATES {\
-        C(RNC_INITIAL),\
-        C(RNC_POSTING),\
-        C(RNC_INVALIDATING),\
-        C(RNC_RESUMING),\
-        C(RNC_READY),\
-        C(RNC_TX_SUSPENDED),\
-        C(RNC_TX_RX_SUSPENDED),\
-        C(RNC_AWAIT_SUSPENSION),\
-        }
-#undef C
-#define C(a) SCI_##a
-enum scis_sds_remote_node_context_states RNC_STATES;
-#undef C
-const char *rnc_state_name(enum scis_sds_remote_node_context_states state);
+enum scis_sds_remote_node_context_states {
+        /**
+         * This state is the initial state for a remote node context.  On a resume
+         * request the remote node context will transition to the posting state.
+         */
+        SCI_RNC_INITIAL,
+
+        /**
+         * This is a transition state that posts the RNi to the hardware. Once the RNC
+         * is posted the remote node context will be made ready.
+         */
+        SCI_RNC_POSTING,
+
+        /**
+         * This is a transition state that will post an RNC invalidate to the
+         * hardware.  Once the invalidate is complete the remote node context will
+         * transition to the posting state.
+         */
+        SCI_RNC_INVALIDATING,
+
+        /**
+         * This is a transition state that will post an RNC resume to the hardare.
+         * Once the event notification of resume complete is received the remote node
+         * context will transition to the ready state.
+         */
+        SCI_RNC_RESUMING,
+
+        /**
+         * This is the state that the remote node context must be in to accept io
+         * request operations.
+         */
+        SCI_RNC_READY,
+
+        /**
+         * This is the state that the remote node context transitions to when it gets
+         * a TX suspend notification from the hardware.
+         */
+        SCI_RNC_TX_SUSPENDED,
+
+        /**
+         * This is the state that the remote node context transitions to when it gets
+         * a TX RX suspend notification from the hardware.
+         */
+        SCI_RNC_TX_RX_SUSPENDED,
+
+        /**
+         * This state is a wait state for the remote node context that waits for a
+         * suspend notification from the hardware.  This state is entered when either
+         * there is a request to supend the remote node context or when there is a TC
+         * completion where the remote node will be suspended by the hardware.
+         */
+        SCI_RNC_AWAIT_SUSPENSION
+};
 
 /**
  *
@@ -142,13 +148,9 @@ const char *rnc_state_name(enum scis_sds_remote_node_context_states state);
  * node context.
  */
 enum sci_remote_node_context_destination_state {
-        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.
-                                   */
+        SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_UNSPECIFIED,
+        SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_READY,
+        SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_FINAL
 };
 
 /**
@@ -165,12 +167,10 @@ struct sci_remote_node_context {
         u16 remote_node_index;
 
         /**
-         * This field is the recored suspension type of the remote node
+         * This field is the recored suspension code or the reason for the remote node
          * context suspension.
          */
-        u32 suspend_type;
-        enum sci_remote_node_suspension_reasons suspend_reason;
-        u32 suspend_count;
+        u32 suspension_code;
 
         /**
          * This field is true if the remote node context is resuming from its current
@@ -204,33 +204,21 @@ 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,
                                                       scics_sds_remote_node_context_callback callback,
                                                       void *callback_parameter);
 enum sci_status sci_remote_node_context_suspend(struct sci_remote_node_context *sci_rnc,
-                                                     enum sci_remote_node_suspension_reasons reason,
-                                                     u32 suspension_code);
+                                                     u32 suspend_type,
+                                                     scics_sds_remote_node_context_callback cb_fn,
+                                                     void *cb_p);
 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,
-                                                   scics_sds_remote_node_context_callback cb_fn,
-                                                   void *cb_p);
+                                                        struct isci_request *ireq);
 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 9594ab62702..225b196800a 100644
--- a/drivers/scsi/isci/request.c
+++ b/drivers/scsi/isci/request.c
@@ -53,7 +53,6 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <scsi/scsi_cmnd.h>
 #include "isci.h"
 #include "task.h"
 #include "request.h"
@@ -61,16 +60,6 @@
 #include "scu_event_codes.h"
 #include "sas.h"
 
-#undef C
-#define C(a) (#a)
-const char *req_state_name(enum sci_base_request_states state)
-{
-        static const char * const strings[] = REQUEST_STATES;
-
-        return strings[state];
-}
-#undef C
-
 static struct scu_sgl_element_pair *to_sgl_element_pair(struct isci_request *ireq,
                                                         int idx)
 {
@@ -92,11 +81,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->tc_dma + offset;
+                return ihost->task_context_dma + offset;
         } else if (idx == 1) {
                 offset = (void *) &ireq->tc->sgl_pair_cd -
                          (void *) &ihost->task_context_table[0];
-                return ihost->tc_dma + offset;
+                return ihost->task_context_dma + offset;
         }
 
         return sci_io_request_get_dma_addr(ireq, &ireq->sg_table[idx - 2]);
@@ -202,7 +191,7 @@ static void sci_task_request_build_ssp_task_iu(struct isci_request *ireq)
 
         task_iu->task_func = isci_tmf->tmf_code;
         task_iu->task_tag =
-                (test_bit(IREQ_TMF, &ireq->flags)) ?
+                (ireq->ttype == tmf_task) ?
                 isci_tmf->io_tag :
                 SCI_CONTROLLER_INVALID_IO_TAG;
 }
@@ -275,141 +264,6 @@ static void scu_ssp_reqeust_construct_task_context(
         task_context->response_iu_lower = lower_32_bits(dma_addr);
 }
 
-static u8 scu_bg_blk_size(struct scsi_device *sdp)
-{
-        switch (sdp->sector_size) {
-        case 512:
-                return 0;
-        case 1024:
-                return 1;
-        case 4096:
-                return 3;
-        default:
-                return 0xff;
-        }
-}
-
-static u32 scu_dif_bytes(u32 len, u32 sector_size)
-{
-        return (len >> ilog2(sector_size)) * 8;
-}
-
-static void scu_ssp_ireq_dif_insert(struct isci_request *ireq, u8 type, u8 op)
-{
-        struct scu_task_context *tc = ireq->tc;
-        struct scsi_cmnd *scmd = ireq->ttype_ptr.io_task_ptr->uldd_task;
-        u8 blk_sz = scu_bg_blk_size(scmd->device);
-
-        tc->block_guard_enable = 1;
-        tc->blk_prot_en = 1;
-        tc->blk_sz = blk_sz;
-        /* DIF write insert */
-        tc->blk_prot_func = 0x2;
-
-        tc->transfer_length_bytes += scu_dif_bytes(tc->transfer_length_bytes,
-                                                   scmd->device->sector_size);
-
-        /* always init to 0, used by hw */
-        tc->interm_crc_val = 0;
-
-        tc->init_crc_seed = 0;
-        tc->app_tag_verify = 0;
-        tc->app_tag_gen = 0;
-        tc->ref_tag_seed_verify = 0;
-
-        /* always init to same as bg_blk_sz */
-        tc->UD_bytes_immed_val = scmd->device->sector_size;
-
-        tc->reserved_DC_0 = 0;
-
-        /* always init to 8 */
-        tc->DIF_bytes_immed_val = 8;
-
-        tc->reserved_DC_1 = 0;
-        tc->bgc_blk_sz = scmd->device->sector_size;
-        tc->reserved_E0_0 = 0;
-        tc->app_tag_gen_mask = 0;
-
-        /** setup block guard control **/
-        tc->bgctl = 0;
-
-        /* DIF write insert */
-        tc->bgctl_f.op = 0x2;
-
-        tc->app_tag_verify_mask = 0;
-
-        /* must init to 0 for hw */
-        tc->blk_guard_err = 0;
-
-        tc->reserved_E8_0 = 0;
-
-        if ((type & SCSI_PROT_DIF_TYPE1) || (type & SCSI_PROT_DIF_TYPE2))
-                tc->ref_tag_seed_gen = scsi_get_lba(scmd) & 0xffffffff;
-        else if (type & SCSI_PROT_DIF_TYPE3)
-                tc->ref_tag_seed_gen = 0;
-}
-
-static void scu_ssp_ireq_dif_strip(struct isci_request *ireq, u8 type, u8 op)
-{
-        struct scu_task_context *tc = ireq->tc;
-        struct scsi_cmnd *scmd = ireq->ttype_ptr.io_task_ptr->uldd_task;
-        u8 blk_sz = scu_bg_blk_size(scmd->device);
-
-        tc->block_guard_enable = 1;
-        tc->blk_prot_en = 1;
-        tc->blk_sz = blk_sz;
-        /* DIF read strip */
-        tc->blk_prot_func = 0x1;
-
-        tc->transfer_length_bytes += scu_dif_bytes(tc->transfer_length_bytes,
-                                                   scmd->device->sector_size);
-
-        /* always init to 0, used by hw */
-        tc->interm_crc_val = 0;
-
-        tc->init_crc_seed = 0;
-        tc->app_tag_verify = 0;
-        tc->app_tag_gen = 0;
-
-        if ((type & SCSI_PROT_DIF_TYPE1) || (type & SCSI_PROT_DIF_TYPE2))
-                tc->ref_tag_seed_verify = scsi_get_lba(scmd) & 0xffffffff;
-        else if (type & SCSI_PROT_DIF_TYPE3)
-                tc->ref_tag_seed_verify = 0;
-
-        /* always init to same as bg_blk_sz */
-        tc->UD_bytes_immed_val = scmd->device->sector_size;
-
-        tc->reserved_DC_0 = 0;
-
-        /* always init to 8 */
-        tc->DIF_bytes_immed_val = 8;
-
-        tc->reserved_DC_1 = 0;
-        tc->bgc_blk_sz = scmd->device->sector_size;
-        tc->reserved_E0_0 = 0;
-        tc->app_tag_gen_mask = 0;
-
-        /** setup block guard control **/
-        tc->bgctl = 0;
-
-        /* DIF read strip */
-        tc->bgctl_f.crc_verify = 1;
-        tc->bgctl_f.op = 0x1;
-        if ((type & SCSI_PROT_DIF_TYPE1) || (type & SCSI_PROT_DIF_TYPE2)) {
-                tc->bgctl_f.ref_tag_chk = 1;
-                tc->bgctl_f.app_f_detect = 1;
-        } else if (type & SCSI_PROT_DIF_TYPE3)
-                tc->bgctl_f.app_ref_f_detect = 1;
-
-        tc->app_tag_verify_mask = 0;
-
-        /* must init to 0 for hw */
-        tc->blk_guard_err = 0;
-
-        tc->reserved_E8_0 = 0;
-        tc->ref_tag_seed_gen = 0;
-}
-
 /**
  * This method is will fill in the SCU Task Context for a SSP IO request.
  * @sci_req:
@@ -420,10 +274,6 @@ static void scu_ssp_io_request_construct_task_context(struct isci_request *ireq,
                                                       u32 len)
 {
         struct scu_task_context *task_context = ireq->tc;
-        struct sas_task *sas_task = ireq->ttype_ptr.io_task_ptr;
-        struct scsi_cmnd *scmd = sas_task->uldd_task;
-        u8 prot_type = scsi_get_prot_type(scmd);
-        u8 prot_op = scsi_get_prot_op(scmd);
 
         scu_ssp_reqeust_construct_task_context(ireq, task_context);
 
@@ -446,13 +296,6 @@ static void scu_ssp_io_request_construct_task_context(struct isci_request *ireq,
 
         if (task_context->transfer_length_bytes > 0)
                 sci_request_build_sgl(ireq);
-
-        if (prot_type != SCSI_PROT_DIF_TYPE0) {
-                if (prot_op == SCSI_PROT_READ_STRIP)
-                        scu_ssp_ireq_dif_strip(ireq, prot_type, prot_op);
-                else if (prot_op == SCSI_PROT_WRITE_INSERT)
-                        scu_ssp_ireq_dif_insert(ireq, prot_type, prot_op);
-        }
 }
 
 /**
@@ -638,29 +481,7 @@ static void sci_stp_optimized_request_construct(struct isci_request *ireq,
         }
 }
 
-static void sci_atapi_construct(struct isci_request *ireq)
-{
-        struct host_to_dev_fis *h2d_fis = &ireq->stp.cmd;
-        struct sas_task *task;
 
-        /* To simplify the implementation we take advantage of the
-         * silicon's partial acceleration of atapi protocol (dma data
-         * transfers), so we promote all commands to dma protocol.  This
-         * breaks compatibility with ATA_HORKAGE_ATAPI_MOD16_DMA drives.
-         */
-        h2d_fis->features |= ATAPI_PKT_DMA;
-
-        scu_stp_raw_request_construct_task_context(ireq);
-
-        task = isci_request_access_task(ireq);
-        if (task->data_dir == DMA_NONE)
-                task->total_xfer_len = 0;
-
-        /* clear the response so we can detect arrivial of an
-         * unsolicited h2d fis
-         */
-        ireq->stp.rsp.fis_type = 0;
-}
 
 static enum sci_status
 sci_io_request_construct_sata(struct isci_request *ireq,
@@ -670,18 +491,23 @@ sci_io_request_construct_sata(struct isci_request *ireq,
 {
         enum sci_status status = SCI_SUCCESS;
         struct sas_task *task = isci_request_access_task(ireq);
-        struct domain_device *dev = ireq->target_device->domain_dev;
 
         /* check for management protocols */
-        if (test_bit(IREQ_TMF, &ireq->flags)) {
+        if (ireq->ttype == tmf_task) {
                 struct isci_tmf *tmf = isci_request_access_tmf(ireq);
 
-                dev_err(&ireq->owning_controller->pdev->dev,
-                        "%s: Request 0x%p received un-handled SAT "
-                        "management protocol 0x%x.\n",
-                        __func__, ireq, tmf->tmf_code);
+                if (tmf->tmf_code == isci_tmf_sata_srst_high ||
+                    tmf->tmf_code == isci_tmf_sata_srst_low) {
+                        scu_stp_raw_request_construct_task_context(ireq);
+                        return SCI_SUCCESS;
+                } else {
+                        dev_err(&ireq->owning_controller->pdev->dev,
+                                "%s: Request 0x%p received un-handled SAT "
+                                "management protocol 0x%x.\n",
+                                __func__, ireq, tmf->tmf_code);
 
-                return SCI_FAILURE;
+                        return SCI_FAILURE;
+                }
         }
 
         if (!sas_protocol_ata(task->task_proto)) {
@@ -693,13 +519,6 @@ sci_io_request_construct_sata(struct isci_request *ireq,
 
         }
 
-        /* ATAPI */
-        if (dev->sata_dev.command_set == ATAPI_COMMAND_SET &&
-            task->ata_task.fis.command == ATA_CMD_PACKET) {
-                sci_atapi_construct(ireq);
-                return SCI_SUCCESS;
-        }
-
         /* non data */
         if (task->data_dir == DMA_NONE) {
                 scu_stp_raw_request_construct_task_context(ireq);
@@ -730,7 +549,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 = SAS_PROTOCOL_SSP;
+        ireq->protocol = SCIC_SSP_PROTOCOL;
 
         scu_ssp_io_request_construct_task_context(ireq,
                                                   task->data_dir,
@@ -763,7 +582,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 = SAS_PROTOCOL_STP;
+        ireq->protocol = SCIC_STP_PROTOCOL;
 
         copy = (task->data_dir == DMA_NONE) ? false : true;
 
@@ -778,9 +597,37 @@ static enum sci_status sci_io_request_construct_basic_sata(struct isci_request *
         return status;
 }
 
+enum sci_status sci_task_request_construct_sata(struct isci_request *ireq)
+{
+        enum sci_status status = SCI_SUCCESS;
+
+        /* check for management protocols */
+        if (ireq->ttype == tmf_task) {
+                struct isci_tmf *tmf = isci_request_access_tmf(ireq);
+
+                if (tmf->tmf_code == isci_tmf_sata_srst_high ||
+                    tmf->tmf_code == isci_tmf_sata_srst_low) {
+                        scu_stp_raw_request_construct_task_context(ireq);
+                } else {
+                        dev_err(&ireq->owning_controller->pdev->dev,
+                                "%s: Request 0x%p received un-handled SAT "
+                                "Protocol 0x%x.\n",
+                                __func__, ireq, tmf->tmf_code);
+
+                        return SCI_FAILURE;
+                }
+        }
+
+        if (status != SCI_SUCCESS)
+                return status;
+        sci_change_state(&ireq->sm, SCI_REQ_CONSTRUCTED);
+
+        return status;
+}
+
 /**
  * sci_req_tx_bytes - bytes transferred when reply underruns request
- * @ireq: request that was terminated early
+ * @sci_req: request that was terminated early
  */
 #define SCU_TASK_CONTEXT_SRAM 0x200000
 static u32 sci_req_tx_bytes(struct isci_request *ireq)
@@ -863,8 +710,6 @@ 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);
@@ -881,11 +726,11 @@ sci_io_request_terminate(struct isci_request *ireq)
         case SCI_REQ_STP_PIO_WAIT_FRAME:
         case SCI_REQ_STP_PIO_DATA_IN:
         case SCI_REQ_STP_PIO_DATA_OUT:
-        case SCI_REQ_ATAPI_WAIT_H2D:
-        case SCI_REQ_ATAPI_WAIT_PIO_SETUP:
-        case SCI_REQ_ATAPI_WAIT_D2H:
-        case SCI_REQ_ATAPI_WAIT_TC_COMP:
-                /* Fall through and change state to ABORTING... */
+        case SCI_REQ_STP_SOFT_RESET_WAIT_H2D_ASSERTED:
+        case SCI_REQ_STP_SOFT_RESET_WAIT_H2D_DIAG:
+        case SCI_REQ_STP_SOFT_RESET_WAIT_D2H:
+                sci_change_state(&ireq->sm, SCI_REQ_ABORTING);
+                return SCI_SUCCESS;
         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
@@ -894,21 +739,20 @@ sci_io_request_terminate(struct isci_request *ireq)
                  * and don't wait for the task response.
                  */
                 sci_change_state(&ireq->sm, SCI_REQ_ABORTING);
-                /* Fall through and handle like ABORTING... */
+                sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
+                return SCI_SUCCESS;
         case SCI_REQ_ABORTING:
-                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.
+                /* If a request has a termination requested twice, return
+                 * a failure indication, since HW confirmation of the first
+                 * abort is still outstanding.
                  */
-                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;
         }
 
@@ -922,8 +766,7 @@ enum sci_status sci_request_complete(struct isci_request *ireq)
 
         state = ireq->sm.current_state_id;
         if (WARN_ONCE(state != SCI_REQ_COMPLETED,
-                      "isci: request completion from wrong state (%s)\n",
-                      req_state_name(state)))
+                      "isci: request completion from wrong state (%d)\n", state))
                 return SCI_FAILURE_INVALID_STATE;
 
         if (ireq->saved_rx_frame_index != SCU_INVALID_FRAME_INDEX)
@@ -944,8 +787,8 @@ enum sci_status sci_io_request_event_handler(struct isci_request *ireq,
         state = ireq->sm.current_state_id;
 
         if (state != SCI_REQ_STP_PIO_DATA_IN) {
-                dev_warn(&ihost->pdev->dev, "%s: (%x) in wrong state %s\n",
-                         __func__, event_code, req_state_name(state));
+                dev_warn(&ihost->pdev->dev, "%s: (%x) in wrong state %d\n",
+                         __func__, event_code, state);
 
                 return SCI_FAILURE_INVALID_STATE;
         }
@@ -1072,7 +915,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 == SAS_PROTOCOL_STP) {
+                if (ireq->protocol == SCIC_STP_PROTOCOL) {
                         ireq->scu_status = SCU_GET_COMPLETION_TL_STATUS(completion_code) >>
                                            SCU_COMPLETION_TL_STATUS_SHIFT;
                         ireq->sci_status = SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
@@ -1351,8 +1194,8 @@ static enum sci_status sci_stp_request_pio_data_out_transmit_data(struct isci_re
 {
         struct isci_stp_request *stp_req = &ireq->stp.req;
         struct scu_sgl_element_pair *sgl_pair;
-        enum sci_status status = SCI_SUCCESS;
         struct scu_sgl_element *sgl;
+        enum sci_status status;
         u32 offset;
         u32 len = 0;
 
@@ -1406,7 +1249,7 @@ static enum sci_status sci_stp_request_pio_data_out_transmit_data(struct isci_re
  */
 static enum sci_status
 sci_stp_request_pio_data_in_copy_data_buffer(struct isci_stp_request *stp_req,
-                                             u8 *data_buf, u32 len)
+                                                  u8 *data_buf, u32 len)
 {
         struct isci_request *ireq;
         u8 *src_addr;
@@ -1427,9 +1270,9 @@ sci_stp_request_pio_data_in_copy_data_buffer(struct isci_stp_request *stp_req,
                         struct page *page = sg_page(sg);
 
                         copy_len = min_t(int, total_len, sg_dma_len(sg));
-                        kaddr = kmap_atomic(page);
+                        kaddr = kmap_atomic(page, KM_IRQ0);
                         memcpy(kaddr + sg->offset, src_addr, copy_len);
-                        kunmap_atomic(kaddr);
+                        kunmap_atomic(kaddr, KM_IRQ0);
                         total_len -= copy_len;
                         src_addr += copy_len;
                         sg = sg_next(sg);
@@ -1580,128 +1423,6 @@ static enum sci_status sci_stp_request_udma_general_frame_handler(struct isci_re
         return status;
 }
 
-static enum sci_status process_unsolicited_fis(struct isci_request *ireq,
-                                               u32 frame_index)
-{
-        struct isci_host *ihost = ireq->owning_controller;
-        enum sci_status status;
-        struct dev_to_host_fis *frame_header;
-        u32 *frame_buffer;
-
-        status = sci_unsolicited_frame_control_get_header(&ihost->uf_control,
-                                                          frame_index,
-                                                          (void **)&frame_header);
-
-        if (status != SCI_SUCCESS)
-                return status;
-
-        if (frame_header->fis_type != FIS_REGD2H) {
-                dev_err(&ireq->isci_host->pdev->dev,
-                        "%s ERROR: invalid fis type 0x%X\n",
-                        __func__, frame_header->fis_type);
-                return SCI_FAILURE;
-        }
-
-        sci_unsolicited_frame_control_get_buffer(&ihost->uf_control,
-                                                 frame_index,
-                                                 (void **)&frame_buffer);
-
-        sci_controller_copy_sata_response(&ireq->stp.rsp,
-                                          (u32 *)frame_header,
-                                          frame_buffer);
-
-        /* Frame has been decoded return it to the controller */
-        sci_controller_release_frame(ihost, frame_index);
-
-        return status;
-}
-
-static enum sci_status atapi_d2h_reg_frame_handler(struct isci_request *ireq,
-                                                   u32 frame_index)
-{
-        struct sas_task *task = isci_request_access_task(ireq);
-        enum sci_status status;
-
-        status = process_unsolicited_fis(ireq, frame_index);
-
-        if (status == SCI_SUCCESS) {
-                if (ireq->stp.rsp.status & ATA_ERR)
-                        status = SCI_IO_FAILURE_RESPONSE_VALID;
-        } else {
-                status = SCI_IO_FAILURE_RESPONSE_VALID;
-        }
-
-        if (status != SCI_SUCCESS) {
-                ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
-                ireq->sci_status = status;
-        } else {
-                ireq->scu_status = SCU_TASK_DONE_GOOD;
-                ireq->sci_status = SCI_SUCCESS;
-        }
-
-        /* the d2h ufi is the end of non-data commands */
-        if (task->data_dir == DMA_NONE)
-                sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
-
-        return status;
-}
-
-static void scu_atapi_reconstruct_raw_frame_task_context(struct isci_request *ireq)
-{
-        struct ata_device *dev = sas_to_ata_dev(ireq->target_device->domain_dev);
-        void *atapi_cdb = ireq->ttype_ptr.io_task_ptr->ata_task.atapi_packet;
-        struct scu_task_context *task_context = ireq->tc;
-
-        /* fill in the SCU Task Context for a DATA fis containing CDB in Raw Frame
-         * type. The TC for previous Packet fis was already there, we only need to
-         * change the H2D fis content.
-         */
-        memset(&ireq->stp.cmd, 0, sizeof(struct host_to_dev_fis));
-        memcpy(((u8 *)&ireq->stp.cmd + sizeof(u32)), atapi_cdb, ATAPI_CDB_LEN);
-        memset(&(task_context->type.stp), 0, sizeof(struct stp_task_context));
-        task_context->type.stp.fis_type = FIS_DATA;
-        task_context->transfer_length_bytes = dev->cdb_len;
-}
-
-static void scu_atapi_construct_task_context(struct isci_request *ireq)
-{
-        struct ata_device *dev = sas_to_ata_dev(ireq->target_device->domain_dev);
-        struct sas_task *task = isci_request_access_task(ireq);
-        struct scu_task_context *task_context = ireq->tc;
-        int cdb_len = dev->cdb_len;
-
-        /* reference: SSTL 1.13.4.2
-         * task_type, sata_direction
-         */
-        if (task->data_dir == DMA_TO_DEVICE) {
-                task_context->task_type = SCU_TASK_TYPE_PACKET_DMA_OUT;
-                task_context->sata_direction = 0;
-        } else {
-                /* todo: for NO_DATA command, we need to send out raw frame. */
-                task_context->task_type = SCU_TASK_TYPE_PACKET_DMA_IN;
-                task_context->sata_direction = 1;
-        }
-
-        memset(&task_context->type.stp, 0, sizeof(task_context->type.stp));
-        task_context->type.stp.fis_type = FIS_DATA;
-
-        memset(&ireq->stp.cmd, 0, sizeof(ireq->stp.cmd));
-        memcpy(&ireq->stp.cmd.lbal, task->ata_task.atapi_packet, cdb_len);
-        task_context->ssp_command_iu_length = cdb_len / sizeof(u32);
-
-        /* task phase is set to TX_CMD */
-        task_context->task_phase = 0x1;
-
-        /* retry counter */
-        task_context->stp_retry_count = 0;
-
-        /* data transfer size. */
-        task_context->transfer_length_bytes = task->total_xfer_len;
-
-        /* setup sgl */
-        sci_request_build_sgl(ireq);
-}
-
 enum sci_status
 sci_io_request_frame_handler(struct isci_request *ireq,
                                   u32 frame_index)
@@ -1777,7 +1498,7 @@ sci_io_request_frame_handler(struct isci_request *ireq,
                 sci_unsolicited_frame_control_get_header(&ihost->uf_control,
                                                          frame_index,
                                                          &frame_header);
-                kaddr = kmap_atomic(sg_page(sg));
+                kaddr = kmap_atomic(sg_page(sg), KM_IRQ0);
                 rsp = kaddr + sg->offset;
                 sci_swab32_cpy(rsp, frame_header, 1);
 
@@ -1814,7 +1535,7 @@ sci_io_request_frame_handler(struct isci_request *ireq,
                         ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
                         sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
                 }
-                kunmap_atomic(kaddr);
+                kunmap_atomic(kaddr, KM_IRQ0);
 
                 sci_controller_release_frame(ihost, frame_index);
 
@@ -1972,7 +1693,7 @@ sci_io_request_frame_handler(struct isci_request *ireq,
                                                                       frame_index,
                                                                       (void **)&frame_buffer);
 
-                        sci_controller_copy_sata_response(&ireq->stp.rsp,
+                        sci_controller_copy_sata_response(&ireq->stp.req,
                                                                frame_header,
                                                                frame_buffer);
 
@@ -2061,24 +1782,59 @@ sci_io_request_frame_handler(struct isci_request *ireq,
                 return status;
         }
 
-        case SCI_REQ_ATAPI_WAIT_PIO_SETUP: {
-                struct sas_task *task = isci_request_access_task(ireq);
+        case SCI_REQ_STP_SOFT_RESET_WAIT_D2H: {
+                struct dev_to_host_fis *frame_header;
+                u32 *frame_buffer;
 
-                sci_controller_release_frame(ihost, frame_index);
-                ireq->target_device->working_request = ireq;
-                if (task->data_dir == DMA_NONE) {
-                        sci_change_state(&ireq->sm, SCI_REQ_ATAPI_WAIT_TC_COMP);
-                        scu_atapi_reconstruct_raw_frame_task_context(ireq);
-                } else {
-                        sci_change_state(&ireq->sm, SCI_REQ_ATAPI_WAIT_D2H);
-                        scu_atapi_construct_task_context(ireq);
+                status = sci_unsolicited_frame_control_get_header(&ihost->uf_control,
+                                                                       frame_index,
+                                                                       (void **)&frame_header);
+                if (status != SCI_SUCCESS) {
+                        dev_err(&ihost->pdev->dev,
+                                "%s: SCIC IO Request 0x%p could not get frame "
+                                "header for frame index %d, status %x\n",
+                                __func__,
+                                stp_req,
+                                frame_index,
+                                status);
+                        return status;
                 }
 
-                sci_controller_continue_io(ireq);
-                return SCI_SUCCESS;
+                switch (frame_header->fis_type) {
+                case FIS_REGD2H:
+                        sci_unsolicited_frame_control_get_buffer(&ihost->uf_control,
+                                                                      frame_index,
+                                                                      (void **)&frame_buffer);
+
+                        sci_controller_copy_sata_response(&ireq->stp.rsp,
+                                                               frame_header,
+                                                               frame_buffer);
+
+                        /* The command has completed with error */
+                        ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
+                        ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
+                        break;
+
+                default:
+                        dev_warn(&ihost->pdev->dev,
+                                 "%s: IO Request:0x%p Frame Id:%d protocol "
+                                 "violation occurred\n",
+                                 __func__,
+                                 stp_req,
+                                 frame_index);
+
+                        ireq->scu_status = SCU_TASK_DONE_UNEXP_FIS;
+                        ireq->sci_status = SCI_FAILURE_PROTOCOL_VIOLATION;
+                        break;
+                }
+
+                sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
+
+                /* Frame has been decoded return it to the controller */
+                sci_controller_release_frame(ihost, frame_index);
+
+                return status;
         }
-        case SCI_REQ_ATAPI_WAIT_D2H:
-                return atapi_d2h_reg_frame_handler(ireq, frame_index);
         case SCI_REQ_ABORTING:
                 /*
                  * TODO: Is it even possible to get an unsolicited frame in the
@@ -2119,7 +1875,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,
-                                                  SCI_SW_SUSPEND_NORMAL);
+                                SCU_EVENT_SPECIFIC(SCU_NORMALIZE_COMPLETION_STATUS(completion_code)));
 
                         ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
                         ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
@@ -2140,6 +1896,14 @@ 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):
+        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_CRC_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);
@@ -2151,257 +1915,66 @@ static enum sci_status stp_request_udma_await_tc_event(struct isci_request *ireq
         return status;
 }
 
-static enum sci_status atapi_raw_completion(struct isci_request *ireq, u32 completion_code,
-                                                  enum sci_base_request_states next)
+static enum sci_status
+stp_request_soft_reset_await_h2d_asserted_tc_event(struct isci_request *ireq,
+                                                   u32 completion_code)
 {
-        enum sci_status status = SCI_SUCCESS;
-
         switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
         case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
                 ireq->scu_status = SCU_TASK_DONE_GOOD;
                 ireq->sci_status = SCI_SUCCESS;
-                sci_change_state(&ireq->sm, next);
+                sci_change_state(&ireq->sm, SCI_REQ_STP_SOFT_RESET_WAIT_H2D_DIAG);
                 break;
+
         default:
-                /* All other completion status cause the IO to be complete.
+                /*
+                 * All other completion status cause the IO to be complete.
                  * If a NAK was received, then it is up to the user to retry
                  * the request.
                  */
                 ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
                 ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
-
                 sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
                 break;
         }
 
-        return status;
+        return SCI_SUCCESS;
 }
 
-static enum sci_status atapi_data_tc_completion_handler(struct isci_request *ireq,
-                                                        u32 completion_code)
+static enum sci_status
+stp_request_soft_reset_await_h2d_diagnostic_tc_event(struct isci_request *ireq,
+                                                     u32 completion_code)
 {
-        struct isci_remote_device *idev = ireq->target_device;
-        struct dev_to_host_fis *d2h = &ireq->stp.rsp;
-        enum sci_status status = SCI_SUCCESS;
-
         switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
-        case (SCU_TASK_DONE_GOOD << SCU_COMPLETION_TL_STATUS_SHIFT):
-                sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
-                break;
-
-        case (SCU_TASK_DONE_UNEXP_FIS << SCU_COMPLETION_TL_STATUS_SHIFT): {
-                u16 len = sci_req_tx_bytes(ireq);
-
-                /* likely non-error data underrrun, workaround missing
-                 * d2h frame from the controller
-                 */
-                if (d2h->fis_type != FIS_REGD2H) {
-                        d2h->fis_type = FIS_REGD2H;
-                        d2h->flags = (1 << 6);
-                        d2h->status = 0x50;
-                        d2h->error = 0;
-                        d2h->lbal = 0;
-                        d2h->byte_count_low = len & 0xff;
-                        d2h->byte_count_high = len >> 8;
-                        d2h->device = 0xa0;
-                        d2h->lbal_exp = 0;
-                        d2h->lbam_exp = 0;
-                        d2h->lbah_exp = 0;
-                        d2h->_r_a = 0;
-                        d2h->sector_count = 0x3;
-                        d2h->sector_count_exp = 0;
-                        d2h->_r_b = 0;
-                        d2h->_r_c = 0;
-                        d2h->_r_d = 0;
-                }
-
-                ireq->scu_status = SCU_TASK_DONE_GOOD;
-                ireq->sci_status = SCI_SUCCESS_IO_DONE_EARLY;
-                status = ireq->sci_status;
-
-                /* the hw will have suspended the rnc, so complete the
-                 * request upon pending resume
-                 */
-                sci_change_state(&idev->sm, SCI_STP_DEV_ATAPI_ERROR);
-                break;
-        }
-        case (SCU_TASK_DONE_EXCESS_DATA << SCU_COMPLETION_TL_STATUS_SHIFT):
-                /* In this case, there is no UF coming after.
-                 * compelte the IO now.
-                 */
+        case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
                 ireq->scu_status = SCU_TASK_DONE_GOOD;
                 ireq->sci_status = SCI_SUCCESS;
-                sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
+                sci_change_state(&ireq->sm, SCI_REQ_STP_SOFT_RESET_WAIT_D2H);
                 break;
 
         default:
-                if (d2h->fis_type == FIS_REGD2H) {
-                        /* UF received change the device state to ATAPI_ERROR */
-                        status = ireq->sci_status;
-                        sci_change_state(&idev->sm, SCI_STP_DEV_ATAPI_ERROR);
-                } else {
-                        /* If receiving any non-success TC status, no UF
-                         * received yet, then an UF for the status fis
-                         * is coming after (XXX: suspect this is
-                         * actually a protocol error or a bug like the
-                         * DONE_UNEXP_FIS case)
-                         */
-                        ireq->scu_status = SCU_TASK_DONE_CHECK_RESPONSE;
-                        ireq->sci_status = SCI_FAILURE_IO_RESPONSE_VALID;
-
-                        sci_change_state(&ireq->sm, SCI_REQ_ATAPI_WAIT_D2H);
-                }
+                /* All other completion status cause the IO to be complete.  If
+                 * a NAK was received, then it is up to the user to retry the
+                 * request.
+                 */
+                ireq->scu_status = SCU_NORMALIZE_COMPLETION_STATUS(completion_code);
+                ireq->sci_status = SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR;
+                sci_change_state(&ireq->sm, SCI_REQ_COMPLETED);
                 break;
         }
 
-        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);
-        }
+        return SCI_SUCCESS;
 }
 
 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);
@@ -2432,24 +2005,25 @@ sci_io_request_tc_completion(struct isci_request *ireq,
         case SCI_REQ_STP_PIO_DATA_OUT:
                 return pio_data_out_tx_done_tc_event(ireq, completion_code);
 
+        case SCI_REQ_STP_SOFT_RESET_WAIT_H2D_ASSERTED:
+                return stp_request_soft_reset_await_h2d_asserted_tc_event(ireq,
+                                                                          completion_code);
+
+        case SCI_REQ_STP_SOFT_RESET_WAIT_H2D_DIAG:
+                return stp_request_soft_reset_await_h2d_diagnostic_tc_event(ireq,
+                                                                            completion_code);
+
         case SCI_REQ_ABORTING:
                 return request_aborting_state_tc_event(ireq,
                                                        completion_code);
 
-        case SCI_REQ_ATAPI_WAIT_H2D:
-                return atapi_raw_completion(ireq, completion_code,
-                                            SCI_REQ_ATAPI_WAIT_PIO_SETUP);
-
-        case SCI_REQ_ATAPI_WAIT_TC_COMP:
-                return atapi_raw_completion(ireq, completion_code,
-                                            SCI_REQ_ATAPI_WAIT_D2H);
-
-        case SCI_REQ_ATAPI_WAIT_D2H:
-                return atapi_data_tc_completion_handler(ireq, completion_code);
-
         default:
-                dev_warn(&ihost->pdev->dev, "%s: %x in wrong state %s\n",
-                         __func__, completion_code, req_state_name(state));
+                dev_warn(&ihost->pdev->dev,
+                         "%s: SCIC IO Request given task completion "
+                         "notification %x while in wrong state %d\n",
+                         __func__,
+                         completion_code,
+                         state);
                 return SCI_FAILURE_INVALID_STATE;
         }
 }
@@ -2493,6 +2067,9 @@ 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.
  *
@@ -2503,12 +2080,14 @@ 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;
 }
 
@@ -2518,6 +2097,9 @@ 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.
  */
@@ -2526,7 +2108,8 @@ 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 exec_status *status_ptr,
+        enum isci_completion_selection *complete_to_host_ptr)
 {
         unsigned int cstatus;
 
@@ -2567,6 +2150,9 @@ 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;
@@ -2577,6 +2163,9 @@ 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;
@@ -2605,6 +2194,8 @@ 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;
 
 
@@ -2615,7 +2206,7 @@ static void isci_request_handle_controller_specific_errors(
 
                 isci_request_set_open_reject_status(
                         request, task, response_ptr, status_ptr,
-                        SAS_OREJ_WRONG_DEST);
+                        complete_to_host_ptr, SAS_OREJ_WRONG_DEST);
                 break;
 
         case SCU_TASK_OPEN_REJECT_ZONE_VIOLATION:
@@ -2625,56 +2216,56 @@ static void isci_request_handle_controller_specific_errors(
                  */
                 isci_request_set_open_reject_status(
                         request, task, response_ptr, status_ptr,
-                        SAS_OREJ_RESV_AB0);
+                        complete_to_host_ptr, 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,
-                        SAS_OREJ_RESV_AB1);
+                        complete_to_host_ptr, 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,
-                        SAS_OREJ_RESV_AB2);
+                        complete_to_host_ptr, 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,
-                        SAS_OREJ_RESV_AB3);
+                        complete_to_host_ptr, SAS_OREJ_RESV_AB3);
                 break;
 
         case SCU_TASK_OPEN_REJECT_BAD_DESTINATION:
 
                 isci_request_set_open_reject_status(
                         request, task, response_ptr, status_ptr,
-                        SAS_OREJ_BAD_DEST);
+                        complete_to_host_ptr, 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,
-                        SAS_OREJ_STP_NORES);
+                        complete_to_host_ptr, 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,
-                        SAS_OREJ_EPROTO);
+                        complete_to_host_ptr, 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,
-                        SAS_OREJ_CONN_RATE);
+                        complete_to_host_ptr, SAS_OREJ_CONN_RATE);
                 break;
 
         case SCU_TASK_DONE_LL_R_ERR:
@@ -2706,10 +2297,114 @@ 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);
-                else
+
+                        *complete_to_host_ptr = isci_perform_normal_io_completion;
+                } 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) */
+                dev_dbg(&host->pdev->dev,
+                        "%s: Normal - task = %p, response=%d (%d), status=%d (%d)\n",
+                        __func__,
+                        task,
+                        task->task_status.resp, response,
+                        task->task_status.stat, status);
+                /* 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.
+                 */
+                dev_dbg(&host->pdev->dev,
+                         "%s: Aborted - task = %p, response=%d (%d), status=%d (%d)\n",
+                         __func__,
+                         task,
+                         task->task_status.resp, response,
+                         task->task_status.stat, status);
+
+                /* 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 */
+                dev_dbg(&host->pdev->dev,
+                         "%s: Error - task = %p, response=%d (%d), status=%d (%d)\n",
+                         __func__,
+                         task,
+                         task->task_status.resp, response,
+                         task->task_status.stat, status);
+                /* Add to the aborted list. */
+                list_add(&request->completed_node,
+                         &host->requests_to_errorback);
+                break;
+
+        default:
+                dev_dbg(&host->pdev->dev,
+                         "%s: Unknown - task = %p, response=%d (%d), status=%d (%d)\n",
+                         __func__,
+                         task,
+                         task->task_status.resp, response,
+                         task->task_status.stat, status);
+
+                /* Add to the error to libsas list. */
+                list_add(&request->completed_node,
+                         &host->requests_to_errorback);
                 break;
         }
 }
@@ -2728,8 +2423,6 @@ static void isci_process_stp_response(struct sas_task *task, struct dev_to_host_
          */
         if (fis->status & ATA_DF)
                 ts->stat = SAS_PROTO_RESPONSE;
-        else if (fis->status & ATA_ERR)
-                ts->stat = SAM_STAT_CHECK_CONDITION;
         else
                 ts->stat = SAM_STAT_GOOD;
 
@@ -2743,167 +2436,298 @@ static void isci_request_io_request_complete(struct isci_host *ihost,
         struct sas_task *task = isci_request_access_task(request);
         struct ssp_response_iu *resp_iu;
         unsigned long task_flags;
-        struct isci_remote_device *idev = request->target_device;
-        enum service_response response = SAS_TASK_UNDELIVERED;
-        enum exec_status status = SAS_ABORTED_TASK;
+        struct isci_remote_device *idev = isci_lookup_device(task->dev);
+        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, "
+                "%s: request = %p, task = %p,\n"
                 "task->data_dir = %d completion_status = 0x%x\n",
-                __func__, request, task, task->data_dir, completion_status);
-
-        /* The request is done from an SCU HW perspective. */
-
-        /* 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) {
+                __func__,
+                request,
+                task,
+                task->data_dir,
+                completion_status);
 
-                        /* crack the iu response buffer. */
-                        resp_iu = &request->ssp.rsp;
-                        isci_request_process_response_iu(task, resp_iu,
-                                                         &ihost->pdev->dev);
+        spin_lock(&request->state_lock);
+        request_status = request->status;
 
-                } else if (SAS_PROTOCOL_SMP == task->task_proto) {
+        /* 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;
 
-                        dev_err(&ihost->pdev->dev,
-                                "%s: SCI_IO_FAILURE_RESPONSE_VALID: "
-                                        "SAS_PROTOCOL_SMP protocol\n",
-                                __func__);
+                /* 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;
 
-                } else
-                        dev_err(&ihost->pdev->dev,
-                                "%s: unknown protocol\n", __func__);
+                complete_to_host = isci_perform_aborted_io_completion;
+                /* This was an aborted request. */
 
-                /* 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;
+                spin_unlock(&request->state_lock);
                 break;
 
-        case SCI_IO_SUCCESS:
-        case SCI_IO_SUCCESS_IO_DONE_EARLY:
-
-                response = SAS_TASK_COMPLETE;
-                status   = SAM_STAT_GOOD;
+        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.
+                 */
                 set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
+                response = SAS_TASK_UNDELIVERED;
 
-                if (completion_status == SCI_IO_SUCCESS_IO_DONE_EARLY) {
-
-                        /* 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);
-
-                        task->task_status.residual
-                                = task->total_xfer_len - transferred_length;
+                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 there were residual bytes, call this an
-                        * underrun.
-                        */
-                        if (task->task_status.residual != 0)
-                                status = SAS_DATA_UNDERRUN;
+                complete_to_host = isci_perform_aborted_io_completion;
 
-                        dev_dbg(&ihost->pdev->dev,
-                                "%s: SCI_IO_SUCCESS_IO_DONE_EARLY %d\n",
-                                __func__, status);
+                /* This was an aborted request. */
 
-                } else
-                        dev_dbg(&ihost->pdev->dev, "%s: SCI_IO_SUCCESS\n",
-                                __func__);
+                spin_unlock(&request->state_lock);
                 break;
 
-        case SCI_IO_FAILURE_TERMINATED:
+        case terminating:
 
-                dev_dbg(&ihost->pdev->dev,
-                        "%s: SCI_IO_FAILURE_TERMINATED (%p/%p)\n",
-                        __func__, request, task);
-
-                /* The request was terminated explicitly. */
+                /* 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.
+                 */
                 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;
-                break;
 
-        case SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR:
+                complete_to_host = isci_perform_aborted_io_completion;
 
-                isci_request_handle_controller_specific_errors(idev, request,
-                                                               task, &response,
-                                                               &status);
+                /* This was a terminated request. */
+
+                spin_unlock(&request->state_lock);
                 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);
+        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;
 
-                /* Fail the I/O. */
-                response = SAS_TASK_UNDELIVERED;
-                status = SAM_STAT_TASK_ABORTED;
+        default:
 
-                clear_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
-                break;
+                /* The request is done from an SCU HW perspective. */
+                request->status = completed;
 
-        case SCI_FAILURE_RETRY_REQUIRED:
+                spin_unlock(&request->state_lock);
 
-                /* Fail the I/O so it can be retried. */
-                response = SAS_TASK_UNDELIVERED;
-                if (!idev)
-                        status = SAS_DEVICE_UNKNOWN;
-                else
-                        status = SAS_ABORTED_TASK;
+                /* This is an active request being completed from the core. */
+                switch (completion_status) {
 
-                set_bit(IREQ_COMPLETE_IN_TARGET, &request->flags);
-                break;
+                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) {
 
-        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);
+                                /* crack the iu response buffer. */
+                                resp_iu = &request->ssp.rsp;
+                                isci_request_process_response_iu(task, resp_iu,
+                                                                 &ihost->pdev->dev);
 
-                response = SAS_TASK_UNDELIVERED;
+                        } else if (SAS_PROTOCOL_SMP == task->task_proto) {
 
-                /* 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;
+                                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;
 
-                if (SAS_PROTOCOL_SMP == task->task_proto)
+                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);
-                else
+
+                        if (completion_status == SCI_IO_SUCCESS_IO_DONE_EARLY) {
+
+                                /* 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);
+
+                                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;
+
+                                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 SCI_IO_FAILURE_TERMINATED:
+                        dev_dbg(&ihost->pdev->dev,
+                                "%s: SCI_IO_FAILURE_TERMINATED (%p/%p)\n",
+                                __func__,
+                                request,
+                                task);
+
+                        /* The request was terminated explicitly.  No handling
+                         * is needed in the SCSI error handler path.
+                         */
+                        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;
                         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;
         }
 
@@ -2928,77 +2752,67 @@ static void isci_request_io_request_complete(struct isci_host *ihost,
                 dma_unmap_sg(&ihost->pdev->dev, sg, 1, DMA_TO_DEVICE);
 
                 /* need to swab it back in case the command buffer is re-used */
-                kaddr = kmap_atomic(sg_page(sg));
+                kaddr = kmap_atomic(sg_page(sg), KM_IRQ0);
                 smp_req = kaddr + sg->offset;
                 sci_swab32_cpy(smp_req, smp_req, sg->length / sizeof(u32));
-                kunmap_atomic(kaddr);
+                kunmap_atomic(kaddr, KM_IRQ0);
                 break;
         }
         default:
                 break;
         }
 
-        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);
+        /* Put the completed request on the correct list */
+        isci_task_save_for_upper_layer_completion(ihost, request, response,
+                                                  status, complete_to_host
+                                                  );
 
         /* complete the io request to the core. */
         sci_controller_complete_io(ihost, request->target_device, request);
+        isci_put_device(idev);
 
         /* set terminated handle so it cannot be completed or
          * terminated again, and to cause any calls into abort
          * 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)
 {
         struct isci_request *ireq = container_of(sm, typeof(*ireq), sm);
         struct domain_device *dev = ireq->target_device->domain_dev;
-        enum sci_base_request_states state;
         struct sas_task *task;
 
         /* XXX as hch said always creating an internal sas_task for tmf
          * requests would simplify the driver
          */
-        task = (test_bit(IREQ_TMF, &ireq->flags)) ? NULL : isci_request_access_task(ireq);
+        task = ireq->ttype == io_task ? isci_request_access_task(ireq) : NULL;
 
         /* all unaccelerated request types (non ssp or ncq) handled with
          * substates
          */
         if (!task && dev->dev_type == SAS_END_DEV) {
-                state = SCI_REQ_TASK_WAIT_TC_COMP;
+                sci_change_state(sm, SCI_REQ_TASK_WAIT_TC_COMP);
+        } else if (!task &&
+                   (isci_request_access_tmf(ireq)->tmf_code == isci_tmf_sata_srst_high ||
+                    isci_request_access_tmf(ireq)->tmf_code == isci_tmf_sata_srst_low)) {
+                sci_change_state(sm, SCI_REQ_STP_SOFT_RESET_WAIT_H2D_ASSERTED);
         } else if (task && task->task_proto == SAS_PROTOCOL_SMP) {
-                state = SCI_REQ_SMP_WAIT_RESP;
+                sci_change_state(sm, SCI_REQ_SMP_WAIT_RESP);
         } else if (task && sas_protocol_ata(task->task_proto) &&
                    !task->ata_task.use_ncq) {
-                if (dev->sata_dev.command_set == ATAPI_COMMAND_SET &&
-                        task->ata_task.fis.command == ATA_CMD_PACKET) {
-                        state = SCI_REQ_ATAPI_WAIT_H2D;
-                } else if (task->data_dir == DMA_NONE) {
+                u32 state;
+
+                if (task->data_dir == DMA_NONE)
                         state = SCI_REQ_STP_NON_DATA_WAIT_H2D;
-                } else if (task->ata_task.dma_xfer) {
+                else if (task->ata_task.dma_xfer)
                         state = SCI_REQ_STP_UDMA_WAIT_TC_COMP;
-                } else /* PIO */ {
+                else /* PIO */
                         state = SCI_REQ_STP_PIO_WAIT_H2D;
-                }
-        } else {
-                /* SSP or NCQ are fully accelerated, no substates */
-                return;
+
+                sci_change_state(sm, state);
         }
-        sci_change_state(sm, state);
 }
 
 static void sci_request_completed_state_enter(struct sci_base_state_machine *sm)
@@ -3036,6 +2850,31 @@ static void sci_stp_request_started_pio_await_h2d_completion_enter(struct sci_ba
         ireq->target_device->working_request = ireq;
 }
 
+static void sci_stp_request_started_soft_reset_await_h2d_asserted_completion_enter(struct sci_base_state_machine *sm)
+{
+        struct isci_request *ireq = container_of(sm, typeof(*ireq), sm);
+
+        ireq->target_device->working_request = ireq;
+}
+
+static void sci_stp_request_started_soft_reset_await_h2d_diagnostic_completion_enter(struct sci_base_state_machine *sm)
+{
+        struct isci_request *ireq = container_of(sm, typeof(*ireq), sm);
+        struct scu_task_context *tc = ireq->tc;
+        struct host_to_dev_fis *h2d_fis;
+        enum sci_status status;
+
+        /* Clear the SRST bit */
+        h2d_fis = &ireq->stp.cmd;
+        h2d_fis->control = 0;
+
+        /* Clear the TC control bit */
+        tc->control_frame = 0;
+
+        status = sci_controller_continue_io(ireq);
+        WARN_ONCE(status != SCI_SUCCESS, "isci: continue io failure\n");
+}
+
 static const struct sci_base_state sci_request_state_table[] = {
         [SCI_REQ_INIT] = { },
         [SCI_REQ_CONSTRUCTED] = { },
@@ -3054,14 +2893,17 @@ static const struct sci_base_state sci_request_state_table[] = {
         [SCI_REQ_STP_PIO_DATA_OUT] = { },
         [SCI_REQ_STP_UDMA_WAIT_TC_COMP] = { },
         [SCI_REQ_STP_UDMA_WAIT_D2H] = { },
+        [SCI_REQ_STP_SOFT_RESET_WAIT_H2D_ASSERTED] = {
+                .enter_state = sci_stp_request_started_soft_reset_await_h2d_asserted_completion_enter,
+        },
+        [SCI_REQ_STP_SOFT_RESET_WAIT_H2D_DIAG] = {
+                .enter_state = sci_stp_request_started_soft_reset_await_h2d_diagnostic_completion_enter,
+        },
+        [SCI_REQ_STP_SOFT_RESET_WAIT_D2H] = { },
         [SCI_REQ_TASK_WAIT_TC_COMP] = { },
         [SCI_REQ_TASK_WAIT_TC_RESP] = { },
         [SCI_REQ_SMP_WAIT_RESP] = { },
         [SCI_REQ_SMP_WAIT_TC_COMP] = { },
-        [SCI_REQ_ATAPI_WAIT_H2D] = { },
-        [SCI_REQ_ATAPI_WAIT_PIO_SETUP] = { },
-        [SCI_REQ_ATAPI_WAIT_D2H] = { },
-        [SCI_REQ_ATAPI_WAIT_TC_COMP] = { },
         [SCI_REQ_COMPLETED] = {
                 .enter_state = sci_request_completed_state_enter,
         },
@@ -3079,7 +2921,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 = SAS_PROTOCOL_NONE;
+        ireq->protocol = SCIC_NO_PROTOCOL;
         ireq->saved_rx_frame_index = SCU_INVALID_FRAME_INDEX;
 
         ireq->sci_status   = SCI_SUCCESS;
@@ -3103,7 +2945,7 @@ sci_io_request_construct(struct isci_host *ihost,
 
         if (dev->dev_type == SAS_END_DEV)
                 /* pass */;
-        else if (dev_is_sata(dev))
+        else if (dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP))
                 memset(&ireq->stp.cmd, 0, sizeof(ireq->stp.cmd));
         else if (dev_is_expander(dev))
                 /* pass */;
@@ -3125,15 +2967,10 @@ enum sci_status sci_task_request_construct(struct isci_host *ihost,
         /* Build the common part of the request */
         sci_general_request_construct(ihost, idev, ireq);
 
-        if (dev->dev_type == SAS_END_DEV || dev_is_sata(dev)) {
+        if (dev->dev_type == SAS_END_DEV ||
+            dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP)) {
                 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;
 
@@ -3195,7 +3032,7 @@ sci_io_request_construct_smp(struct device *dev,
         u8 req_len;
         u32 cmd;
 
-        kaddr = kmap_atomic(sg_page(sg));
+        kaddr = kmap_atomic(sg_page(sg), KM_IRQ0);
         smp_req = kaddr + sg->offset;
         /*
          * Look at the SMP requests' header fields; for certain SAS 1.x SMP
@@ -3221,12 +3058,12 @@ sci_io_request_construct_smp(struct device *dev,
         req_len = smp_req->req_len;
         sci_swab32_cpy(smp_req, smp_req, sg->length / sizeof(u32));
         cmd = *(u32 *) smp_req;
-        kunmap_atomic(kaddr);
+        kunmap_atomic(kaddr, KM_IRQ0);
 
         if (!dma_map_sg(dev, sg, 1, DMA_TO_DEVICE))
                 return SCI_FAILURE;
 
-        ireq->protocol = SAS_PROTOCOL_SMP;
+        ireq->protocol = SCIC_SMP_PROTOCOL;
 
         /* byte swap the smp request. */
 
@@ -3411,6 +3248,9 @@ 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;
 }
@@ -3423,7 +3263,7 @@ static struct isci_request *isci_io_request_from_tag(struct isci_host *ihost,
 
         ireq = isci_request_from_tag(ihost, tag);
         ireq->ttype_ptr.io_task_ptr = task;
-        clear_bit(IREQ_TMF, &ireq->flags);
+        ireq->ttype = io_task;
         task->lldd_task = ireq;
 
         return ireq;
@@ -3437,7 +3277,7 @@ struct isci_request *isci_tmf_request_from_tag(struct isci_host *ihost,
 
         ireq = isci_request_from_tag(ihost, tag);
         ireq->ttype_ptr.tmf_task_ptr = isci_tmf;
-        set_bit(IREQ_TMF, &ireq->flags);
+        ireq->ttype = tmf_task;
 
         return ireq;
 }
@@ -3494,15 +3334,26 @@ 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.
          */
-        if (status != SCI_SUCCESS) {
+        list_add(&ireq->dev_node, &idev->reqs_in_process);
+
+        if (status == SCI_SUCCESS) {
+                isci_request_change_state(ireq, started);
+        } else {
                 /* 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);
 
@@ -3519,7 +3370,8 @@ int isci_request_execute(struct isci_host *ihost, struct isci_remote_device *ide
                 /* Cause this task to be scheduled in the SCSI error
                  * handler thread.
                  */
-                sas_task_abort(task);
+                isci_execpath_callback(ihost, task,
+                                       sas_task_abort);
 
                 /* Change the status, since we are holding
                  * the I/O until it is managed by the SCSI
diff --git a/drivers/scsi/isci/request.h b/drivers/scsi/isci/request.h
index aff95317fcf..58d70b6606e 100644
--- a/drivers/scsi/isci/request.h
+++ b/drivers/scsi/isci/request.h
@@ -61,12 +61,42 @@
 #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 task_type {
+        io_task  = 0,
+        tmf_task = 1
+};
+
+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
  *           to wait for another fis or if the transfer is complete.  Upon
  *           receipt of a d2h fis this will be the status field of that fis.
  * @sgl - track pio transfer progress as we iterate through the sgl
+ * @device_cdb_len - atapi device advertises it's transfer constraints at setup
  */
 struct isci_stp_request {
         u32 pio_len;
@@ -77,24 +107,28 @@ struct isci_stp_request {
                 u8 set;
                 u32 offset;
         } sgl;
+        u32 device_cdb_len;
 };
 
 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 */
+        enum task_type ttype;
         union ttype_ptr_union {
                 struct sas_task *io_task_ptr;   /* When ttype==io_task  */
                 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;
@@ -114,7 +148,7 @@ struct isci_request {
         struct isci_host *owning_controller;
         struct isci_remote_device *target_device;
         u16 io_tag;
-        enum sas_protocol protocol;
+        enum sci_request_protocol protocol;
         u32 scu_status; /* hardware result */
         u32 sci_status; /* upper layer disposition */
         u32 post_context;
@@ -156,103 +190,112 @@ static inline struct isci_request *to_ireq(struct isci_stp_request *stp_req)
 }
 
 /**
- * enum sci_base_request_states - request state machine states
- *
- * @SCI_REQ_INIT: Simply the initial state for the base request state machine.
- *
- * @SCI_REQ_CONSTRUCTED: This state indicates that the request has been
- * constructed.  This state is entered from the INITIAL state.
- *
- * @SCI_REQ_STARTED: This state indicates that the request has been started.
- * This state is entered from the CONSTRUCTED state.
- *
- * @SCI_REQ_STP_UDMA_WAIT_TC_COMP:
- * @SCI_REQ_STP_UDMA_WAIT_D2H:
- * @SCI_REQ_STP_NON_DATA_WAIT_H2D:
- * @SCI_REQ_STP_NON_DATA_WAIT_D2H:
- *
- * @SCI_REQ_STP_PIO_WAIT_H2D: While in this state the IO request object is
- * waiting for the TC completion notification for the H2D Register FIS
- *
- * @SCI_REQ_STP_PIO_WAIT_FRAME: While in this state the IO request object is
- * waiting for either a PIO Setup FIS or a D2H register FIS.  The type of frame
- * received is based on the result of the prior frame and line conditions.
- *
- * @SCI_REQ_STP_PIO_DATA_IN: While in this state the IO request object is
- * waiting for a DATA frame from the device.
- *
- * @SCI_REQ_STP_PIO_DATA_OUT: While in this state the IO request object is
- * waiting to transmit the next data frame to the device.
- *
- * @SCI_REQ_ATAPI_WAIT_H2D: While in this state the IO request object is
- * waiting for the TC completion notification for the H2D Register FIS
- *
- * @SCI_REQ_ATAPI_WAIT_PIO_SETUP: While in this state the IO request object is
- * waiting for either a PIO Setup.
- *
- * @SCI_REQ_ATAPI_WAIT_D2H: The non-data IO transit to this state in this state
- * after receiving TC completion. While in this state IO request object is
- * waiting for D2H status frame as UF.
- *
- * @SCI_REQ_ATAPI_WAIT_TC_COMP: When transmitting raw frames hardware reports
- * task context completion after every frame submission, so in the
- * non-accelerated case we need to expect the completion for the "cdb" frame.
- *
- * @SCI_REQ_TASK_WAIT_TC_COMP: The AWAIT_TC_COMPLETION sub-state indicates that
- * the started raw task management request is waiting for the transmission of
- * the initial frame (i.e. command, task, etc.).
- *
- * @SCI_REQ_TASK_WAIT_TC_RESP: This sub-state indicates that the started task
- * management request is waiting for the reception of an unsolicited frame
- * (i.e.  response IU).
- *
- * @SCI_REQ_SMP_WAIT_RESP: This sub-state indicates that the started task
- * management request is waiting for the reception of an unsolicited frame
- * (i.e.  response IU).
+ * enum sci_base_request_states - This enumeration depicts all the states for
+ *    the common request state machine.
  *
- * @SCI_REQ_SMP_WAIT_TC_COMP: The AWAIT_TC_COMPLETION sub-state indicates that
- * the started SMP request is waiting for the transmission of the initial frame
- * (i.e.  command, task, etc.).
  *
- * @SCI_REQ_COMPLETED: This state indicates that the request has completed.
- * This state is entered from the STARTED state. This state is entered from the
- * ABORTING state.
- *
- * @SCI_REQ_ABORTING: This state indicates that the request is in the process
- * of being terminated/aborted.  This state is entered from the CONSTRUCTED
- * state.  This state is entered from the STARTED state.
- *
- * @SCI_REQ_FINAL: Simply the final state for the base request state machine.
  */
-#define REQUEST_STATES {\
-        C(REQ_INIT),\
-        C(REQ_CONSTRUCTED),\
-        C(REQ_STARTED),\
-        C(REQ_STP_UDMA_WAIT_TC_COMP),\
-        C(REQ_STP_UDMA_WAIT_D2H),\
-        C(REQ_STP_NON_DATA_WAIT_H2D),\
-        C(REQ_STP_NON_DATA_WAIT_D2H),\
-        C(REQ_STP_PIO_WAIT_H2D),\
-        C(REQ_STP_PIO_WAIT_FRAME),\
-        C(REQ_STP_PIO_DATA_IN),\
-        C(REQ_STP_PIO_DATA_OUT),\
-        C(REQ_ATAPI_WAIT_H2D),\
-        C(REQ_ATAPI_WAIT_PIO_SETUP),\
-        C(REQ_ATAPI_WAIT_D2H),\
-        C(REQ_ATAPI_WAIT_TC_COMP),\
-        C(REQ_TASK_WAIT_TC_COMP),\
-        C(REQ_TASK_WAIT_TC_RESP),\
-        C(REQ_SMP_WAIT_RESP),\
-        C(REQ_SMP_WAIT_TC_COMP),\
-        C(REQ_COMPLETED),\
-        C(REQ_ABORTING),\
-        C(REQ_FINAL),\
-        }
-#undef C
-#define C(a) SCI_##a
-enum sci_base_request_states REQUEST_STATES;
-#undef C
-const char *req_state_name(enum sci_base_request_states state);
+enum sci_base_request_states {
+        /*
+         * Simply the initial state for the base request state machine.
+         */
+        SCI_REQ_INIT,
+
+        /*
+         * This state indicates that the request has been constructed.
+         * This state is entered from the INITIAL state.
+         */
+        SCI_REQ_CONSTRUCTED,
+
+        /*
+         * This state indicates that the request has been started. This state
+         * is entered from the CONSTRUCTED state.
+         */
+        SCI_REQ_STARTED,
+
+        SCI_REQ_STP_UDMA_WAIT_TC_COMP,
+        SCI_REQ_STP_UDMA_WAIT_D2H,
+
+        SCI_REQ_STP_NON_DATA_WAIT_H2D,
+        SCI_REQ_STP_NON_DATA_WAIT_D2H,
+
+        SCI_REQ_STP_SOFT_RESET_WAIT_H2D_ASSERTED,
+        SCI_REQ_STP_SOFT_RESET_WAIT_H2D_DIAG,
+        SCI_REQ_STP_SOFT_RESET_WAIT_D2H,
+
+        /*
+         * While in this state the IO request object is waiting for the TC
+         * completion notification for the H2D Register FIS
+         */
+        SCI_REQ_STP_PIO_WAIT_H2D,
+
+        /*
+         * While in this state the IO request object is waiting for either a
+         * PIO Setup FIS or a D2H register FIS.  The type of frame received is
+         * based on the result of the prior frame and line conditions.
+         */
+        SCI_REQ_STP_PIO_WAIT_FRAME,
+
+        /*
+         * While in this state the IO request object is waiting for a DATA
+         * frame from the device.
+         */
+        SCI_REQ_STP_PIO_DATA_IN,
+
+        /*
+         * While in this state the IO request object is waiting to transmit
+         * the next data frame to the device.
+         */
+        SCI_REQ_STP_PIO_DATA_OUT,
+
+        /*
+         * The AWAIT_TC_COMPLETION sub-state indicates that the started raw
+         * task management request is waiting for the transmission of the
+         * initial frame (i.e. command, task, etc.).
+         */
+        SCI_REQ_TASK_WAIT_TC_COMP,
+
+        /*
+         * This sub-state indicates that the started task management request
+         * is waiting for the reception of an unsolicited frame
+         * (i.e. response IU).
+         */
+        SCI_REQ_TASK_WAIT_TC_RESP,
+
+        /*
+         * This sub-state indicates that the started task management request
+         * is waiting for the reception of an unsolicited frame
+         * (i.e. response IU).
+         */
+        SCI_REQ_SMP_WAIT_RESP,
+
+        /*
+         * The AWAIT_TC_COMPLETION sub-state indicates that the started SMP
+         * request is waiting for the transmission of the initial frame
+         * (i.e. command, task, etc.).
+         */
+        SCI_REQ_SMP_WAIT_TC_COMP,
+
+        /*
+         * This state indicates that the request has completed.
+         * This state is entered from the STARTED state. This state is entered
+         * from the ABORTING state.
+         */
+        SCI_REQ_COMPLETED,
+
+        /*
+         * This state indicates that the request is in the process of being
+         * terminated/aborted.
+         * This state is entered from the CONSTRUCTED state.
+         * This state is entered from the STARTED state.
+         */
+        SCI_REQ_ABORTING,
+
+        /*
+         * Simply the final state for the base request state machine.
+         */
+        SCI_REQ_FINAL,
+};
 
 enum sci_status sci_request_start(struct isci_request *ireq);
 enum sci_status sci_io_request_terminate(struct isci_request *ireq);
@@ -283,6 +326,92 @@ 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)
@@ -292,12 +421,17 @@ 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,
                             u16 io_tag,
                             struct isci_request *ireq);
-enum sci_status sci_task_request_construct_ssp(struct isci_request *ireq);
+enum sci_status
+sci_task_request_construct_ssp(struct isci_request *ireq);
+enum sci_status
+sci_task_request_construct_sata(struct isci_request *ireq);
 void sci_smp_request_copy_response(struct isci_request *ireq);
 
 static inline int isci_task_is_ncq_recovery(struct sas_task *task)
@@ -307,4 +441,5 @@ 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 071cb74a211..c8b329c695f 100644
--- a/drivers/scsi/isci/scu_completion_codes.h
+++ b/drivers/scsi/isci/scu_completion_codes.h
@@ -224,7 +224,6 @@
  * 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)
@@ -238,7 +237,6 @@
 #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/scu_task_context.h b/drivers/scsi/isci/scu_task_context.h
index 869a979eb5b..7df87d92328 100644
--- a/drivers/scsi/isci/scu_task_context.h
+++ b/drivers/scsi/isci/scu_task_context.h
@@ -866,9 +866,9 @@ struct scu_task_context {
         struct transport_snapshot snapshot; /* read only set to 0 */
 
         /* OFFSET 0x5C */
-        u32 blk_prot_en:1;
-        u32 blk_sz:2;
-        u32 blk_prot_func:2;
+        u32 block_protection_enable:1;
+        u32 block_size:2;
+        u32 block_protection_function:2;
         u32 reserved_5C_0:9;
         u32 active_sgl_element:2;  /* read only set to 0 */
         u32 sgl_exhausted:1;  /* read only set to 0 */
@@ -896,56 +896,33 @@ struct scu_task_context {
         u32 reserved_C4_CC[3];
 
         /* OFFSET 0xD0 */
-        u32 interm_crc_val:16;
-        u32 init_crc_seed:16;
+        u32 intermediate_crc_value:16;
+        u32 initial_crc_seed:16;
 
         /* OFFSET 0xD4 */
-        u32 app_tag_verify:16;
-        u32 app_tag_gen:16;
+        u32 application_tag_for_verify:16;
+        u32 application_tag_for_generate:16;
 
         /* OFFSET 0xD8 */
-        u32 ref_tag_seed_verify;
+        u32 reference_tag_seed_for_verify_function;
 
         /* OFFSET 0xDC */
-        u32 UD_bytes_immed_val:13;
-        u32 reserved_DC_0:3;
-        u32 DIF_bytes_immed_val:4;
-        u32 reserved_DC_1:12;
+        u32 reserved_DC;
 
         /* OFFSET 0xE0 */
-        u32 bgc_blk_sz:13;
-        u32 reserved_E0_0:3;
-        u32 app_tag_gen_mask:16;
+        u32 reserved_E0_0:16;
+        u32 application_tag_mask_for_generate:16;
 
         /* OFFSET 0xE4 */
-        union {
-                u16 bgctl;
-                struct {
-                        u16 crc_verify:1;
-                        u16 app_tag_chk:1;
-                        u16 ref_tag_chk:1;
-                        u16 op:2;
-                        u16 legacy:1;
-                        u16 invert_crc_seed:1;
-                        u16 ref_tag_gen:1;
-                        u16 fixed_ref_tag:1;
-                        u16 invert_crc:1;
-                        u16 app_ref_f_detect:1;
-                        u16 uninit_dif_check_err:1;
-                        u16 uninit_dif_bypass:1;
-                        u16 app_f_detect:1;
-                        u16 reserved_0:2;
-                } bgctl_f;
-        };
-
-        u16 app_tag_verify_mask;
+        u32 block_protection_control:16;
+        u32 application_tag_mask_for_verify:16;
 
         /* OFFSET 0xE8 */
-        u32 blk_guard_err:8;
+        u32 block_protection_error:8;
         u32 reserved_E8_0:24;
 
         /* OFFSET 0xEC */
-        u32 ref_tag_seed_gen;
+        u32 reference_tag_seed_for_verify;
 
         /* OFFSET 0xF0 */
         u32 intermediate_crc_valid_snapshot:16;
@@ -960,6 +937,6 @@ struct scu_task_context {
         /* OFFSET 0xFC */
         u32 reference_tag_seed_for_generate_function_snapshot;
 
-} __packed;
+};
 
 #endif /* _SCU_TASK_CONTEXT_H_ */
diff --git a/drivers/scsi/isci/task.c b/drivers/scsi/isci/task.c
index b6f19a1db78..d6bcdd013dc 100644
--- a/drivers/scsi/isci/task.c
+++ b/drivers/scsi/isci/task.c
@@ -78,25 +78,56 @@ static void isci_task_refuse(struct isci_host *ihost, struct sas_task *task,
                              enum exec_status status)
 
 {
-        unsigned long flags;
+        enum isci_completion_selection disposition;
 
-        /* Normal notification (task_done) */
-        dev_dbg(&ihost->pdev->dev, "%s: task = %p, response=%d, status=%d\n",
-                __func__, task, response, status);
+        disposition = isci_perform_normal_io_completion;
+        disposition = isci_task_set_completion_status(task, response, status,
+                                                      disposition);
 
-        spin_lock_irqsave(&task->task_state_lock, flags);
+        /* 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->task_status.resp = response;
-        task->task_status.stat = status;
+                task->lldd_task = NULL;
 
-        /* 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);
+                isci_execpath_callback(ihost, task, task->task_done);
+                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;
+
+        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);
+
+                isci_execpath_callback(ihost, task, sas_task_abort);
+                break;
 
-        task->task_done(task);
+        default:
+                dev_dbg(&ihost->pdev->dev,
+                        "%s: isci task notification default case!",
+                        __func__);
+                sas_task_abort(task);
+                break;
+        }
 }
 
 #define for_each_sas_task(num, task) \
@@ -181,27 +212,16 @@ int isci_task_execute_task(struct sas_task *task, int num, gfp_t gfp_flags)
                                         task->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
                                         spin_unlock_irqrestore(&task->task_state_lock, flags);
 
-                                        if (test_bit(IDEV_GONE, &idev->flags)) {
-
-                                                /* Indicate that the device
-                                                 * is gone.
-                                                 */
-                                                isci_task_refuse(ihost, task,
-                                                        SAS_TASK_UNDELIVERED,
-                                                        SAS_DEVICE_UNKNOWN);
-                                        } else {
-                                                /* Indicate QUEUE_FULL so that
-                                                 * the scsi midlayer retries.
-                                                 * If the request failed for
-                                                 * remote device reasons, it
-                                                 * gets returned as
-                                                 * SAS_TASK_UNDELIVERED next
-                                                 * time through.
-                                                 */
-                                                isci_task_refuse(ihost, task,
-                                                        SAS_TASK_COMPLETE,
-                                                        SAS_QUEUE_FULL);
-                                        }
+                                        /* Indicate QUEUE_FULL so that the scsi
+                                        * midlayer retries. if the request
+                                        * failed for remote device reasons,
+                                        * it gets returned as
+                                        * SAS_TASK_UNDELIVERED next time
+                                        * through.
+                                        */
+                                        isci_task_refuse(ihost, task,
+                                                         SAS_TASK_COMPLETE,
+                                                         SAS_QUEUE_FULL);
                                 }
                         }
                 }
@@ -218,6 +238,46 @@ int isci_task_execute_task(struct sas_task *task, int num, gfp_t gfp_flags)
         return 0;
 }
 
+static enum sci_status isci_sata_management_task_request_build(struct isci_request *ireq)
+{
+        struct isci_tmf *isci_tmf;
+        enum sci_status status;
+
+        if (tmf_task != ireq->ttype)
+                return SCI_FAILURE;
+
+        isci_tmf = isci_request_access_tmf(ireq);
+
+        switch (isci_tmf->tmf_code) {
+
+        case isci_tmf_sata_srst_high:
+        case isci_tmf_sata_srst_low: {
+                struct host_to_dev_fis *fis = &ireq->stp.cmd;
+
+                memset(fis, 0, sizeof(*fis));
+
+                fis->fis_type  =  0x27;
+                fis->flags     &= ~0x80;
+                fis->flags     &= 0xF0;
+                if (isci_tmf->tmf_code == isci_tmf_sata_srst_high)
+                        fis->control |= ATA_SRST;
+                else
+                        fis->control &= ~ATA_SRST;
+                break;
+        }
+        /* other management commnd go here... */
+        default:
+                return SCI_FAILURE;
+        }
+
+        /* core builds the protocol specific request
+         *  based on the h2d fis.
+         */
+        status = sci_task_request_construct_sata(ireq);
+
+        return status;
+}
+
 static struct isci_request *isci_task_request_build(struct isci_host *ihost,
                                                     struct isci_remote_device *idev,
                                                     u16 tag, struct isci_tmf *isci_tmf)
@@ -257,6 +317,13 @@ static struct isci_request *isci_task_request_build(struct isci_host *ihost,
                         return NULL;
         }
 
+        if (dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP)) {
+                isci_tmf->proto = SAS_PROTOCOL_SATA;
+                status = isci_sata_management_task_request_build(ireq);
+
+                if (status != SCI_SUCCESS)
+                        return NULL;
+        }
         return ireq;
 }
 
@@ -297,7 +364,6 @@ static int isci_task_execute_tmf(struct isci_host *ihost,
 
         /* Assign the pointer to the TMF's completion kernel wait structure. */
         tmf->complete = &completion;
-        tmf->status = SCI_FAILURE_TIMEOUT;
 
         ireq = isci_task_request_build(ihost, idev, tag, tmf);
         if (!ireq)
@@ -317,23 +383,37 @@ static int isci_task_execute_tmf(struct isci_host *ihost,
                 spin_unlock_irqrestore(&ihost->scic_lock, flags);
                 goto err_tci;
         }
-        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);
+        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);
 
         /* Wait for the TMF to complete, or a timeout. */
         timeleft = wait_for_completion_timeout(&completion,
                                                msecs_to_jiffies(timeout_ms));
 
         if (timeleft == 0) {
-                /* The TMF did not complete - this could be because
-                 * of an unplug.  Terminate the TMF request now.
-                 */
-                isci_remote_device_suspend_terminate(ihost, idev, ireq);
+                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);
+
+                wait_for_completion(tmf->complete);
         }
 
-        isci_print_tmf(ihost, tmf);
+        isci_print_tmf(tmf);
 
         if (tmf->status == SCI_SUCCESS)
                 ret =  TMF_RESP_FUNC_COMPLETE;
@@ -362,21 +442,366 @@ 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)
+                                enum isci_tmf_function_codes code,
+                                void (*tmf_sent_cb)(enum isci_tmf_cb_state,
+                                                    struct isci_tmf *,
+                                                    void *),
+                                void *cb_data)
 {
         memset(tmf, 0, sizeof(*tmf));
-        tmf->tmf_code = code;
+
+        tmf->tmf_code      = code;
+        tmf->cb_state_func = tmf_sent_cb;
+        tmf->cb_data       = cb_data;
 }
 
 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);
+        isci_task_build_tmf(tmf, code, tmf_sent_cb, old_request);
         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;
+}
+
+/**
+* isci_request_cleanup_completed_loiterer() - This function will take care of
+*    the final cleanup on any request which has been explicitly terminated.
+* @isci_host: This parameter specifies the ISCI host object
+* @isci_device: This is the device to which the request is pending.
+* @isci_request: This parameter specifies the terminated request object.
+* @task: This parameter is the libsas I/O request.
+*/
+static void isci_request_cleanup_completed_loiterer(
+        struct isci_host          *isci_host,
+        struct isci_remote_device *isci_device,
+        struct isci_request       *isci_request,
+        struct sas_task           *task)
+{
+        unsigned long flags;
+
+        dev_dbg(&isci_host->pdev->dev,
+                "%s: isci_device=%p, request=%p, task=%p\n",
+                __func__, isci_device, isci_request, task);
+
+        if (task != NULL) {
+
+                spin_lock_irqsave(&task->task_state_lock, flags);
+                task->lldd_task = NULL;
+
+                task->task_state_flags &= ~SAS_TASK_NEED_DEV_RESET;
+
+                isci_set_task_doneflags(task);
+
+                /* If this task is not in the abort path, call task_done. */
+                if (!(task->task_state_flags & SAS_TASK_STATE_ABORTED)) {
+
+                        spin_unlock_irqrestore(&task->task_state_lock, flags);
+                        task->task_done(task);
+                } else
+                        spin_unlock_irqrestore(&task->task_state_lock, flags);
+        }
+
+        if (isci_request != NULL) {
+                spin_lock_irqsave(&isci_host->scic_lock, flags);
+                list_del_init(&isci_request->dev_node);
+                spin_unlock_irqrestore(&isci_host->scic_lock, flags);
+        }
+}
+
+/**
+ * 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;
+        enum isci_request_status request_status;
+        unsigned long     flags;
+        unsigned long     termination_completed = 1;
+        struct completion *io_request_completion;
+        struct sas_task   *task;
+
+        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;
+
+        task = (isci_request->ttype == io_task)
+                ? isci_request_access_task(isci_request)
+                : NULL;
+
+        /* 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. */
+                        #define TERMINATION_TIMEOUT_MSEC 500
+                        termination_completed
+                                = wait_for_completion_timeout(
+                                   io_request_completion,
+                                   msecs_to_jiffies(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.
+                                         *
+                                         * Set the request state to "dead",
+                                         * and clear the task pointer so that
+                                         * an actual completion event callback
+                                         * doesn't do anything.
+                                         */
+                                        isci_request->status = dead;
+                                        isci_request->io_request_completion
+                                                = NULL;
+
+                                        if (isci_request->ttype == io_task) {
+
+                                                /* Break links with the
+                                                * sas_task.
+                                                */
+                                                isci_request->ttype_ptr.io_task_ptr
+                                                        = NULL;
+                                        }
+                                } 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);
+                        request_status = isci_request->status;
+
+                        if ((isci_request->ttype == io_task) /* TMFs are in their own thread */
+                            && ((request_status == aborted)
+                                || (request_status == aborting)
+                                || (request_status == terminating)
+                                || (request_status == completed)
+                                || (request_status == dead)
+                                )
+                            ) {
+
+                                /* The completion routine won't free a request in
+                                 * the aborted/aborting/etc. states, so we do
+                                 * it here.
+                                 */
+                                needs_cleanup_handling = true;
+                        }
+                        spin_unlock_irqrestore(&isci_request->state_lock, flags);
+
+                }
+                if (needs_cleanup_handling)
+                        isci_request_cleanup_completed_loiterer(
+                                ihost, idev, isci_request, task);
+        }
+}
+
+/**
+ * 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,
+                        ireq->ttype == io_task ? 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.
@@ -399,7 +824,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);
+        isci_task_build_tmf(&tmf, isci_tmf_ssp_lun_reset, NULL, NULL);
 
         #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);
@@ -416,46 +841,85 @@ static int isci_task_send_lu_reset_sas(
         return ret;
 }
 
-int isci_task_lu_reset(struct domain_device *dev, u8 *lun)
+static int isci_task_send_lu_reset_sata(struct isci_host *ihost,
+                                 struct isci_remote_device *idev, u8 *lun)
 {
-        struct isci_host *ihost = dev_to_ihost(dev);
-        struct isci_remote_device *idev;
+        int ret = TMF_RESP_FUNC_FAILED;
+        struct isci_tmf tmf;
+
+        /* Send the soft reset to the target */
+        #define ISCI_SRST_TIMEOUT_MS 25000 /* 25 second timeout. */
+        isci_task_build_tmf(&tmf, isci_tmf_sata_srst_high, NULL, NULL);
+
+        ret = isci_task_execute_tmf(ihost, idev, &tmf, ISCI_SRST_TIMEOUT_MS);
+
+        if (ret != TMF_RESP_FUNC_COMPLETE) {
+                dev_dbg(&ihost->pdev->dev,
+                         "%s: Assert SRST failed (%p) = %x",
+                         __func__, idev, ret);
+
+                /* Return the failure so that the LUN reset is escalated
+                 * to a target reset.
+                 */
+        }
+        return ret;
+}
+
+/**
+ * isci_task_lu_reset() - This function is one of the SAS Domain Template
+ *    functions. This is one of the Task Management functoins called by libsas,
+ *    to reset the given lun. Note the assumption that while this call is
+ *    executing, no I/O will be sent by the host to the device.
+ * @lun: This parameter specifies the lun to be reset.
+ *
+ * status, zero indicates success.
+ */
+int isci_task_lu_reset(struct domain_device *domain_device, u8 *lun)
+{
+        struct isci_host *isci_host = dev_to_ihost(domain_device);
+        struct isci_remote_device *isci_device;
         unsigned long flags;
-        int ret = TMF_RESP_FUNC_COMPLETE;
+        int ret;
 
-        spin_lock_irqsave(&ihost->scic_lock, flags);
-        idev = isci_get_device(dev->lldd_dev);
-        spin_unlock_irqrestore(&ihost->scic_lock, flags);
+        spin_lock_irqsave(&isci_host->scic_lock, flags);
+        isci_device = isci_lookup_device(domain_device);
+        spin_unlock_irqrestore(&isci_host->scic_lock, flags);
 
-        dev_dbg(&ihost->pdev->dev,
+        dev_dbg(&isci_host->pdev->dev,
                 "%s: domain_device=%p, isci_host=%p; isci_device=%p\n",
-                __func__, dev, ihost, idev);
+                 __func__, domain_device, isci_host, isci_device);
 
-        if (!idev) {
-                /* If the device is gone, escalate to I_T_Nexus_Reset. */
-                dev_dbg(&ihost->pdev->dev, "%s: No dev\n", __func__);
+        if (isci_device)
+                set_bit(IDEV_EH, &isci_device->flags);
 
+        /* If there is a device reset pending on any request in the
+         * device's list, fail this LUN reset request in order to
+         * escalate to the device reset.
+         */
+        if (!isci_device ||
+            isci_device_is_reset_pending(isci_host, isci_device)) {
+                dev_dbg(&isci_host->pdev->dev,
+                         "%s: No dev (%p), or "
+                         "RESET PENDING: domain_device=%p\n",
+                         __func__, isci_device, domain_device);
                 ret = TMF_RESP_FUNC_FAILED;
                 goto out;
         }
 
-        /* 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);
-        }
+        /* Send the task management part of the reset. */
+        if (sas_protocol_ata(domain_device->tproto)) {
+                ret = isci_task_send_lu_reset_sata(isci_host, isci_device, lun);
+        } 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);
+
  out:
-        isci_put_device(idev);
+        isci_put_device(isci_device);
         return ret;
 }
 
@@ -476,6 +940,63 @@ 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.
@@ -484,20 +1005,22 @@ int isci_task_clear_nexus_ha(struct sas_ha_struct *ha)
  */
 int isci_task_abort_task(struct sas_task *task)
 {
-        struct isci_host *ihost = dev_to_ihost(task->dev);
+        struct isci_host *isci_host = dev_to_ihost(task->dev);
         DECLARE_COMPLETION_ONSTACK(aborted_io_completion);
         struct isci_request       *old_request = NULL;
-        struct isci_remote_device *idev = NULL;
+        enum isci_request_status  old_state;
+        struct isci_remote_device *isci_device = NULL;
         struct isci_tmf           tmf;
         int                       ret = TMF_RESP_FUNC_FAILED;
         unsigned long             flags;
+        bool                      any_dev_reset = false;
 
         /* 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(&ihost->scic_lock, flags);
+        spin_lock_irqsave(&isci_host->scic_lock, flags);
         spin_lock(&task->task_state_lock);
 
         old_request = task->lldd_task;
@@ -506,108 +1029,171 @@ 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)
-                idev = isci_get_device(task->dev->lldd_dev);
+                isci_device = isci_lookup_device(task->dev);
 
         spin_unlock(&task->task_state_lock);
-        spin_unlock_irqrestore(&ihost->scic_lock, flags);
+        spin_unlock_irqrestore(&isci_host->scic_lock, flags);
 
-        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 (!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
-                * was successful.
-                */
-                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);
+        dev_dbg(&isci_host->pdev->dev,
+                "%s: task = %p\n", __func__, task);
 
-                ret = TMF_RESP_FUNC_COMPLETE;
+        if (!isci_device || !old_request)
+                goto out;
 
-                dev_warn(&ihost->pdev->dev,
-                         "%s: abort task not needed for %p\n",
-                         __func__, task);
+        set_bit(IDEV_EH, &isci_device->flags);
+
+        /* This version of the driver will fail abort requests for
+         * SATA/STP.  Failing the abort request this way will cause the
+         * SCSI error handler thread to escalate to LUN reset
+         */
+        if (sas_protocol_ata(task->task_proto)) {
+                dev_dbg(&isci_host->pdev->dev,
+                            " task %p is for a STP/SATA device;"
+                            " returning TMF_RESP_FUNC_FAILED\n"
+                            " to cause a LUN reset...\n", task);
                 goto out;
         }
-        /* 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;
+
+        dev_dbg(&isci_host->pdev->dev,
+                "%s: old_request == %p\n", __func__, old_request);
+
+        any_dev_reset = isci_device_is_reset_pending(isci_host, isci_device);
+
+        spin_lock_irqsave(&task->task_state_lock, flags);
+
+        any_dev_reset = any_dev_reset || (task->task_state_flags & SAS_TASK_NEED_DEV_RESET);
+
+        /* If the extraction of the request reference from the task
+         * failed, then the request has been completed (or if there is a
+         * pending reset then this abort request function must be failed
+         * in order to escalate to the target reset).
+         */
+        if ((old_request == NULL) || any_dev_reset) {
+
+                /* If the device reset task flag is set, fail the task
+                 * management request.  Otherwise, the original request
+                 * has completed.
+                 */
+                if (any_dev_reset) {
+
+                        /* Turn off the task's DONE to make sure this
+                         * task is escalated to a target reset.
+                         */
+                        task->task_state_flags &= ~SAS_TASK_STATE_DONE;
+
+                        /* Make the reset happen as soon as possible. */
+                        task->task_state_flags |= SAS_TASK_NEED_DEV_RESET;
+
+                        spin_unlock_irqrestore(&task->task_state_lock, flags);
+
+                        /* Fail the task management request in order to
+                         * escalate to the target reset.
+                         */
+                        ret = TMF_RESP_FUNC_FAILED;
+
+                        dev_dbg(&isci_host->pdev->dev,
+                                "%s: Failing task abort in order to "
+                                "escalate to target reset because\n"
+                                "SAS_TASK_NEED_DEV_RESET is set for "
+                                "task %p on dev %p\n",
+                                __func__, task, isci_device);
+
+
+                } else {
+                        /* 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
+                         * was sucessful.
+                         */
+                        isci_set_task_doneflags(task);
+
+                        spin_unlock_irqrestore(&task->task_state_lock, flags);
+
+                        ret = TMF_RESP_FUNC_COMPLETE;
+
+                        dev_dbg(&isci_host->pdev->dev,
+                                "%s: abort task not needed for %p\n",
+                                __func__, task);
+                }
                 goto out;
+        } else {
+                spin_unlock_irqrestore(&task->task_state_lock, flags);
         }
-        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(IDEV_GONE, &idev->flags)) {
+        spin_lock_irqsave(&isci_host->scic_lock, flags);
 
-                spin_unlock_irqrestore(&ihost->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)) {
 
-                /* No task to send, so explicitly resume the device here */
-                isci_remote_device_resume_from_abort(ihost, idev);
+                spin_unlock_irqrestore(&isci_host->scic_lock, flags);
 
-                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));
+                /* 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;
+                goto out;
+        }
+        if (task->task_proto == SAS_PROTOCOL_SMP ||
+            test_bit(IREQ_COMPLETE_IN_TARGET, &old_request->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);
+                spin_unlock_irqrestore(&isci_host->scic_lock, flags);
+
+                dev_dbg(&isci_host->pdev->dev,
+                        "%s: SMP request (%d)"
+                        " or complete_in_target (%d), thus no TMF\n",
+                        __func__, (task->task_proto == SAS_PROTOCOL_SMP),
+                        test_bit(IREQ_COMPLETE_IN_TARGET, &old_request->flags));
+
+                /* Set the state on the task. */
+                isci_task_all_done(task);
 
                 ret = TMF_RESP_FUNC_COMPLETE;
+
+                /* Stopping and SMP devices are not sent a TMF, and are not
+                 * reset, but the outstanding I/O request is terminated below.
+                 */
         } 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(&ihost->scic_lock, flags);
+                spin_unlock_irqrestore(&isci_host->scic_lock, flags);
 
-                /* Send the task management request. */
-                #define ISCI_ABORT_TASK_TIMEOUT_MS 500 /* 1/2 second timeout */
-                ret = isci_task_execute_tmf(ihost, idev, &tmf,
+                #define ISCI_ABORT_TASK_TIMEOUT_MS 500 /* half second timeout. */
+                ret = isci_task_execute_tmf(isci_host, isci_device, &tmf,
                                             ISCI_ABORT_TASK_TIMEOUT_MS);
+
+                if (ret != TMF_RESP_FUNC_COMPLETE)
+                        dev_dbg(&isci_host->pdev->dev,
+                                "%s: isci_task_send_tmf failed\n",
+                                __func__);
         }
-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);
+        if (ret == TMF_RESP_FUNC_COMPLETE) {
+                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);
         return ret;
 }
 
@@ -702,84 +1288,345 @@ isci_task_request_complete(struct isci_host *ihost,
                            enum sci_task_status completion_status)
 {
         struct isci_tmf *tmf = isci_request_access_tmf(ireq);
-        struct completion *tmf_complete = NULL;
+        struct completion *tmf_complete;
 
         dev_dbg(&ihost->pdev->dev,
                 "%s: request = %p, status=%d\n",
                 __func__, ireq, completion_status);
 
+        isci_request_change_state(ireq, completed);
+
+        tmf->status = completion_status;
         set_bit(IREQ_COMPLETE_IN_TARGET, &ireq->flags);
 
-        if (tmf) {
-                tmf->status = completion_status;
-
-                if (tmf->proto == SAS_PROTOCOL_SSP) {
-                        memcpy(&tmf->resp.resp_iu,
-                               &ireq->ssp.rsp,
-                               SSP_RESP_IU_MAX_SIZE);
-                } else if (tmf->proto == SAS_PROTOCOL_SATA) {
-                        memcpy(&tmf->resp.d2h_fis,
-                               &ireq->stp.rsp,
-                               sizeof(struct dev_to_host_fis));
-                }
-                /* PRINT_TMF( ((struct isci_tmf *)request->task)); */
-                tmf_complete = tmf->complete;
+        if (tmf->proto == SAS_PROTOCOL_SSP) {
+                memcpy(&tmf->resp.resp_iu,
+                       &ireq->ssp.rsp,
+                       SSP_RESP_IU_MAX_SIZE);
+        } else if (tmf->proto == SAS_PROTOCOL_SATA) {
+                memcpy(&tmf->resp.d2h_fis,
+                       &ireq->stp.rsp,
+                       sizeof(struct dev_to_host_fis));
         }
+
+        /* PRINT_TMF( ((struct isci_tmf *)request->task)); */
+        tmf_complete = tmf->complete;
+
         sci_controller_complete_io(ihost, ireq->target_device, ireq);
         /* set the 'terminated' flag handle to make sure it cannot be terminated
          *  or completed again.
          */
         set_bit(IREQ_TERMINATED, &ireq->flags);
 
-        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_request_change_state(ireq, unallocated);
+        list_del_init(&ireq->dev_node);
 
         /* The task management part completes last. */
-        if (tmf_complete)
-                complete(tmf_complete);
+        complete(tmf_complete);
+}
+
+static void isci_smp_task_timedout(unsigned long _task)
+{
+        struct sas_task *task = (void *) _task;
+        unsigned long flags;
+
+        spin_lock_irqsave(&task->task_state_lock, flags);
+        if (!(task->task_state_flags & SAS_TASK_STATE_DONE))
+                task->task_state_flags |= SAS_TASK_STATE_ABORTED;
+        spin_unlock_irqrestore(&task->task_state_lock, flags);
+
+        complete(&task->completion);
+}
+
+static void isci_smp_task_done(struct sas_task *task)
+{
+        if (!del_timer(&task->timer))
+                return;
+        complete(&task->completion);
+}
+
+static struct sas_task *isci_alloc_task(void)
+{
+        struct sas_task *task = kzalloc(sizeof(*task), GFP_KERNEL);
+
+        if (task) {
+                INIT_LIST_HEAD(&task->list);
+                spin_lock_init(&task->task_state_lock);
+                task->task_state_flags = SAS_TASK_STATE_PENDING;
+                init_timer(&task->timer);
+                init_completion(&task->completion);
+        }
+
+        return task;
+}
+
+static void isci_free_task(struct isci_host *ihost, struct sas_task  *task)
+{
+        if (task) {
+                BUG_ON(!list_empty(&task->list));
+                kfree(task);
+        }
+}
+
+static int isci_smp_execute_task(struct isci_host *ihost,
+                                 struct domain_device *dev, void *req,
+                                 int req_size, void *resp, int resp_size)
+{
+        int res, retry;
+        struct sas_task *task = NULL;
+
+        for (retry = 0; retry < 3; retry++) {
+                task = isci_alloc_task();
+                if (!task)
+                        return -ENOMEM;
+
+                task->dev = dev;
+                task->task_proto = dev->tproto;
+                sg_init_one(&task->smp_task.smp_req, req, req_size);
+                sg_init_one(&task->smp_task.smp_resp, resp, resp_size);
+
+                task->task_done = isci_smp_task_done;
+
+                task->timer.data = (unsigned long) task;
+                task->timer.function = isci_smp_task_timedout;
+                task->timer.expires = jiffies + 10*HZ;
+                add_timer(&task->timer);
+
+                res = isci_task_execute_task(task, 1, GFP_KERNEL);
+
+                if (res) {
+                        del_timer(&task->timer);
+                        dev_dbg(&ihost->pdev->dev,
+                                "%s: executing SMP task failed:%d\n",
+                                __func__, res);
+                        goto ex_err;
+                }
+
+                wait_for_completion(&task->completion);
+                res = -ECOMM;
+                if ((task->task_state_flags & SAS_TASK_STATE_ABORTED)) {
+                        dev_dbg(&ihost->pdev->dev,
+                                "%s: smp task timed out or aborted\n",
+                                __func__);
+                        isci_task_abort_task(task);
+                        if (!(task->task_state_flags & SAS_TASK_STATE_DONE)) {
+                                dev_dbg(&ihost->pdev->dev,
+                                        "%s: SMP task aborted and not done\n",
+                                        __func__);
+                                goto ex_err;
+                        }
+                }
+                if (task->task_status.resp == SAS_TASK_COMPLETE &&
+                    task->task_status.stat == SAM_STAT_GOOD) {
+                        res = 0;
+                        break;
+                }
+                if (task->task_status.resp == SAS_TASK_COMPLETE &&
+                      task->task_status.stat == SAS_DATA_UNDERRUN) {
+                        /* no error, but return the number of bytes of
+                        * underrun */
+                        res = task->task_status.residual;
+                        break;
+                }
+                if (task->task_status.resp == SAS_TASK_COMPLETE &&
+                      task->task_status.stat == SAS_DATA_OVERRUN) {
+                        res = -EMSGSIZE;
+                        break;
+                } else {
+                        dev_dbg(&ihost->pdev->dev,
+                                "%s: task to dev %016llx response: 0x%x "
+                                "status 0x%x\n", __func__,
+                                SAS_ADDR(dev->sas_addr),
+                                task->task_status.resp,
+                                task->task_status.stat);
+                        isci_free_task(ihost, task);
+                        task = NULL;
+                }
+        }
+ex_err:
+        BUG_ON(retry == 3 && task != NULL);
+        isci_free_task(ihost, task);
+        return res;
+}
+
+#define DISCOVER_REQ_SIZE  16
+#define DISCOVER_RESP_SIZE 56
+
+int isci_smp_get_phy_attached_dev_type(struct isci_host *ihost,
+                                       struct domain_device *dev,
+                                       int phy_id, int *adt)
+{
+        struct smp_resp *disc_resp;
+        u8 *disc_req;
+        int res;
+
+        disc_resp = kzalloc(DISCOVER_RESP_SIZE, GFP_KERNEL);
+        if (!disc_resp)
+                return -ENOMEM;
+
+        disc_req = kzalloc(DISCOVER_REQ_SIZE, GFP_KERNEL);
+        if (disc_req) {
+                disc_req[0] = SMP_REQUEST;
+                disc_req[1] = SMP_DISCOVER;
+                disc_req[9] = phy_id;
+        } else {
+                kfree(disc_resp);
+                return -ENOMEM;
+        }
+        res = isci_smp_execute_task(ihost, dev, disc_req, DISCOVER_REQ_SIZE,
+                                    disc_resp, DISCOVER_RESP_SIZE);
+        if (!res) {
+                if (disc_resp->result != SMP_RESP_FUNC_ACC)
+                        res = disc_resp->result;
+                else
+                        *adt = disc_resp->disc.attached_dev_type;
+        }
+        kfree(disc_req);
+        kfree(disc_resp);
+
+        return res;
+}
+
+static void isci_wait_for_smp_phy_reset(struct isci_remote_device *idev, int phy_num)
+{
+        struct domain_device *dev = idev->domain_dev;
+        struct isci_port *iport = idev->isci_port;
+        struct isci_host *ihost = iport->isci_host;
+        int res, iteration = 0, attached_device_type;
+        #define STP_WAIT_MSECS 25000
+        unsigned long tmo = msecs_to_jiffies(STP_WAIT_MSECS);
+        unsigned long deadline = jiffies + tmo;
+        enum {
+                SMP_PHYWAIT_PHYDOWN,
+                SMP_PHYWAIT_PHYUP,
+                SMP_PHYWAIT_DONE
+        } phy_state = SMP_PHYWAIT_PHYDOWN;
+
+        /* While there is time, wait for the phy to go away and come back */
+        while (time_is_after_jiffies(deadline) && phy_state != SMP_PHYWAIT_DONE) {
+                int event = atomic_read(&iport->event);
+
+                ++iteration;
+
+                tmo = wait_event_timeout(ihost->eventq,
+                                         event != atomic_read(&iport->event) ||
+                                         !test_bit(IPORT_BCN_BLOCKED, &iport->flags),
+                                         tmo);
+                /* link down, stop polling */
+                if (!test_bit(IPORT_BCN_BLOCKED, &iport->flags))
+                        break;
+
+                dev_dbg(&ihost->pdev->dev,
+                        "%s: iport %p, iteration %d,"
+                        " phase %d: time_remaining %lu, bcns = %d\n",
+                        __func__, iport, iteration, phy_state,
+                        tmo, test_bit(IPORT_BCN_PENDING, &iport->flags));
+
+                res = isci_smp_get_phy_attached_dev_type(ihost, dev, phy_num,
+                                                         &attached_device_type);
+                tmo = deadline - jiffies;
+
+                if (res) {
+                        dev_dbg(&ihost->pdev->dev,
+                                 "%s: iteration %d, phase %d:"
+                                 " SMP error=%d, time_remaining=%lu\n",
+                                 __func__, iteration, phy_state, res, tmo);
+                        break;
+                }
+                dev_dbg(&ihost->pdev->dev,
+                        "%s: iport %p, iteration %d,"
+                        " phase %d: time_remaining %lu, bcns = %d, "
+                        "attdevtype = %x\n",
+                        __func__, iport, iteration, phy_state,
+                        tmo, test_bit(IPORT_BCN_PENDING, &iport->flags),
+                        attached_device_type);
+
+                switch (phy_state) {
+                case SMP_PHYWAIT_PHYDOWN:
+                        /* Has the device gone away? */
+                        if (!attached_device_type)
+                                phy_state = SMP_PHYWAIT_PHYUP;
+
+                        break;
+
+                case SMP_PHYWAIT_PHYUP:
+                        /* Has the device come back? */
+                        if (attached_device_type)
+                                phy_state = SMP_PHYWAIT_DONE;
+                        break;
+
+                case SMP_PHYWAIT_DONE:
+                        break;
+                }
+
+        }
+        dev_dbg(&ihost->pdev->dev, "%s: done\n",  __func__);
 }
 
 static int isci_reset_device(struct isci_host *ihost,
-                             struct domain_device *dev,
                              struct isci_remote_device *idev)
 {
-        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;
+        struct sas_phy *phy = sas_find_local_phy(idev->domain_dev);
+        struct isci_port *iport = idev->isci_port;
+        enum sci_status status;
+        unsigned long flags;
+        int rc;
 
         dev_dbg(&ihost->pdev->dev, "%s: idev %p\n", __func__, idev);
 
-        /* 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;
+        spin_lock_irqsave(&ihost->scic_lock, flags);
+        status = sci_remote_device_reset(idev);
+        if (status != SCI_SUCCESS) {
+                spin_unlock_irqrestore(&ihost->scic_lock, flags);
+
+                dev_dbg(&ihost->pdev->dev,
+                         "%s: sci_remote_device_reset(%p) returned %d!\n",
+                         __func__, idev, status);
+
+                return TMF_RESP_FUNC_FAILED;
         }
-        /* 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];
+        spin_unlock_irqrestore(&ihost->scic_lock, flags);
 
-                        reset_stat = isci_port_perform_hard_reset(ihost, iport,
-                                                                  iphy);
-                } else
-                        reset_stat = sas_phy_reset(phy, !dev_is_sata(dev));
+        /* Make sure all pending requests are able to be fully terminated. */
+        isci_device_clear_reset_pending(ihost, idev);
+
+        /* If this is a device on an expander, disable BCN processing. */
+        if (!scsi_is_sas_phy_local(phy))
+                set_bit(IPORT_BCN_BLOCKED, &iport->flags);
+
+        rc = sas_phy_reset(phy, true);
+
+        /* 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 this is a device on an expander, bring the phy back up. */
+        if (!scsi_is_sas_phy_local(phy)) {
+                /* A phy reset will cause the device to go away then reappear.
+                 * Since libsas will take action on incoming BCNs (eg. remove
+                 * a device going through an SMP phy-control driven reset),
+                 * we need to wait until the phy comes back up before letting
+                 * discovery proceed in libsas.
+                 */
+                isci_wait_for_smp_phy_reset(idev, phy->number);
+
+                spin_lock_irqsave(&ihost->scic_lock, flags);
+                isci_port_bcn_enable(ihost, idev->isci_port);
+                spin_unlock_irqrestore(&ihost->scic_lock, flags);
         }
-        /* 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, reset_stat=%d.\n",
-                __func__, idev, reset_stat);
- out:
-        sas_put_local_phy(phy);
+        if (status != SCI_SUCCESS) {
+                dev_dbg(&ihost->pdev->dev,
+                         "%s: sci_remote_device_reset_complete(%p) "
+                         "returned %d!\n", __func__, idev, status);
+        }
+
+        dev_dbg(&ihost->pdev->dev, "%s: idev %p complete.\n", __func__, idev);
+
         return rc;
 }
 
@@ -791,18 +1638,38 @@ int isci_task_I_T_nexus_reset(struct domain_device *dev)
         int ret;
 
         spin_lock_irqsave(&ihost->scic_lock, flags);
-        idev = isci_get_device(dev->lldd_dev);
+        idev = isci_lookup_device(dev);
+        spin_unlock_irqrestore(&ihost->scic_lock, flags);
+
+        if (!idev || !test_bit(IDEV_EH, &idev->flags)) {
+                ret = TMF_RESP_FUNC_COMPLETE;
+                goto out;
+        }
+
+        ret = isci_reset_device(ihost, idev);
+ out:
+        isci_put_device(idev);
+        return ret;
+}
+
+int isci_bus_reset_handler(struct scsi_cmnd *cmd)
+{
+        struct domain_device *dev = sdev_to_domain_dev(cmd->device);
+        struct isci_host *ihost = dev_to_ihost(dev);
+        struct isci_remote_device *idev;
+        unsigned long flags;
+        int ret;
+
+        spin_lock_irqsave(&ihost->scic_lock, flags);
+        idev = isci_lookup_device(dev);
         spin_unlock_irqrestore(&ihost->scic_lock, flags);
 
         if (!idev) {
-                /* XXX: need to cleanup any ireqs targeting this
-                 * domain_device
-                 */
                 ret = TMF_RESP_FUNC_COMPLETE;
                 goto out;
         }
 
-        ret = isci_reset_device(ihost, dev, idev);
+        ret = isci_reset_device(ihost, idev);
  out:
         isci_put_device(idev);
         return ret;
diff --git a/drivers/scsi/isci/task.h b/drivers/scsi/isci/task.h
index 9c06cbad1d2..4a7fa90287e 100644
--- a/drivers/scsi/isci/task.h
+++ b/drivers/scsi/isci/task.h
@@ -58,11 +58,22 @@
 #include <scsi/sas_ata.h>
 #include "host.h"
 
-#define ISCI_TERMINATION_TIMEOUT_MSEC 500
-
 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.
  *
@@ -73,8 +84,9 @@ enum isci_tmf_function_codes {
         isci_tmf_func_none      = 0,
         isci_tmf_ssp_task_abort = TMF_ABORT_TASK,
         isci_tmf_ssp_lun_reset  = TMF_LU_RESET,
+        isci_tmf_sata_srst_high = TMF_LU_RESET + 0x100, /* Non SCSI */
+        isci_tmf_sata_srst_low  = TMF_LU_RESET + 0x101  /* Non SCSI */
 };
-
 /**
  * struct isci_tmf - This class represents the task management object which
  *    acts as an interface to libsas for processing task management requests
@@ -92,14 +104,24 @@ struct isci_tmf {
         } resp;
         unsigned char lun[8];
         u16 io_tag;
+        struct isci_remote_device *device;
         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)
+static inline void isci_print_tmf(struct isci_tmf *tmf)
 {
         if (SAS_PROTOCOL_SATA == tmf->proto)
-                dev_dbg(&ihost->pdev->dev,
+                dev_dbg(&tmf->device->isci_port->isci_host->pdev->dev,
                         "%s: status = %x\n"
                         "tmf->resp.d2h_fis.status = %x\n"
                         "tmf->resp.d2h_fis.error = %x\n",
@@ -108,7 +130,7 @@ static inline void isci_print_tmf(struct isci_host *ihost, struct isci_tmf *tmf)
                         tmf->resp.d2h_fis.status,
                         tmf->resp.d2h_fis.error);
         else
-                dev_dbg(&ihost->pdev->dev,
+                dev_dbg(&tmf->device->isci_port->isci_host->pdev->dev,
                         "%s: status = %x\n"
                         "tmf->resp.resp_iu.data_present = %x\n"
                         "tmf->resp.resp_iu.status = %x\n"
@@ -187,4 +209,159 @@ int isci_queuecommand(
         struct scsi_cmnd *scsi_cmd,
         void (*donefunc)(struct scsi_cmnd *));
 
+int isci_bus_reset_handler(struct scsi_cmnd *cmd);
+
+/**
+ * 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 */
+};
+
+static inline void isci_set_task_doneflags(
+        struct sas_task *task)
+{
+        /* Since no futher action will be taken on this task,
+         * make sure to mark it complete from the lldd perspective.
+         */
+        task->task_state_flags |= SAS_TASK_STATE_DONE;
+        task->task_state_flags &= ~SAS_TASK_AT_INITIATOR;
+        task->task_state_flags &= ~SAS_TASK_STATE_PENDING;
+}
+/**
+ * isci_task_all_done() - This function clears the task bits to indicate the
+ *    LLDD is done with the task.
+ *
+ *
+ */
+static inline void isci_task_all_done(
+        struct sas_task *task)
+{
+        unsigned long flags;
+
+        /* Since no futher action will be taken on this task,
+         * make sure to mark it complete from the lldd perspective.
+         */
+        spin_lock_irqsave(&task->task_state_lock, flags);
+        isci_set_task_doneflags(task);
+        spin_unlock_irqrestore(&task->task_state_lock, flags);
+}
+
+/**
+ * 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_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) */
+                isci_set_task_doneflags(task);
+                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;
+
+}
+/**
+* isci_execpath_callback() - This function is called from the task
+* execute path when the task needs to callback libsas about the submit-time
+* task failure.  The callback occurs either through the task's done function
+* or through sas_task_abort.  In the case of regular non-discovery SATA/STP I/O
+* requests, libsas takes the host lock before calling execute task.  Therefore
+* in this situation the host lock must be managed before calling the func.
+*
+* @ihost: This parameter is the controller to which the I/O request was sent.
+* @task: This parameter is the I/O request.
+* @func: This parameter is the function to call in the correct context.
+* @status: This parameter is the status code for the completed task.
+*
+*/
+static inline void isci_execpath_callback(struct isci_host *ihost,
+                                          struct sas_task  *task,
+                                          void (*func)(struct sas_task *))
+{
+        struct domain_device *dev = task->dev;
+
+        if (dev_is_sata(dev) && task->uldd_task) {
+                unsigned long flags;
+
+                /* Since we are still in the submit path, and since
+                 * libsas takes the host lock on behalf of SATA
+                 * devices before I/O starts (in the non-discovery case),
+                 * we need to unlock before we can call the callback function.
+                 */
+                raw_local_irq_save(flags);
+                spin_unlock(dev->sata_dev.ap->lock);
+                func(task);
+                spin_lock(dev->sata_dev.ap->lock);
+                raw_local_irq_restore(flags);
+        } else
+                func(task);
+}
 #endif /* !defined(_SCI_TASK_H_) */
diff --git a/drivers/scsi/isci/unsolicited_frame_control.c b/drivers/scsi/isci/unsolicited_frame_control.c
index 04a6d0d59a2..16f88ab939c 100644
--- a/drivers/scsi/isci/unsolicited_frame_control.c
+++ b/drivers/scsi/isci/unsolicited_frame_control.c
@@ -57,19 +57,31 @@
 #include "unsolicited_frame_control.h"
 #include "registers.h"
 
-void sci_unsolicited_frame_control_construct(struct isci_host *ihost)
+int sci_unsolicited_frame_control_construct(struct isci_host *ihost)
 {
         struct sci_unsolicited_frame_control *uf_control = &ihost->uf_control;
         struct sci_unsolicited_frame *uf;
-        dma_addr_t dma = ihost->ufi_dma;
-        void *virt = ihost->ufi_buf;
-        int i;
+        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]);
 
         /*
          * 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.
@@ -81,8 +93,8 @@ void 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 + SCI_UFI_BUF_SIZE;
-        uf_control->headers.array = virt + SCI_UFI_BUF_SIZE;
+        uf_control->headers.physical_address = dma + buf_len;
+        uf_control->headers.array = virt + buf_len;
 
         /*
          * Program the location of the UF address table into the SCU.
@@ -91,8 +103,8 @@ void 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 + SCI_UFI_BUF_SIZE + SCI_UFI_HDR_SIZE;
-        uf_control->address_table.array = virt + SCI_UFI_BUF_SIZE + SCI_UFI_HDR_SIZE;
+        uf_control->address_table.physical_address = dma + buf_len + header_len;
+        uf_control->address_table.array = virt + buf_len + header_len;
         uf_control->get = 0;
 
         /*
@@ -123,6 +135,8 @@ void 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 1bc551ec611..75d896686f5 100644
--- a/drivers/scsi/isci/unsolicited_frame_control.h
+++ b/drivers/scsi/isci/unsolicited_frame_control.h
@@ -257,13 +257,9 @@ 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;
 
-void sci_unsolicited_frame_control_construct(struct isci_host *ihost);
+int 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,