isci: state machine cleanup

This cleans up several areas of the state machine mechanism:

 o Rename sci_base_state_machine_change_state to sci_change_state
 o Remove sci_base_state_machine_get_state function
 o Rename 'state_machine' struct member to 'sm' in client structs
 o Shorten the name of request states
 o Shorten state machine state names as follows:
        SCI_BASE_CONTROLLER_STATE_xxx to SCIC_xxx
        SCI_BASE_PHY_STATE_xxx to SCI_PHY_xxx
        SCIC_SDS_PHY_STARTING_SUBSTATE_xxx to SCI_PHY_SUB_xxx
        SCI_BASE_PORT_STATE_xxx to SCI_PORT_xxx and
        SCIC_SDS_PORT_READY_SUBSTATE_xxx to SCI_PORT_SUB_xxx
        SCI_BASE_REMOTE_DEVICE_STATE_xxx to SCI_DEV_xxx
        SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_xxx to SCI_STP_DEV_xxx
        SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_xxx to SCI_SMP_DEV_xxx
        SCIC_SDS_REMOTE_NODE_CONTEXT_xxx_STATE to SCI_RNC_xxx

Signed-off-by: Edmund Nadolski <edmund.nadolski@intel.com>
Signed-off-by: Dave Jiang <dave.jiang@intel.com>
Signed-off-by: Dan Williams <dan.j.williams@intel.com>

15 files changed, 1076 insertions, 1160 deletions

diff --git a/drivers/scsi/isci/host.c b/drivers/scsi/isci/host.c
index 8801955be213..81ee64c0a4b7 100644
--- a/drivers/scsi/isci/host.c
+++ b/drivers/scsi/isci/host.c
@@ -635,8 +635,7 @@ static void scic_sds_controller_error_handler(struct scic_sds_controller *scic)
                 dev_err(scic_to_dev(scic), "%s: status: %#x\n", __func__,
                         interrupt_status);
 
-                sci_base_state_machine_change_state(&scic->state_machine,
-                                                    SCI_BASE_CONTROLLER_STATE_FAILED);
+                sci_change_state(&scic->sm, SCIC_FAILED);
 
                 return;
         }
@@ -895,14 +894,12 @@ static void scic_sds_controller_transition_to_ready(
 {
         struct isci_host *ihost = scic_to_ihost(scic);
 
-        if (scic->state_machine.current_state_id ==
-            SCI_BASE_CONTROLLER_STATE_STARTING) {
+        if (scic->sm.current_state_id == SCIC_STARTING) {
                 /*
                  * We move into the ready state, because some of the phys/ports
                  * may be up and operational.
                  */
-                sci_base_state_machine_change_state(&scic->state_machine,
-                                                    SCI_BASE_CONTROLLER_STATE_READY);
+                sci_change_state(&scic->sm, SCIC_READY);
 
                 isci_host_start_complete(ihost, status);
         }
@@ -912,18 +909,18 @@ static bool is_phy_starting(struct scic_sds_phy *sci_phy)
 {
         enum scic_sds_phy_states state;
 
-        state = sci_phy->state_machine.current_state_id;
+        state = sci_phy->sm.current_state_id;
         switch (state) {
-        case SCI_BASE_PHY_STATE_STARTING:
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_INITIAL:
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SAS_SPEED_EN:
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_IAF_UF:
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SAS_POWER:
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SATA_POWER:
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SATA_PHY_EN:
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SATA_SPEED_EN:
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SIG_FIS_UF:
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_FINAL:
+        case SCI_PHY_STARTING:
+        case SCI_PHY_SUB_INITIAL:
+        case SCI_PHY_SUB_AWAIT_SAS_SPEED_EN:
+        case SCI_PHY_SUB_AWAIT_IAF_UF:
+        case SCI_PHY_SUB_AWAIT_SAS_POWER:
+        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_SIG_FIS_UF:
+        case SCI_PHY_SUB_FINAL:
                 return true;
         default:
                 return false;
@@ -957,7 +954,7 @@ static enum sci_status scic_sds_controller_start_next_phy(struct scic_sds_contro
 
                 for (index = 0; index < SCI_MAX_PHYS; index++) {
                         sci_phy = &ihost->phys[index].sci;
-                        state = sci_phy->state_machine.current_state_id;
+                        state = sci_phy->sm.current_state_id;
 
                         if (!phy_get_non_dummy_port(sci_phy))
                                 continue;
@@ -968,12 +965,9 @@ static enum sci_status scic_sds_controller_start_next_phy(struct scic_sds_contro
                          * - have an indication of a connected device and it has
                          *   finished the link training process.
                          */
-                        if ((sci_phy->is_in_link_training == false &&
-                             state == SCI_BASE_PHY_STATE_INITIAL) ||
-                            (sci_phy->is_in_link_training == false &&
-                             state == SCI_BASE_PHY_STATE_STOPPED) ||
-                            (sci_phy->is_in_link_training == true &&
-                             is_phy_starting(sci_phy))) {
+                        if ((sci_phy->is_in_link_training == false && state == SCI_PHY_INITIAL) ||
+                            (sci_phy->is_in_link_training == false && state == SCI_PHY_STOPPED) ||
+                            (sci_phy->is_in_link_training == true && is_phy_starting(sci_phy))) {
                                 is_controller_start_complete = false;
                                 break;
                         }
@@ -1059,8 +1053,7 @@ static enum sci_status scic_controller_start(struct scic_sds_controller *scic,
         enum sci_status result;
         u16 index;
 
-        if (scic->state_machine.current_state_id !=
-            SCI_BASE_CONTROLLER_STATE_INITIALIZED) {
+        if (scic->sm.current_state_id != SCIC_INITIALIZED) {
                 dev_warn(scic_to_dev(scic),
                          "SCIC Controller start operation requested in "
                          "invalid state\n");
@@ -1108,8 +1101,7 @@ static enum sci_status scic_controller_start(struct scic_sds_controller *scic,
 
         sci_mod_timer(&scic->timer, timeout);
 
-        sci_base_state_machine_change_state(&scic->state_machine,
-                                            SCI_BASE_CONTROLLER_STATE_STARTING);
+        sci_change_state(&scic->sm, SCIC_STARTING);
 
         return SCI_SUCCESS;
 }
@@ -1279,8 +1271,7 @@ static void isci_host_completion_routine(unsigned long data)
 static enum sci_status scic_controller_stop(struct scic_sds_controller *scic,
                                             u32 timeout)
 {
-        if (scic->state_machine.current_state_id !=
-            SCI_BASE_CONTROLLER_STATE_READY) {
+        if (scic->sm.current_state_id != SCIC_READY) {
                 dev_warn(scic_to_dev(scic),
                          "SCIC Controller stop operation requested in "
                          "invalid state\n");
@@ -1288,8 +1279,7 @@ static enum sci_status scic_controller_stop(struct scic_sds_controller *scic,
         }
 
         sci_mod_timer(&scic->timer, timeout);
-        sci_base_state_machine_change_state(&scic->state_machine,
-                                            SCI_BASE_CONTROLLER_STATE_STOPPING);
+        sci_change_state(&scic->sm, SCIC_STOPPING);
         return SCI_SUCCESS;
 }
 
@@ -1307,17 +1297,16 @@ static enum sci_status scic_controller_stop(struct scic_sds_controller *scic,
  */
 static enum sci_status scic_controller_reset(struct scic_sds_controller *scic)
 {
-        switch (scic->state_machine.current_state_id) {
-        case SCI_BASE_CONTROLLER_STATE_RESET:
-        case SCI_BASE_CONTROLLER_STATE_READY:
-        case SCI_BASE_CONTROLLER_STATE_STOPPED:
-        case SCI_BASE_CONTROLLER_STATE_FAILED:
+        switch (scic->sm.current_state_id) {
+        case SCIC_RESET:
+        case SCIC_READY:
+        case SCIC_STOPPED:
+        case SCIC_FAILED:
                 /*
                  * The reset operation is not a graceful cleanup, just
                  * perform the state transition.
                  */
-                sci_base_state_machine_change_state(&scic->state_machine,
-                                SCI_BASE_CONTROLLER_STATE_RESETTING);
+                sci_change_state(&scic->sm, SCIC_RESETTING);
                 return SCI_SUCCESS;
         default:
                 dev_warn(scic_to_dev(scic),
@@ -1416,15 +1405,14 @@ static void isci_user_parameters_get(
 
 static void scic_sds_controller_initial_state_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_controller *scic = container_of(sm, typeof(*scic), state_machine);
+        struct scic_sds_controller *scic = container_of(sm, typeof(*scic), sm);
 
-        sci_base_state_machine_change_state(&scic->state_machine,
-                        SCI_BASE_CONTROLLER_STATE_RESET);
+        sci_change_state(&scic->sm, SCIC_RESET);
 }
 
 static inline void scic_sds_controller_starting_state_exit(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_controller *scic = container_of(sm, typeof(*scic), state_machine);
+        struct scic_sds_controller *scic = container_of(sm, typeof(*scic), sm);
 
         sci_del_timer(&scic->timer);
 }
@@ -1551,7 +1539,7 @@ static enum sci_status scic_controller_set_interrupt_coalescence(
 
 static void scic_sds_controller_ready_state_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_controller *scic = container_of(sm, typeof(*scic), state_machine);
+        struct scic_sds_controller *scic = container_of(sm, typeof(*scic), sm);
 
         /* set the default interrupt coalescence number and timeout value. */
         scic_controller_set_interrupt_coalescence(scic, 0x10, 250);
@@ -1559,7 +1547,7 @@ static void scic_sds_controller_ready_state_enter(struct sci_base_state_machine
 
 static void scic_sds_controller_ready_state_exit(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_controller *scic = container_of(sm, typeof(*scic), state_machine);
+        struct scic_sds_controller *scic = container_of(sm, typeof(*scic), sm);
 
         /* disable interrupt coalescence. */
         scic_controller_set_interrupt_coalescence(scic, 0, 0);
@@ -1650,7 +1638,7 @@ static enum sci_status scic_sds_controller_stop_devices(struct scic_sds_controll
 
 static void scic_sds_controller_stopping_state_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_controller *scic = container_of(sm, typeof(*scic), state_machine);
+        struct scic_sds_controller *scic = container_of(sm, typeof(*scic), sm);
 
         /* Stop all of the components for this controller */
         scic_sds_controller_stop_phys(scic);
@@ -1660,7 +1648,7 @@ static void scic_sds_controller_stopping_state_enter(struct sci_base_state_machi
 
 static void scic_sds_controller_stopping_state_exit(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_controller *scic = container_of(sm, typeof(*scic), state_machine);
+        struct scic_sds_controller *scic = container_of(sm, typeof(*scic), sm);
 
         sci_del_timer(&scic->timer);
 }
@@ -1691,36 +1679,35 @@ static void scic_sds_controller_reset_hardware(struct scic_sds_controller *scic)
 
 static void scic_sds_controller_resetting_state_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_controller *scic = container_of(sm, typeof(*scic), state_machine);
+        struct scic_sds_controller *scic = container_of(sm, typeof(*scic), sm);
 
         scic_sds_controller_reset_hardware(scic);
-        sci_base_state_machine_change_state(&scic->state_machine,
-                                            SCI_BASE_CONTROLLER_STATE_RESET);
+        sci_change_state(&scic->sm, SCIC_RESET);
 }
 
 static const struct sci_base_state scic_sds_controller_state_table[] = {
-        [SCI_BASE_CONTROLLER_STATE_INITIAL] = {
+        [SCIC_INITIAL] = {
                 .enter_state = scic_sds_controller_initial_state_enter,
         },
-        [SCI_BASE_CONTROLLER_STATE_RESET] = {},
-        [SCI_BASE_CONTROLLER_STATE_INITIALIZING] = {},
-        [SCI_BASE_CONTROLLER_STATE_INITIALIZED] = {},
-        [SCI_BASE_CONTROLLER_STATE_STARTING] = {
+        [SCIC_RESET] = {},
+        [SCIC_INITIALIZING] = {},
+        [SCIC_INITIALIZED] = {},
+        [SCIC_STARTING] = {
                 .exit_state  = scic_sds_controller_starting_state_exit,
         },
-        [SCI_BASE_CONTROLLER_STATE_READY] = {
+        [SCIC_READY] = {
                 .enter_state = scic_sds_controller_ready_state_enter,
                 .exit_state  = scic_sds_controller_ready_state_exit,
         },
-        [SCI_BASE_CONTROLLER_STATE_RESETTING] = {
+        [SCIC_RESETTING] = {
                 .enter_state = scic_sds_controller_resetting_state_enter,
         },
-        [SCI_BASE_CONTROLLER_STATE_STOPPING] = {
+        [SCIC_STOPPING] = {
                 .enter_state = scic_sds_controller_stopping_state_enter,
                 .exit_state = scic_sds_controller_stopping_state_exit,
         },
-        [SCI_BASE_CONTROLLER_STATE_STOPPED] = {},
-        [SCI_BASE_CONTROLLER_STATE_FAILED] = {}
+        [SCIC_STOPPED] = {},
+        [SCIC_FAILED] = {}
 };
 
 static void scic_sds_controller_set_default_config_parameters(struct scic_sds_controller *scic)
@@ -1774,7 +1761,7 @@ static void controller_timeout(unsigned long data)
         struct sci_timer *tmr = (struct sci_timer *)data;
         struct scic_sds_controller *scic = container_of(tmr, typeof(*scic), timer);
         struct isci_host *ihost = scic_to_ihost(scic);
-        struct sci_base_state_machine *sm = &scic->state_machine;
+        struct sci_base_state_machine *sm = &scic->sm;
         unsigned long flags;
 
         spin_lock_irqsave(&ihost->scic_lock, flags);
@@ -1782,10 +1769,10 @@ static void controller_timeout(unsigned long data)
         if (tmr->cancel)
                 goto done;
 
-        if (sm->current_state_id == SCI_BASE_CONTROLLER_STATE_STARTING)
+        if (sm->current_state_id == SCIC_STARTING)
                 scic_sds_controller_transition_to_ready(scic, SCI_FAILURE_TIMEOUT);
-        else if (sm->current_state_id == SCI_BASE_CONTROLLER_STATE_STOPPING) {
-                sci_base_state_machine_change_state(sm, SCI_BASE_CONTROLLER_STATE_FAILED);
+        else if (sm->current_state_id == SCIC_STOPPING) {
+                sci_change_state(sm, SCIC_FAILED);
                 isci_host_stop_complete(ihost, SCI_FAILURE_TIMEOUT);
         } else  /* / @todo Now what do we want to do in this case? */
                 dev_err(scic_to_dev(scic),
@@ -1820,11 +1807,11 @@ static enum sci_status scic_controller_construct(struct scic_sds_controller *sci
         struct isci_host *ihost = scic_to_ihost(scic);
         u8 i;
 
-        sci_base_state_machine_construct(&scic->state_machine,
+        sci_base_state_machine_construct(&scic->sm,
                                          scic_sds_controller_state_table,
-                                         SCI_BASE_CONTROLLER_STATE_INITIAL);
+                                         SCIC_INITIAL);
 
-        sci_base_state_machine_start(&scic->state_machine);
+        sci_base_state_machine_start(&scic->sm);
 
         scic->scu_registers = scu_base;
         scic->smu_registers = smu_base;
@@ -1899,11 +1886,11 @@ int scic_oem_parameters_validate(struct scic_sds_oem_params *oem)
 static enum sci_status scic_oem_parameters_set(struct scic_sds_controller *scic,
                                         union scic_oem_parameters *scic_parms)
 {
-        u32 state = scic->state_machine.current_state_id;
+        u32 state = scic->sm.current_state_id;
 
-        if (state == SCI_BASE_CONTROLLER_STATE_RESET ||
-            state == SCI_BASE_CONTROLLER_STATE_INITIALIZING ||
-            state == SCI_BASE_CONTROLLER_STATE_INITIALIZED) {
+        if (state == SCIC_RESET ||
+            state == SCIC_INITIALIZING ||
+            state == SCIC_INITIALIZED) {
 
                 if (scic_oem_parameters_validate(&scic_parms->sds1))
                         return SCI_FAILURE_INVALID_PARAMETER_VALUE;
@@ -2168,10 +2155,8 @@ static enum sci_status scic_controller_set_mode(struct scic_sds_controller *scic
 {
         enum sci_status status          = SCI_SUCCESS;
 
-        if ((scic->state_machine.current_state_id ==
-                                SCI_BASE_CONTROLLER_STATE_INITIALIZING) ||
-            (scic->state_machine.current_state_id ==
-                                SCI_BASE_CONTROLLER_STATE_INITIALIZED)) {
+        if ((scic->sm.current_state_id == SCIC_INITIALIZING) ||
+            (scic->sm.current_state_id == SCIC_INITIALIZED)) {
                 switch (operating_mode) {
                 case SCI_MODE_SPEED:
                         scic->remote_node_entries      = SCI_MAX_REMOTE_DEVICES;
@@ -2216,20 +2201,19 @@ static void scic_sds_controller_initialize_power_control(struct scic_sds_control
 
 static enum sci_status scic_controller_initialize(struct scic_sds_controller *scic)
 {
-        struct sci_base_state_machine *sm = &scic->state_machine;
+        struct sci_base_state_machine *sm = &scic->sm;
         enum sci_status result = SCI_SUCCESS;
         struct isci_host *ihost = scic_to_ihost(scic);
         u32 index, state;
 
-        if (scic->state_machine.current_state_id !=
-            SCI_BASE_CONTROLLER_STATE_RESET) {
+        if (scic->sm.current_state_id != SCIC_RESET) {
                 dev_warn(scic_to_dev(scic),
                          "SCIC Controller initialize operation requested "
                          "in invalid state\n");
                 return SCI_FAILURE_INVALID_STATE;
         }
 
-        sci_base_state_machine_change_state(sm, SCI_BASE_CONTROLLER_STATE_INITIALIZING);
+        sci_change_state(sm, SCIC_INITIALIZING);
 
         sci_init_timer(&scic->phy_timer, phy_startup_timeout);
 
@@ -2374,10 +2358,10 @@ static enum sci_status scic_controller_initialize(struct scic_sds_controller *sc
 
         /* Advance the controller state machine */
         if (result == SCI_SUCCESS)
-                state = SCI_BASE_CONTROLLER_STATE_INITIALIZED;
+                state = SCIC_INITIALIZED;
         else
-                state = SCI_BASE_CONTROLLER_STATE_FAILED;
-        sci_base_state_machine_change_state(sm, state);
+                state = SCIC_FAILED;
+        sci_change_state(sm, state);
 
         return result;
 }
@@ -2386,11 +2370,11 @@ static enum sci_status scic_user_parameters_set(
         struct scic_sds_controller *scic,
         union scic_user_parameters *scic_parms)
 {
-        u32 state = scic->state_machine.current_state_id;
+        u32 state = scic->sm.current_state_id;
 
-        if (state == SCI_BASE_CONTROLLER_STATE_RESET ||
-            state == SCI_BASE_CONTROLLER_STATE_INITIALIZING ||
-            state == SCI_BASE_CONTROLLER_STATE_INITIALIZED) {
+        if (state == SCIC_RESET ||
+            state == SCIC_INITIALIZING ||
+            state == SCIC_INITIALIZED) {
                 u16 index;
 
                 /*
@@ -2612,15 +2596,15 @@ int isci_host_init(struct isci_host *isci_host)
 void scic_sds_controller_link_up(struct scic_sds_controller *scic,
                 struct scic_sds_port *port, struct scic_sds_phy *phy)
 {
-        switch (scic->state_machine.current_state_id) {
-        case SCI_BASE_CONTROLLER_STATE_STARTING:
+        switch (scic->sm.current_state_id) {
+        case SCIC_STARTING:
                 sci_del_timer(&scic->phy_timer);
                 scic->phy_startup_timer_pending = false;
                 scic->port_agent.link_up_handler(scic, &scic->port_agent,
                                                  port, phy);
                 scic_sds_controller_start_next_phy(scic);
                 break;
-        case SCI_BASE_CONTROLLER_STATE_READY:
+        case SCIC_READY:
                 scic->port_agent.link_up_handler(scic, &scic->port_agent,
                                                  port, phy);
                 break;
@@ -2628,16 +2612,16 @@ void scic_sds_controller_link_up(struct scic_sds_controller *scic,
                 dev_dbg(scic_to_dev(scic),
                         "%s: SCIC Controller linkup event from phy %d in "
                         "unexpected state %d\n", __func__, phy->phy_index,
-                        scic->state_machine.current_state_id);
+                        scic->sm.current_state_id);
         }
 }
 
 void scic_sds_controller_link_down(struct scic_sds_controller *scic,
                 struct scic_sds_port *port, struct scic_sds_phy *phy)
 {
-        switch (scic->state_machine.current_state_id) {
-        case SCI_BASE_CONTROLLER_STATE_STARTING:
-        case SCI_BASE_CONTROLLER_STATE_READY:
+        switch (scic->sm.current_state_id) {
+        case SCIC_STARTING:
+        case SCIC_READY:
                 scic->port_agent.link_down_handler(scic, &scic->port_agent,
                                                    port, phy);
                 break;
@@ -2647,7 +2631,7 @@ void scic_sds_controller_link_down(struct scic_sds_controller *scic,
                         "unexpected state %d\n",
                         __func__,
                         phy->phy_index,
-                        scic->state_machine.current_state_id);
+                        scic->sm.current_state_id);
         }
 }
 
@@ -2663,8 +2647,7 @@ static bool scic_sds_controller_has_remote_devices_stopping(
 
         for (index = 0; index < controller->remote_node_entries; index++) {
                 if ((controller->device_table[index] != NULL) &&
-                   (controller->device_table[index]->state_machine.current_state_id
-                    == SCI_BASE_REMOTE_DEVICE_STATE_STOPPING))
+                   (controller->device_table[index]->sm.current_state_id == SCI_DEV_STOPPING))
                         return true;
         }
 
@@ -2678,19 +2661,17 @@ static bool scic_sds_controller_has_remote_devices_stopping(
 void scic_sds_controller_remote_device_stopped(struct scic_sds_controller *scic,
                                                struct scic_sds_remote_device *sci_dev)
 {
-        if (scic->state_machine.current_state_id !=
-            SCI_BASE_CONTROLLER_STATE_STOPPING) {
+        if (scic->sm.current_state_id != SCIC_STOPPING) {
                 dev_dbg(scic_to_dev(scic),
                         "SCIC Controller 0x%p remote device stopped event "
                         "from device 0x%p in unexpected state %d\n",
                         scic, sci_dev,
-                        scic->state_machine.current_state_id);
+                        scic->sm.current_state_id);
                 return;
         }
 
         if (!scic_sds_controller_has_remote_devices_stopping(scic)) {
-                sci_base_state_machine_change_state(&scic->state_machine,
-                                SCI_BASE_CONTROLLER_STATE_STOPPED);
+                sci_change_state(&scic->sm, SCIC_STOPPED);
         }
 }
 
@@ -2948,8 +2929,7 @@ enum sci_status scic_controller_start_io(
 {
         enum sci_status status;
 
-        if (scic->state_machine.current_state_id !=
-            SCI_BASE_CONTROLLER_STATE_READY) {
+        if (scic->sm.current_state_id != SCIC_READY) {
                 dev_warn(scic_to_dev(scic), "invalid state to start I/O");
                 return SCI_FAILURE_INVALID_STATE;
         }
@@ -2986,8 +2966,7 @@ enum sci_status scic_controller_terminate_request(
 {
         enum sci_status status;
 
-        if (scic->state_machine.current_state_id !=
-            SCI_BASE_CONTROLLER_STATE_READY) {
+        if (scic->sm.current_state_id != SCIC_READY) {
                 dev_warn(scic_to_dev(scic),
                          "invalid state to terminate request\n");
                 return SCI_FAILURE_INVALID_STATE;
@@ -3037,11 +3016,11 @@ enum sci_status scic_controller_complete_io(
         enum sci_status status;
         u16 index;
 
-        switch (scic->state_machine.current_state_id) {
-        case SCI_BASE_CONTROLLER_STATE_STOPPING:
+        switch (scic->sm.current_state_id) {
+        case SCIC_STOPPING:
                 /* XXX: Implement this function */
                 return SCI_FAILURE;
-        case SCI_BASE_CONTROLLER_STATE_READY:
+        case SCIC_READY:
                 status = scic_sds_remote_device_complete_io(scic, rdev, request);
                 if (status != SCI_SUCCESS)
                         return status;
@@ -3060,8 +3039,7 @@ enum sci_status scic_controller_continue_io(struct scic_sds_request *sci_req)
 {
         struct scic_sds_controller *scic = sci_req->owning_controller;
 
-        if (scic->state_machine.current_state_id !=
-            SCI_BASE_CONTROLLER_STATE_READY) {
+        if (scic->sm.current_state_id != SCIC_READY) {
                 dev_warn(scic_to_dev(scic), "invalid state to continue I/O");
                 return SCI_FAILURE_INVALID_STATE;
         }
@@ -3107,8 +3085,7 @@ enum sci_task_status scic_controller_start_task(
 {
         enum sci_status status;
 
-        if (scic->state_machine.current_state_id !=
-            SCI_BASE_CONTROLLER_STATE_READY) {
+        if (scic->sm.current_state_id != SCIC_READY) {
                 dev_warn(scic_to_dev(scic),
                          "%s: SCIC Controller starting task from invalid "
                          "state\n",
diff --git a/drivers/scsi/isci/host.h b/drivers/scsi/isci/host.h
index 4ce39e1803ff..be09765ee1d5 100644
--- a/drivers/scsi/isci/host.h
+++ b/drivers/scsi/isci/host.h
@@ -134,7 +134,7 @@ struct scic_sds_controller {
          * This field contains the information for the base controller state
          * machine.
          */
-        struct sci_base_state_machine state_machine;
+        struct sci_base_state_machine sm;
 
         /**
          * Timer for controller start/stop operations.
@@ -359,7 +359,7 @@ enum scic_sds_controller_states {
         /**
          * Simply the initial state for the base controller state machine.
          */
-        SCI_BASE_CONTROLLER_STATE_INITIAL = 0,
+        SCIC_INITIAL = 0,
 
         /**
          * This state indicates that the controller is reset.  The memory for
@@ -368,7 +368,7 @@ enum scic_sds_controller_states {
          * This state is entered from the INITIAL state.
          * This state is entered from the RESETTING state.
          */
-        SCI_BASE_CONTROLLER_STATE_RESET,
+        SCIC_RESET,
 
         /**
          * This state is typically an action state that indicates the controller
@@ -376,28 +376,28 @@ enum scic_sds_controller_states {
          * are permitted.
          * This state is entered from the RESET state.
          */
-        SCI_BASE_CONTROLLER_STATE_INITIALIZING,
+        SCIC_INITIALIZING,
 
         /**
          * This state indicates that the controller has been successfully
          * initialized.  In this state no new IO operations are permitted.
          * This state is entered from the INITIALIZING state.
          */
-        SCI_BASE_CONTROLLER_STATE_INITIALIZED,
+        SCIC_INITIALIZED,
 
         /**
          * This state indicates the the controller 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 INITIALIZED state.
          */
-        SCI_BASE_CONTROLLER_STATE_STARTING,
+        SCIC_STARTING,
 
         /**
          * This state indicates the controller is now ready.  Thus, the user
          * is able to perform IO operations on the controller.
          * This state is entered from the STARTING state.
          */
-        SCI_BASE_CONTROLLER_STATE_READY,
+        SCIC_READY,
 
         /**
          * This state is typically an action state that indicates the controller
@@ -408,7 +408,7 @@ enum scic_sds_controller_states {
          * This state is entered from the FAILED state.
          * This state is entered from the STOPPED state.
          */
-        SCI_BASE_CONTROLLER_STATE_RESETTING,
+        SCIC_RESETTING,
 
         /**
          * This state indicates that the controller is in the process of stopping.
@@ -416,14 +416,14 @@ enum scic_sds_controller_states {
          * operations are allowed to complete.
          * This state is entered from the READY state.
          */
-        SCI_BASE_CONTROLLER_STATE_STOPPING,
+        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.
          */
-        SCI_BASE_CONTROLLER_STATE_STOPPED,
+        SCIC_STOPPED,
 
         /**
          * This state indicates that the controller could not successfully be
@@ -433,10 +433,7 @@ enum scic_sds_controller_states {
          * This state is entered from the STOPPING state.
          * This state is entered from the RESETTING state.
          */
-        SCI_BASE_CONTROLLER_STATE_FAILED,
-
-        SCI_BASE_CONTROLLER_MAX_STATES
-
+        SCIC_FAILED,
 };
 
 
diff --git a/drivers/scsi/isci/phy.c b/drivers/scsi/isci/phy.c
index fc196e389ffb..9de21c719351 100644
--- a/drivers/scsi/isci/phy.c
+++ b/drivers/scsi/isci/phy.c
@@ -249,8 +249,7 @@ scic_sds_phy_link_layer_initialization(struct scic_sds_phy *sci_phy,
         writel(0x1F4, &sci_phy->link_layer_registers->link_layer_hang_detection_timeout);
 
         /* We can exit the initial state to the stopped state */
-        sci_base_state_machine_change_state(&sci_phy->state_machine,
-                                            SCI_BASE_PHY_STATE_STOPPED);
+        sci_change_state(&sci_phy->sm, SCI_PHY_STOPPED);
 
         return SCI_SUCCESS;
 }
@@ -273,8 +272,7 @@ static void phy_sata_timeout(unsigned long data)
                  __func__,
                  sci_phy);
 
-        sci_base_state_machine_change_state(&sci_phy->state_machine,
-                                            SCI_BASE_PHY_STATE_STARTING);
+        sci_change_state(&sci_phy->sm, SCI_PHY_STARTING);
 done:
         spin_unlock_irqrestore(&ihost->scic_lock, flags);
 }
@@ -342,8 +340,7 @@ enum sci_status scic_sds_phy_initialize(
         /*
          * There is nothing that needs to be done in this state just
          * transition to the stopped state. */
-        sci_base_state_machine_change_state(&sci_phy->state_machine,
-                                            SCI_BASE_PHY_STATE_STOPPED);
+        sci_change_state(&sci_phy->sm, SCI_PHY_STOPPED);
 
         return SCI_SUCCESS;
 }
@@ -436,34 +433,33 @@ void scic_sds_phy_get_protocols(struct scic_sds_phy *sci_phy,
 
 enum sci_status scic_sds_phy_start(struct scic_sds_phy *sci_phy)
 {
-        enum scic_sds_phy_states state = sci_phy->state_machine.current_state_id;
+        enum scic_sds_phy_states state = sci_phy->sm.current_state_id;
 
-        if (state != SCI_BASE_PHY_STATE_STOPPED) {
+        if (state != SCI_PHY_STOPPED) {
                 dev_dbg(sciphy_to_dev(sci_phy),
                          "%s: in wrong state: %d\n", __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
         }
 
-        sci_base_state_machine_change_state(&sci_phy->state_machine,
-                                            SCI_BASE_PHY_STATE_STARTING);
+        sci_change_state(&sci_phy->sm, SCI_PHY_STARTING);
         return SCI_SUCCESS;
 }
 
 enum sci_status scic_sds_phy_stop(struct scic_sds_phy *sci_phy)
 {
-        enum scic_sds_phy_states state = sci_phy->state_machine.current_state_id;
+        enum scic_sds_phy_states state = sci_phy->sm.current_state_id;
 
         switch (state) {
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_INITIAL:
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_OSSP_EN:
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SAS_SPEED_EN:
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SAS_POWER:
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SATA_POWER:
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SATA_PHY_EN:
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SATA_SPEED_EN:
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SIG_FIS_UF:
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_FINAL:
-        case SCI_BASE_PHY_STATE_READY:
+        case SCI_PHY_SUB_INITIAL:
+        case SCI_PHY_SUB_AWAIT_OSSP_EN:
+        case SCI_PHY_SUB_AWAIT_SAS_SPEED_EN:
+        case SCI_PHY_SUB_AWAIT_SAS_POWER:
+        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_SIG_FIS_UF:
+        case SCI_PHY_SUB_FINAL:
+        case SCI_PHY_READY:
                 break;
         default:
                 dev_dbg(sciphy_to_dev(sci_phy),
@@ -471,32 +467,30 @@ enum sci_status scic_sds_phy_stop(struct scic_sds_phy *sci_phy)
                 return SCI_FAILURE_INVALID_STATE;
         }
 
-        sci_base_state_machine_change_state(&sci_phy->state_machine,
-                                            SCI_BASE_PHY_STATE_STOPPED);
+        sci_change_state(&sci_phy->sm, SCI_PHY_STOPPED);
         return SCI_SUCCESS;
 }
 
 enum sci_status scic_sds_phy_reset(struct scic_sds_phy *sci_phy)
 {
-        enum scic_sds_phy_states state = sci_phy->state_machine.current_state_id;
+        enum scic_sds_phy_states state = sci_phy->sm.current_state_id;
 
-        if (state != SCI_BASE_PHY_STATE_READY) {
+        if (state != SCI_PHY_READY) {
                 dev_dbg(sciphy_to_dev(sci_phy),
                         "%s: in wrong state: %d\n", __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
         }
 
-        sci_base_state_machine_change_state(&sci_phy->state_machine,
-                                            SCI_BASE_PHY_STATE_RESETTING);
+        sci_change_state(&sci_phy->sm, SCI_PHY_RESETTING);
         return SCI_SUCCESS;
 }
 
 enum sci_status scic_sds_phy_consume_power_handler(struct scic_sds_phy *sci_phy)
 {
-        enum scic_sds_phy_states state = sci_phy->state_machine.current_state_id;
+        enum scic_sds_phy_states state = sci_phy->sm.current_state_id;
 
         switch (state) {
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SAS_POWER: {
+        case SCI_PHY_SUB_AWAIT_SAS_POWER: {
                 u32 enable_spinup;
 
                 enable_spinup = readl(&sci_phy->link_layer_registers->notify_enable_spinup_control);
@@ -504,12 +498,11 @@ enum sci_status scic_sds_phy_consume_power_handler(struct scic_sds_phy *sci_phy)
                 writel(enable_spinup, &sci_phy->link_layer_registers->notify_enable_spinup_control);
 
                 /* Change state to the final state this substate machine has run to completion */
-                sci_base_state_machine_change_state(&sci_phy->state_machine,
-                                                    SCIC_SDS_PHY_STARTING_SUBSTATE_FINAL);
+                sci_change_state(&sci_phy->sm, SCI_PHY_SUB_FINAL);
 
                 return SCI_SUCCESS;
         }
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SATA_POWER: {
+        case SCI_PHY_SUB_AWAIT_SATA_POWER: {
                 u32 scu_sas_pcfg_value;
 
                 /* Release the spinup hold state and reset the OOB state machine */
@@ -528,8 +521,7 @@ enum sci_status scic_sds_phy_consume_power_handler(struct scic_sds_phy *sci_phy)
                         &sci_phy->link_layer_registers->phy_configuration);
 
                 /* Change state to the final state this substate machine has run to completion */
-                sci_base_state_machine_change_state(&sci_phy->state_machine,
-                                                    SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SATA_PHY_EN);
+                sci_change_state(&sci_phy->sm, SCI_PHY_SUB_AWAIT_SATA_PHY_EN);
 
                 return SCI_SUCCESS;
         }
@@ -566,10 +558,7 @@ static void scic_sds_phy_start_sas_link_training(
         writel(phy_control,
                 &sci_phy->link_layer_registers->phy_configuration);
 
-        sci_base_state_machine_change_state(
-                &sci_phy->state_machine,
-                SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SAS_SPEED_EN
-                );
+        sci_change_state(&sci_phy->sm, SCI_PHY_SUB_AWAIT_SAS_SPEED_EN);
 
         sci_phy->protocol = SCIC_SDS_PHY_PROTOCOL_SAS;
 }
@@ -585,10 +574,7 @@ static void scic_sds_phy_start_sas_link_training(
 static void scic_sds_phy_start_sata_link_training(
         struct scic_sds_phy *sci_phy)
 {
-        sci_base_state_machine_change_state(
-                &sci_phy->state_machine,
-                SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SATA_POWER
-                );
+        sci_change_state(&sci_phy->sm, SCI_PHY_SUB_AWAIT_SATA_POWER);
 
         sci_phy->protocol = SCIC_SDS_PHY_PROTOCOL_SATA;
 }
@@ -611,17 +597,16 @@ static void scic_sds_phy_complete_link_training(
 {
         sci_phy->max_negotiated_speed = max_link_rate;
 
-        sci_base_state_machine_change_state(&sci_phy->state_machine,
-                                            next_state);
+        sci_change_state(&sci_phy->sm, next_state);
 }
 
 enum sci_status scic_sds_phy_event_handler(struct scic_sds_phy *sci_phy,
                                            u32 event_code)
 {
-        enum scic_sds_phy_states state = sci_phy->state_machine.current_state_id;
+        enum scic_sds_phy_states state = sci_phy->sm.current_state_id;
 
         switch (state) {
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_OSSP_EN:
+        case SCI_PHY_SUB_AWAIT_OSSP_EN:
                 switch (scu_get_event_code(event_code)) {
                 case SCU_EVENT_SAS_PHY_DETECTED:
                         scic_sds_phy_start_sas_link_training(sci_phy);
@@ -640,7 +625,7 @@ enum sci_status scic_sds_phy_event_handler(struct scic_sds_phy *sci_phy,
                         return SCI_FAILURE;
                 }
                 return SCI_SUCCESS;
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SAS_SPEED_EN:
+        case SCI_PHY_SUB_AWAIT_SAS_SPEED_EN:
                 switch (scu_get_event_code(event_code)) {
                 case SCU_EVENT_SAS_PHY_DETECTED:
                         /*
@@ -652,21 +637,21 @@ enum sci_status scic_sds_phy_event_handler(struct scic_sds_phy *sci_phy,
                         scic_sds_phy_complete_link_training(
                                 sci_phy,
                                 SAS_LINK_RATE_1_5_GBPS,
-                                SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_IAF_UF);
+                                SCI_PHY_SUB_AWAIT_IAF_UF);
                         break;
                 case SCU_EVENT_SAS_30:
                 case SCU_EVENT_SAS_30_SSC:
                         scic_sds_phy_complete_link_training(
                                 sci_phy,
                                 SAS_LINK_RATE_3_0_GBPS,
-                                SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_IAF_UF);
+                                SCI_PHY_SUB_AWAIT_IAF_UF);
                         break;
                 case SCU_EVENT_SAS_60:
                 case SCU_EVENT_SAS_60_SSC:
                         scic_sds_phy_complete_link_training(
                                 sci_phy,
                                 SAS_LINK_RATE_6_0_GBPS,
-                                SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_IAF_UF);
+                                SCI_PHY_SUB_AWAIT_IAF_UF);
                         break;
                 case SCU_EVENT_SATA_SPINUP_HOLD:
                         /*
@@ -676,8 +661,7 @@ enum sci_status scic_sds_phy_event_handler(struct scic_sds_phy *sci_phy,
                         break;
                 case SCU_EVENT_LINK_FAILURE:
                         /* Link failure change state back to the starting state */
-                        sci_base_state_machine_change_state(&sci_phy->state_machine,
-                                                            SCI_BASE_PHY_STATE_STARTING);
+                        sci_change_state(&sci_phy->sm, SCI_PHY_STARTING);
                         break;
                 default:
                         dev_warn(sciphy_to_dev(sci_phy),
@@ -689,7 +673,7 @@ enum sci_status scic_sds_phy_event_handler(struct scic_sds_phy *sci_phy,
                         break;
                 }
                 return SCI_SUCCESS;
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_IAF_UF:
+        case SCI_PHY_SUB_AWAIT_IAF_UF:
                 switch (scu_get_event_code(event_code)) {
                 case SCU_EVENT_SAS_PHY_DETECTED:
                         /* Backup the state machine */
@@ -706,8 +690,7 @@ enum sci_status scic_sds_phy_event_handler(struct scic_sds_phy *sci_phy,
                 case SCU_EVENT_LINK_FAILURE:
                 case SCU_EVENT_HARD_RESET_RECEIVED:
                         /* Start the oob/sn state machine over again */
-                        sci_base_state_machine_change_state(&sci_phy->state_machine,
-                                                            SCI_BASE_PHY_STATE_STARTING);
+                        sci_change_state(&sci_phy->sm, SCI_PHY_STARTING);
                         break;
                 default:
                         dev_warn(sciphy_to_dev(sci_phy),
@@ -717,12 +700,11 @@ enum sci_status scic_sds_phy_event_handler(struct scic_sds_phy *sci_phy,
                         return SCI_FAILURE;
                 }
                 return SCI_SUCCESS;
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SAS_POWER:
+        case SCI_PHY_SUB_AWAIT_SAS_POWER:
                 switch (scu_get_event_code(event_code)) {
                 case SCU_EVENT_LINK_FAILURE:
                         /* Link failure change state back to the starting state */
-                        sci_base_state_machine_change_state(&sci_phy->state_machine,
-                                                            SCI_BASE_PHY_STATE_STARTING);
+                        sci_change_state(&sci_phy->sm, SCI_PHY_STARTING);
                         break;
                 default:
                         dev_warn(sciphy_to_dev(sci_phy),
@@ -733,12 +715,11 @@ enum sci_status scic_sds_phy_event_handler(struct scic_sds_phy *sci_phy,
                         return SCI_FAILURE;
                 }
                 return SCI_SUCCESS;
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SATA_POWER:
+        case SCI_PHY_SUB_AWAIT_SATA_POWER:
                 switch (scu_get_event_code(event_code)) {
                 case SCU_EVENT_LINK_FAILURE:
                         /* Link failure change state back to the starting state */
-                        sci_base_state_machine_change_state(&sci_phy->state_machine,
-                                                            SCI_BASE_PHY_STATE_STARTING);
+                        sci_change_state(&sci_phy->sm, SCI_PHY_STARTING);
                         break;
                 case SCU_EVENT_SATA_SPINUP_HOLD:
                         /* These events are received every 10ms and are
@@ -762,12 +743,11 @@ enum sci_status scic_sds_phy_event_handler(struct scic_sds_phy *sci_phy,
                         return SCI_FAILURE;
                 }
                 return SCI_SUCCESS;
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SATA_PHY_EN:
+        case SCI_PHY_SUB_AWAIT_SATA_PHY_EN:
                 switch (scu_get_event_code(event_code)) {
                 case SCU_EVENT_LINK_FAILURE:
                         /* Link failure change state back to the starting state */
-                        sci_base_state_machine_change_state(&sci_phy->state_machine,
-                                                            SCI_BASE_PHY_STATE_STARTING);
+                        sci_change_state(&sci_phy->sm, SCI_PHY_STARTING);
                         break;
                 case SCU_EVENT_SATA_SPINUP_HOLD:
                         /* These events might be received since we dont know how many may be in
@@ -778,8 +758,7 @@ enum sci_status scic_sds_phy_event_handler(struct scic_sds_phy *sci_phy,
                         sci_phy->protocol = SCIC_SDS_PHY_PROTOCOL_SATA;
 
                         /* We have received the SATA PHY notification change state */
-                        sci_base_state_machine_change_state(&sci_phy->state_machine,
-                                                            SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SATA_SPEED_EN);
+                        sci_change_state(&sci_phy->sm, SCI_PHY_SUB_AWAIT_SATA_SPEED_EN);
                         break;
                 case SCU_EVENT_SAS_PHY_DETECTED:
                         /* There has been a change in the phy type before OOB/SN for the
@@ -797,7 +776,7 @@ enum sci_status scic_sds_phy_event_handler(struct scic_sds_phy *sci_phy,
                         return SCI_FAILURE;;
                 }
                 return SCI_SUCCESS;
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SATA_SPEED_EN:
+        case SCI_PHY_SUB_AWAIT_SATA_SPEED_EN:
                 switch (scu_get_event_code(event_code)) {
                 case SCU_EVENT_SATA_PHY_DETECTED:
                         /*
@@ -809,26 +788,25 @@ enum sci_status scic_sds_phy_event_handler(struct scic_sds_phy *sci_phy,
                         scic_sds_phy_complete_link_training(
                                 sci_phy,
                                 SAS_LINK_RATE_1_5_GBPS,
-                                SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SIG_FIS_UF);
+                                SCI_PHY_SUB_AWAIT_SIG_FIS_UF);
                         break;
                 case SCU_EVENT_SATA_30:
                 case SCU_EVENT_SATA_30_SSC:
                         scic_sds_phy_complete_link_training(
                                 sci_phy,
                                 SAS_LINK_RATE_3_0_GBPS,
-                                SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SIG_FIS_UF);
+                                SCI_PHY_SUB_AWAIT_SIG_FIS_UF);
                         break;
                 case SCU_EVENT_SATA_60:
                 case SCU_EVENT_SATA_60_SSC:
                         scic_sds_phy_complete_link_training(
                                 sci_phy,
                                 SAS_LINK_RATE_6_0_GBPS,
-                                SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SIG_FIS_UF);
+                                SCI_PHY_SUB_AWAIT_SIG_FIS_UF);
                         break;
                 case SCU_EVENT_LINK_FAILURE:
                         /* Link failure change state back to the starting state */
-                        sci_base_state_machine_change_state(&sci_phy->state_machine,
-                                                            SCI_BASE_PHY_STATE_STARTING);
+                        sci_change_state(&sci_phy->sm, SCI_PHY_STARTING);
                         break;
                 case SCU_EVENT_SAS_PHY_DETECTED:
                         /*
@@ -846,18 +824,16 @@ enum sci_status scic_sds_phy_event_handler(struct scic_sds_phy *sci_phy,
                 }
 
                 return SCI_SUCCESS;
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SIG_FIS_UF:
+        case SCI_PHY_SUB_AWAIT_SIG_FIS_UF:
                 switch (scu_get_event_code(event_code)) {
                 case SCU_EVENT_SATA_PHY_DETECTED:
                         /* Backup the state machine */
-                        sci_base_state_machine_change_state(&sci_phy->state_machine,
-                                                            SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SATA_SPEED_EN);
+                        sci_change_state(&sci_phy->sm, SCI_PHY_SUB_AWAIT_SATA_SPEED_EN);
                         break;
 
                 case SCU_EVENT_LINK_FAILURE:
                         /* Link failure change state back to the starting state */
-                        sci_base_state_machine_change_state(&sci_phy->state_machine,
-                                                            SCI_BASE_PHY_STATE_STARTING);
+                        sci_change_state(&sci_phy->sm, SCI_PHY_STARTING);
                         break;
 
                 default:
@@ -870,12 +846,11 @@ enum sci_status scic_sds_phy_event_handler(struct scic_sds_phy *sci_phy,
                         return SCI_FAILURE;
                 }
                 return SCI_SUCCESS;
-        case SCI_BASE_PHY_STATE_READY:
+        case SCI_PHY_READY:
                 switch (scu_get_event_code(event_code)) {
                 case SCU_EVENT_LINK_FAILURE:
                         /* Link failure change state back to the starting state */
-                        sci_base_state_machine_change_state(&sci_phy->state_machine,
-                                                            SCI_BASE_PHY_STATE_STARTING);
+                        sci_change_state(&sci_phy->sm, SCI_PHY_STARTING);
                         break;
                 case SCU_EVENT_BROADCAST_CHANGE:
                         /* Broadcast change received. Notify the port. */
@@ -892,12 +867,11 @@ enum sci_status scic_sds_phy_event_handler(struct scic_sds_phy *sci_phy,
                         return SCI_FAILURE_INVALID_STATE;
                 }
                 return SCI_SUCCESS;
-        case SCI_BASE_PHY_STATE_RESETTING:
+        case SCI_PHY_RESETTING:
                 switch (scu_get_event_code(event_code)) {
                 case SCU_EVENT_HARD_RESET_TRANSMITTED:
                         /* Link failure change state back to the starting state */
-                        sci_base_state_machine_change_state(&sci_phy->state_machine,
-                                                            SCI_BASE_PHY_STATE_STARTING);
+                        sci_change_state(&sci_phy->sm, SCI_PHY_STARTING);
                         break;
                 default:
                         dev_warn(sciphy_to_dev(sci_phy),
@@ -919,12 +893,12 @@ enum sci_status scic_sds_phy_event_handler(struct scic_sds_phy *sci_phy,
 enum sci_status scic_sds_phy_frame_handler(struct scic_sds_phy *sci_phy,
                                            u32 frame_index)
 {
-        enum scic_sds_phy_states state = sci_phy->state_machine.current_state_id;
+        enum scic_sds_phy_states state = sci_phy->sm.current_state_id;
         struct scic_sds_controller *scic = sci_phy->owning_port->owning_controller;
         enum sci_status result;
 
         switch (state) {
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_IAF_UF: {
+        case SCI_PHY_SUB_AWAIT_IAF_UF: {
                 u32 *frame_words;
                 struct sas_identify_frame iaf;
                 struct isci_phy *iphy = sci_phy_to_iphy(sci_phy);
@@ -946,15 +920,14 @@ enum sci_status scic_sds_phy_frame_handler(struct scic_sds_phy *sci_phy,
                                  * state since there are no power requirements for
                                  * expander phys.
                                  */
-                                state = SCIC_SDS_PHY_STARTING_SUBSTATE_FINAL;
+                                state = SCI_PHY_SUB_FINAL;
                         } else {
                                 /* We got the IAF we can now go to the await spinup
                                  * semaphore state
                                  */
-                                state = SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SAS_POWER;
+                                state = SCI_PHY_SUB_AWAIT_SAS_POWER;
                         }
-                        sci_base_state_machine_change_state(&sci_phy->state_machine,
-                                                            state);
+                        sci_change_state(&sci_phy->sm, state);
                         result = SCI_SUCCESS;
                 } else
                         dev_warn(sciphy_to_dev(sci_phy),
@@ -965,7 +938,7 @@ enum sci_status scic_sds_phy_frame_handler(struct scic_sds_phy *sci_phy,
                 scic_sds_controller_release_frame(scic, frame_index);
                 return result;
         }
-        case SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SIG_FIS_UF: {
+        case SCI_PHY_SUB_AWAIT_SIG_FIS_UF: {
                 struct dev_to_host_fis *frame_header;
                 u32 *fis_frame_data;
                 struct isci_phy *iphy = sci_phy_to_iphy(sci_phy);
@@ -989,8 +962,7 @@ enum sci_status scic_sds_phy_frame_handler(struct scic_sds_phy *sci_phy,
                                                                fis_frame_data);
 
                         /* got IAF we can now go to the await spinup semaphore state */
-                        sci_base_state_machine_change_state(&sci_phy->state_machine,
-                                                            SCIC_SDS_PHY_STARTING_SUBSTATE_FINAL);
+                        sci_change_state(&sci_phy->sm, SCI_PHY_SUB_FINAL);
 
                         result = SCI_SUCCESS;
                 } else
@@ -1014,16 +986,15 @@ enum sci_status scic_sds_phy_frame_handler(struct scic_sds_phy *sci_phy,
 
 static void scic_sds_phy_starting_initial_substate_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), state_machine);
+        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), sm);
 
         /* This is just an temporary state go off to the starting state */
-        sci_base_state_machine_change_state(&sci_phy->state_machine,
-                                            SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_OSSP_EN);
+        sci_change_state(&sci_phy->sm, SCI_PHY_SUB_AWAIT_OSSP_EN);
 }
 
 static void scic_sds_phy_starting_await_sas_power_substate_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), state_machine);
+        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), sm);
         struct scic_sds_controller *scic = sci_phy->owning_port->owning_controller;
 
         scic_sds_controller_power_control_queue_insert(scic, sci_phy);
@@ -1031,7 +1002,7 @@ static void scic_sds_phy_starting_await_sas_power_substate_enter(struct sci_base
 
 static void scic_sds_phy_starting_await_sas_power_substate_exit(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), state_machine);
+        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), sm);
         struct scic_sds_controller *scic = sci_phy->owning_port->owning_controller;
 
         scic_sds_controller_power_control_queue_remove(scic, sci_phy);
@@ -1039,7 +1010,7 @@ static void scic_sds_phy_starting_await_sas_power_substate_exit(struct sci_base_
 
 static void scic_sds_phy_starting_await_sata_power_substate_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), state_machine);
+        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), sm);
         struct scic_sds_controller *scic = sci_phy->owning_port->owning_controller;
 
         scic_sds_controller_power_control_queue_insert(scic, sci_phy);
@@ -1047,7 +1018,7 @@ static void scic_sds_phy_starting_await_sata_power_substate_enter(struct sci_bas
 
 static void scic_sds_phy_starting_await_sata_power_substate_exit(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), state_machine);
+        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), sm);
         struct scic_sds_controller *scic = sci_phy->owning_port->owning_controller;
 
         scic_sds_controller_power_control_queue_remove(scic, sci_phy);
@@ -1055,35 +1026,35 @@ static void scic_sds_phy_starting_await_sata_power_substate_exit(struct sci_base
 
 static void scic_sds_phy_starting_await_sata_phy_substate_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), state_machine);
+        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), sm);
 
         sci_mod_timer(&sci_phy->sata_timer, SCIC_SDS_SATA_LINK_TRAINING_TIMEOUT);
 }
 
 static void scic_sds_phy_starting_await_sata_phy_substate_exit(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), state_machine);
+        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), sm);
 
         sci_del_timer(&sci_phy->sata_timer);
 }
 
 static void scic_sds_phy_starting_await_sata_speed_substate_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), state_machine);
+        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), sm);
 
         sci_mod_timer(&sci_phy->sata_timer, SCIC_SDS_SATA_LINK_TRAINING_TIMEOUT);
 }
 
 static void scic_sds_phy_starting_await_sata_speed_substate_exit(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), state_machine);
+        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), sm);
 
         sci_del_timer(&sci_phy->sata_timer);
 }
 
 static void scic_sds_phy_starting_await_sig_fis_uf_substate_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), state_machine);
+        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), sm);
 
         if (scic_sds_port_link_detected(sci_phy->owning_port, sci_phy)) {
 
@@ -1103,20 +1074,19 @@ static void scic_sds_phy_starting_await_sig_fis_uf_substate_enter(struct sci_bas
 
 static void scic_sds_phy_starting_await_sig_fis_uf_substate_exit(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), state_machine);
+        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), sm);
 
         sci_del_timer(&sci_phy->sata_timer);
 }
 
 static void scic_sds_phy_starting_final_substate_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), state_machine);
+        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), sm);
 
         /* State machine has run to completion so exit out and change
          * the base state machine to the ready state
          */
-        sci_base_state_machine_change_state(&sci_phy->state_machine,
-                                            SCI_BASE_PHY_STATE_READY);
+        sci_change_state(&sci_phy->sm, SCI_PHY_READY);
 }
 
 /**
@@ -1202,7 +1172,7 @@ static void scu_link_layer_tx_hard_reset(
 
 static void scic_sds_phy_stopped_state_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), state_machine);
+        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), sm);
 
         /*
          * @todo We need to get to the controller to place this PE in a
@@ -1212,7 +1182,7 @@ static void scic_sds_phy_stopped_state_enter(struct sci_base_state_machine *sm)
 
         scu_link_layer_stop_protocol_engine(sci_phy);
 
-        if (sci_phy->state_machine.previous_state_id != SCI_BASE_PHY_STATE_INITIAL)
+        if (sci_phy->sm.previous_state_id != SCI_PHY_INITIAL)
                 scic_sds_controller_link_down(scic_sds_phy_get_controller(sci_phy),
                                               phy_get_non_dummy_port(sci_phy),
                                               sci_phy);
@@ -1220,7 +1190,7 @@ static void scic_sds_phy_stopped_state_enter(struct sci_base_state_machine *sm)
 
 static void scic_sds_phy_starting_state_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), state_machine);
+        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), sm);
 
         scu_link_layer_stop_protocol_engine(sci_phy);
         scu_link_layer_start_oob(sci_phy);
@@ -1229,18 +1199,17 @@ static void scic_sds_phy_starting_state_enter(struct sci_base_state_machine *sm)
         sci_phy->protocol = SCIC_SDS_PHY_PROTOCOL_UNKNOWN;
         sci_phy->bcn_received_while_port_unassigned = false;
 
-        if (sci_phy->state_machine.previous_state_id == SCI_BASE_PHY_STATE_READY)
+        if (sci_phy->sm.previous_state_id == SCI_PHY_READY)
                 scic_sds_controller_link_down(scic_sds_phy_get_controller(sci_phy),
                                               phy_get_non_dummy_port(sci_phy),
                                               sci_phy);
 
-        sci_base_state_machine_change_state(&sci_phy->state_machine,
-                                            SCIC_SDS_PHY_STARTING_SUBSTATE_INITIAL);
+        sci_change_state(&sci_phy->sm, SCI_PHY_SUB_INITIAL);
 }
 
 static void scic_sds_phy_ready_state_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), state_machine);
+        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), sm);
 
         scic_sds_controller_link_up(scic_sds_phy_get_controller(sci_phy),
                                     phy_get_non_dummy_port(sci_phy),
@@ -1250,14 +1219,14 @@ static void scic_sds_phy_ready_state_enter(struct sci_base_state_machine *sm)
 
 static void scic_sds_phy_ready_state_exit(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), state_machine);
+        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), sm);
 
         scic_sds_phy_suspend(sci_phy);
 }
 
 static void scic_sds_phy_resetting_state_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), state_machine);
+        struct scic_sds_phy *sci_phy = container_of(sm, typeof(*sci_phy), sm);
 
         /* The phy is being reset, therefore deactivate it from the port.  In
          * the resetting state we don't notify the user regarding link up and
@@ -1271,66 +1240,65 @@ static void scic_sds_phy_resetting_state_enter(struct sci_base_state_machine *sm
                 /* The SCU does not need to have a discrete reset state so
                  * just go back to the starting state.
                  */
-                sci_base_state_machine_change_state(&sci_phy->state_machine,
-                                                    SCI_BASE_PHY_STATE_STARTING);
+                sci_change_state(&sci_phy->sm, SCI_PHY_STARTING);
         }
 }
 
 static const struct sci_base_state scic_sds_phy_state_table[] = {
-        [SCI_BASE_PHY_STATE_INITIAL] = { },
-        [SCI_BASE_PHY_STATE_STOPPED] = {
+        [SCI_PHY_INITIAL] = { },
+        [SCI_PHY_STOPPED] = {
                 .enter_state = scic_sds_phy_stopped_state_enter,
         },
-        [SCI_BASE_PHY_STATE_STARTING] = {
+        [SCI_PHY_STARTING] = {
                 .enter_state = scic_sds_phy_starting_state_enter,
         },
-        [SCIC_SDS_PHY_STARTING_SUBSTATE_INITIAL] = {
+        [SCI_PHY_SUB_INITIAL] = {
                 .enter_state = scic_sds_phy_starting_initial_substate_enter,
         },
-        [SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_OSSP_EN] = { },
-        [SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SAS_SPEED_EN] = { },
-        [SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_IAF_UF] = { },
-        [SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SAS_POWER] = {
+        [SCI_PHY_SUB_AWAIT_OSSP_EN] = { },
+        [SCI_PHY_SUB_AWAIT_SAS_SPEED_EN] = { },
+        [SCI_PHY_SUB_AWAIT_IAF_UF] = { },
+        [SCI_PHY_SUB_AWAIT_SAS_POWER] = {
                 .enter_state = scic_sds_phy_starting_await_sas_power_substate_enter,
                 .exit_state  = scic_sds_phy_starting_await_sas_power_substate_exit,
         },
-        [SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SATA_POWER] = {
+        [SCI_PHY_SUB_AWAIT_SATA_POWER] = {
                 .enter_state = scic_sds_phy_starting_await_sata_power_substate_enter,
                 .exit_state  = scic_sds_phy_starting_await_sata_power_substate_exit
         },
-        [SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SATA_PHY_EN] = {
+        [SCI_PHY_SUB_AWAIT_SATA_PHY_EN] = {
                 .enter_state = scic_sds_phy_starting_await_sata_phy_substate_enter,
                 .exit_state  = scic_sds_phy_starting_await_sata_phy_substate_exit
         },
-        [SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SATA_SPEED_EN] = {
+        [SCI_PHY_SUB_AWAIT_SATA_SPEED_EN] = {
                 .enter_state = scic_sds_phy_starting_await_sata_speed_substate_enter,
                 .exit_state  = scic_sds_phy_starting_await_sata_speed_substate_exit
         },
-        [SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SIG_FIS_UF] = {
+        [SCI_PHY_SUB_AWAIT_SIG_FIS_UF] = {
                 .enter_state = scic_sds_phy_starting_await_sig_fis_uf_substate_enter,
                 .exit_state  = scic_sds_phy_starting_await_sig_fis_uf_substate_exit
         },
-        [SCIC_SDS_PHY_STARTING_SUBSTATE_FINAL] = {
+        [SCI_PHY_SUB_FINAL] = {
                 .enter_state = scic_sds_phy_starting_final_substate_enter,
         },
-        [SCI_BASE_PHY_STATE_READY] = {
+        [SCI_PHY_READY] = {
                 .enter_state = scic_sds_phy_ready_state_enter,
                 .exit_state = scic_sds_phy_ready_state_exit,
         },
-        [SCI_BASE_PHY_STATE_RESETTING] = {
+        [SCI_PHY_RESETTING] = {
                 .enter_state = scic_sds_phy_resetting_state_enter,
         },
-        [SCI_BASE_PHY_STATE_FINAL] = { },
+        [SCI_PHY_FINAL] = { },
 };
 
 void scic_sds_phy_construct(struct scic_sds_phy *sci_phy,
                             struct scic_sds_port *owning_port, u8 phy_index)
 {
-        sci_base_state_machine_construct(&sci_phy->state_machine,
+        sci_base_state_machine_construct(&sci_phy->sm,
                                          scic_sds_phy_state_table,
-                                         SCI_BASE_PHY_STATE_INITIAL);
+                                         SCI_PHY_INITIAL);
 
-        sci_base_state_machine_start(&sci_phy->state_machine);
+        sci_base_state_machine_start(&sci_phy->sm);
 
         /* Copy the rest of the input data to our locals */
         sci_phy->owning_port = owning_port;
diff --git a/drivers/scsi/isci/phy.h b/drivers/scsi/isci/phy.h
index da3f0f1d56d4..9d21d2754dbb 100644
--- a/drivers/scsi/isci/phy.h
+++ b/drivers/scsi/isci/phy.h
@@ -94,7 +94,7 @@ struct scic_sds_phy {
         /**
          * This field contains the information for the base phy state machine.
          */
-        struct sci_base_state_machine state_machine;
+        struct sci_base_state_machine sm;
 
         /**
          * This field specifies the port object that owns/contains this phy.
@@ -410,7 +410,7 @@ enum scic_sds_phy_states {
         /**
          * Simply the initial state for the base domain state machine.
          */
-        SCI_BASE_PHY_STATE_INITIAL,
+        SCI_PHY_INITIAL,
 
         /**
          * This state indicates that the phy has successfully been stopped.
@@ -420,7 +420,7 @@ enum scic_sds_phy_states {
          * This state is entered from the READY state.
          * This state is entered from the RESETTING state.
          */
-        SCI_BASE_PHY_STATE_STOPPED,
+        SCI_PHY_STOPPED,
 
         /**
          * This state indicates that the phy is in the process of becomming
@@ -429,57 +429,57 @@ enum scic_sds_phy_states {
          * This state is entered from the READY state.
          * This state is entered from the RESETTING state.
          */
-        SCI_BASE_PHY_STATE_STARTING,
+        SCI_PHY_STARTING,
 
         /**
          * Initial state
          */
-        SCIC_SDS_PHY_STARTING_SUBSTATE_INITIAL,
+        SCI_PHY_SUB_INITIAL,
 
         /**
          * Wait state for the hardware OSSP event type notification
          */
-        SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_OSSP_EN,
+        SCI_PHY_SUB_AWAIT_OSSP_EN,
 
         /**
          * Wait state for the PHY speed notification
          */
-        SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SAS_SPEED_EN,
+        SCI_PHY_SUB_AWAIT_SAS_SPEED_EN,
 
         /**
          * Wait state for the IAF Unsolicited frame notification
          */
-        SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_IAF_UF,
+        SCI_PHY_SUB_AWAIT_IAF_UF,
 
         /**
          * Wait state for the request to consume power
          */
-        SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SAS_POWER,
+        SCI_PHY_SUB_AWAIT_SAS_POWER,
 
         /**
          * Wait state for request to consume power
          */
-        SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SATA_POWER,
+        SCI_PHY_SUB_AWAIT_SATA_POWER,
 
         /**
          * Wait state for the SATA PHY notification
          */
-        SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SATA_PHY_EN,
+        SCI_PHY_SUB_AWAIT_SATA_PHY_EN,
 
         /**
          * Wait for the SATA PHY speed notification
          */
-        SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SATA_SPEED_EN,
+        SCI_PHY_SUB_AWAIT_SATA_SPEED_EN,
 
         /**
          * Wait state for the SIGNATURE FIS unsolicited frame notification
          */
-        SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SIG_FIS_UF,
+        SCI_PHY_SUB_AWAIT_SIG_FIS_UF,
 
         /**
          * Exit state for this state machine
          */
-        SCIC_SDS_PHY_STARTING_SUBSTATE_FINAL,
+        SCI_PHY_SUB_FINAL,
 
         /**
          * This state indicates the the phy is now ready.  Thus, the user
@@ -487,19 +487,19 @@ enum scic_sds_phy_states {
          * is currently part of a valid port.
          * This state is entered from the STARTING state.
          */
-        SCI_BASE_PHY_STATE_READY,
+        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_BASE_PHY_STATE_RESETTING,
+        SCI_PHY_RESETTING,
 
         /**
          * Simply the final state for the base phy state machine.
          */
-        SCI_BASE_PHY_STATE_FINAL,
+        SCI_PHY_FINAL,
 };
 
 /**
diff --git a/drivers/scsi/isci/port.c b/drivers/scsi/isci/port.c
index 8d88ca21a51c..6370b93bd6ae 100644
--- a/drivers/scsi/isci/port.c
+++ b/drivers/scsi/isci/port.c
@@ -807,10 +807,10 @@ static void scic_sds_port_invalid_link_up(struct scic_sds_port *sci_port,
 static bool is_port_ready_state(enum scic_sds_port_states state)
 {
         switch (state) {
-        case SCI_BASE_PORT_STATE_READY:
-        case SCIC_SDS_PORT_READY_SUBSTATE_WAITING:
-        case SCIC_SDS_PORT_READY_SUBSTATE_OPERATIONAL:
-        case SCIC_SDS_PORT_READY_SUBSTATE_CONFIGURING:
+        case SCI_PORT_READY:
+        case SCI_PORT_SUB_WAITING:
+        case SCI_PORT_SUB_OPERATIONAL:
+        case SCI_PORT_SUB_CONFIGURING:
                 return true;
         default:
                 return false;
@@ -821,13 +821,13 @@ static bool is_port_ready_state(enum scic_sds_port_states state)
 static void port_state_machine_change(struct scic_sds_port *sci_port,
                                       enum scic_sds_port_states state)
 {
-        struct sci_base_state_machine *sm = &sci_port->state_machine;
+        struct sci_base_state_machine *sm = &sci_port->sm;
         enum scic_sds_port_states old_state = sm->current_state_id;
 
         if (is_port_ready_state(old_state) && !is_port_ready_state(state))
                 sci_port->ready_exit = true;
 
-        sci_base_state_machine_change_state(sm, state);
+        sci_change_state(sm, state);
         sci_port->ready_exit = false;
 }
 
@@ -862,11 +862,11 @@ static void scic_sds_port_general_link_up_handler(struct scic_sds_port *sci_port
         if ((phy_sas_address.high == port_sas_address.high &&
              phy_sas_address.low  == port_sas_address.low) ||
             sci_port->active_phy_mask == 0) {
-                struct sci_base_state_machine *sm = &sci_port->state_machine;
+                struct sci_base_state_machine *sm = &sci_port->sm;
 
                 scic_sds_port_activate_phy(sci_port, sci_phy, do_notify_user);
-                if (sm->current_state_id == SCI_BASE_PORT_STATE_RESETTING)
-                        port_state_machine_change(sci_port, SCI_BASE_PORT_STATE_READY);
+                if (sm->current_state_id == SCI_PORT_RESETTING)
+                        port_state_machine_change(sci_port, SCI_PORT_READY);
         } else
                 scic_sds_port_invalid_link_up(sci_port, sci_phy);
 }
@@ -938,14 +938,14 @@ static void port_timeout(unsigned long data)
         if (tmr->cancel)
                 goto done;
 
-        current_state = sci_base_state_machine_get_state(&sci_port->state_machine);
+        current_state = sci_port->sm.current_state_id;
 
-        if (current_state == SCI_BASE_PORT_STATE_RESETTING) {
+        if (current_state == SCI_PORT_RESETTING) {
                 /* if the port is still in the resetting state then the timeout
                  * fired before the reset completed.
                  */
-                port_state_machine_change(sci_port, SCI_BASE_PORT_STATE_FAILED);
-        } else if (current_state == SCI_BASE_PORT_STATE_STOPPED) {
+                port_state_machine_change(sci_port, SCI_PORT_FAILED);
+        } else if (current_state == SCI_PORT_STOPPED) {
                 /* if the port is stopped then the start request failed In this
                  * case stay in the stopped state.
                  */
@@ -953,7 +953,7 @@ static void port_timeout(unsigned long data)
                         "%s: SCIC Port 0x%p failed to stop before tiemout.\n",
                         __func__,
                         sci_port);
-        } else if (current_state == SCI_BASE_PORT_STATE_STOPPING) {
+        } else if (current_state == SCI_PORT_STOPPING) {
                 /* if the port is still stopping then the stop has not completed */
                 isci_port_stop_complete(sci_port->owning_controller,
                                         sci_port,
@@ -1139,7 +1139,7 @@ scic_sds_port_resume_port_task_scheduler(struct scic_sds_port *port)
 
 static void scic_sds_port_ready_substate_waiting_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_port *sci_port = container_of(sm, typeof(*sci_port), state_machine);
+        struct scic_sds_port *sci_port = container_of(sm, typeof(*sci_port), sm);
 
         scic_sds_port_suspend_port_task_scheduler(sci_port);
 
@@ -1148,14 +1148,14 @@ static void scic_sds_port_ready_substate_waiting_enter(struct sci_base_state_mac
         if (sci_port->active_phy_mask != 0) {
                 /* At least one of the phys on the port is ready */
                 port_state_machine_change(sci_port,
-                                          SCIC_SDS_PORT_READY_SUBSTATE_OPERATIONAL);
+                                          SCI_PORT_SUB_OPERATIONAL);
         }
 }
 
 static void scic_sds_port_ready_substate_operational_enter(struct sci_base_state_machine *sm)
 {
         u32 index;
-        struct scic_sds_port *sci_port = container_of(sm, typeof(*sci_port), state_machine);
+        struct scic_sds_port *sci_port = container_of(sm, typeof(*sci_port), sm);
         struct scic_sds_controller *scic = sci_port->owning_controller;
         struct isci_host *ihost = scic_to_ihost(scic);
         struct isci_port *iport = sci_port_to_iport(sci_port);
@@ -1211,12 +1211,12 @@ static void scic_sds_port_invalidate_dummy_remote_node(struct scic_sds_port *sci
  * @object: This is the object which is cast to a struct scic_sds_port object.
  *
  * This method will perform the actions required by the struct scic_sds_port on
- * exiting the SCIC_SDS_PORT_READY_SUBSTATE_OPERATIONAL. This function reports
+ * exiting the SCI_PORT_SUB_OPERATIONAL. This function reports
  * the port not ready and suspends the port task scheduler. none
  */
 static void scic_sds_port_ready_substate_operational_exit(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_port *sci_port = container_of(sm, typeof(*sci_port), state_machine);
+        struct scic_sds_port *sci_port = container_of(sm, typeof(*sci_port), sm);
         struct scic_sds_controller *scic = sci_port->owning_controller;
         struct isci_host *ihost = scic_to_ihost(scic);
         struct isci_port *iport = sci_port_to_iport(sci_port);
@@ -1236,7 +1236,7 @@ static void scic_sds_port_ready_substate_operational_exit(struct sci_base_state_
 
 static void scic_sds_port_ready_substate_configuring_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_port *sci_port = container_of(sm, typeof(*sci_port), state_machine);
+        struct scic_sds_port *sci_port = container_of(sm, typeof(*sci_port), sm);
         struct scic_sds_controller *scic = sci_port->owning_controller;
         struct isci_host *ihost = scic_to_ihost(scic);
         struct isci_port *iport = sci_port_to_iport(sci_port);
@@ -1245,15 +1245,15 @@ static void scic_sds_port_ready_substate_configuring_enter(struct sci_base_state
                 isci_port_not_ready(ihost, iport);
 
                 port_state_machine_change(sci_port,
-                                          SCIC_SDS_PORT_READY_SUBSTATE_WAITING);
+                                          SCI_PORT_SUB_WAITING);
         } else if (sci_port->started_request_count == 0)
                 port_state_machine_change(sci_port,
-                                          SCIC_SDS_PORT_READY_SUBSTATE_OPERATIONAL);
+                                          SCI_PORT_SUB_OPERATIONAL);
 }
 
 static void scic_sds_port_ready_substate_configuring_exit(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_port *sci_port = container_of(sm, typeof(*sci_port), state_machine);
+        struct scic_sds_port *sci_port = container_of(sm, typeof(*sci_port), sm);
 
         scic_sds_port_suspend_port_task_scheduler(sci_port);
         if (sci_port->ready_exit)
@@ -1267,8 +1267,8 @@ enum sci_status scic_sds_port_start(struct scic_sds_port *sci_port)
         enum scic_sds_port_states state;
         u32 phy_mask;
 
-        state = sci_port->state_machine.current_state_id;
-        if (state != SCI_BASE_PORT_STATE_STOPPED) {
+        state = sci_port->sm.current_state_id;
+        if (state != SCI_PORT_STOPPED) {
                 dev_warn(sciport_to_dev(sci_port),
                          "%s: in wrong state: %d\n", __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
@@ -1315,7 +1315,7 @@ enum sci_status scic_sds_port_start(struct scic_sds_port *sci_port)
                  */
                 if (scic_sds_port_is_phy_mask_valid(sci_port, phy_mask) == true) {
                         port_state_machine_change(sci_port,
-                                                  SCI_BASE_PORT_STATE_READY);
+                                                  SCI_PORT_READY);
 
                         return SCI_SUCCESS;
                 }
@@ -1332,16 +1332,16 @@ enum sci_status scic_sds_port_stop(struct scic_sds_port *sci_port)
 {
         enum scic_sds_port_states state;
 
-        state = sci_port->state_machine.current_state_id;
+        state = sci_port->sm.current_state_id;
         switch (state) {
-        case SCI_BASE_PORT_STATE_STOPPED:
+        case SCI_PORT_STOPPED:
                 return SCI_SUCCESS;
-        case SCIC_SDS_PORT_READY_SUBSTATE_WAITING:
-        case SCIC_SDS_PORT_READY_SUBSTATE_OPERATIONAL:
-        case SCIC_SDS_PORT_READY_SUBSTATE_CONFIGURING:
-        case SCI_BASE_PORT_STATE_RESETTING:
+        case SCI_PORT_SUB_WAITING:
+        case SCI_PORT_SUB_OPERATIONAL:
+        case SCI_PORT_SUB_CONFIGURING:
+        case SCI_PORT_RESETTING:
                 port_state_machine_change(sci_port,
-                                          SCI_BASE_PORT_STATE_STOPPING);
+                                          SCI_PORT_STOPPING);
                 return SCI_SUCCESS;
         default:
                 dev_warn(sciport_to_dev(sci_port),
@@ -1357,8 +1357,8 @@ static enum sci_status scic_port_hard_reset(struct scic_sds_port *sci_port, u32
         enum scic_sds_port_states state;
         u32 phy_index;
 
-        state = sci_port->state_machine.current_state_id;
-        if (state != SCIC_SDS_PORT_READY_SUBSTATE_OPERATIONAL) {
+        state = sci_port->sm.current_state_id;
+        if (state != SCI_PORT_SUB_OPERATIONAL) {
                 dev_warn(sciport_to_dev(sci_port),
                          "%s: in wrong state: %d\n", __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
@@ -1389,7 +1389,7 @@ static enum sci_status scic_port_hard_reset(struct scic_sds_port *sci_port, u32
         sci_port->not_ready_reason = SCIC_PORT_NOT_READY_HARD_RESET_REQUESTED;
 
         port_state_machine_change(sci_port,
-                                  SCI_BASE_PORT_STATE_RESETTING);
+                                  SCI_PORT_RESETTING);
         return SCI_SUCCESS;
 }
 
@@ -1408,9 +1408,9 @@ enum sci_status scic_sds_port_add_phy(struct scic_sds_port *sci_port,
         enum sci_status status;
         enum scic_sds_port_states state;
 
-        state = sci_port->state_machine.current_state_id;
+        state = sci_port->sm.current_state_id;
         switch (state) {
-        case SCI_BASE_PORT_STATE_STOPPED: {
+        case SCI_PORT_STOPPED: {
                 struct sci_sas_address port_sas_address;
 
                 /* Read the port assigned SAS Address if there is one */
@@ -1430,8 +1430,8 @@ enum sci_status scic_sds_port_add_phy(struct scic_sds_port *sci_port,
                 }
                 return scic_sds_port_set_phy(sci_port, sci_phy);
         }
-        case SCIC_SDS_PORT_READY_SUBSTATE_WAITING:
-        case SCIC_SDS_PORT_READY_SUBSTATE_OPERATIONAL:
+        case SCI_PORT_SUB_WAITING:
+        case SCI_PORT_SUB_OPERATIONAL:
                 status = scic_sds_port_set_phy(sci_port, sci_phy);
 
                 if (status != SCI_SUCCESS)
@@ -1439,10 +1439,10 @@ enum sci_status scic_sds_port_add_phy(struct scic_sds_port *sci_port,
 
                 scic_sds_port_general_link_up_handler(sci_port, sci_phy, true);
                 sci_port->not_ready_reason = SCIC_PORT_NOT_READY_RECONFIGURING;
-                port_state_machine_change(sci_port, SCIC_SDS_PORT_READY_SUBSTATE_CONFIGURING);
+                port_state_machine_change(sci_port, SCI_PORT_SUB_CONFIGURING);
 
                 return status;
-        case SCIC_SDS_PORT_READY_SUBSTATE_CONFIGURING:
+        case SCI_PORT_SUB_CONFIGURING:
                 status = scic_sds_port_set_phy(sci_port, sci_phy);
 
                 if (status != SCI_SUCCESS)
@@ -1453,7 +1453,7 @@ enum sci_status scic_sds_port_add_phy(struct scic_sds_port *sci_port,
                  * the port.
                  */
                 port_state_machine_change(sci_port,
-                                          SCIC_SDS_PORT_READY_SUBSTATE_CONFIGURING);
+                                          SCI_PORT_SUB_CONFIGURING);
                 return SCI_SUCCESS;
         default:
                 dev_warn(sciport_to_dev(sci_port),
@@ -1477,12 +1477,12 @@ enum sci_status scic_sds_port_remove_phy(struct scic_sds_port *sci_port,
         enum sci_status status;
         enum scic_sds_port_states state;
 
-        state = sci_port->state_machine.current_state_id;
+        state = sci_port->sm.current_state_id;
 
         switch (state) {
-        case SCI_BASE_PORT_STATE_STOPPED:
+        case SCI_PORT_STOPPED:
                 return scic_sds_port_clear_phy(sci_port, sci_phy);
-        case SCIC_SDS_PORT_READY_SUBSTATE_OPERATIONAL:
+        case SCI_PORT_SUB_OPERATIONAL:
                 status = scic_sds_port_clear_phy(sci_port, sci_phy);
                 if (status != SCI_SUCCESS)
                         return status;
@@ -1490,9 +1490,9 @@ enum sci_status scic_sds_port_remove_phy(struct scic_sds_port *sci_port,
                 scic_sds_port_deactivate_phy(sci_port, sci_phy, true);
                 sci_port->not_ready_reason = SCIC_PORT_NOT_READY_RECONFIGURING;
                 port_state_machine_change(sci_port,
-                                          SCIC_SDS_PORT_READY_SUBSTATE_CONFIGURING);
+                                          SCI_PORT_SUB_CONFIGURING);
                 return SCI_SUCCESS;
-        case SCIC_SDS_PORT_READY_SUBSTATE_CONFIGURING:
+        case SCI_PORT_SUB_CONFIGURING:
                 status = scic_sds_port_clear_phy(sci_port, sci_phy);
 
                 if (status != SCI_SUCCESS)
@@ -1503,7 +1503,7 @@ enum sci_status scic_sds_port_remove_phy(struct scic_sds_port *sci_port,
                  * the port
                  */
                 port_state_machine_change(sci_port,
-                                          SCIC_SDS_PORT_READY_SUBSTATE_CONFIGURING);
+                                          SCI_PORT_SUB_CONFIGURING);
                 return SCI_SUCCESS;
         default:
                 dev_warn(sciport_to_dev(sci_port),
@@ -1517,21 +1517,21 @@ enum sci_status scic_sds_port_link_up(struct scic_sds_port *sci_port,
 {
         enum scic_sds_port_states state;
 
-        state = sci_port->state_machine.current_state_id;
+        state = sci_port->sm.current_state_id;
         switch (state) {
-        case SCIC_SDS_PORT_READY_SUBSTATE_WAITING:
+        case SCI_PORT_SUB_WAITING:
                 /* Since this is the first phy going link up for the port we
                  * can just enable it and continue
                  */
                 scic_sds_port_activate_phy(sci_port, sci_phy, true);
 
                 port_state_machine_change(sci_port,
-                                          SCIC_SDS_PORT_READY_SUBSTATE_OPERATIONAL);
+                                          SCI_PORT_SUB_OPERATIONAL);
                 return SCI_SUCCESS;
-        case SCIC_SDS_PORT_READY_SUBSTATE_OPERATIONAL:
+        case SCI_PORT_SUB_OPERATIONAL:
                 scic_sds_port_general_link_up_handler(sci_port, sci_phy, true);
                 return SCI_SUCCESS;
-        case SCI_BASE_PORT_STATE_RESETTING:
+        case SCI_PORT_RESETTING:
                 /* TODO We should  make  sure  that  the phy  that  has gone
                  * link up is the same one on which we sent the reset.  It is
                  * possible that the phy on which we sent  the reset is not the
@@ -1560,9 +1560,9 @@ enum sci_status scic_sds_port_link_down(struct scic_sds_port *sci_port,
 {
         enum scic_sds_port_states state;
 
-        state = sci_port->state_machine.current_state_id;
+        state = sci_port->sm.current_state_id;
         switch (state) {
-        case SCIC_SDS_PORT_READY_SUBSTATE_OPERATIONAL:
+        case SCI_PORT_SUB_OPERATIONAL:
                 scic_sds_port_deactivate_phy(sci_port, sci_phy, true);
 
                 /* If there are no active phys left in the port, then
@@ -1571,9 +1571,9 @@ enum sci_status scic_sds_port_link_down(struct scic_sds_port *sci_port,
                  */
                 if (sci_port->active_phy_mask == 0)
                         port_state_machine_change(sci_port,
-                                                  SCIC_SDS_PORT_READY_SUBSTATE_WAITING);
+                                                  SCI_PORT_SUB_WAITING);
                 return SCI_SUCCESS;
-        case SCI_BASE_PORT_STATE_RESETTING:
+        case SCI_PORT_RESETTING:
                 /* In the resetting state we don't notify the user regarding
                  * link up and link down notifications. */
                 scic_sds_port_deactivate_phy(sci_port, sci_phy, false);
@@ -1591,11 +1591,11 @@ enum sci_status scic_sds_port_start_io(struct scic_sds_port *sci_port,
 {
         enum scic_sds_port_states state;
 
-        state = sci_port->state_machine.current_state_id;
+        state = sci_port->sm.current_state_id;
         switch (state) {
-        case SCIC_SDS_PORT_READY_SUBSTATE_WAITING:
+        case SCI_PORT_SUB_WAITING:
                 return SCI_FAILURE_INVALID_STATE;
-        case SCIC_SDS_PORT_READY_SUBSTATE_OPERATIONAL:
+        case SCI_PORT_SUB_OPERATIONAL:
                 sci_port->started_request_count++;
                 return SCI_SUCCESS;
         default:
@@ -1611,31 +1611,31 @@ enum sci_status scic_sds_port_complete_io(struct scic_sds_port *sci_port,
 {
         enum scic_sds_port_states state;
 
-        state = sci_port->state_machine.current_state_id;
+        state = sci_port->sm.current_state_id;
         switch (state) {
-        case SCI_BASE_PORT_STATE_STOPPED:
+        case SCI_PORT_STOPPED:
                 dev_warn(sciport_to_dev(sci_port),
                          "%s: in wrong state: %d\n", __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
-        case SCI_BASE_PORT_STATE_STOPPING:
+        case SCI_PORT_STOPPING:
                 scic_sds_port_decrement_request_count(sci_port);
 
                 if (sci_port->started_request_count == 0)
                         port_state_machine_change(sci_port,
-                                                  SCI_BASE_PORT_STATE_STOPPED);
+                                                  SCI_PORT_STOPPED);
                 break;
-        case SCI_BASE_PORT_STATE_READY:
-        case SCI_BASE_PORT_STATE_RESETTING:
-        case SCI_BASE_PORT_STATE_FAILED:
-        case SCIC_SDS_PORT_READY_SUBSTATE_WAITING:
-        case SCIC_SDS_PORT_READY_SUBSTATE_OPERATIONAL:
+        case SCI_PORT_READY:
+        case SCI_PORT_RESETTING:
+        case SCI_PORT_FAILED:
+        case SCI_PORT_SUB_WAITING:
+        case SCI_PORT_SUB_OPERATIONAL:
                 scic_sds_port_decrement_request_count(sci_port);
                 break;
-        case SCIC_SDS_PORT_READY_SUBSTATE_CONFIGURING:
+        case SCI_PORT_SUB_CONFIGURING:
                 scic_sds_port_decrement_request_count(sci_port);
                 if (sci_port->started_request_count == 0) {
                         port_state_machine_change(sci_port,
-                                                  SCIC_SDS_PORT_READY_SUBSTATE_OPERATIONAL);
+                                                  SCI_PORT_SUB_OPERATIONAL);
                 }
                 break;
         }
@@ -1707,9 +1707,9 @@ static void scic_sds_port_post_dummy_remote_node(struct scic_sds_port *sci_port)
 
 static void scic_sds_port_stopped_state_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_port *sci_port = container_of(sm, typeof(*sci_port), state_machine);
+        struct scic_sds_port *sci_port = container_of(sm, typeof(*sci_port), sm);
 
-        if (sci_port->state_machine.previous_state_id == SCI_BASE_PORT_STATE_STOPPING) {
+        if (sci_port->sm.previous_state_id == SCI_PORT_STOPPING) {
                 /*
                  * If we enter this state becasuse of a request to stop
                  * the port then we want to disable the hardwares port
@@ -1720,7 +1720,7 @@ static void scic_sds_port_stopped_state_enter(struct sci_base_state_machine *sm)
 
 static void scic_sds_port_stopped_state_exit(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_port *sci_port = container_of(sm, typeof(*sci_port), state_machine);
+        struct scic_sds_port *sci_port = container_of(sm, typeof(*sci_port), sm);
 
         /* Enable and suspend the port task scheduler */
         scic_sds_port_enable_port_task_scheduler(sci_port);
@@ -1728,14 +1728,14 @@ static void scic_sds_port_stopped_state_exit(struct sci_base_state_machine *sm)
 
 static void scic_sds_port_ready_state_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_port *sci_port = container_of(sm, typeof(*sci_port), state_machine);
+        struct scic_sds_port *sci_port = container_of(sm, typeof(*sci_port), sm);
         struct scic_sds_controller *scic = sci_port->owning_controller;
         struct isci_host *ihost = scic_to_ihost(scic);
         struct isci_port *iport = sci_port_to_iport(sci_port);
         u32 prev_state;
 
-        prev_state = sci_port->state_machine.previous_state_id;
-        if (prev_state  == SCI_BASE_PORT_STATE_RESETTING)
+        prev_state = sci_port->sm.previous_state_id;
+        if (prev_state  == SCI_PORT_RESETTING)
                 isci_port_hard_reset_complete(iport, SCI_SUCCESS);
         else
                 isci_port_not_ready(ihost, iport);
@@ -1745,19 +1745,19 @@ static void scic_sds_port_ready_state_enter(struct sci_base_state_machine *sm)
 
         /* Start the ready substate machine */
         port_state_machine_change(sci_port,
-                                  SCIC_SDS_PORT_READY_SUBSTATE_WAITING);
+                                  SCI_PORT_SUB_WAITING);
 }
 
 static void scic_sds_port_resetting_state_exit(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_port *sci_port = container_of(sm, typeof(*sci_port), state_machine);
+        struct scic_sds_port *sci_port = container_of(sm, typeof(*sci_port), sm);
 
         sci_del_timer(&sci_port->timer);
 }
 
 static void scic_sds_port_stopping_state_exit(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_port *sci_port = container_of(sm, typeof(*sci_port), state_machine);
+        struct scic_sds_port *sci_port = container_of(sm, typeof(*sci_port), sm);
 
         sci_del_timer(&sci_port->timer);
 
@@ -1766,7 +1766,7 @@ static void scic_sds_port_stopping_state_exit(struct sci_base_state_machine *sm)
 
 static void scic_sds_port_failed_state_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_port *sci_port = container_of(sm, typeof(*sci_port), state_machine);
+        struct scic_sds_port *sci_port = container_of(sm, typeof(*sci_port), sm);
         struct isci_port *iport = sci_port_to_iport(sci_port);
 
         isci_port_hard_reset_complete(iport, SCI_FAILURE_TIMEOUT);
@@ -1775,31 +1775,31 @@ static void scic_sds_port_failed_state_enter(struct sci_base_state_machine *sm)
 /* --------------------------------------------------------------------------- */
 
 static const struct sci_base_state scic_sds_port_state_table[] = {
-        [SCI_BASE_PORT_STATE_STOPPED] = {
+        [SCI_PORT_STOPPED] = {
                 .enter_state = scic_sds_port_stopped_state_enter,
                 .exit_state  = scic_sds_port_stopped_state_exit
         },
-        [SCI_BASE_PORT_STATE_STOPPING] = {
+        [SCI_PORT_STOPPING] = {
                 .exit_state  = scic_sds_port_stopping_state_exit
         },
-        [SCI_BASE_PORT_STATE_READY] = {
+        [SCI_PORT_READY] = {
                 .enter_state = scic_sds_port_ready_state_enter,
         },
-        [SCIC_SDS_PORT_READY_SUBSTATE_WAITING] = {
+        [SCI_PORT_SUB_WAITING] = {
                 .enter_state = scic_sds_port_ready_substate_waiting_enter,
         },
-        [SCIC_SDS_PORT_READY_SUBSTATE_OPERATIONAL] = {
+        [SCI_PORT_SUB_OPERATIONAL] = {
                 .enter_state = scic_sds_port_ready_substate_operational_enter,
                 .exit_state  = scic_sds_port_ready_substate_operational_exit
         },
-        [SCIC_SDS_PORT_READY_SUBSTATE_CONFIGURING] = {
+        [SCI_PORT_SUB_CONFIGURING] = {
                 .enter_state = scic_sds_port_ready_substate_configuring_enter,
                 .exit_state  = scic_sds_port_ready_substate_configuring_exit
         },
-        [SCI_BASE_PORT_STATE_RESETTING] = {
+        [SCI_PORT_RESETTING] = {
                 .exit_state  = scic_sds_port_resetting_state_exit
         },
-        [SCI_BASE_PORT_STATE_FAILED] = {
+        [SCI_PORT_FAILED] = {
                 .enter_state = scic_sds_port_failed_state_enter,
         }
 };
@@ -1807,11 +1807,11 @@ static const struct sci_base_state scic_sds_port_state_table[] = {
 void scic_sds_port_construct(struct scic_sds_port *sci_port, u8 index,
                              struct scic_sds_controller *scic)
 {
-        sci_base_state_machine_construct(&sci_port->state_machine,
+        sci_base_state_machine_construct(&sci_port->sm,
                                          scic_sds_port_state_table,
-                                         SCI_BASE_PORT_STATE_STOPPED);
+                                         SCI_PORT_STOPPED);
 
-        sci_base_state_machine_start(&sci_port->state_machine);
+        sci_base_state_machine_start(&sci_port->sm);
 
         sci_port->logical_port_index  = SCIC_SDS_DUMMY_PORT;
         sci_port->physical_port_index = index;
diff --git a/drivers/scsi/isci/port.h b/drivers/scsi/isci/port.h
index 9a6912855fc1..fee6d80df769 100644
--- a/drivers/scsi/isci/port.h
+++ b/drivers/scsi/isci/port.h
@@ -84,7 +84,7 @@ struct scic_sds_port {
         /**
          * This field contains the information for the base port state machine.
          */
-        struct sci_base_state_machine state_machine;
+        struct sci_base_state_machine sm;
 
         bool ready_exit;
 
@@ -224,7 +224,7 @@ enum scic_sds_port_states {
          * In this state no new IO operations are permitted.
          * This state is entered from the STOPPING state.
          */
-        SCI_BASE_PORT_STATE_STOPPED,
+        SCI_PORT_STOPPED,
 
         /**
          * This state indicates that the port is in the process of stopping.
@@ -232,33 +232,33 @@ enum scic_sds_port_states {
          * operations are allowed to complete.
          * This state is entered from the READY state.
          */
-        SCI_BASE_PORT_STATE_STOPPING,
+        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_BASE_PORT_STATE_READY,
+        SCI_PORT_READY,
 
         /**
          * The substate where the port is started and ready but has no
          * active phys.
          */
-        SCIC_SDS_PORT_READY_SUBSTATE_WAITING,
+        SCI_PORT_SUB_WAITING,
 
         /**
          * The substate where the port is started and ready and there is
          * at least one phy operational.
          */
-        SCIC_SDS_PORT_READY_SUBSTATE_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)
          */
-        SCIC_SDS_PORT_READY_SUBSTATE_CONFIGURING,
+        SCI_PORT_SUB_CONFIGURING,
 
         /**
          * This state indicates the port is in the process of performing a hard
@@ -266,14 +266,14 @@ enum scic_sds_port_states {
          * port.
          * This state is entered from the READY state.
          */
-        SCI_BASE_PORT_STATE_RESETTING,
+        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_BASE_PORT_STATE_FAILED,
+        SCI_PORT_FAILED,
 
 
 };
diff --git a/drivers/scsi/isci/port_config.c b/drivers/scsi/isci/port_config.c
index 38401f644e18..fcb8f030b7ae 100644
--- a/drivers/scsi/isci/port_config.c
+++ b/drivers/scsi/isci/port_config.c
@@ -661,13 +661,13 @@ static void scic_sds_apc_agent_link_up(struct scic_sds_controller *scic,
                 scic_sds_apc_agent_configure_ports(scic, port_agent, sci_phy, true);
         } else {
                 /* the phy is already the part of the port */
-                u32 port_state = sci_port->state_machine.current_state_id;
+                u32 port_state = sci_port->sm.current_state_id;
 
                 /* if the PORT'S state is resetting then the link up is from
                  * port hard reset in this case, we need to tell the port
                  * that link up is recieved
                  */
-                BUG_ON(port_state != SCI_BASE_PORT_STATE_RESETTING);
+                BUG_ON(port_state != SCI_PORT_RESETTING);
                 port_agent->phy_ready_mask |= 1 << phy_index;
                 scic_sds_port_link_up(sci_port, sci_phy);
         }
diff --git a/drivers/scsi/isci/remote_device.c b/drivers/scsi/isci/remote_device.c
index 68b63b04be19..6c93f20f3dd3 100644
--- a/drivers/scsi/isci/remote_device.c
+++ b/drivers/scsi/isci/remote_device.c
@@ -126,8 +126,7 @@ static void rnc_destruct_done(void *_dev)
         struct scic_sds_remote_device *sci_dev = _dev;
 
         BUG_ON(sci_dev->started_request_count != 0);
-        sci_base_state_machine_change_state(&sci_dev->state_machine,
-                                            SCI_BASE_REMOTE_DEVICE_STATE_STOPPED);
+        sci_change_state(&sci_dev->sm, SCI_DEV_STOPPED);
 }
 
 static enum sci_status scic_sds_remote_device_terminate_requests(struct scic_sds_remote_device *sci_dev)
@@ -154,20 +153,20 @@ static enum sci_status scic_sds_remote_device_terminate_requests(struct scic_sds
 enum sci_status scic_remote_device_stop(struct scic_sds_remote_device *sci_dev,
                                         u32 timeout)
 {
-        struct sci_base_state_machine *sm = &sci_dev->state_machine;
+        struct sci_base_state_machine *sm = &sci_dev->sm;
         enum scic_sds_remote_device_states state = sm->current_state_id;
 
         switch (state) {
-        case SCI_BASE_REMOTE_DEVICE_STATE_INITIAL:
-        case SCI_BASE_REMOTE_DEVICE_STATE_FAILED:
-        case SCI_BASE_REMOTE_DEVICE_STATE_FINAL:
+        case SCI_DEV_INITIAL:
+        case SCI_DEV_FAILED:
+        case SCI_DEV_FINAL:
         default:
                 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
                          __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
-        case SCI_BASE_REMOTE_DEVICE_STATE_STOPPED:
+        case SCI_DEV_STOPPED:
                 return SCI_SUCCESS;
-        case SCI_BASE_REMOTE_DEVICE_STATE_STARTING:
+        case SCI_DEV_STARTING:
                 /* device not started so there had better be no requests */
                 BUG_ON(sci_dev->started_request_count != 0);
                 scic_sds_remote_node_context_destruct(&sci_dev->rnc,
@@ -175,17 +174,17 @@ enum sci_status scic_remote_device_stop(struct scic_sds_remote_device *sci_dev,
                 /* Transition to the stopping state and wait for the
                  * remote node to complete being posted and invalidated.
                  */
-                sci_base_state_machine_change_state(sm, SCI_BASE_REMOTE_DEVICE_STATE_STOPPING);
+                sci_change_state(sm, SCI_DEV_STOPPING);
                 return SCI_SUCCESS;
-        case SCI_BASE_REMOTE_DEVICE_STATE_READY:
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ:
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR:
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET:
-        case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
-        case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
-                sci_base_state_machine_change_state(sm, SCI_BASE_REMOTE_DEVICE_STATE_STOPPING);
+        case SCI_DEV_READY:
+        case SCI_STP_DEV_IDLE:
+        case SCI_STP_DEV_CMD:
+        case SCI_STP_DEV_NCQ:
+        case SCI_STP_DEV_NCQ_ERROR:
+        case SCI_STP_DEV_AWAIT_RESET:
+        case SCI_SMP_DEV_IDLE:
+        case SCI_SMP_DEV_CMD:
+                sci_change_state(sm, SCI_DEV_STOPPING);
                 if (sci_dev->started_request_count == 0) {
                         scic_sds_remote_node_context_destruct(&sci_dev->rnc,
                                                               rnc_destruct_done, sci_dev);
@@ -193,70 +192,70 @@ enum sci_status scic_remote_device_stop(struct scic_sds_remote_device *sci_dev,
                 } else
                         return scic_sds_remote_device_terminate_requests(sci_dev);
                 break;
-        case SCI_BASE_REMOTE_DEVICE_STATE_STOPPING:
+        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
                  * try again to terminate.
                  */
                 return scic_sds_remote_device_terminate_requests(sci_dev);
-        case SCI_BASE_REMOTE_DEVICE_STATE_RESETTING:
-                sci_base_state_machine_change_state(sm, SCI_BASE_REMOTE_DEVICE_STATE_STOPPING);
+        case SCI_DEV_RESETTING:
+                sci_change_state(sm, SCI_DEV_STOPPING);
                 return SCI_SUCCESS;
         }
 }
 
 enum sci_status scic_remote_device_reset(struct scic_sds_remote_device *sci_dev)
 {
-        struct sci_base_state_machine *sm = &sci_dev->state_machine;
+        struct sci_base_state_machine *sm = &sci_dev->sm;
         enum scic_sds_remote_device_states state = sm->current_state_id;
 
         switch (state) {
-        case SCI_BASE_REMOTE_DEVICE_STATE_INITIAL:
-        case SCI_BASE_REMOTE_DEVICE_STATE_STOPPED:
-        case SCI_BASE_REMOTE_DEVICE_STATE_STARTING:
-        case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
-        case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
-        case SCI_BASE_REMOTE_DEVICE_STATE_STOPPING:
-        case SCI_BASE_REMOTE_DEVICE_STATE_FAILED:
-        case SCI_BASE_REMOTE_DEVICE_STATE_RESETTING:
-        case SCI_BASE_REMOTE_DEVICE_STATE_FINAL:
+        case SCI_DEV_INITIAL:
+        case SCI_DEV_STOPPED:
+        case SCI_DEV_STARTING:
+        case SCI_SMP_DEV_IDLE:
+        case SCI_SMP_DEV_CMD:
+        case SCI_DEV_STOPPING:
+        case SCI_DEV_FAILED:
+        case SCI_DEV_RESETTING:
+        case SCI_DEV_FINAL:
         default:
                 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
                          __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
-        case SCI_BASE_REMOTE_DEVICE_STATE_READY:
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ:
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR:
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET:
-                sci_base_state_machine_change_state(sm, SCI_BASE_REMOTE_DEVICE_STATE_RESETTING);
+        case SCI_DEV_READY:
+        case SCI_STP_DEV_IDLE:
+        case SCI_STP_DEV_CMD:
+        case SCI_STP_DEV_NCQ:
+        case SCI_STP_DEV_NCQ_ERROR:
+        case SCI_STP_DEV_AWAIT_RESET:
+                sci_change_state(sm, SCI_DEV_RESETTING);
                 return SCI_SUCCESS;
         }
 }
 
 enum sci_status scic_remote_device_reset_complete(struct scic_sds_remote_device *sci_dev)
 {
-        struct sci_base_state_machine *sm = &sci_dev->state_machine;
+        struct sci_base_state_machine *sm = &sci_dev->sm;
         enum scic_sds_remote_device_states state = sm->current_state_id;
 
-        if (state != SCI_BASE_REMOTE_DEVICE_STATE_RESETTING) {
+        if (state != SCI_DEV_RESETTING) {
                 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
                          __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
         }
 
-        sci_base_state_machine_change_state(sm, SCI_BASE_REMOTE_DEVICE_STATE_READY);
+        sci_change_state(sm, SCI_DEV_READY);
         return SCI_SUCCESS;
 }
 
 enum sci_status scic_sds_remote_device_suspend(struct scic_sds_remote_device *sci_dev,
                                                u32 suspend_type)
 {
-        struct sci_base_state_machine *sm = &sci_dev->state_machine;
+        struct sci_base_state_machine *sm = &sci_dev->sm;
         enum scic_sds_remote_device_states state = sm->current_state_id;
 
-        if (state != SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD) {
+        if (state != SCI_STP_DEV_CMD) {
                 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
                          __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
@@ -269,30 +268,30 @@ enum sci_status scic_sds_remote_device_suspend(struct scic_sds_remote_device *sc
 enum sci_status scic_sds_remote_device_frame_handler(struct scic_sds_remote_device *sci_dev,
                                                      u32 frame_index)
 {
-        struct sci_base_state_machine *sm = &sci_dev->state_machine;
+        struct sci_base_state_machine *sm = &sci_dev->sm;
         enum scic_sds_remote_device_states state = sm->current_state_id;
         struct scic_sds_controller *scic = sci_dev->owning_port->owning_controller;
         enum sci_status status;
 
         switch (state) {
-        case SCI_BASE_REMOTE_DEVICE_STATE_INITIAL:
-        case SCI_BASE_REMOTE_DEVICE_STATE_STOPPED:
-        case SCI_BASE_REMOTE_DEVICE_STATE_STARTING:
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
-        case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
-        case SCI_BASE_REMOTE_DEVICE_STATE_FINAL:
+        case SCI_DEV_INITIAL:
+        case SCI_DEV_STOPPED:
+        case SCI_DEV_STARTING:
+        case SCI_STP_DEV_IDLE:
+        case SCI_SMP_DEV_IDLE:
+        case SCI_DEV_FINAL:
         default:
                 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
                          __func__, state);
                 /* Return the frame back to the controller */
                 scic_sds_controller_release_frame(scic, frame_index);
                 return SCI_FAILURE_INVALID_STATE;
-        case SCI_BASE_REMOTE_DEVICE_STATE_READY:
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR:
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET:
-        case SCI_BASE_REMOTE_DEVICE_STATE_STOPPING:
-        case SCI_BASE_REMOTE_DEVICE_STATE_FAILED:
-        case SCI_BASE_REMOTE_DEVICE_STATE_RESETTING: {
+        case SCI_DEV_READY:
+        case SCI_STP_DEV_NCQ_ERROR:
+        case SCI_STP_DEV_AWAIT_RESET:
+        case SCI_DEV_STOPPING:
+        case SCI_DEV_FAILED:
+        case SCI_DEV_RESETTING: {
                 struct scic_sds_request *sci_req;
                 struct ssp_frame_hdr hdr;
                 void *frame_header;
@@ -319,7 +318,7 @@ enum sci_status scic_sds_remote_device_frame_handler(struct scic_sds_remote_devi
                 }
                 break;
         }
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ: {
+        case SCI_STP_DEV_NCQ: {
                 struct dev_to_host_fis *hdr;
 
                 status = scic_sds_unsolicited_frame_control_get_header(&scic->uf_control,
@@ -333,7 +332,7 @@ enum sci_status scic_sds_remote_device_frame_handler(struct scic_sds_remote_devi
                         sci_dev->not_ready_reason = SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED;
 
                         /* TODO Check sactive and complete associated IO if any. */
-                        sci_base_state_machine_change_state(sm, SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR);
+                        sci_change_state(sm, SCI_STP_DEV_NCQ_ERROR);
                 } else if (hdr->fis_type == FIS_REGD2H &&
                            (hdr->status & ATA_ERR)) {
                         /*
@@ -341,16 +340,15 @@ enum sci_status scic_sds_remote_device_frame_handler(struct scic_sds_remote_devi
                          * Treat this like an SDB error FIS ready reason.
                          */
                         sci_dev->not_ready_reason = SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED;
-                        sci_base_state_machine_change_state(&sci_dev->state_machine,
-                                                            SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR);
+                        sci_change_state(&sci_dev->sm, SCI_STP_DEV_NCQ_ERROR);
                 } else
                         status = SCI_FAILURE;
 
                 scic_sds_controller_release_frame(scic, frame_index);
                 break;
         }
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
-        case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
+        case SCI_STP_DEV_CMD:
+        case SCI_SMP_DEV_CMD:
                 /* The device does not process any UF received from the hardware while
                  * in this state.  All unsolicited frames are forwarded to the io request
                  * object.
@@ -365,18 +363,18 @@ enum sci_status scic_sds_remote_device_frame_handler(struct scic_sds_remote_devi
 static bool is_remote_device_ready(struct scic_sds_remote_device *sci_dev)
 {
 
-        struct sci_base_state_machine *sm = &sci_dev->state_machine;
+        struct sci_base_state_machine *sm = &sci_dev->sm;
         enum scic_sds_remote_device_states state = sm->current_state_id;
 
         switch (state) {
-        case SCI_BASE_REMOTE_DEVICE_STATE_READY:
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ:
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR:
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET:
-        case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
-        case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
+        case SCI_DEV_READY:
+        case SCI_STP_DEV_IDLE:
+        case SCI_STP_DEV_CMD:
+        case SCI_STP_DEV_NCQ:
+        case SCI_STP_DEV_NCQ_ERROR:
+        case SCI_STP_DEV_AWAIT_RESET:
+        case SCI_SMP_DEV_IDLE:
+        case SCI_SMP_DEV_CMD:
                 return true;
         default:
                 return false;
@@ -386,7 +384,7 @@ static bool is_remote_device_ready(struct scic_sds_remote_device *sci_dev)
 enum sci_status scic_sds_remote_device_event_handler(struct scic_sds_remote_device *sci_dev,
                                                      u32 event_code)
 {
-        struct sci_base_state_machine *sm = &sci_dev->state_machine;
+        struct sci_base_state_machine *sm = &sci_dev->sm;
         enum scic_sds_remote_device_states state = sm->current_state_id;
         enum sci_status status;
 
@@ -429,7 +427,7 @@ enum sci_status scic_sds_remote_device_event_handler(struct scic_sds_remote_devi
         if (status != SCI_SUCCESS)
                 return status;
 
-        if (state == SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE) {
+        if (state == SCI_STP_DEV_IDLE) {
 
                 /* We pick up suspension events to handle specifically to this
                  * state. We resume the RNC right away.
@@ -459,26 +457,26 @@ enum sci_status scic_sds_remote_device_start_io(struct scic_sds_controller *scic
                                                 struct scic_sds_remote_device *sci_dev,
                                                 struct scic_sds_request *sci_req)
 {
-        struct sci_base_state_machine *sm = &sci_dev->state_machine;
+        struct sci_base_state_machine *sm = &sci_dev->sm;
         enum scic_sds_remote_device_states state = sm->current_state_id;
         struct scic_sds_port *sci_port = sci_dev->owning_port;
         struct isci_request *ireq = sci_req_to_ireq(sci_req);
         enum sci_status status;
 
         switch (state) {
-        case SCI_BASE_REMOTE_DEVICE_STATE_INITIAL:
-        case SCI_BASE_REMOTE_DEVICE_STATE_STOPPED:
-        case SCI_BASE_REMOTE_DEVICE_STATE_STARTING:
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR:
-        case SCI_BASE_REMOTE_DEVICE_STATE_STOPPING:
-        case SCI_BASE_REMOTE_DEVICE_STATE_FAILED:
-        case SCI_BASE_REMOTE_DEVICE_STATE_RESETTING:
-        case SCI_BASE_REMOTE_DEVICE_STATE_FINAL:
+        case SCI_DEV_INITIAL:
+        case SCI_DEV_STOPPED:
+        case SCI_DEV_STARTING:
+        case SCI_STP_DEV_NCQ_ERROR:
+        case SCI_DEV_STOPPING:
+        case SCI_DEV_FAILED:
+        case SCI_DEV_RESETTING:
+        case SCI_DEV_FINAL:
         default:
                 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
                          __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
-        case SCI_BASE_REMOTE_DEVICE_STATE_READY:
+        case SCI_DEV_READY:
                 /* attempt to start an io request for this device object. The remote
                  * device object will issue the start request for the io and if
                  * successful it will start the request for the port object then
@@ -494,7 +492,7 @@ enum sci_status scic_sds_remote_device_start_io(struct scic_sds_controller *scic
 
                 status = scic_sds_request_start(sci_req);
                 break;
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE: {
+        case SCI_STP_DEV_IDLE: {
                 /* handle the start io operation for a sata device that is in
                  * the command idle state. - Evalute the type of IO request to
                  * be started - If its an NCQ request change to NCQ substate -
@@ -519,15 +517,15 @@ enum sci_status scic_sds_remote_device_start_io(struct scic_sds_controller *scic
                         break;
 
                 if (task->ata_task.use_ncq)
-                        new_state = SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ;
+                        new_state = SCI_STP_DEV_NCQ;
                 else {
                         sci_dev->working_request = sci_req;
-                        new_state = SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD;
+                        new_state = SCI_STP_DEV_CMD;
                 }
-                sci_base_state_machine_change_state(sm, new_state);
+                sci_change_state(sm, new_state);
                 break;
         }
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ: {
+        case SCI_STP_DEV_NCQ: {
                 struct sas_task *task = isci_request_access_task(ireq);
 
                 if (task->ata_task.use_ncq) {
@@ -544,9 +542,9 @@ enum sci_status scic_sds_remote_device_start_io(struct scic_sds_controller *scic
                         return SCI_FAILURE_INVALID_STATE;
                 break;
         }
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET:
+        case SCI_STP_DEV_AWAIT_RESET:
                 return SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
-        case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
+        case SCI_SMP_DEV_IDLE:
                 status = scic_sds_port_start_io(sci_port, sci_dev, sci_req);
                 if (status != SCI_SUCCESS)
                         return status;
@@ -560,11 +558,10 @@ enum sci_status scic_sds_remote_device_start_io(struct scic_sds_controller *scic
                         break;
 
                 sci_dev->working_request = sci_req;
-                sci_base_state_machine_change_state(&sci_dev->state_machine,
-                                                    SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD);
+                sci_change_state(&sci_dev->sm, SCI_SMP_DEV_CMD);
                 break;
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
-        case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
+        case SCI_STP_DEV_CMD:
+        case SCI_SMP_DEV_CMD:
                 /* device is already handling a command it can not accept new commands
                  * until this one is complete.
                  */
@@ -597,31 +594,31 @@ enum sci_status scic_sds_remote_device_complete_io(struct scic_sds_controller *s
                                                    struct scic_sds_remote_device *sci_dev,
                                                    struct scic_sds_request *sci_req)
 {
-        struct sci_base_state_machine *sm = &sci_dev->state_machine;
+        struct sci_base_state_machine *sm = &sci_dev->sm;
         enum scic_sds_remote_device_states state = sm->current_state_id;
         struct scic_sds_port *sci_port = sci_dev->owning_port;
         enum sci_status status;
 
         switch (state) {
-        case SCI_BASE_REMOTE_DEVICE_STATE_INITIAL:
-        case SCI_BASE_REMOTE_DEVICE_STATE_STOPPED:
-        case SCI_BASE_REMOTE_DEVICE_STATE_STARTING:
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
-        case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
-        case SCI_BASE_REMOTE_DEVICE_STATE_FAILED:
-        case SCI_BASE_REMOTE_DEVICE_STATE_FINAL:
+        case SCI_DEV_INITIAL:
+        case SCI_DEV_STOPPED:
+        case SCI_DEV_STARTING:
+        case SCI_STP_DEV_IDLE:
+        case SCI_SMP_DEV_IDLE:
+        case SCI_DEV_FAILED:
+        case SCI_DEV_FINAL:
         default:
                 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
                          __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
-        case SCI_BASE_REMOTE_DEVICE_STATE_READY:
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET:
-        case SCI_BASE_REMOTE_DEVICE_STATE_RESETTING:
+        case SCI_DEV_READY:
+        case SCI_STP_DEV_AWAIT_RESET:
+        case SCI_DEV_RESETTING:
                 status = common_complete_io(sci_port, sci_dev, sci_req);
                 break;
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ:
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR:
+        case SCI_STP_DEV_CMD:
+        case SCI_STP_DEV_NCQ:
+        case SCI_STP_DEV_NCQ_ERROR:
                 status = common_complete_io(sci_port, sci_dev, sci_req);
                 if (status != SCI_SUCCESS)
                         break;
@@ -632,17 +629,17 @@ enum sci_status scic_sds_remote_device_complete_io(struct scic_sds_controller *s
                          * can reach RNC state handler, these IOs will be completed by RNC with
                          * status of "DEVICE_RESET_REQUIRED", instead of "INVALID STATE".
                          */
-                        sci_base_state_machine_change_state(sm, SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET);
+                        sci_change_state(sm, SCI_STP_DEV_AWAIT_RESET);
                 } else if (scic_sds_remote_device_get_request_count(sci_dev) == 0)
-                        sci_base_state_machine_change_state(sm, SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE);
+                        sci_change_state(sm, SCI_STP_DEV_IDLE);
                 break;
-        case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
+        case SCI_SMP_DEV_CMD:
                 status = common_complete_io(sci_port, sci_dev, sci_req);
                 if (status != SCI_SUCCESS)
                         break;
-                sci_base_state_machine_change_state(sm, SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE);
+                sci_change_state(sm, SCI_SMP_DEV_IDLE);
                 break;
-        case SCI_BASE_REMOTE_DEVICE_STATE_STOPPING:
+        case SCI_DEV_STOPPING:
                 status = common_complete_io(sci_port, sci_dev, sci_req);
                 if (status != SCI_SUCCESS)
                         break;
@@ -676,30 +673,30 @@ enum sci_status scic_sds_remote_device_start_task(struct scic_sds_controller *sc
                                                   struct scic_sds_remote_device *sci_dev,
                                                   struct scic_sds_request *sci_req)
 {
-        struct sci_base_state_machine *sm = &sci_dev->state_machine;
+        struct sci_base_state_machine *sm = &sci_dev->sm;
         enum scic_sds_remote_device_states state = sm->current_state_id;
         struct scic_sds_port *sci_port = sci_dev->owning_port;
         enum sci_status status;
 
         switch (state) {
-        case SCI_BASE_REMOTE_DEVICE_STATE_INITIAL:
-        case SCI_BASE_REMOTE_DEVICE_STATE_STOPPED:
-        case SCI_BASE_REMOTE_DEVICE_STATE_STARTING:
-        case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
-        case SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
-        case SCI_BASE_REMOTE_DEVICE_STATE_STOPPING:
-        case SCI_BASE_REMOTE_DEVICE_STATE_FAILED:
-        case SCI_BASE_REMOTE_DEVICE_STATE_RESETTING:
-        case SCI_BASE_REMOTE_DEVICE_STATE_FINAL:
+        case SCI_DEV_INITIAL:
+        case SCI_DEV_STOPPED:
+        case SCI_DEV_STARTING:
+        case SCI_SMP_DEV_IDLE:
+        case SCI_SMP_DEV_CMD:
+        case SCI_DEV_STOPPING:
+        case SCI_DEV_FAILED:
+        case SCI_DEV_RESETTING:
+        case SCI_DEV_FINAL:
         default:
                 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
                          __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE:
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD:
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ:
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR:
-        case SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET:
+        case SCI_STP_DEV_IDLE:
+        case SCI_STP_DEV_CMD:
+        case SCI_STP_DEV_NCQ:
+        case SCI_STP_DEV_NCQ_ERROR:
+        case SCI_STP_DEV_AWAIT_RESET:
                 status = scic_sds_port_start_io(sci_port, sci_dev, sci_req);
                 if (status != SCI_SUCCESS)
                         return status;
@@ -717,7 +714,7 @@ enum sci_status scic_sds_remote_device_start_task(struct scic_sds_controller *sc
                  * management request.
                  */
                 sci_dev->working_request = sci_req;
-                sci_base_state_machine_change_state(sm, SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD);
+                sci_change_state(sm, SCI_STP_DEV_CMD);
 
                 /* The remote node context must cleanup the TCi to NCQ mapping
                  * table.  The only way to do this correctly is to either write
@@ -739,7 +736,7 @@ enum sci_status scic_sds_remote_device_start_task(struct scic_sds_controller *sc
                  * post TC when RNC gets resumed.
                  */
                 return SCI_FAILURE_RESET_DEVICE_PARTIAL_SUCCESS;
-        case SCI_BASE_REMOTE_DEVICE_STATE_READY:
+        case SCI_DEV_READY:
                 status = scic_sds_port_start_io(sci_port, sci_dev, sci_req);
                 if (status != SCI_SUCCESS)
                         return status;
@@ -790,8 +787,7 @@ static void remote_device_resume_done(void *_dev)
                 return;
 
         /* go 'ready' if we are not already in a ready state */
-        sci_base_state_machine_change_state(&sci_dev->state_machine,
-                                            SCI_BASE_REMOTE_DEVICE_STATE_READY);
+        sci_change_state(&sci_dev->sm, SCI_DEV_READY);
 }
 
 static void scic_sds_stp_remote_device_ready_idle_substate_resume_complete_handler(void *_dev)
@@ -803,17 +799,16 @@ static void scic_sds_stp_remote_device_ready_idle_substate_resume_complete_handl
         /* For NCQ operation we do not issue a isci_remote_device_not_ready().
          * As a result, avoid sending the ready notification.
          */
-        if (sci_dev->state_machine.previous_state_id != SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ)
+        if (sci_dev->sm.previous_state_id != SCI_STP_DEV_NCQ)
                 isci_remote_device_ready(scic_to_ihost(scic), idev);
 }
 
 static void scic_sds_remote_device_initial_state_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), state_machine);
+        struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), sm);
 
         /* Initial state is a transitional state to the stopped state */
-        sci_base_state_machine_change_state(&sci_dev->state_machine,
-                                            SCI_BASE_REMOTE_DEVICE_STATE_STOPPED);
+        sci_change_state(&sci_dev->sm, SCI_DEV_STOPPED);
 }
 
 /**
@@ -831,11 +826,11 @@ static void scic_sds_remote_device_initial_state_enter(struct sci_base_state_mac
  */
 static enum sci_status scic_remote_device_destruct(struct scic_sds_remote_device *sci_dev)
 {
-        struct sci_base_state_machine *sm = &sci_dev->state_machine;
+        struct sci_base_state_machine *sm = &sci_dev->sm;
         enum scic_sds_remote_device_states state = sm->current_state_id;
         struct scic_sds_controller *scic;
 
-        if (state != SCI_BASE_REMOTE_DEVICE_STATE_STOPPED) {
+        if (state != SCI_DEV_STOPPED) {
                 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
                          __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
@@ -845,7 +840,7 @@ static enum sci_status scic_remote_device_destruct(struct scic_sds_remote_device
         scic_sds_controller_free_remote_node_context(scic, sci_dev,
                                                      sci_dev->rnc.remote_node_index);
         sci_dev->rnc.remote_node_index = SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX;
-        sci_base_state_machine_change_state(sm, SCI_BASE_REMOTE_DEVICE_STATE_FINAL);
+        sci_change_state(sm, SCI_DEV_FINAL);
 
         return SCI_SUCCESS;
 }
@@ -906,7 +901,7 @@ static void isci_remote_device_stop_complete(struct isci_host *ihost,
 
 static void scic_sds_remote_device_stopped_state_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), state_machine);
+        struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), sm);
         struct scic_sds_controller *scic = sci_dev->owning_port->owning_controller;
         struct isci_remote_device *idev = sci_dev_to_idev(sci_dev);
         u32 prev_state;
@@ -914,8 +909,8 @@ static void scic_sds_remote_device_stopped_state_enter(struct sci_base_state_mac
         /* If we are entering from the stopping state let the SCI User know that
          * the stop operation has completed.
          */
-        prev_state = sci_dev->state_machine.previous_state_id;
-        if (prev_state == SCI_BASE_REMOTE_DEVICE_STATE_STOPPING)
+        prev_state = sci_dev->sm.previous_state_id;
+        if (prev_state == SCI_DEV_STOPPING)
                 isci_remote_device_stop_complete(scic_to_ihost(scic), idev);
 
         scic_sds_controller_remote_device_stopped(scic, sci_dev);
@@ -923,7 +918,7 @@ static void scic_sds_remote_device_stopped_state_enter(struct sci_base_state_mac
 
 static void scic_sds_remote_device_starting_state_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), state_machine);
+        struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), sm);
         struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev);
         struct isci_host *ihost = scic_to_ihost(scic);
         struct isci_remote_device *idev = sci_dev_to_idev(sci_dev);
@@ -934,7 +929,7 @@ static void scic_sds_remote_device_starting_state_enter(struct sci_base_state_ma
 
 static void scic_sds_remote_device_ready_state_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), state_machine);
+        struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), sm);
         struct scic_sds_controller *scic = sci_dev->owning_port->owning_controller;
         struct isci_remote_device *idev = sci_dev_to_idev(sci_dev);
         struct domain_device *dev = idev->domain_dev;
@@ -942,18 +937,16 @@ static void scic_sds_remote_device_ready_state_enter(struct sci_base_state_machi
         scic->remote_device_sequence[sci_dev->rnc.remote_node_index]++;
 
         if (dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_SATA)) {
-                sci_base_state_machine_change_state(&sci_dev->state_machine,
-                                                    SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE);
+                sci_change_state(&sci_dev->sm, SCI_STP_DEV_IDLE);
         } else if (dev_is_expander(dev)) {
-                sci_base_state_machine_change_state(&sci_dev->state_machine,
-                                                    SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE);
+                sci_change_state(&sci_dev->sm, SCI_SMP_DEV_IDLE);
         } else
                 isci_remote_device_ready(scic_to_ihost(scic), idev);
 }
 
 static void scic_sds_remote_device_ready_state_exit(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), state_machine);
+        struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), sm);
         struct domain_device *dev = sci_dev_to_domain(sci_dev);
 
         if (dev->dev_type == SAS_END_DEV) {
@@ -967,7 +960,7 @@ static void scic_sds_remote_device_ready_state_exit(struct sci_base_state_machin
 
 static void scic_sds_remote_device_resetting_state_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), state_machine);
+        struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), sm);
 
         scic_sds_remote_node_context_suspend(
                 &sci_dev->rnc, SCI_SOFTWARE_SUSPENSION, NULL, NULL);
@@ -975,14 +968,14 @@ static void scic_sds_remote_device_resetting_state_enter(struct sci_base_state_m
 
 static void scic_sds_remote_device_resetting_state_exit(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), state_machine);
+        struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), sm);
 
         scic_sds_remote_node_context_resume(&sci_dev->rnc, NULL, NULL);
 }
 
 static void scic_sds_stp_remote_device_ready_idle_substate_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), state_machine);
+        struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), sm);
 
         sci_dev->working_request = NULL;
         if (scic_sds_remote_node_context_is_ready(&sci_dev->rnc)) {
@@ -999,7 +992,7 @@ static void scic_sds_stp_remote_device_ready_idle_substate_enter(struct sci_base
 
 static void scic_sds_stp_remote_device_ready_cmd_substate_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), state_machine);
+        struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), sm);
         struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev);
 
         BUG_ON(sci_dev->working_request == NULL);
@@ -1010,7 +1003,7 @@ static void scic_sds_stp_remote_device_ready_cmd_substate_enter(struct sci_base_
 
 static void scic_sds_stp_remote_device_ready_ncq_error_substate_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), state_machine);
+        struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), sm);
         struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev);
         struct isci_remote_device *idev = sci_dev_to_idev(sci_dev);
 
@@ -1021,7 +1014,7 @@ static void scic_sds_stp_remote_device_ready_ncq_error_substate_enter(struct sci
 
 static void scic_sds_smp_remote_device_ready_idle_substate_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), state_machine);
+        struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), sm);
         struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev);
 
         isci_remote_device_ready(scic_to_ihost(scic), sci_dev_to_idev(sci_dev));
@@ -1029,7 +1022,7 @@ static void scic_sds_smp_remote_device_ready_idle_substate_enter(struct sci_base
 
 static void scic_sds_smp_remote_device_ready_cmd_substate_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), state_machine);
+        struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), sm);
         struct scic_sds_controller *scic = scic_sds_remote_device_get_controller(sci_dev);
 
         BUG_ON(sci_dev->working_request == NULL);
@@ -1040,50 +1033,50 @@ static void scic_sds_smp_remote_device_ready_cmd_substate_enter(struct sci_base_
 
 static void scic_sds_smp_remote_device_ready_cmd_substate_exit(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), state_machine);
+        struct scic_sds_remote_device *sci_dev = container_of(sm, typeof(*sci_dev), sm);
 
         sci_dev->working_request = NULL;
 }
 
 static const struct sci_base_state scic_sds_remote_device_state_table[] = {
-        [SCI_BASE_REMOTE_DEVICE_STATE_INITIAL] = {
+        [SCI_DEV_INITIAL] = {
                 .enter_state = scic_sds_remote_device_initial_state_enter,
         },
-        [SCI_BASE_REMOTE_DEVICE_STATE_STOPPED] = {
+        [SCI_DEV_STOPPED] = {
                 .enter_state = scic_sds_remote_device_stopped_state_enter,
         },
-        [SCI_BASE_REMOTE_DEVICE_STATE_STARTING] = {
+        [SCI_DEV_STARTING] = {
                 .enter_state = scic_sds_remote_device_starting_state_enter,
         },
-        [SCI_BASE_REMOTE_DEVICE_STATE_READY] = {
+        [SCI_DEV_READY] = {
                 .enter_state = scic_sds_remote_device_ready_state_enter,
                 .exit_state  = scic_sds_remote_device_ready_state_exit
         },
-        [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE] = {
+        [SCI_STP_DEV_IDLE] = {
                 .enter_state = scic_sds_stp_remote_device_ready_idle_substate_enter,
         },
-        [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD] = {
+        [SCI_STP_DEV_CMD] = {
                 .enter_state = scic_sds_stp_remote_device_ready_cmd_substate_enter,
         },
-        [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ] = { },
-        [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR] = {
+        [SCI_STP_DEV_NCQ] = { },
+        [SCI_STP_DEV_NCQ_ERROR] = {
                 .enter_state = scic_sds_stp_remote_device_ready_ncq_error_substate_enter,
         },
-        [SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET] = { },
-        [SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE] = {
+        [SCI_STP_DEV_AWAIT_RESET] = { },
+        [SCI_SMP_DEV_IDLE] = {
                 .enter_state = scic_sds_smp_remote_device_ready_idle_substate_enter,
         },
-        [SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD] = {
+        [SCI_SMP_DEV_CMD] = {
                 .enter_state = scic_sds_smp_remote_device_ready_cmd_substate_enter,
                 .exit_state  = scic_sds_smp_remote_device_ready_cmd_substate_exit,
         },
-        [SCI_BASE_REMOTE_DEVICE_STATE_STOPPING] = { },
-        [SCI_BASE_REMOTE_DEVICE_STATE_FAILED] = { },
-        [SCI_BASE_REMOTE_DEVICE_STATE_RESETTING] = {
+        [SCI_DEV_STOPPING] = { },
+        [SCI_DEV_FAILED] = { },
+        [SCI_DEV_RESETTING] = {
                 .enter_state = scic_sds_remote_device_resetting_state_enter,
                 .exit_state  = scic_sds_remote_device_resetting_state_exit
         },
-        [SCI_BASE_REMOTE_DEVICE_STATE_FINAL] = { },
+        [SCI_DEV_FINAL] = { },
 };
 
 /**
@@ -1102,11 +1095,11 @@ static void scic_remote_device_construct(struct scic_sds_port *sci_port,
         sci_dev->owning_port = sci_port;
         sci_dev->started_request_count = 0;
 
-        sci_base_state_machine_construct(&sci_dev->state_machine,
+        sci_base_state_machine_construct(&sci_dev->sm,
                                          scic_sds_remote_device_state_table,
-                                         SCI_BASE_REMOTE_DEVICE_STATE_INITIAL);
+                                         SCI_DEV_INITIAL);
 
-        sci_base_state_machine_start(&sci_dev->state_machine);
+        sci_base_state_machine_start(&sci_dev->sm);
 
         scic_sds_remote_node_context_construct(&sci_dev->rnc,
                                                SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX);
@@ -1224,11 +1217,11 @@ static enum sci_status scic_remote_device_ea_construct(struct scic_sds_port *sci
 static enum sci_status scic_remote_device_start(struct scic_sds_remote_device *sci_dev,
                                                 u32 timeout)
 {
-        struct sci_base_state_machine *sm = &sci_dev->state_machine;
+        struct sci_base_state_machine *sm = &sci_dev->sm;
         enum scic_sds_remote_device_states state = sm->current_state_id;
         enum sci_status status;
 
-        if (state != SCI_BASE_REMOTE_DEVICE_STATE_STOPPED) {
+        if (state != SCI_DEV_STOPPED) {
                 dev_warn(scirdev_to_dev(sci_dev), "%s: in wrong state: %d\n",
                          __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
@@ -1240,7 +1233,7 @@ static enum sci_status scic_remote_device_start(struct scic_sds_remote_device *s
         if (status != SCI_SUCCESS)
                 return status;
 
-        sci_base_state_machine_change_state(sm, SCI_BASE_REMOTE_DEVICE_STATE_STARTING);
+        sci_change_state(sm, SCI_DEV_STARTING);
 
         return SCI_SUCCESS;
 }
diff --git a/drivers/scsi/isci/remote_device.h b/drivers/scsi/isci/remote_device.h
index a118f5873f64..2b6a5bb7bd60 100644
--- a/drivers/scsi/isci/remote_device.h
+++ b/drivers/scsi/isci/remote_device.h
@@ -74,7 +74,7 @@ struct scic_sds_remote_device {
          * This field contains the information for the base remote device state
          * machine.
          */
-        struct sci_base_state_machine state_machine;
+        struct sci_base_state_machine sm;
 
         /**
          * This field is the programmed device port width.  This value is
@@ -109,7 +109,7 @@ struct scic_sds_remote_device {
 
         /**
          * This field contains the stated request count for the remote device.  The
-         * device can not reach the SCI_BASE_REMOTE_DEVICE_STATE_STOPPED until all
+         * device can not reach the SCI_DEV_STOPPED until all
          * requests are complete and the rnc_posted value is false.
          */
         u32 started_request_count;
@@ -213,7 +213,7 @@ enum scic_sds_remote_device_states {
         /**
          * Simply the initial state for the base remote device state machine.
          */
-        SCI_BASE_REMOTE_DEVICE_STATE_INITIAL,
+        SCI_DEV_INITIAL,
 
         /**
          * This state indicates that the remote device has successfully been
@@ -221,7 +221,7 @@ enum scic_sds_remote_device_states {
          * This state is entered from the INITIAL state.
          * This state is entered from the STOPPING state.
          */
-        SCI_BASE_REMOTE_DEVICE_STATE_STOPPED,
+        SCI_DEV_STOPPED,
 
         /**
          * This state indicates the the remote device is in the process of
@@ -229,34 +229,34 @@ enum scic_sds_remote_device_states {
          * are permitted.
          * This state is entered from the STOPPED state.
          */
-        SCI_BASE_REMOTE_DEVICE_STATE_STARTING,
+        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_BASE_REMOTE_DEVICE_STATE_READY,
+        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.
          */
-        SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE,
+        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.
          */
-        SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_CMD,
+        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.
          */
-        SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ,
+        SCI_STP_DEV_NCQ,
 
         /**
          * This is the NCQ error state for the STP remote device.  This state is
@@ -264,25 +264,25 @@ enum scic_sds_remote_device_states {
          * NCQ state.  The device object will only accept a READ LOG command while in
          * this state.
          */
-        SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR,
+        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.
          */
-        SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET,
+        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.
          */
-        SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_IDLE,
+        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.
          */
-        SCIC_SDS_SMP_REMOTE_DEVICE_READY_SUBSTATE_CMD,
+        SCI_SMP_DEV_CMD,
 
         /**
          * This state indicates that the remote device is in the process of
@@ -291,7 +291,7 @@ enum scic_sds_remote_device_states {
          * This state is entered from the READY state.
          * This state is entered from the FAILED state.
          */
-        SCI_BASE_REMOTE_DEVICE_STATE_STOPPING,
+        SCI_DEV_STOPPING,
 
         /**
          * This state indicates that the remote device has failed.
@@ -299,19 +299,19 @@ enum scic_sds_remote_device_states {
          * This state is entered from the INITIALIZING state.
          * This state is entered from the READY state.
          */
-        SCI_BASE_REMOTE_DEVICE_STATE_FAILED,
+        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_BASE_REMOTE_DEVICE_STATE_RESETTING,
+        SCI_DEV_RESETTING,
 
         /**
          * Simply the final state for the base remote device state machine.
          */
-        SCI_BASE_REMOTE_DEVICE_STATE_FINAL,
+        SCI_DEV_FINAL,
 };
 
 static inline struct scic_sds_remote_device *rnc_to_dev(struct scic_sds_remote_node_context *rnc)
diff --git a/drivers/scsi/isci/remote_node_context.c b/drivers/scsi/isci/remote_node_context.c
index e7fa5bac7d53..24b1d8acf7b8 100644
--- a/drivers/scsi/isci/remote_node_context.c
+++ b/drivers/scsi/isci/remote_node_context.c
@@ -84,9 +84,9 @@
 bool scic_sds_remote_node_context_is_ready(
         struct scic_sds_remote_node_context *sci_rnc)
 {
-        u32 current_state = sci_base_state_machine_get_state(&sci_rnc->state_machine);
+        u32 current_state = sci_rnc->sm.current_state_id;
 
-        if (current_state == SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE) {
+        if (current_state == SCI_RNC_READY) {
                 return true;
         }
 
@@ -268,12 +268,12 @@ static void scic_sds_remote_node_context_invalidate_context_buffer(
 
 static void scic_sds_remote_node_context_initial_state_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_remote_node_context *rnc = container_of(sm, typeof(*rnc), state_machine);
+        struct scic_sds_remote_node_context *rnc = container_of(sm, typeof(*rnc), sm);
 
         /* 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 == SCIC_SDS_REMOTE_NODE_CONTEXT_INVALIDATING_STATE) {
+        if (sm->previous_state_id == SCI_RNC_INVALIDATING) {
                 rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_UNSPECIFIED;
                 scic_sds_remote_node_context_notify_user(rnc);
         }
@@ -281,21 +281,21 @@ static void scic_sds_remote_node_context_initial_state_enter(struct sci_base_sta
 
 static void scic_sds_remote_node_context_posting_state_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_remote_node_context *sci_rnc = container_of(sm, typeof(*sci_rnc), state_machine);
+        struct scic_sds_remote_node_context *sci_rnc = container_of(sm, typeof(*sci_rnc), sm);
 
         scic_sds_remote_node_context_validate_context_buffer(sci_rnc);
 }
 
 static void scic_sds_remote_node_context_invalidating_state_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_remote_node_context *rnc = container_of(sm, typeof(*rnc), state_machine);
+        struct scic_sds_remote_node_context *rnc = container_of(sm, typeof(*rnc), sm);
 
         scic_sds_remote_node_context_invalidate_context_buffer(rnc);
 }
 
 static void scic_sds_remote_node_context_resuming_state_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_remote_node_context *rnc = container_of(sm, typeof(*rnc), state_machine);
+        struct scic_sds_remote_node_context *rnc = container_of(sm, typeof(*rnc), sm);
         struct scic_sds_remote_device *sci_dev;
         struct domain_device *dev;
 
@@ -318,7 +318,7 @@ static void scic_sds_remote_node_context_resuming_state_enter(struct sci_base_st
 
 static void scic_sds_remote_node_context_ready_state_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_remote_node_context *rnc = container_of(sm, typeof(*rnc), state_machine);
+        struct scic_sds_remote_node_context *rnc = container_of(sm, typeof(*rnc), sm);
 
         rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_UNSPECIFIED;
 
@@ -328,41 +328,41 @@ static void scic_sds_remote_node_context_ready_state_enter(struct sci_base_state
 
 static void scic_sds_remote_node_context_tx_suspended_state_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_remote_node_context *rnc = container_of(sm, typeof(*rnc), state_machine);
+        struct scic_sds_remote_node_context *rnc = container_of(sm, typeof(*rnc), sm);
 
         scic_sds_remote_node_context_continue_state_transitions(rnc);
 }
 
 static void scic_sds_remote_node_context_tx_rx_suspended_state_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_remote_node_context *rnc = container_of(sm, typeof(*rnc), state_machine);
+        struct scic_sds_remote_node_context *rnc = container_of(sm, typeof(*rnc), sm);
 
         scic_sds_remote_node_context_continue_state_transitions(rnc);
 }
 
 static const struct sci_base_state scic_sds_remote_node_context_state_table[] = {
-        [SCIC_SDS_REMOTE_NODE_CONTEXT_INITIAL_STATE] = {
+        [SCI_RNC_INITIAL] = {
                 .enter_state = scic_sds_remote_node_context_initial_state_enter,
         },
-        [SCIC_SDS_REMOTE_NODE_CONTEXT_POSTING_STATE] = {
+        [SCI_RNC_POSTING] = {
                 .enter_state = scic_sds_remote_node_context_posting_state_enter,
         },
-        [SCIC_SDS_REMOTE_NODE_CONTEXT_INVALIDATING_STATE] = {
+        [SCI_RNC_INVALIDATING] = {
                 .enter_state = scic_sds_remote_node_context_invalidating_state_enter,
         },
-        [SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE] = {
+        [SCI_RNC_RESUMING] = {
                 .enter_state = scic_sds_remote_node_context_resuming_state_enter,
         },
-        [SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE] = {
+        [SCI_RNC_READY] = {
                 .enter_state = scic_sds_remote_node_context_ready_state_enter,
         },
-        [SCIC_SDS_REMOTE_NODE_CONTEXT_TX_SUSPENDED_STATE] = {
+        [SCI_RNC_TX_SUSPENDED] = {
                 .enter_state = scic_sds_remote_node_context_tx_suspended_state_enter,
         },
-        [SCIC_SDS_REMOTE_NODE_CONTEXT_TX_RX_SUSPENDED_STATE] = {
+        [SCI_RNC_TX_RX_SUSPENDED] = {
                 .enter_state = scic_sds_remote_node_context_tx_rx_suspended_state_enter,
         },
-        [SCIC_SDS_REMOTE_NODE_CONTEXT_AWAIT_SUSPENSION_STATE] = { },
+        [SCI_RNC_AWAIT_SUSPENSION] = { },
 };
 
 void scic_sds_remote_node_context_construct(struct scic_sds_remote_node_context *rnc,
@@ -373,11 +373,11 @@ void scic_sds_remote_node_context_construct(struct scic_sds_remote_node_context
         rnc->remote_node_index = remote_node_index;
         rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_UNSPECIFIED;
 
-        sci_base_state_machine_construct(&rnc->state_machine,
+        sci_base_state_machine_construct(&rnc->sm,
                                          scic_sds_remote_node_context_state_table,
-                                         SCIC_SDS_REMOTE_NODE_CONTEXT_INITIAL_STATE);
+                                         SCI_RNC_INITIAL);
 
-        sci_base_state_machine_start(&rnc->state_machine);
+        sci_base_state_machine_start(&rnc->sm);
 }
 
 enum sci_status scic_sds_remote_node_context_event_handler(struct scic_sds_remote_node_context *sci_rnc,
@@ -385,26 +385,24 @@ enum sci_status scic_sds_remote_node_context_event_handler(struct scic_sds_remot
 {
         enum scis_sds_remote_node_context_states state;
 
-        state = sci_rnc->state_machine.current_state_id;
+        state = sci_rnc->sm.current_state_id;
         switch (state) {
-        case SCIC_SDS_REMOTE_NODE_CONTEXT_POSTING_STATE:
+        case SCI_RNC_POSTING:
                 switch (scu_get_event_code(event_code)) {
                 case SCU_EVENT_POST_RNC_COMPLETE:
-                        sci_base_state_machine_change_state(&sci_rnc->state_machine,
-                                                            SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE);
+                        sci_change_state(&sci_rnc->sm, SCI_RNC_READY);
                         break;
                 default:
                         goto out;
                 }
                 break;
-        case SCIC_SDS_REMOTE_NODE_CONTEXT_INVALIDATING_STATE:
+        case SCI_RNC_INVALIDATING:
                 if (scu_get_event_code(event_code) == SCU_EVENT_POST_RNC_INVALIDATE_COMPLETE) {
                         if (sci_rnc->destination_state == SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_FINAL)
-                                state = SCIC_SDS_REMOTE_NODE_CONTEXT_INITIAL_STATE;
+                                state = SCI_RNC_INITIAL;
                         else
-                                state = SCIC_SDS_REMOTE_NODE_CONTEXT_POSTING_STATE;
-                        sci_base_state_machine_change_state(&sci_rnc->state_machine,
-                                                            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:
@@ -421,10 +419,9 @@ enum sci_status scic_sds_remote_node_context_event_handler(struct scic_sds_remot
                         }
                 }
                 break;
-        case SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE:
+        case SCI_RNC_RESUMING:
                 if (scu_get_event_code(event_code) == SCU_EVENT_POST_RCN_RELEASE) {
-                        sci_base_state_machine_change_state(&sci_rnc->state_machine,
-                                                            SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE);
+                        sci_change_state(&sci_rnc->sm, SCI_RNC_READY);
                 } else {
                         switch (scu_get_event_type(event_code)) {
                         case SCU_EVENT_TYPE_RNC_SUSPEND_TX:
@@ -441,32 +438,28 @@ enum sci_status scic_sds_remote_node_context_event_handler(struct scic_sds_remot
                         }
                 }
                 break;
-        case SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE:
+        case SCI_RNC_READY:
                 switch (scu_get_event_type(event_code)) {
                 case SCU_EVENT_TL_RNC_SUSPEND_TX:
-                        sci_base_state_machine_change_state(&sci_rnc->state_machine,
-                                                            SCIC_SDS_REMOTE_NODE_CONTEXT_TX_SUSPENDED_STATE);
+                        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:
-                        sci_base_state_machine_change_state(&sci_rnc->state_machine,
-                                                            SCIC_SDS_REMOTE_NODE_CONTEXT_TX_RX_SUSPENDED_STATE);
+                        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;
                 }
                 break;
-        case SCIC_SDS_REMOTE_NODE_CONTEXT_AWAIT_SUSPENSION_STATE:
+        case SCI_RNC_AWAIT_SUSPENSION:
                 switch (scu_get_event_type(event_code)) {
                 case SCU_EVENT_TL_RNC_SUSPEND_TX:
-                        sci_base_state_machine_change_state(&sci_rnc->state_machine,
-                                                            SCIC_SDS_REMOTE_NODE_CONTEXT_TX_SUSPENDED_STATE);
+                        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:
-                        sci_base_state_machine_change_state(&sci_rnc->state_machine,
-                                                            SCIC_SDS_REMOTE_NODE_CONTEXT_TX_RX_SUSPENDED_STATE);
+                        sci_change_state(&sci_rnc->sm, SCI_RNC_TX_RX_SUSPENDED);
                         sci_rnc->suspension_code = scu_get_event_specifier(event_code);
                         break;
                 default:
@@ -493,22 +486,21 @@ enum sci_status scic_sds_remote_node_context_destruct(struct scic_sds_remote_nod
 {
         enum scis_sds_remote_node_context_states state;
 
-        state = sci_rnc->state_machine.current_state_id;
+        state = sci_rnc->sm.current_state_id;
         switch (state) {
-        case SCIC_SDS_REMOTE_NODE_CONTEXT_INVALIDATING_STATE:
+        case SCI_RNC_INVALIDATING:
                 scic_sds_remote_node_context_setup_to_destory(sci_rnc, cb_fn, cb_p);
                 return SCI_SUCCESS;
-        case SCIC_SDS_REMOTE_NODE_CONTEXT_POSTING_STATE:
-        case SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE:
-        case SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE:
-        case SCIC_SDS_REMOTE_NODE_CONTEXT_TX_SUSPENDED_STATE:
-        case SCIC_SDS_REMOTE_NODE_CONTEXT_TX_RX_SUSPENDED_STATE:
-        case SCIC_SDS_REMOTE_NODE_CONTEXT_AWAIT_SUSPENSION_STATE:
+        case SCI_RNC_POSTING:
+        case SCI_RNC_RESUMING:
+        case SCI_RNC_READY:
+        case SCI_RNC_TX_SUSPENDED:
+        case SCI_RNC_TX_RX_SUSPENDED:
+        case SCI_RNC_AWAIT_SUSPENSION:
                 scic_sds_remote_node_context_setup_to_destory(sci_rnc, cb_fn, cb_p);
-                sci_base_state_machine_change_state(&sci_rnc->state_machine,
-                                                    SCIC_SDS_REMOTE_NODE_CONTEXT_INVALIDATING_STATE);
+                sci_change_state(&sci_rnc->sm, SCI_RNC_INVALIDATING);
                 return SCI_SUCCESS;
-        case SCIC_SDS_REMOTE_NODE_CONTEXT_INITIAL_STATE:
+        case SCI_RNC_INITIAL:
                 dev_warn(scirdev_to_dev(rnc_to_dev(sci_rnc)),
                          "%s: invalid state %d\n", __func__, state);
                 /* We have decided that the destruct request on the remote node context
@@ -530,8 +522,8 @@ enum sci_status scic_sds_remote_node_context_suspend(struct scic_sds_remote_node
 {
         enum scis_sds_remote_node_context_states state;
 
-        state = sci_rnc->state_machine.current_state_id;
-        if (state != SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE) {
+        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 %d\n", __func__, state);
                 return SCI_FAILURE_INVALID_STATE;
@@ -546,8 +538,7 @@ enum sci_status scic_sds_remote_node_context_suspend(struct scic_sds_remote_node
                                                     SCU_CONTEXT_COMMAND_POST_RNC_SUSPEND_TX);
         }
 
-        sci_base_state_machine_change_state(&sci_rnc->state_machine,
-                                            SCIC_SDS_REMOTE_NODE_CONTEXT_AWAIT_SUSPENSION_STATE);
+        sci_change_state(&sci_rnc->sm, SCI_RNC_AWAIT_SUSPENSION);
         return SCI_SUCCESS;
 }
 
@@ -557,27 +548,26 @@ enum sci_status scic_sds_remote_node_context_resume(struct scic_sds_remote_node_
 {
         enum scis_sds_remote_node_context_states state;
 
-        state = sci_rnc->state_machine.current_state_id;
+        state = sci_rnc->sm.current_state_id;
         switch (state) {
-        case SCIC_SDS_REMOTE_NODE_CONTEXT_INITIAL_STATE:
+        case SCI_RNC_INITIAL:
                 if (sci_rnc->remote_node_index == SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX)
                         return SCI_FAILURE_INVALID_STATE;
 
                 scic_sds_remote_node_context_setup_to_resume(sci_rnc, cb_fn, cb_p);
                 scic_sds_remote_node_context_construct_buffer(sci_rnc);
-                sci_base_state_machine_change_state(&sci_rnc->state_machine,
-                                                    SCIC_SDS_REMOTE_NODE_CONTEXT_POSTING_STATE);
+                sci_change_state(&sci_rnc->sm, SCI_RNC_POSTING);
                 return SCI_SUCCESS;
-        case SCIC_SDS_REMOTE_NODE_CONTEXT_POSTING_STATE:
-        case SCIC_SDS_REMOTE_NODE_CONTEXT_INVALIDATING_STATE:
-        case SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE:
+        case SCI_RNC_POSTING:
+        case SCI_RNC_INVALIDATING:
+        case SCI_RNC_RESUMING:
                 if (sci_rnc->destination_state != SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_READY)
                         return SCI_FAILURE_INVALID_STATE;
 
                 sci_rnc->user_callback = cb_fn;
                 sci_rnc->user_cookie   = cb_p;
                 return SCI_SUCCESS;
-        case SCIC_SDS_REMOTE_NODE_CONTEXT_TX_SUSPENDED_STATE: {
+        case SCI_RNC_TX_SUSPENDED: {
                 struct scic_sds_remote_device *sci_dev = rnc_to_dev(sci_rnc);
                 struct domain_device *dev = sci_dev_to_domain(sci_dev);
 
@@ -585,27 +575,23 @@ enum sci_status scic_sds_remote_node_context_resume(struct scic_sds_remote_node_
 
                 /* TODO: consider adding a resume action of NONE, INVALIDATE, WRITE_TLCR */
                 if (dev->dev_type == SAS_END_DEV || dev_is_expander(dev))
-                        sci_base_state_machine_change_state(&sci_rnc->state_machine,
-                                                            SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE);
+                        sci_change_state(&sci_rnc->sm, SCI_RNC_RESUMING);
                 else if (dev->dev_type == SATA_DEV || (dev->tproto & SAS_PROTOCOL_STP)) {
                         if (sci_dev->is_direct_attached) {
                                 /* @todo Fix this since I am being silly in writing to the STPTLDARNI register. */
-                                sci_base_state_machine_change_state(&sci_rnc->state_machine,
-                                        SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE);
+                                sci_change_state(&sci_rnc->sm, SCI_RNC_RESUMING);
                         } else {
-                                sci_base_state_machine_change_state(&sci_rnc->state_machine,
-                                        SCIC_SDS_REMOTE_NODE_CONTEXT_INVALIDATING_STATE);
+                                sci_change_state(&sci_rnc->sm, SCI_RNC_INVALIDATING);
                         }
                 } else
                         return SCI_FAILURE;
                 return SCI_SUCCESS;
         }
-        case SCIC_SDS_REMOTE_NODE_CONTEXT_TX_RX_SUSPENDED_STATE:
+        case SCI_RNC_TX_RX_SUSPENDED:
                 scic_sds_remote_node_context_setup_to_resume(sci_rnc, cb_fn, cb_p);
-                sci_base_state_machine_change_state(&sci_rnc->state_machine,
-                                                    SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE);
+                sci_change_state(&sci_rnc->sm, SCI_RNC_RESUMING);
                 return SCI_FAILURE_INVALID_STATE;
-        case SCIC_SDS_REMOTE_NODE_CONTEXT_AWAIT_SUSPENSION_STATE:
+        case SCI_RNC_AWAIT_SUSPENSION:
                 scic_sds_remote_node_context_setup_to_resume(sci_rnc, cb_fn, cb_p);
                 return SCI_SUCCESS;
         default:
@@ -620,8 +606,8 @@ enum sci_status scic_sds_remote_node_context_start_io(struct scic_sds_remote_nod
 {
         enum scis_sds_remote_node_context_states state;
 
-        state = sci_rnc->state_machine.current_state_id;
-        if (state != SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE) {
+        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 %d\n", __func__, state);
                 return SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
@@ -634,14 +620,14 @@ enum sci_status scic_sds_remote_node_context_start_task(struct scic_sds_remote_n
 {
         enum scis_sds_remote_node_context_states state;
 
-        state = sci_rnc->state_machine.current_state_id;
+        state = sci_rnc->sm.current_state_id;
         switch (state) {
-        case SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE:
-        case SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE:
-        case SCIC_SDS_REMOTE_NODE_CONTEXT_AWAIT_SUSPENSION_STATE:
+        case SCI_RNC_RESUMING:
+        case SCI_RNC_READY:
+        case SCI_RNC_AWAIT_SUSPENSION:
                 return SCI_SUCCESS;
-        case SCIC_SDS_REMOTE_NODE_CONTEXT_TX_SUSPENDED_STATE:
-        case SCIC_SDS_REMOTE_NODE_CONTEXT_TX_RX_SUSPENDED_STATE:
+        case SCI_RNC_TX_SUSPENDED:
+        case SCI_RNC_TX_RX_SUSPENDED:
                 scic_sds_remote_node_context_resume(sci_rnc, NULL, NULL);
                 return SCI_SUCCESS;
         default:
diff --git a/drivers/scsi/isci/remote_node_context.h b/drivers/scsi/isci/remote_node_context.h
index f53329f782c8..e6c7248be3f6 100644
--- a/drivers/scsi/isci/remote_node_context.h
+++ b/drivers/scsi/isci/remote_node_context.h
@@ -92,45 +92,45 @@ 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.
          */
-        SCIC_SDS_REMOTE_NODE_CONTEXT_INITIAL_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.
          */
-        SCIC_SDS_REMOTE_NODE_CONTEXT_POSTING_STATE,
+        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.
          */
-        SCIC_SDS_REMOTE_NODE_CONTEXT_INVALIDATING_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.
          */
-        SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE,
+        SCI_RNC_RESUMING,
 
         /**
          * This is the state that the remote node context must be in to accept io
          * request operations.
          */
-        SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE,
+        SCI_RNC_READY,
 
         /**
          * This is the state that the remote node context transitions to when it gets
          * a TX suspend notification from the hardware.
          */
-        SCIC_SDS_REMOTE_NODE_CONTEXT_TX_SUSPENDED_STATE,
+        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.
          */
-        SCIC_SDS_REMOTE_NODE_CONTEXT_TX_RX_SUSPENDED_STATE,
+        SCI_RNC_TX_RX_SUSPENDED,
 
         /**
          * This state is a wait state for the remote node context that waits for a
@@ -138,7 +138,7 @@ enum scis_sds_remote_node_context_states {
          * 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.
          */
-        SCIC_SDS_REMOTE_NODE_CONTEXT_AWAIT_SUSPENSION_STATE
+        SCI_RNC_AWAIT_SUSPENSION
 };
 
 /**
@@ -194,7 +194,7 @@ struct scic_sds_remote_node_context {
         /**
          * This field contains the data for the object's state machine.
          */
-        struct sci_base_state_machine state_machine;
+        struct sci_base_state_machine sm;
 };
 
 void scic_sds_remote_node_context_construct(struct scic_sds_remote_node_context *rnc,
diff --git a/drivers/scsi/isci/request.c b/drivers/scsi/isci/request.c
index 31c9b2c34259..89f0ab925c27 100644
--- a/drivers/scsi/isci/request.c
+++ b/drivers/scsi/isci/request.c
@@ -649,8 +649,7 @@ static enum sci_status scic_io_request_construct_basic_ssp(struct scic_sds_reque
 
         scic_sds_io_request_build_ssp_command_iu(sci_req);
 
-        sci_base_state_machine_change_state(&sci_req->state_machine,
-                                            SCI_BASE_REQUEST_STATE_CONSTRUCTED);
+        sci_change_state(&sci_req->sm, SCI_REQ_CONSTRUCTED);
 
         return SCI_SUCCESS;
 }
@@ -664,8 +663,7 @@ enum sci_status scic_task_request_construct_ssp(
         /* Fill in the SSP Task IU */
         scic_sds_task_request_build_ssp_task_iu(sci_req);
 
-        sci_base_state_machine_change_state(&sci_req->state_machine,
-                                            SCI_BASE_REQUEST_STATE_CONSTRUCTED);
+        sci_change_state(&sci_req->sm, SCI_REQ_CONSTRUCTED);
 
         return SCI_SUCCESS;
 }
@@ -687,8 +685,7 @@ static enum sci_status scic_io_request_construct_basic_sata(struct scic_sds_requ
                                                 copy);
 
         if (status == SCI_SUCCESS)
-                sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                    SCI_BASE_REQUEST_STATE_CONSTRUCTED);
+                sci_change_state(&sci_req->sm, SCI_REQ_CONSTRUCTED);
 
         return status;
 }
@@ -718,8 +715,7 @@ enum sci_status scic_task_request_construct_sata(struct scic_sds_request *sci_re
 
         if (status != SCI_SUCCESS)
                 return status;
-        sci_base_state_machine_change_state(&sci_req->state_machine,
-                                            SCI_BASE_REQUEST_STATE_CONSTRUCTED);
+        sci_change_state(&sci_req->sm, SCI_REQ_CONSTRUCTED);
 
         return status;
 }
@@ -761,8 +757,8 @@ enum sci_status scic_sds_request_start(struct scic_sds_request *sci_req)
             scic_sds_remote_device_get_sequence(sci_req->target_device))
                 return SCI_FAILURE;
 
-        state = sci_req->state_machine.current_state_id;
-        if (state != SCI_BASE_REQUEST_STATE_CONSTRUCTED) {
+        state = sci_req->sm.current_state_id;
+        if (state != SCI_REQ_CONSTRUCTED) {
                 dev_warn(scic_to_dev(scic),
                         "%s: SCIC IO Request requested to start while in wrong "
                          "state %d\n", __func__, state);
@@ -818,8 +814,7 @@ enum sci_status scic_sds_request_start(struct scic_sds_request *sci_req)
                 sci_req->post_context |= scic_sds_io_tag_get_index(sci_req->io_tag);
 
                 /* Everything is good go ahead and change state */
-                sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                    SCI_BASE_REQUEST_STATE_STARTED);
+                sci_change_state(&sci_req->sm, SCI_REQ_STARTED);
 
                 return SCI_SUCCESS;
         }
@@ -832,52 +827,47 @@ scic_sds_io_request_terminate(struct scic_sds_request *sci_req)
 {
         enum sci_base_request_states state;
 
-        state = sci_req->state_machine.current_state_id;
+        state = sci_req->sm.current_state_id;
 
         switch (state) {
-        case SCI_BASE_REQUEST_STATE_CONSTRUCTED:
+        case SCI_REQ_CONSTRUCTED:
                 scic_sds_request_set_status(sci_req,
                         SCU_TASK_DONE_TASK_ABORT,
                         SCI_FAILURE_IO_TERMINATED);
 
-                sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                    SCI_BASE_REQUEST_STATE_COMPLETED);
+                sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
                 return SCI_SUCCESS;
-        case SCI_BASE_REQUEST_STATE_STARTED:
-        case SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATE_AWAIT_TC_COMPLETION:
-        case SCIC_SDS_SMP_REQUEST_STARTED_SUBSTATE_AWAIT_RESPONSE:
-        case SCIC_SDS_SMP_REQUEST_STARTED_SUBSTATE_AWAIT_TC_COMPLETION:
-        case SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_TC_COMPLETION_SUBSTATE:
-        case SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_D2H_REG_FIS_SUBSTATE:
-        case SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_H2D_COMPLETION_SUBSTATE:
-        case SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_D2H_SUBSTATE:
-        case SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_H2D_COMPLETION_SUBSTATE:
-        case SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE:
-        case SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_IN_AWAIT_DATA_SUBSTATE:
-        case SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_OUT_TRANSMIT_DATA_SUBSTATE:
-        case SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_ASSERTED_COMPLETION_SUBSTATE:
-        case SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_DIAGNOSTIC_COMPLETION_SUBSTATE:
-        case SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_D2H_RESPONSE_FRAME_SUBSTATE:
-                sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                    SCI_BASE_REQUEST_STATE_ABORTING);
+        case SCI_REQ_STARTED:
+        case SCI_REQ_TASK_WAIT_TC_COMP:
+        case SCI_REQ_SMP_WAIT_RESP:
+        case SCI_REQ_SMP_WAIT_TC_COMP:
+        case SCI_REQ_STP_UDMA_WAIT_TC_COMP:
+        case SCI_REQ_STP_UDMA_WAIT_D2H:
+        case SCI_REQ_STP_NON_DATA_WAIT_H2D:
+        case SCI_REQ_STP_NON_DATA_WAIT_D2H:
+        case SCI_REQ_STP_PIO_WAIT_H2D:
+        case SCI_REQ_STP_PIO_WAIT_FRAME:
+        case SCI_REQ_STP_PIO_DATA_IN:
+        case SCI_REQ_STP_PIO_DATA_OUT:
+        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(&sci_req->sm, SCI_REQ_ABORTING);
                 return SCI_SUCCESS;
-        case SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATE_AWAIT_TC_RESPONSE:
-                sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                    SCI_BASE_REQUEST_STATE_ABORTING);
-                sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                    SCI_BASE_REQUEST_STATE_COMPLETED);
+        case SCI_REQ_TASK_WAIT_TC_RESP:
+                sci_change_state(&sci_req->sm, SCI_REQ_ABORTING);
+                sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
                 return SCI_SUCCESS;
-        case SCI_BASE_REQUEST_STATE_ABORTING:
-                sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                    SCI_BASE_REQUEST_STATE_COMPLETED);
+        case SCI_REQ_ABORTING:
+                sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
                 return SCI_SUCCESS;
-        case SCI_BASE_REQUEST_STATE_COMPLETED:
+        case SCI_REQ_COMPLETED:
         default:
                 dev_warn(scic_to_dev(sci_req->owning_controller),
                          "%s: SCIC IO Request requested to abort while in wrong "
                          "state %d\n",
                          __func__,
-                         sci_base_state_machine_get_state(&sci_req->state_machine));
+                         sci_req->sm.current_state_id);
                 break;
         }
 
@@ -889,8 +879,8 @@ enum sci_status scic_sds_request_complete(struct scic_sds_request *sci_req)
         enum sci_base_request_states state;
         struct scic_sds_controller *scic = sci_req->owning_controller;
 
-        state = sci_req->state_machine.current_state_id;
-        if (WARN_ONCE(state != SCI_BASE_REQUEST_STATE_COMPLETED,
+        state = sci_req->sm.current_state_id;
+        if (WARN_ONCE(state != SCI_REQ_COMPLETED,
                       "isci: request completion from wrong state (%d)\n", state))
                 return SCI_FAILURE_INVALID_STATE;
 
@@ -902,8 +892,7 @@ enum sci_status scic_sds_request_complete(struct scic_sds_request *sci_req)
                                                   sci_req->saved_rx_frame_index);
 
         /* XXX can we just stop the machine and remove the 'final' state? */
-        sci_base_state_machine_change_state(&sci_req->state_machine,
-                                            SCI_BASE_REQUEST_STATE_FINAL);
+        sci_change_state(&sci_req->sm, SCI_REQ_FINAL);
         return SCI_SUCCESS;
 }
 
@@ -913,9 +902,9 @@ enum sci_status scic_sds_io_request_event_handler(struct scic_sds_request *sci_r
         enum sci_base_request_states state;
         struct scic_sds_controller *scic = sci_req->owning_controller;
 
-        state = sci_req->state_machine.current_state_id;
+        state = sci_req->sm.current_state_id;
 
-        if (state != SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_IN_AWAIT_DATA_SUBSTATE) {
+        if (state != SCI_REQ_STP_PIO_DATA_IN) {
                 dev_warn(scic_to_dev(scic), "%s: (%x) in wrong state %d\n",
                          __func__, event_code, state);
 
@@ -927,8 +916,7 @@ enum sci_status scic_sds_io_request_event_handler(struct scic_sds_request *sci_r
                 /* We are waiting for data and the SCU has R_ERR the data frame.
                  * Go back to waiting for the D2H Register FIS
                  */
-                sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                    SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE);
+                sci_change_state(&sci_req->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
                 return SCI_SUCCESS;
         default:
                 dev_err(scic_to_dev(scic),
@@ -967,8 +955,9 @@ static void scic_sds_io_request_copy_response(struct scic_sds_request *sci_req)
         memcpy(resp_buf, ssp_response->resp_data, len);
 }
 
-static enum sci_status request_started_state_tc_event(struct scic_sds_request *sci_req,
-                                                      u32 completion_code)
+static enum sci_status
+request_started_state_tc_event(struct scic_sds_request *sci_req,
+                               u32 completion_code)
 {
         struct ssp_response_iu *resp_iu;
         u8 datapres;
@@ -1110,13 +1099,13 @@ static enum sci_status request_started_state_tc_event(struct scic_sds_request *s
          */
 
         /* In all cases we will treat this as the completion of the IO req. */
-        sci_base_state_machine_change_state(&sci_req->state_machine,
-                                            SCI_BASE_REQUEST_STATE_COMPLETED);
+        sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
         return SCI_SUCCESS;
 }
 
-static enum sci_status request_aborting_state_tc_event(struct scic_sds_request *sci_req,
-                                                       u32 completion_code)
+static enum sci_status
+request_aborting_state_tc_event(struct scic_sds_request *sci_req,
+                                u32 completion_code)
 {
         switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
         case (SCU_TASK_DONE_GOOD << SCU_COMPLETION_TL_STATUS_SHIFT):
@@ -1124,8 +1113,7 @@ static enum sci_status request_aborting_state_tc_event(struct scic_sds_request *
                 scic_sds_request_set_status(sci_req, SCU_TASK_DONE_TASK_ABORT,
                                             SCI_FAILURE_IO_TERMINATED);
 
-                sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                    SCI_BASE_REQUEST_STATE_COMPLETED);
+                sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
                 break;
 
         default:
@@ -1146,8 +1134,7 @@ static enum sci_status ssp_task_request_await_tc_event(struct scic_sds_request *
                 scic_sds_request_set_status(sci_req, SCU_TASK_DONE_GOOD,
                                             SCI_SUCCESS);
 
-                sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                    SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATE_AWAIT_TC_RESPONSE);
+                sci_change_state(&sci_req->sm, SCI_REQ_TASK_WAIT_TC_RESP);
                 break;
         case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_ACK_NAK_TO):
                 /* Currently, the decision is to simply allow the task request
@@ -1160,27 +1147,28 @@ static enum sci_status ssp_task_request_await_tc_event(struct scic_sds_request *
                          "ACK/NAK timeout\n", __func__, sci_req,
                          completion_code);
 
-                sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                    SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATE_AWAIT_TC_RESPONSE);
+                sci_change_state(&sci_req->sm, SCI_REQ_TASK_WAIT_TC_RESP);
                 break;
         default:
-                /* 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.
+                /*
+                 * 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.
                  */
                 scic_sds_request_set_status(sci_req,
                         SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
                         SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR);
 
-                sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                    SCI_BASE_REQUEST_STATE_COMPLETED);
+                sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
                 break;
         }
 
         return SCI_SUCCESS;
 }
 
-static enum sci_status smp_request_await_response_tc_event(struct scic_sds_request *sci_req,
-                                                           u32 completion_code)
+static enum sci_status
+smp_request_await_response_tc_event(struct scic_sds_request *sci_req,
+                                    u32 completion_code)
 {
         switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
         case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
@@ -1191,8 +1179,7 @@ static enum sci_status smp_request_await_response_tc_event(struct scic_sds_reque
                 scic_sds_request_set_status(sci_req, SCU_TASK_DONE_GOOD,
                                             SCI_SUCCESS);
 
-                sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                    SCI_BASE_REQUEST_STATE_COMPLETED);
+                sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
                 break;
 
         case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SMP_RESP_TO_ERR):
@@ -1209,8 +1196,7 @@ static enum sci_status smp_request_await_response_tc_event(struct scic_sds_reque
                 scic_sds_request_set_status(sci_req, SCU_TASK_DONE_SMP_RESP_TO_ERR,
                                             SCI_FAILURE_RETRY_REQUIRED);
 
-                sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                    SCI_BASE_REQUEST_STATE_COMPLETED);
+                sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
                 break;
 
         default:
@@ -1221,24 +1207,23 @@ static enum sci_status smp_request_await_response_tc_event(struct scic_sds_reque
                                             SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
                                             SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR);
 
-                sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                    SCI_BASE_REQUEST_STATE_COMPLETED);
+                sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
                 break;
         }
 
         return SCI_SUCCESS;
 }
 
-static enum sci_status smp_request_await_tc_event(struct scic_sds_request *sci_req,
-                                                  u32 completion_code)
+static enum sci_status
+smp_request_await_tc_event(struct scic_sds_request *sci_req,
+                           u32 completion_code)
 {
         switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
         case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
                 scic_sds_request_set_status(sci_req, SCU_TASK_DONE_GOOD,
                                             SCI_SUCCESS);
 
-                sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                    SCI_BASE_REQUEST_STATE_COMPLETED);
+                sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
                 break;
         default:
                 /* All other completion status cause the IO to be
@@ -1249,8 +1234,7 @@ static enum sci_status smp_request_await_tc_event(struct scic_sds_request *sci_r
                                             SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
                                             SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR);
 
-                sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                    SCI_BASE_REQUEST_STATE_COMPLETED);
+                sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
                 break;
         }
 
@@ -1311,16 +1295,16 @@ static struct scu_sgl_element *scic_sds_stp_request_pio_get_next_sgl(struct scic
         return current_sgl;
 }
 
-static enum sci_status stp_request_non_data_await_h2d_tc_event(struct scic_sds_request *sci_req,
-                                                               u32 completion_code)
+static enum sci_status
+stp_request_non_data_await_h2d_tc_event(struct scic_sds_request *sci_req,
+                                        u32 completion_code)
 {
         switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
         case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
                 scic_sds_request_set_status(sci_req, SCU_TASK_DONE_GOOD,
                                             SCI_SUCCESS);
 
-                sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                    SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_D2H_SUBSTATE);
+                sci_change_state(&sci_req->sm, SCI_REQ_STP_NON_DATA_WAIT_D2H);
                 break;
 
         default:
@@ -1332,8 +1316,7 @@ static enum sci_status stp_request_non_data_await_h2d_tc_event(struct scic_sds_r
                                             SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
                                             SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR);
 
-                sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                    SCI_BASE_REQUEST_STATE_COMPLETED);
+                sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
                 break;
         }
 
@@ -1509,17 +1492,19 @@ static enum sci_status scic_sds_stp_request_pio_data_in_copy_data(
         return status;
 }
 
-static enum sci_status stp_request_pio_await_h2d_completion_tc_event(struct scic_sds_request *sci_req,
-                                                                     u32 completion_code)
+static enum sci_status
+stp_request_pio_await_h2d_completion_tc_event(struct scic_sds_request *sci_req,
+                                              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):
-                scic_sds_request_set_status(sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS);
+                scic_sds_request_set_status(sci_req,
+                                            SCU_TASK_DONE_GOOD,
+                                            SCI_SUCCESS);
 
-                sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                    SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE);
+                sci_change_state(&sci_req->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
                 break;
 
         default:
@@ -1531,16 +1516,16 @@ static enum sci_status stp_request_pio_await_h2d_completion_tc_event(struct scic
                                             SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
                                             SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR);
 
-                sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                    SCI_BASE_REQUEST_STATE_COMPLETED);
+                sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
                 break;
         }
 
         return status;
 }
 
-static enum sci_status pio_data_out_tx_done_tc_event(struct scic_sds_request *sci_req,
-                                                     u32 completion_code)
+static enum sci_status
+pio_data_out_tx_done_tc_event(struct scic_sds_request *sci_req,
+                              u32 completion_code)
 {
         enum sci_status status = SCI_SUCCESS;
         bool all_frames_transferred = false;
@@ -1566,28 +1551,24 @@ static enum sci_status pio_data_out_tx_done_tc_event(struct scic_sds_request *sc
                 /* all data transferred. */
                 if (all_frames_transferred) {
                         /*
-                         * Change the state to SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_IN_AWAIT_FRAME_SUBSTATE
+                         * Change the state to SCI_REQ_STP_PIO_DATA_IN
                          * and wait for PIO_SETUP fis / or D2H REg fis. */
-                        sci_base_state_machine_change_state(
-                                &sci_req->state_machine,
-                                SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE
-                                );
+                        sci_change_state(&sci_req->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
                 }
                 break;
+
         default:
                 /*
-                 * 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. */
+                 * 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.
+                 */
                 scic_sds_request_set_status(
                         sci_req,
                         SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
-                        SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
-                        );
+                        SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR);
 
-                sci_base_state_machine_change_state(
-                        &sci_req->state_machine,
-                        SCI_BASE_REQUEST_STATE_COMPLETED
-                        );
+                sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
                 break;
         }
 
@@ -1600,8 +1581,7 @@ static void scic_sds_stp_request_udma_complete_request(
         enum sci_status sci_status)
 {
         scic_sds_request_set_status(request, scu_status, sci_status);
-        sci_base_state_machine_change_state(&request->state_machine,
-                SCI_BASE_REQUEST_STATE_COMPLETED);
+        sci_change_state(&request->sm, SCI_REQ_COMPLETED);
 }
 
 static enum sci_status scic_sds_stp_request_udma_general_frame_handler(struct scic_sds_request *sci_req,
@@ -1632,8 +1612,9 @@ static enum sci_status scic_sds_stp_request_udma_general_frame_handler(struct sc
         return status;
 }
 
-enum sci_status scic_sds_io_request_frame_handler(struct scic_sds_request *sci_req,
-                                                  u32 frame_index)
+enum sci_status
+scic_sds_io_request_frame_handler(struct scic_sds_request *sci_req,
+                                  u32 frame_index)
 {
         struct scic_sds_controller *scic = sci_req->owning_controller;
         struct scic_sds_stp_request *stp_req = &sci_req->stp.req;
@@ -1641,9 +1622,9 @@ enum sci_status scic_sds_io_request_frame_handler(struct scic_sds_request *sci_r
         enum sci_status status;
         ssize_t word_cnt;
 
-        state = sci_req->state_machine.current_state_id;
+        state = sci_req->sm.current_state_id;
         switch (state)  {
-        case SCI_BASE_REQUEST_STATE_STARTED: {
+        case SCI_REQ_STARTED: {
                 struct ssp_frame_hdr ssp_hdr;
                 void *frame_header;
 
@@ -1684,20 +1665,21 @@ enum sci_status scic_sds_io_request_frame_handler(struct scic_sds_request *sci_r
                 }
 
                 /*
-                 * In any case we are done with this frame buffer return it to the
-                 * controller
+                 * In any case we are done with this frame buffer return it to
+                 * the controller
                  */
                 scic_sds_controller_release_frame(scic, frame_index);
 
                 return SCI_SUCCESS;
         }
-        case SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATE_AWAIT_TC_RESPONSE:
+
+        case SCI_REQ_TASK_WAIT_TC_RESP:
                 scic_sds_io_request_copy_response(sci_req);
-                sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                    SCI_BASE_REQUEST_STATE_COMPLETED);
+                sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
                 scic_sds_controller_release_frame(scic,frame_index);
                 return SCI_SUCCESS;
-        case SCIC_SDS_SMP_REQUEST_STARTED_SUBSTATE_AWAIT_RESPONSE: {
+
+        case SCI_REQ_SMP_WAIT_RESP: {
                 struct smp_resp *rsp_hdr = &sci_req->smp.rsp;
                 void *frame_header;
 
@@ -1725,32 +1707,40 @@ enum sci_status scic_sds_io_request_frame_handler(struct scic_sds_request *sci_r
                         scic_sds_request_set_status(sci_req, SCU_TASK_DONE_GOOD,
                                                     SCI_SUCCESS);
 
-                        sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                            SCIC_SDS_SMP_REQUEST_STARTED_SUBSTATE_AWAIT_TC_COMPLETION);
+                        sci_change_state(&sci_req->sm, SCI_REQ_SMP_WAIT_TC_COMP);
                 } else {
-                        /* This was not a response frame why did it get forwarded? */
+                        /*
+                         * This was not a response frame why did it get
+                         * forwarded?
+                         */
                         dev_err(scic_to_dev(scic),
-                                "%s: SCIC SMP Request 0x%p received unexpected frame "
-                                "%d type 0x%02x\n", __func__, sci_req,
-                                frame_index, rsp_hdr->frame_type);
+                                "%s: SCIC SMP Request 0x%p received unexpected "
+                                "frame %d type 0x%02x\n",
+                                __func__,
+                                sci_req,
+                                frame_index,
+                                rsp_hdr->frame_type);
 
                         scic_sds_request_set_status(sci_req,
                                                     SCU_TASK_DONE_SMP_FRM_TYPE_ERR,
                                                     SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR);
 
-                        sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                            SCI_BASE_REQUEST_STATE_COMPLETED);
+                        sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
                 }
 
                 scic_sds_controller_release_frame(scic, frame_index);
 
                 return SCI_SUCCESS;
         }
-        case SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_TC_COMPLETION_SUBSTATE:
-                return scic_sds_stp_request_udma_general_frame_handler(sci_req, frame_index);
-        case SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_D2H_REG_FIS_SUBSTATE:
+
+        case SCI_REQ_STP_UDMA_WAIT_TC_COMP:
+                return scic_sds_stp_request_udma_general_frame_handler(sci_req,
+                                                                       frame_index);
+
+        case SCI_REQ_STP_UDMA_WAIT_D2H:
                 /* Use the general frame handler to copy the resposne data */
-                status = scic_sds_stp_request_udma_general_frame_handler(sci_req, frame_index);
+                status = scic_sds_stp_request_udma_general_frame_handler(sci_req,
+                                                                         frame_index);
 
                 if (status != SCI_SUCCESS)
                         return status;
@@ -1758,8 +1748,10 @@ enum sci_status scic_sds_io_request_frame_handler(struct scic_sds_request *sci_r
                 scic_sds_stp_request_udma_complete_request(sci_req,
                                                            SCU_TASK_DONE_CHECK_RESPONSE,
                                                            SCI_FAILURE_IO_RESPONSE_VALID);
+
                 return SCI_SUCCESS;
-        case SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_D2H_SUBSTATE: {
+
+        case SCI_REQ_STP_NON_DATA_WAIT_D2H: {
                 struct dev_to_host_fis *frame_header;
                 u32 *frame_buffer;
 
@@ -1769,9 +1761,12 @@ enum sci_status scic_sds_io_request_frame_handler(struct scic_sds_request *sci_r
 
                 if (status != SCI_SUCCESS) {
                         dev_err(scic_to_dev(scic),
-                                "%s: SCIC IO Request 0x%p could not get frame header "
-                                "for frame index %d, status %x\n",
-                                __func__, stp_req, frame_index, status);
+                                "%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;
                 }
@@ -1802,15 +1797,15 @@ enum sci_status scic_sds_io_request_frame_handler(struct scic_sds_request *sci_r
                         break;
                 }
 
-                sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                    SCI_BASE_REQUEST_STATE_COMPLETED);
+                sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
 
                 /* Frame has been decoded return it to the controller */
                 scic_sds_controller_release_frame(scic, frame_index);
 
                 return status;
         }
-        case SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE: {
+
+        case SCI_REQ_STP_PIO_WAIT_FRAME: {
                 struct isci_request *ireq = sci_req_to_ireq(sci_req);
                 struct sas_task *task = isci_request_access_task(ireq);
                 struct dev_to_host_fis *frame_header;
@@ -1822,8 +1817,8 @@ enum sci_status scic_sds_io_request_frame_handler(struct scic_sds_request *sci_r
 
                 if (status != SCI_SUCCESS) {
                         dev_err(scic_to_dev(scic),
-                                "%s: SCIC IO Request 0x%p could not get frame header "
-                                "for frame index %d, status %x\n",
+                                "%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;
                 }
@@ -1835,9 +1830,10 @@ enum sci_status scic_sds_io_request_frame_handler(struct scic_sds_request *sci_r
                                                                       frame_index,
                                                                       (void **)&frame_buffer);
 
-                        /* Get the data from the PIO Setup The SCU Hardware returns
-                         * first word in the frame_header and the rest of the data is in
-                         * the frame buffer so we need to back up one dword
+                        /* Get the data from the PIO Setup The SCU Hardware
+                         * returns first word in the frame_header and the rest
+                         * of the data is in the frame buffer so we need to
+                         * back up one dword
                          */
 
                         /* transfer_count: first 16bits in the 4th dword */
@@ -1856,31 +1852,33 @@ enum sci_status scic_sds_io_request_frame_handler(struct scic_sds_request *sci_r
                          * request was PIO Data-in or Data out
                          */
                         if (task->data_dir == DMA_FROM_DEVICE) {
-                                sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                                    SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_IN_AWAIT_DATA_SUBSTATE);
+                                sci_change_state(&sci_req->sm, SCI_REQ_STP_PIO_DATA_IN);
                         } else if (task->data_dir == DMA_TO_DEVICE) {
                                 /* Transmit data */
                                 status = scic_sds_stp_request_pio_data_out_transmit_data(sci_req);
                                 if (status != SCI_SUCCESS)
                                         break;
-                                sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                                    SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_OUT_TRANSMIT_DATA_SUBSTATE);
+                                sci_change_state(&sci_req->sm, SCI_REQ_STP_PIO_DATA_OUT);
                         }
                         break;
+
                 case FIS_SETDEVBITS:
-                        sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                            SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE);
+                        sci_change_state(&sci_req->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
                         break;
+
                 case FIS_REGD2H:
                         if (frame_header->status & ATA_BUSY) {
-                                /* Now why is the drive sending a D2H Register FIS when
-                                 * it is still busy?  Do nothing since we are still in
-                                 * the right state.
+                                /*
+                                 * Now why is the drive sending a D2H Register
+                                 * FIS when it is still busy?  Do nothing since
+                                 * we are still in the right state.
                                  */
                                 dev_dbg(scic_to_dev(scic),
                                         "%s: SCIC PIO Request 0x%p received "
                                         "D2H Register FIS with BSY status "
-                                        "0x%x\n", __func__, stp_req,
+                                        "0x%x\n",
+                                        __func__,
+                                        stp_req,
                                         frame_header->status);
                                 break;
                         }
@@ -1897,9 +1895,9 @@ enum sci_status scic_sds_io_request_frame_handler(struct scic_sds_request *sci_r
                                                     SCU_TASK_DONE_CHECK_RESPONSE,
                                                     SCI_FAILURE_IO_RESPONSE_VALID);
 
-                        sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                            SCI_BASE_REQUEST_STATE_COMPLETED);
+                        sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
                         break;
+
                 default:
                         /* FIXME: what do we do here? */
                         break;
@@ -1910,7 +1908,8 @@ enum sci_status scic_sds_io_request_frame_handler(struct scic_sds_request *sci_r
 
                 return status;
         }
-        case SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_IN_AWAIT_DATA_SUBSTATE: {
+
+        case SCI_REQ_STP_PIO_DATA_IN: {
                 struct dev_to_host_fis *frame_header;
                 struct sata_fis_data *frame_buffer;
 
@@ -1920,9 +1919,12 @@ enum sci_status scic_sds_io_request_frame_handler(struct scic_sds_request *sci_r
 
                 if (status != SCI_SUCCESS) {
                         dev_err(scic_to_dev(scic),
-                                "%s: SCIC IO Request 0x%p could not get frame header "
-                                "for frame index %d, status %x\n",
-                                __func__, stp_req, frame_index, status);
+                                "%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;
                 }
 
@@ -1930,15 +1932,17 @@ enum sci_status scic_sds_io_request_frame_handler(struct scic_sds_request *sci_r
                         dev_err(scic_to_dev(scic),
                                 "%s: SCIC PIO Request 0x%p received frame %d "
                                 "with fis type 0x%02x when expecting a data "
-                                "fis.\n", __func__, stp_req, frame_index,
+                                "fis.\n",
+                                __func__,
+                                stp_req,
+                                frame_index,
                                 frame_header->fis_type);
 
                         scic_sds_request_set_status(sci_req,
                                                     SCU_TASK_DONE_GOOD,
                                                     SCI_FAILURE_IO_REQUIRES_SCSI_ABORT);
 
-                        sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                            SCI_BASE_REQUEST_STATE_COMPLETED);
+                        sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
 
                         /* Frame is decoded return it to the controller */
                         scic_sds_controller_release_frame(scic, frame_index);
@@ -1972,15 +1976,14 @@ enum sci_status scic_sds_io_request_frame_handler(struct scic_sds_request *sci_r
                                                     SCU_TASK_DONE_CHECK_RESPONSE,
                                                     SCI_FAILURE_IO_RESPONSE_VALID);
 
-                        sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                            SCI_BASE_REQUEST_STATE_COMPLETED);
+                        sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
                 } else {
-                        sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                            SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE);
+                        sci_change_state(&sci_req->sm, SCI_REQ_STP_PIO_WAIT_FRAME);
                 }
                 return status;
         }
-        case SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_D2H_RESPONSE_FRAME_SUBSTATE: {
+
+        case SCI_REQ_STP_SOFT_RESET_WAIT_D2H: {
                 struct dev_to_host_fis *frame_header;
                 u32 *frame_buffer;
 
@@ -1989,9 +1992,12 @@ enum sci_status scic_sds_io_request_frame_handler(struct scic_sds_request *sci_r
                                                                        (void **)&frame_header);
                 if (status != SCI_SUCCESS) {
                         dev_err(scic_to_dev(scic),
-                                "%s: SCIC IO Request 0x%p could not get frame header "
-                                "for frame index %d, status %x\n",
-                                __func__, stp_req, frame_index, status);
+                                "%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;
                 }
 
@@ -2010,35 +2016,43 @@ enum sci_status scic_sds_io_request_frame_handler(struct scic_sds_request *sci_r
                                                     SCU_TASK_DONE_CHECK_RESPONSE,
                                                     SCI_FAILURE_IO_RESPONSE_VALID);
                         break;
+
                 default:
                         dev_warn(scic_to_dev(scic),
                                  "%s: IO Request:0x%p Frame Id:%d protocol "
-                                 "violation occurred\n", __func__, stp_req,
+                                 "violation occurred\n",
+                                 __func__,
+                                 stp_req,
                                  frame_index);
 
-                        scic_sds_request_set_status(sci_req, SCU_TASK_DONE_UNEXP_FIS,
+                        scic_sds_request_set_status(sci_req,
+                                                    SCU_TASK_DONE_UNEXP_FIS,
                                                     SCI_FAILURE_PROTOCOL_VIOLATION);
                         break;
                 }
 
-                sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                    SCI_BASE_REQUEST_STATE_COMPLETED);
+                sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
 
                 /* Frame has been decoded return it to the controller */
                 scic_sds_controller_release_frame(scic, frame_index);
 
                 return status;
         }
-        case SCI_BASE_REQUEST_STATE_ABORTING:
-                /* TODO: Is it even possible to get an unsolicited frame in the
+        case SCI_REQ_ABORTING:
+                /*
+                 * TODO: Is it even possible to get an unsolicited frame in the
                  * aborting state?
                  */
                 scic_sds_controller_release_frame(scic, frame_index);
                 return SCI_SUCCESS;
+
         default:
                 dev_warn(scic_to_dev(scic),
-                         "%s: SCIC IO Request given unexpected frame %x while in "
-                         "state %d\n", __func__, frame_index, state);
+                         "%s: SCIC IO Request given unexpected frame %x while "
+                         "in state %d\n",
+                         __func__,
+                         frame_index,
+                         state);
 
                 scic_sds_controller_release_frame(scic, frame_index);
                 return SCI_FAILURE_INVALID_STATE;
@@ -2075,8 +2089,7 @@ static enum sci_status stp_request_udma_await_tc_event(struct scic_sds_request *
                          * the device so we must change state to wait
                          * for it
                          */
-                        sci_base_state_machine_change_state(&sci_req->state_machine,
-                                SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_D2H_REG_FIS_SUBSTATE);
+                        sci_change_state(&sci_req->sm, SCI_REQ_STP_UDMA_WAIT_D2H);
                 }
                 break;
 
@@ -2105,45 +2118,45 @@ static enum sci_status stp_request_udma_await_tc_event(struct scic_sds_request *
         return status;
 }
 
-static enum sci_status stp_request_soft_reset_await_h2d_asserted_tc_event(struct scic_sds_request *sci_req,
-                                                                          u32 completion_code)
+static enum sci_status
+stp_request_soft_reset_await_h2d_asserted_tc_event(struct scic_sds_request *sci_req,
+                                                   u32 completion_code)
 {
         switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
         case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
                 scic_sds_request_set_status(sci_req, SCU_TASK_DONE_GOOD,
                                             SCI_SUCCESS);
 
-                sci_base_state_machine_change_state(&sci_req->state_machine,
-                        SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_DIAGNOSTIC_COMPLETION_SUBSTATE);
+                sci_change_state(&sci_req->sm, SCI_REQ_STP_SOFT_RESET_WAIT_H2D_DIAG);
                 break;
 
         default:
                 /*
-                 * 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. */
+                 * 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.
+                 */
                 scic_sds_request_set_status(sci_req,
-                        SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
-                        SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR);
+                                            SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
+                                            SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR);
 
-                sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                    SCI_BASE_REQUEST_STATE_COMPLETED);
+                sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
                 break;
         }
 
         return SCI_SUCCESS;
 }
 
-static enum sci_status stp_request_soft_reset_await_h2d_diagnostic_tc_event(
-        struct scic_sds_request *sci_req,
-        u32 completion_code)
+static enum sci_status
+stp_request_soft_reset_await_h2d_diagnostic_tc_event(struct scic_sds_request *sci_req,
+                                                     u32 completion_code)
 {
         switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
         case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
                 scic_sds_request_set_status(sci_req, SCU_TASK_DONE_GOOD,
                                             SCI_SUCCESS);
 
-                sci_base_state_machine_change_state(&sci_req->state_machine,
-                        SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_D2H_RESPONSE_FRAME_SUBSTATE);
+                sci_change_state(&sci_req->sm, SCI_REQ_STP_SOFT_RESET_WAIT_D2H);
                 break;
 
         default:
@@ -2155,8 +2168,7 @@ static enum sci_status stp_request_soft_reset_await_h2d_diagnostic_tc_event(
                         SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
                         SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR);
 
-                sci_base_state_machine_change_state(&sci_req->state_machine,
-                                                    SCI_BASE_REQUEST_STATE_COMPLETED);
+                sci_change_state(&sci_req->sm, SCI_REQ_COMPLETED);
                 break;
         }
 
@@ -2164,42 +2176,64 @@ static enum sci_status stp_request_soft_reset_await_h2d_diagnostic_tc_event(
 }
 
 enum sci_status
-scic_sds_io_request_tc_completion(struct scic_sds_request *sci_req, u32 completion_code)
+scic_sds_io_request_tc_completion(struct scic_sds_request *sci_req,
+                                  u32 completion_code)
 {
         enum sci_base_request_states state;
         struct scic_sds_controller *scic = sci_req->owning_controller;
 
-        state = sci_req->state_machine.current_state_id;
+        state = sci_req->sm.current_state_id;
 
         switch (state) {
-                case SCI_BASE_REQUEST_STATE_STARTED:
-                        return request_started_state_tc_event(sci_req, completion_code);
-                case SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATE_AWAIT_TC_COMPLETION:
-                        return ssp_task_request_await_tc_event(sci_req, completion_code);
-                case SCIC_SDS_SMP_REQUEST_STARTED_SUBSTATE_AWAIT_RESPONSE:
-                        return smp_request_await_response_tc_event(sci_req, completion_code);
-                case SCIC_SDS_SMP_REQUEST_STARTED_SUBSTATE_AWAIT_TC_COMPLETION:
-                        return smp_request_await_tc_event(sci_req, completion_code);
-                case SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_TC_COMPLETION_SUBSTATE:
-                        return stp_request_udma_await_tc_event(sci_req, completion_code);
-                case SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_H2D_COMPLETION_SUBSTATE:
-                        return stp_request_non_data_await_h2d_tc_event(sci_req, completion_code);
-                case SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_H2D_COMPLETION_SUBSTATE:
-                        return stp_request_pio_await_h2d_completion_tc_event(sci_req, completion_code);
-                case SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_OUT_TRANSMIT_DATA_SUBSTATE:
-                        return pio_data_out_tx_done_tc_event(sci_req, completion_code);
-                case SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_ASSERTED_COMPLETION_SUBSTATE:
-                        return stp_request_soft_reset_await_h2d_asserted_tc_event(sci_req, completion_code);
-                case SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_DIAGNOSTIC_COMPLETION_SUBSTATE:
-                        return stp_request_soft_reset_await_h2d_diagnostic_tc_event(sci_req, completion_code);
-                case SCI_BASE_REQUEST_STATE_ABORTING:
-                        return request_aborting_state_tc_event(sci_req, completion_code);
-                default:
-                        dev_warn(scic_to_dev(scic),
-                                "%s: SCIC IO Request given task completion notification %x "
-                                "while in wrong state %d\n", __func__, completion_code,
-                                state);
-                        return SCI_FAILURE_INVALID_STATE;
+        case SCI_REQ_STARTED:
+                return request_started_state_tc_event(sci_req, completion_code);
+
+        case SCI_REQ_TASK_WAIT_TC_COMP:
+                return ssp_task_request_await_tc_event(sci_req,
+                                                       completion_code);
+
+        case SCI_REQ_SMP_WAIT_RESP:
+                return smp_request_await_response_tc_event(sci_req,
+                                                           completion_code);
+
+        case SCI_REQ_SMP_WAIT_TC_COMP:
+                return smp_request_await_tc_event(sci_req, completion_code);
+
+        case SCI_REQ_STP_UDMA_WAIT_TC_COMP:
+                return stp_request_udma_await_tc_event(sci_req,
+                                                       completion_code);
+
+        case SCI_REQ_STP_NON_DATA_WAIT_H2D:
+                return stp_request_non_data_await_h2d_tc_event(sci_req,
+                                                               completion_code);
+
+        case SCI_REQ_STP_PIO_WAIT_H2D:
+                return stp_request_pio_await_h2d_completion_tc_event(sci_req,
+                                                                     completion_code);
+
+        case SCI_REQ_STP_PIO_DATA_OUT:
+                return pio_data_out_tx_done_tc_event(sci_req, completion_code);
+
+        case SCI_REQ_STP_SOFT_RESET_WAIT_H2D_ASSERTED:
+                return stp_request_soft_reset_await_h2d_asserted_tc_event(sci_req,
+                                                                          completion_code);
+
+        case SCI_REQ_STP_SOFT_RESET_WAIT_H2D_DIAG:
+                return stp_request_soft_reset_await_h2d_diagnostic_tc_event(sci_req,
+                                                                            completion_code);
+
+        case SCI_REQ_ABORTING:
+                return request_aborting_state_tc_event(sci_req,
+                                                       completion_code);
+
+        default:
+                dev_warn(scic_to_dev(scic),
+                         "%s: SCIC IO Request given task completion "
+                         "notification %x while in wrong state %d\n",
+                         __func__,
+                         completion_code,
+                         state);
+                return SCI_FAILURE_INVALID_STATE;
         }
 }
 
@@ -2896,7 +2930,7 @@ static void isci_request_io_request_complete(struct isci_host *isci_host,
 
 static void scic_sds_request_started_state_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_request *sci_req = container_of(sm, typeof(*sci_req), state_machine);
+        struct scic_sds_request *sci_req = container_of(sm, typeof(*sci_req), sm);
         struct isci_request *ireq = sci_req_to_ireq(sci_req);
         struct domain_device *dev = sci_dev_to_domain(sci_req->target_device);
         struct sas_task *task;
@@ -2910,34 +2944,31 @@ static void scic_sds_request_started_state_enter(struct sci_base_state_machine *
          * substates
          */
         if (!task && dev->dev_type == SAS_END_DEV) {
-                sci_base_state_machine_change_state(sm,
-                        SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATE_AWAIT_TC_COMPLETION);
+                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_base_state_machine_change_state(sm,
-                        SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_ASSERTED_COMPLETION_SUBSTATE);
+                sci_change_state(sm, SCI_REQ_STP_SOFT_RESET_WAIT_H2D_ASSERTED);
         } else if (task && task->task_proto == SAS_PROTOCOL_SMP) {
-                sci_base_state_machine_change_state(sm,
-                        SCIC_SDS_SMP_REQUEST_STARTED_SUBSTATE_AWAIT_RESPONSE);
+                sci_change_state(sm, SCI_REQ_SMP_WAIT_RESP);
         } else if (task && sas_protocol_ata(task->task_proto) &&
                    !task->ata_task.use_ncq) {
                 u32 state;
 
                 if (task->data_dir == DMA_NONE)
-                         state = SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_H2D_COMPLETION_SUBSTATE;
+                        state = SCI_REQ_STP_NON_DATA_WAIT_H2D;
                 else if (task->ata_task.dma_xfer)
-                        state = SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_TC_COMPLETION_SUBSTATE;
+                        state = SCI_REQ_STP_UDMA_WAIT_TC_COMP;
                 else /* PIO */
-                        state = SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_H2D_COMPLETION_SUBSTATE;
+                        state = SCI_REQ_STP_PIO_WAIT_H2D;
 
-                sci_base_state_machine_change_state(sm, state);
+                sci_change_state(sm, state);
         }
 }
 
 static void scic_sds_request_completed_state_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_request *sci_req = container_of(sm, typeof(*sci_req), state_machine);
+        struct scic_sds_request *sci_req = container_of(sm, typeof(*sci_req), sm);
         struct scic_sds_controller *scic = sci_req->owning_controller;
         struct isci_host *ihost = scic_to_ihost(scic);
         struct isci_request *ireq = sci_req_to_ireq(sci_req);
@@ -2952,7 +2983,7 @@ static void scic_sds_request_completed_state_enter(struct sci_base_state_machine
 
 static void scic_sds_request_aborting_state_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_request *sci_req = container_of(sm, typeof(*sci_req), state_machine);
+        struct scic_sds_request *sci_req = container_of(sm, typeof(*sci_req), sm);
 
         /* Setting the abort bit in the Task Context is required by the silicon. */
         sci_req->task_context_buffer->abort = 1;
@@ -2960,7 +2991,7 @@ static void scic_sds_request_aborting_state_enter(struct sci_base_state_machine
 
 static void scic_sds_stp_request_started_non_data_await_h2d_completion_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_request *sci_req = container_of(sm, typeof(*sci_req), state_machine);
+        struct scic_sds_request *sci_req = container_of(sm, typeof(*sci_req), sm);
 
         scic_sds_remote_device_set_working_request(sci_req->target_device,
                                                    sci_req);
@@ -2968,7 +2999,7 @@ static void scic_sds_stp_request_started_non_data_await_h2d_completion_enter(str
 
 static void scic_sds_stp_request_started_pio_await_h2d_completion_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_request *sci_req = container_of(sm, typeof(*sci_req), state_machine);
+        struct scic_sds_request *sci_req = container_of(sm, typeof(*sci_req), sm);
 
         scic_sds_remote_device_set_working_request(sci_req->target_device,
                                                    sci_req);
@@ -2976,7 +3007,7 @@ static void scic_sds_stp_request_started_pio_await_h2d_completion_enter(struct s
 
 static void scic_sds_stp_request_started_soft_reset_await_h2d_asserted_completion_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_request *sci_req = container_of(sm, typeof(*sci_req), state_machine);
+        struct scic_sds_request *sci_req = container_of(sm, typeof(*sci_req), sm);
 
         scic_sds_remote_device_set_working_request(sci_req->target_device,
                                                    sci_req);
@@ -2984,7 +3015,7 @@ static void scic_sds_stp_request_started_soft_reset_await_h2d_asserted_completio
 
 static void scic_sds_stp_request_started_soft_reset_await_h2d_diagnostic_completion_enter(struct sci_base_state_machine *sm)
 {
-        struct scic_sds_request *sci_req = container_of(sm, typeof(*sci_req), state_machine);
+        struct scic_sds_request *sci_req = container_of(sm, typeof(*sci_req), sm);
         struct scu_task_context *task_context;
         struct host_to_dev_fis *h2d_fis;
         enum sci_status status;
@@ -3003,51 +3034,53 @@ static void scic_sds_stp_request_started_soft_reset_await_h2d_diagnostic_complet
 }
 
 static const struct sci_base_state scic_sds_request_state_table[] = {
-        [SCI_BASE_REQUEST_STATE_INITIAL] = { },
-        [SCI_BASE_REQUEST_STATE_CONSTRUCTED] = { },
-        [SCI_BASE_REQUEST_STATE_STARTED] = {
+        [SCI_REQ_INIT] = { },
+        [SCI_REQ_CONSTRUCTED] = { },
+        [SCI_REQ_STARTED] = {
                 .enter_state = scic_sds_request_started_state_enter,
         },
-        [SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_H2D_COMPLETION_SUBSTATE] = {
+        [SCI_REQ_STP_NON_DATA_WAIT_H2D] = {
                 .enter_state = scic_sds_stp_request_started_non_data_await_h2d_completion_enter,
         },
-        [SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_D2H_SUBSTATE] = { },
-        [SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_H2D_COMPLETION_SUBSTATE] = {
+        [SCI_REQ_STP_NON_DATA_WAIT_D2H] = { },
+        [SCI_REQ_STP_PIO_WAIT_H2D] = {
                 .enter_state = scic_sds_stp_request_started_pio_await_h2d_completion_enter,
         },
-        [SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE] = { },
-        [SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_IN_AWAIT_DATA_SUBSTATE] = { },
-        [SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_OUT_TRANSMIT_DATA_SUBSTATE] = { },
-        [SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_TC_COMPLETION_SUBSTATE] = { },
-        [SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_D2H_REG_FIS_SUBSTATE] = { },
-        [SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_ASSERTED_COMPLETION_SUBSTATE] = {
+        [SCI_REQ_STP_PIO_WAIT_FRAME] = { },
+        [SCI_REQ_STP_PIO_DATA_IN] = { },
+        [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 = scic_sds_stp_request_started_soft_reset_await_h2d_asserted_completion_enter,
         },
-        [SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_DIAGNOSTIC_COMPLETION_SUBSTATE] = {
+        [SCI_REQ_STP_SOFT_RESET_WAIT_H2D_DIAG] = {
                 .enter_state = scic_sds_stp_request_started_soft_reset_await_h2d_diagnostic_completion_enter,
         },
-        [SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_D2H_RESPONSE_FRAME_SUBSTATE] = { },
-        [SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATE_AWAIT_TC_COMPLETION] = { },
-        [SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATE_AWAIT_TC_RESPONSE] = { },
-        [SCIC_SDS_SMP_REQUEST_STARTED_SUBSTATE_AWAIT_RESPONSE] = { },
-        [SCIC_SDS_SMP_REQUEST_STARTED_SUBSTATE_AWAIT_TC_COMPLETION] = { },
-        [SCI_BASE_REQUEST_STATE_COMPLETED] = {
+        [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_COMPLETED] = {
                 .enter_state = scic_sds_request_completed_state_enter,
         },
-        [SCI_BASE_REQUEST_STATE_ABORTING] = {
+        [SCI_REQ_ABORTING] = {
                 .enter_state = scic_sds_request_aborting_state_enter,
         },
-        [SCI_BASE_REQUEST_STATE_FINAL] = { },
+        [SCI_REQ_FINAL] = { },
 };
 
-static void scic_sds_general_request_construct(struct scic_sds_controller *scic,
-                                               struct scic_sds_remote_device *sci_dev,
-                                               u16 io_tag, struct scic_sds_request *sci_req)
+static void
+scic_sds_general_request_construct(struct scic_sds_controller *scic,
+                                   struct scic_sds_remote_device *sci_dev,
+                                   u16 io_tag,
+                                   struct scic_sds_request *sci_req)
 {
-        sci_base_state_machine_construct(&sci_req->state_machine,
+        sci_base_state_machine_construct(&sci_req->sm,
                                          scic_sds_request_state_table,
-                                         SCI_BASE_REQUEST_STATE_INITIAL);
-        sci_base_state_machine_start(&sci_req->state_machine);
+                                         SCI_REQ_INIT);
+        sci_base_state_machine_start(&sci_req->sm);
 
         sci_req->io_tag = io_tag;
         sci_req->owning_controller = scic;
@@ -3322,8 +3355,7 @@ scic_io_request_construct_smp(struct scic_sds_request *sci_req)
 
         scu_smp_request_construct_task_context(sci_req, smp_req->req_len);
 
-        sci_base_state_machine_change_state(&sci_req->state_machine,
-                                            SCI_BASE_REQUEST_STATE_CONSTRUCTED);
+        sci_change_state(&sci_req->sm, SCI_REQ_CONSTRUCTED);
 
         return SCI_SUCCESS;
 }
diff --git a/drivers/scsi/isci/request.h b/drivers/scsi/isci/request.h
index 31d6d5717473..757cd99ae2ed 100644
--- a/drivers/scsi/isci/request.h
+++ b/drivers/scsi/isci/request.h
@@ -96,37 +96,42 @@ struct scic_sds_stp_request {
                 u32 udma;
 
                 struct scic_sds_stp_pio_request {
-                        /**
-                         * Total transfer for the entire PIO request recorded at request constuction
-                         * time.
+                        /*
+                         * Total transfer for the entire PIO request recorded
+                         * at request constuction time.
                          *
-                         * @todo Should we just decrement this value for each byte of data transitted
-                         *       or received to elemenate the current_transfer_bytes field?
+                         * @todo Should we just decrement this value for each
+                         * byte of data transitted or received to elemenate
+                         * the current_transfer_bytes field?
                          */
                         u32 total_transfer_bytes;
 
-                        /**
-                         * Total number of bytes received/transmitted in data frames since the start
-                         * of the IO request.  At the end of the IO request this should equal the
+                        /*
+                         * Total number of bytes received/transmitted in data
+                         * frames since the start of the IO request.  At the
+                         * end of the IO request this should equal the
                          * total_transfer_bytes.
                          */
                         u32 current_transfer_bytes;
 
-                        /**
-                         * The number of bytes requested in the in the PIO setup.
+                        /*
+                         * The number of bytes requested in the in the PIO
+                         * setup.
                          */
                         u32 pio_transfer_bytes;
 
-                        /**
-                         * PIO Setup ending status value to tell us if we need to wait for another FIS
-                         * or if the transfer is complete. On the receipt of a D2H FIS this will be
+                        /*
+                         * PIO Setup ending status value to tell us if we need
+                         * to wait for another FIS or if the transfer is
+                         * complete. On the receipt of a D2H FIS this will be
                          * the status field of that FIS.
                          */
                         u8 ending_status;
 
-                        /**
-                         * On receipt of a D2H FIS this will be the ending error field if the
-                         * ending_status has the SATA_STATUS_ERR bit set.
+                        /*
+                         * On receipt of a D2H FIS this will be the ending
+                         * error field if the ending_status has the
+                         * SATA_STATUS_ERR bit set.
                          */
                         u8 ending_error;
 
@@ -138,8 +143,9 @@ struct scic_sds_stp_request {
                 } pio;
 
                 struct {
-                        /**
-                         * The number of bytes requested in the PIO setup before CDB data frame.
+                        /*
+                         * The number of bytes requested in the PIO setup
+                         * before CDB data frame.
                          */
                         u32 device_preferred_cdb_length;
                 } packet;
@@ -147,57 +153,59 @@ struct scic_sds_stp_request {
 };
 
 struct scic_sds_request {
-        /**
-         * This field contains the information for the base request state machine.
+        /*
+         * This field contains the information for the base request state
+         * machine.
          */
-        struct sci_base_state_machine state_machine;
+        struct sci_base_state_machine sm;
 
-        /**
+        /*
          * This field simply points to the controller to which this IO request
          * is associated.
          */
         struct scic_sds_controller *owning_controller;
 
-        /**
-         * This field simply points to the remote device to which this IO request
-         * is associated.
+        /*
+         * This field simply points to the remote device to which this IO
+         * request is associated.
          */
         struct scic_sds_remote_device *target_device;
 
-        /**
+        /*
          * This field is utilized to determine if the SCI user is managing
          * the IO tag for this request or if the core is managing it.
          */
         bool was_tag_assigned_by_user;
 
-        /**
+        /*
          * This field indicates the IO tag for this request.  The IO tag is
          * comprised of the task_index and a sequence count. The sequence count
          * is utilized to help identify tasks from one life to another.
          */
         u16 io_tag;
 
-        /**
+        /*
          * This field specifies the protocol being utilized for this
          * IO request.
          */
         enum sci_request_protocol protocol;
 
-        /**
+        /*
          * This field indicates the completion status taken from the SCUs
-         * completion code.  It indicates the completion result for the SCU hardware.
+         * completion code.  It indicates the completion result for the SCU
+         * hardware.
          */
         u32 scu_status;
 
-        /**
-         * This field indicates the completion status returned to the SCI user.  It
-         * indicates the users view of the io request completion.
+        /*
+         * This field indicates the completion status returned to the SCI user.
+         * It indicates the users view of the io request completion.
          */
         u32 sci_status;
 
-        /**
-         * This field contains the value to be utilized when posting (e.g. Post_TC,
-         * Post_TC_Abort) this request to the silicon.
+        /*
+         * This field contains the value to be utilized when posting
+         * (e.g. Post_TC, * Post_TC_Abort) this request to the silicon.
          */
         u32 post_context;
 
@@ -208,26 +216,26 @@ struct scic_sds_request {
         #define SCU_SGL_SIZE ((SCU_IO_REQUEST_SGE_COUNT + 1) / 2)
         struct scu_sgl_element_pair sg_table[SCU_SGL_SIZE] __attribute__ ((aligned(32)));
 
-        /**
+        /*
          * This field indicates if this request is a task management request or
          * normal IO request.
          */
         bool is_task_management_request;
 
-        /**
-         * This field is a pointer to the stored rx frame data.  It is used in STP
-         * internal requests and SMP response frames.  If this field is non-NULL the
-         * saved frame must be released on IO request completion.
+        /*
+         * This field is a pointer to the stored rx frame data.  It is used in
+         * STP internal requests and SMP response frames.  If this field is
+         * non-NULL the saved frame must be released on IO request completion.
          *
          * @todo In the future do we want to keep a list of RX frame buffers?
          */
         u32 saved_rx_frame_index;
 
-        /**
-         * This field in the recorded device sequence for the io request.  This is
-         * recorded during the build operation and is compared in the start
-         * operation.  If the sequence is different then there was a change of
-         * devices from the build to start operations.
+        /*
+         * This field in the recorded device sequence for the io request.
+         * This is recorded during the build operation and is compared in the
+         * start operation.  If the sequence is different then there was a
+         * change of devices from the build to start operations.
          */
         u8 device_sequence;
 
@@ -286,7 +294,7 @@ struct isci_request {
         dma_addr_t request_daddr;
         dma_addr_t zero_scatter_daddr;
 
-        unsigned int num_sg_entries;                    /* returned by pci_alloc_sg */
+        unsigned int num_sg_entries;                    /* returned by pci_alloc_sg */
 
         /** Note: "io_request_completion" is completed in two different ways
          * depending on whether this is a TMF or regular request.
@@ -315,104 +323,105 @@ static inline struct isci_request *sci_req_to_ireq(struct scic_sds_request *sci_
  *
  */
 enum sci_base_request_states {
-        /**
+        /*
          * Simply the initial state for the base request state machine.
          */
-        SCI_BASE_REQUEST_STATE_INITIAL,
+        SCI_REQ_INIT,
 
-        /**
-         * This state indicates that the request has been constructed. This state
-         * is entered from the INITIAL state.
+        /*
+         * This state indicates that the request has been constructed.
+         * This state is entered from the INITIAL state.
          */
-        SCI_BASE_REQUEST_STATE_CONSTRUCTED,
+        SCI_REQ_CONSTRUCTED,
 
-        /**
-         * This state indicates that the request has been started. This state is
-         * entered from the CONSTRUCTED state.
+        /*
+         * This state indicates that the request has been started. This state
+         * is entered from the CONSTRUCTED state.
          */
-        SCI_BASE_REQUEST_STATE_STARTED,
+        SCI_REQ_STARTED,
 
-        SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_TC_COMPLETION_SUBSTATE,
-        SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_D2H_REG_FIS_SUBSTATE,
+        SCI_REQ_STP_UDMA_WAIT_TC_COMP,
+        SCI_REQ_STP_UDMA_WAIT_D2H,
 
-        SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_H2D_COMPLETION_SUBSTATE,
-        SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_D2H_SUBSTATE,
+        SCI_REQ_STP_NON_DATA_WAIT_H2D,
+        SCI_REQ_STP_NON_DATA_WAIT_D2H,
 
-        SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_ASSERTED_COMPLETION_SUBSTATE,
-        SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_DIAGNOSTIC_COMPLETION_SUBSTATE,
-        SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_D2H_RESPONSE_FRAME_SUBSTATE,
+        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
+        /*
+         * While in this state the IO request object is waiting for the TC
+         * completion notification for the H2D Register FIS
          */
-        SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_H2D_COMPLETION_SUBSTATE,
+        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.
+        /*
+         * 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.
          */
-        SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE,
+        SCI_REQ_STP_PIO_WAIT_FRAME,
 
-        /**
-         * While in this state the IO request object is waiting for a DATA frame from
-         * the device.
+        /*
+         * While in this state the IO request object is waiting for a DATA
+         * frame from the device.
          */
-        SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_IN_AWAIT_DATA_SUBSTATE,
+        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.
+        /*
+         * While in this state the IO request object is waiting to transmit
+         * the next data frame to the device.
          */
-        SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_OUT_TRANSMIT_DATA_SUBSTATE,
+        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.).
          */
-        SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATE_AWAIT_TC_COMPLETION,
+        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).
          */
-        SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATE_AWAIT_TC_RESPONSE,
+        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).
          */
-        SCIC_SDS_SMP_REQUEST_STARTED_SUBSTATE_AWAIT_RESPONSE,
+        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.).
+        /*
+         * 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.).
          */
-        SCIC_SDS_SMP_REQUEST_STARTED_SUBSTATE_AWAIT_TC_COMPLETION,
+        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.
+         * This state is entered from the STARTED state. This state is entered
+         * from the ABORTING state.
          */
-        SCI_BASE_REQUEST_STATE_COMPLETED,
+        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_BASE_REQUEST_STATE_ABORTING,
+        SCI_REQ_ABORTING,
 
-        /**
+        /*
          * Simply the final state for the base request state machine.
          */
-        SCI_BASE_REQUEST_STATE_FINAL,
+        SCI_REQ_FINAL,
 };
 
 /**
@@ -498,13 +507,18 @@ enum sci_base_request_states {
 
 enum sci_status scic_sds_request_start(struct scic_sds_request *sci_req);
 enum sci_status scic_sds_io_request_terminate(struct scic_sds_request *sci_req);
-enum sci_status scic_sds_io_request_event_handler(struct scic_sds_request *sci_req,
-                                                  u32 event_code);
-enum sci_status scic_sds_io_request_frame_handler(struct scic_sds_request *sci_req,
-                                                  u32 frame_index);
-enum sci_status scic_sds_task_request_terminate(struct scic_sds_request *sci_req);
-extern enum sci_status scic_sds_request_complete(struct scic_sds_request *sci_req);
-extern enum sci_status scic_sds_io_request_tc_completion(struct scic_sds_request *sci_req, u32 code);
+enum sci_status
+scic_sds_io_request_event_handler(struct scic_sds_request *sci_req,
+                                  u32 event_code);
+enum sci_status
+scic_sds_io_request_frame_handler(struct scic_sds_request *sci_req,
+                                  u32 frame_index);
+enum sci_status
+scic_sds_task_request_terminate(struct scic_sds_request *sci_req);
+extern enum sci_status
+scic_sds_request_complete(struct scic_sds_request *sci_req);
+extern enum sci_status
+scic_sds_io_request_tc_completion(struct scic_sds_request *sci_req, u32 code);
 
 /* XXX open code in caller */
 static inline void *scic_request_get_virt_addr(struct scic_sds_request *sci_req,
@@ -523,8 +537,8 @@ static inline void *scic_request_get_virt_addr(struct scic_sds_request *sci_req,
 }
 
 /* XXX open code in caller */
-static inline dma_addr_t scic_io_request_get_dma_addr(struct scic_sds_request *sci_req,
-                                                      void *virt_addr)
+static inline dma_addr_t
+scic_io_request_get_dma_addr(struct scic_sds_request *sci_req, void *virt_addr)
 {
         struct isci_request *ireq = sci_req_to_ireq(sci_req);
 
@@ -543,9 +557,8 @@ static inline dma_addr_t scic_io_request_get_dma_addr(struct scic_sds_request *s
  *
  * status of the object as a isci_request_status enum.
  */
-static inline
-enum isci_request_status isci_request_get_state(
-        struct isci_request *isci_request)
+static inline enum isci_request_status
+isci_request_get_state(struct isci_request *isci_request)
 {
         BUG_ON(isci_request == NULL);
 
@@ -566,9 +579,9 @@ enum isci_request_status isci_request_get_state(
  * @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)
+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;
@@ -597,10 +610,10 @@ static inline enum isci_request_status isci_request_change_state(
  *
  * 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)
+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;
@@ -615,6 +628,7 @@ static inline enum isci_request_status isci_request_change_started_to_newstate(
                 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,
@@ -635,13 +649,13 @@ static inline enum isci_request_status isci_request_change_started_to_newstate(
  *
  * 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)
+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
-                       );
+        return isci_request_change_started_to_newstate(isci_request,
+                                                       completion_ptr,
+                                                       aborted);
 }
 /**
  * isci_request_free() - This function frees the request object.
@@ -649,62 +663,33 @@ static inline enum isci_request_status isci_request_change_started_to_aborted(
  * @isci_request: This parameter points to the isci_request object
  *
  */
-static inline void isci_request_free(
-        struct isci_host *isci_host,
-        struct isci_request *isci_request)
+static inline void isci_request_free(struct isci_host *isci_host,
+                                     struct isci_request *isci_request)
 {
         if (!isci_request)
                 return;
 
         /* release the dma memory if we fail. */
-        dma_pool_free(isci_host->dma_pool, isci_request,
+        dma_pool_free(isci_host->dma_pool,
+                      isci_request,
                       isci_request->request_daddr);
 }
 
+#define isci_request_access_task(req) ((req)->ttype_ptr.io_task_ptr)
 
-/* #define ISCI_REQUEST_VALIDATE_ACCESS
- */
-
-#ifdef ISCI_REQUEST_VALIDATE_ACCESS
-
-static inline
-struct sas_task *isci_request_access_task(struct isci_request *isci_request)
-{
-        BUG_ON(isci_request->ttype != io_task);
-        return isci_request->ttype_ptr.io_task_ptr;
-}
-
-static inline
-struct isci_tmf *isci_request_access_tmf(struct isci_request *isci_request)
-{
-        BUG_ON(isci_request->ttype != tmf_task);
-        return isci_request->ttype_ptr.tmf_task_ptr;
-}
-
-#else  /* not ISCI_REQUEST_VALIDATE_ACCESS */
-
-#define isci_request_access_task(RequestPtr) \
-        ((RequestPtr)->ttype_ptr.io_task_ptr)
-
-#define isci_request_access_tmf(RequestPtr)  \
-        ((RequestPtr)->ttype_ptr.tmf_task_ptr)
-
-#endif /* not ISCI_REQUEST_VALIDATE_ACCESS */
-
+#define isci_request_access_tmf(req) ((req)->ttype_ptr.tmf_task_ptr)
 
-int isci_request_alloc_tmf(
-        struct isci_host *isci_host,
-        struct isci_tmf *isci_tmf,
-        struct isci_request **isci_request,
-        struct isci_remote_device *isci_device,
-        gfp_t gfp_flags);
+int isci_request_alloc_tmf(struct isci_host *isci_host,
+                           struct isci_tmf *isci_tmf,
+                           struct isci_request **isci_request,
+                           struct isci_remote_device *isci_device,
+                           gfp_t gfp_flags);
 
 
-int isci_request_execute(
-        struct isci_host *isci_host,
-        struct sas_task *task,
-        struct isci_request **request,
-        gfp_t gfp_flags);
+int isci_request_execute(struct isci_host *isci_host,
+                         struct sas_task *task,
+                         struct isci_request **request,
+                         gfp_t gfp_flags);
 
 /**
  * isci_request_unmap_sgl() - This function unmaps the DMA address of a given
@@ -713,9 +698,8 @@ int isci_request_execute(
  * @*pdev: This Parameter is the pci_device struct for the controller
  *
  */
-static inline void isci_request_unmap_sgl(
-        struct isci_request *request,
-        struct pci_dev *pdev)
+static inline void
+isci_request_unmap_sgl(struct isci_request *request, struct pci_dev *pdev)
 {
         struct sas_task *task = isci_request_access_task(request);
 
@@ -758,9 +742,9 @@ static inline void isci_request_unmap_sgl(
  *
  * pointer to the next sge for specified request.
  */
-static inline void *isci_request_io_request_get_next_sge(
-        struct isci_request *request,
-        void *current_sge_address)
+static inline void *
+isci_request_io_request_get_next_sge(struct isci_request *request,
+                                     void *current_sge_address)
 {
         struct sas_task *task = isci_request_access_task(request);
         void *ret = NULL;
@@ -791,15 +775,20 @@ static inline void *isci_request_io_request_get_next_sge(
         return ret;
 }
 
-void isci_terminate_pending_requests(struct isci_host *isci_host,
-                                     struct isci_remote_device *isci_device,
-                                     enum isci_request_status new_request_state);
-enum sci_status scic_task_request_construct(struct scic_sds_controller *scic,
-                                            struct scic_sds_remote_device *sci_dev,
-                                            u16 io_tag,
-                                            struct scic_sds_request *sci_req);
-enum sci_status scic_task_request_construct_ssp(struct scic_sds_request *sci_req);
-enum sci_status scic_task_request_construct_sata(struct scic_sds_request *sci_req);
-void scic_stp_io_request_set_ncq_tag(struct scic_sds_request *sci_req, u16 ncq_tag);
+void
+isci_terminate_pending_requests(struct isci_host *isci_host,
+                                struct isci_remote_device *isci_device,
+                                enum isci_request_status new_request_state);
+enum sci_status
+scic_task_request_construct(struct scic_sds_controller *scic,
+                            struct scic_sds_remote_device *sci_dev,
+                            u16 io_tag,
+                            struct scic_sds_request *sci_req);
+enum sci_status
+scic_task_request_construct_ssp(struct scic_sds_request *sci_req);
+enum sci_status
+scic_task_request_construct_sata(struct scic_sds_request *sci_req);
+void
+scic_stp_io_request_set_ncq_tag(struct scic_sds_request *sci_req, u16 ncq_tag);
 void scic_sds_smp_request_copy_response(struct scic_sds_request *sci_req);
 #endif /* !defined(_ISCI_REQUEST_H_) */
diff --git a/drivers/scsi/isci/state_machine.c b/drivers/scsi/isci/state_machine.c
index 1bcd925e502f..8cfefb959f22 100644
--- a/drivers/scsi/isci/state_machine.c
+++ b/drivers/scsi/isci/state_machine.c
@@ -127,16 +127,7 @@ void sci_base_state_machine_stop(
         sci_state_machine_exit_state(sm);
 }
 
-/**
- * This method performs an update to the current state of the state machine.
- * @sm: This parameter specifies the state machine for which
- *    the caller wishes to perform a state change.
- * @next_state: This parameter specifies the new state for the state machine.
- *
- */
-void sci_base_state_machine_change_state(
-        struct sci_base_state_machine *sm,
-        u32 next_state)
+void sci_change_state(struct sci_base_state_machine *sm, u32 next_state)
 {
         sci_state_machine_exit_state(sm);
 
@@ -145,18 +136,3 @@ void sci_base_state_machine_change_state(
 
         sci_state_machine_enter_state(sm);
 }
-
-/**
- * This method simply returns the current state of the state machine to the
- *    caller.
- * @sm: This parameter specifies the state machine for which to
- *    retrieve the current state.
- *
- * This method returns a u32 value indicating the current state for the
- * supplied state machine.
- */
-u32 sci_base_state_machine_get_state(struct sci_base_state_machine *sm)
-{
-        return sm->current_state_id;
-}
-
diff --git a/drivers/scsi/isci/state_machine.h b/drivers/scsi/isci/state_machine.h
index 067ed9126bf2..6cb55a0adc54 100644
--- a/drivers/scsi/isci/state_machine.h
+++ b/drivers/scsi/isci/state_machine.h
@@ -117,8 +117,6 @@ void sci_base_state_machine_construct(struct sci_base_state_machine *sm,
                                       u32 initial_state);
 void sci_base_state_machine_start(struct sci_base_state_machine *sm);
 void sci_base_state_machine_stop(struct sci_base_state_machine *sm);
-void sci_base_state_machine_change_state(struct sci_base_state_machine *sm,
-                                         u32 next_state);
-u32 sci_base_state_machine_get_state(struct sci_base_state_machine *sm);
+void sci_change_state(struct sci_base_state_machine *sm, u32 next_state);
 
 #endif /* _SCI_BASE_STATE_MACHINE_H_ */