isci: replace this_* and the_* variables with more meaningful names

Removed any instances of the_* and this_* to variable names that are more
meaningful and tell us what they actually are.

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

21 files changed, 1481 insertions, 1477 deletions

diff --git a/drivers/scsi/isci/core/sci_pool.h b/drivers/scsi/isci/core/sci_pool.h
index c0d2ea32529b..016ec832f74f 100644
--- a/drivers/scsi/isci/core/sci_pool.h
+++ b/drivers/scsi/isci/core/sci_pool.h
@@ -73,8 +73,8 @@
  *
  * Private operation for the pool
  */
-#define SCI_POOL_INCREMENT(this_pool, index) \
-        (((index) + 1) == (this_pool).size ? 0 : (index) + 1)
+#define SCI_POOL_INCREMENT(pool, index) \
+        (((index) + 1) == (pool).size ? 0 : (index) + 1)
 
 /**
  * SCI_POOL_CREATE() -
@@ -98,8 +98,8 @@
  * This macro evaluates the pool and returns true if the pool is empty. If the
  * pool is empty the user should not perform any get operation on the pool.
  */
-#define sci_pool_empty(this_pool) \
-        ((this_pool).get == (this_pool).put)
+#define sci_pool_empty(pool) \
+        ((pool).get == (pool).put)
 
 /**
  * sci_pool_full() -
@@ -107,8 +107,8 @@
  * This macro evaluates the pool and returns true if the pool is full.  If the
  * pool is full the user should not perform any put operation.
  */
-#define sci_pool_full(this_pool) \
-        (SCI_POOL_INCREMENT(this_pool, (this_pool).put) == (this_pool).get)
+#define sci_pool_full(pool) \
+        (SCI_POOL_INCREMENT(pool, (pool).put) == (pool).get)
 
 /**
  * sci_pool_size() -
@@ -118,25 +118,25 @@
  * pointers can be written simultaneously by different users.  As a result,
  * this macro subtracts 1 from the internal size
  */
-#define sci_pool_size(this_pool) \
-        ((this_pool).size - 1)
+#define sci_pool_size(pool) \
+        ((pool).size - 1)
 
 /**
  * sci_pool_count() -
  *
  * This macro indicates the number of elements currently contained in the pool.
  */
-#define sci_pool_count(this_pool) \
+#define sci_pool_count(pool) \
         (\
-                sci_pool_empty((this_pool)) \
+                sci_pool_empty((pool)) \
                 ? 0 \
                 : (\
-                        sci_pool_full((this_pool)) \
-                        ? sci_pool_size((this_pool)) \
+                        sci_pool_full((pool)) \
+                        ? sci_pool_size((pool)) \
                         : (\
-                                (this_pool).get > (this_pool).put \
-                                ? ((this_pool).size - (this_pool).get + (this_pool).put) \
-                                : ((this_pool).put - (this_pool).get) \
+                                (pool).get > (pool).put \
+                                ? ((pool).size - (pool).get + (pool).put) \
+                                : ((pool).put - (pool).get) \
                                 ) \
                         ) \
         )
@@ -146,11 +146,11 @@
  *
  * This macro initializes the pool to an empty condition.
  */
-#define sci_pool_initialize(this_pool) \
+#define sci_pool_initialize(pool) \
         { \
-                (this_pool).size = (sizeof((this_pool).array) / sizeof((this_pool).array[0])); \
-                (this_pool).get = 0; \
-                (this_pool).put = 0; \
+                (pool).size = (sizeof((pool).array) / sizeof((pool).array[0])); \
+                (pool).get = 0; \
+                (pool).put = 0; \
         }
 
 /**
@@ -159,10 +159,10 @@
  * This macro will get the next free element from the pool. This should only be
  * called if the pool is not empty.
  */
-#define sci_pool_get(this_pool, my_value) \
+#define sci_pool_get(pool, my_value) \
         { \
-                (my_value) = (this_pool).array[(this_pool).get]; \
-                (this_pool).get = SCI_POOL_INCREMENT((this_pool), (this_pool).get); \
+                (my_value) = (pool).array[(pool).get]; \
+                (pool).get = SCI_POOL_INCREMENT((pool), (pool).get); \
         }
 
 /**
@@ -171,10 +171,10 @@
  * This macro will put the value into the pool. This should only be called if
  * the pool is not full.
  */
-#define sci_pool_put(this_pool, the_value) \
+#define sci_pool_put(pool, value) \
         { \
-                (this_pool).array[(this_pool).put] = (the_value); \
-                (this_pool).put = SCI_POOL_INCREMENT((this_pool), (this_pool).put); \
+                (pool).array[(pool).put] = (value); \
+                (pool).put = SCI_POOL_INCREMENT((pool), (pool).put); \
         }
 
 /**
@@ -183,16 +183,16 @@
  * This macro will search the pool and remove any elements in the pool matching
  * the supplied value. This method can only be utilized on pools
  */
-#define sci_pool_erase(this_pool, type, the_value) \
+#define sci_pool_erase(pool, type, value) \
         { \
                 type tmp_value; \
                 u32 index; \
-                u32 element_count = sci_pool_count((this_pool)); \
+                u32 element_count = sci_pool_count((pool)); \
  \
                 for (index = 0; index < element_count; index++) {       \
-                        sci_pool_get((this_pool), tmp_value); \
-                        if (tmp_value != (the_value)) \
-                                sci_pool_put((this_pool), tmp_value); \
+                        sci_pool_get((pool), tmp_value); \
+                        if (tmp_value != (value)) \
+                                sci_pool_put((pool), tmp_value); \
                 } \
         }
 
diff --git a/drivers/scsi/isci/core/scic_sds_controller.c b/drivers/scsi/isci/core/scic_sds_controller.c
index 9bb78a2e6ff7..63f4cd130d1d 100644
--- a/drivers/scsi/isci/core/scic_sds_controller.c
+++ b/drivers/scsi/isci/core/scic_sds_controller.c
@@ -290,7 +290,7 @@ int scic_controller_mem_init(struct scic_sds_controller *scic)
 
 /**
  * This method initializes the task context data for the controller.
- * @this_controller:
+ * @scic:
  *
  */
 static void
@@ -321,22 +321,22 @@ scic_sds_controller_assign_task_entries(struct scic_sds_controller *controller)
  *
  */
 static void scic_sds_controller_initialize_completion_queue(
-        struct scic_sds_controller *this_controller)
+        struct scic_sds_controller *scic)
 {
         u32 index;
         u32 completion_queue_control_value;
         u32 completion_queue_get_value;
         u32 completion_queue_put_value;
 
-        this_controller->completion_queue_get = 0;
+        scic->completion_queue_get = 0;
 
         completion_queue_control_value = (
-                SMU_CQC_QUEUE_LIMIT_SET(this_controller->completion_queue_entries - 1)
-                | SMU_CQC_EVENT_LIMIT_SET(this_controller->completion_event_entries - 1)
+                SMU_CQC_QUEUE_LIMIT_SET(scic->completion_queue_entries - 1)
+                | SMU_CQC_EVENT_LIMIT_SET(scic->completion_event_entries - 1)
                 );
 
         writel(completion_queue_control_value,
-                &this_controller->smu_registers->completion_queue_control);
+               &scic->smu_registers->completion_queue_control);
 
 
         /* Set the completion queue get pointer and enable the queue */
@@ -348,7 +348,7 @@ static void scic_sds_controller_initialize_completion_queue(
                 );
 
         writel(completion_queue_get_value,
-                &this_controller->smu_registers->completion_queue_get);
+               &scic->smu_registers->completion_queue_get);
 
         /* Set the completion queue put pointer */
         completion_queue_put_value = (
@@ -357,16 +357,15 @@ static void scic_sds_controller_initialize_completion_queue(
                 );
 
         writel(completion_queue_put_value,
-                &this_controller->smu_registers->completion_queue_put);
-
+               &scic->smu_registers->completion_queue_put);
 
         /* Initialize the cycle bit of the completion queue entries */
-        for (index = 0; index < this_controller->completion_queue_entries; index++) {
+        for (index = 0; index < scic->completion_queue_entries; index++) {
                 /*
                  * If get.cycle_bit != completion_queue.cycle_bit
                  * its not a valid completion queue entry
                  * so at system start all entries are invalid */
-                this_controller->completion_queue[index] = 0x80000000;
+                scic->completion_queue[index] = 0x80000000;
         }
 }
 
@@ -376,7 +375,7 @@ static void scic_sds_controller_initialize_completion_queue(
  *
  */
 static void scic_sds_controller_initialize_unsolicited_frame_queue(
-        struct scic_sds_controller *this_controller)
+        struct scic_sds_controller *scic)
 {
         u32 frame_queue_control_value;
         u32 frame_queue_get_value;
@@ -384,10 +383,11 @@ static void scic_sds_controller_initialize_unsolicited_frame_queue(
 
         /* Write the queue size */
         frame_queue_control_value =
-                SCU_UFQC_GEN_VAL(QUEUE_SIZE, this_controller->uf_control.address_table.count);
+                SCU_UFQC_GEN_VAL(QUEUE_SIZE,
+                                 scic->uf_control.address_table.count);
 
         writel(frame_queue_control_value,
-                &this_controller->scu_registers->sdma.unsolicited_frame_queue_control);
+               &scic->scu_registers->sdma.unsolicited_frame_queue_control);
 
         /* Setup the get pointer for the unsolicited frame queue */
         frame_queue_get_value = (
@@ -396,11 +396,11 @@ static void scic_sds_controller_initialize_unsolicited_frame_queue(
                 );
 
         writel(frame_queue_get_value,
-                &this_controller->scu_registers->sdma.unsolicited_frame_get_pointer);
+               &scic->scu_registers->sdma.unsolicited_frame_get_pointer);
         /* Setup the put pointer for the unsolicited frame queue */
         frame_queue_put_value = SCU_UFQPP_GEN_VAL(POINTER, 0);
         writel(frame_queue_put_value,
-                &this_controller->scu_registers->sdma.unsolicited_frame_put_pointer);
+               &scic->scu_registers->sdma.unsolicited_frame_put_pointer);
 }
 
 /**
@@ -409,16 +409,17 @@ static void scic_sds_controller_initialize_unsolicited_frame_queue(
  *
  */
 static void scic_sds_controller_enable_port_task_scheduler(
-        struct scic_sds_controller *this_controller)
+        struct scic_sds_controller *scic)
 {
         u32 port_task_scheduler_value;
 
         port_task_scheduler_value =
-                readl(&this_controller->scu_registers->peg0.ptsg.control);
+                readl(&scic->scu_registers->peg0.ptsg.control);
         port_task_scheduler_value |=
-                (SCU_PTSGCR_GEN_BIT(ETM_ENABLE) | SCU_PTSGCR_GEN_BIT(PTSG_ENABLE));
+                (SCU_PTSGCR_GEN_BIT(ETM_ENABLE) |
+                 SCU_PTSGCR_GEN_BIT(PTSG_ENABLE));
         writel(port_task_scheduler_value,
-                &this_controller->scu_registers->peg0.ptsg.control);
+               &scic->scu_registers->peg0.ptsg.control);
 }
 
 /**
@@ -564,7 +565,7 @@ static void scic_sds_controller_afe_initialization(struct scic_sds_controller *s
  * This method will attempt to transition into the ready state for the
  *    controller and indicate that the controller start operation has completed
  *    if all criteria are met.
- * @this_controller: This parameter indicates the controller object for which
+ * @scic: This parameter indicates the controller object for which
  *    to transition to ready.
  * @status: This parameter indicates the status value to be pass into the call
  *    to scic_cb_controller_start_complete().
@@ -858,30 +859,30 @@ static void scic_sds_controller_power_control_timer_restart(struct scic_sds_cont
 static void scic_sds_controller_power_control_timer_handler(
         void *controller)
 {
-        struct scic_sds_controller *this_controller;
+        struct scic_sds_controller *scic;
 
-        this_controller = (struct scic_sds_controller *)controller;
+        scic = (struct scic_sds_controller *)controller;
 
-        this_controller->power_control.phys_granted_power = 0;
+        scic->power_control.phys_granted_power = 0;
 
-        if (this_controller->power_control.phys_waiting == 0) {
-                this_controller->power_control.timer_started = false;
+        if (scic->power_control.phys_waiting == 0) {
+                scic->power_control.timer_started = false;
         } else {
-                struct scic_sds_phy *the_phy = NULL;
+                struct scic_sds_phy *sci_phy = NULL;
                 u8 i;
 
                 for (i = 0;
                      (i < SCI_MAX_PHYS)
-                     && (this_controller->power_control.phys_waiting != 0);
+                     && (scic->power_control.phys_waiting != 0);
                      i++) {
-                        if (this_controller->power_control.requesters[i] != NULL) {
-                                if (this_controller->power_control.phys_granted_power <
-                                    this_controller->oem_parameters.sds1.controller.max_concurrent_dev_spin_up) {
-                                        the_phy = this_controller->power_control.requesters[i];
-                                        this_controller->power_control.requesters[i] = NULL;
-                                        this_controller->power_control.phys_waiting--;
-                                        this_controller->power_control.phys_granted_power++;
-                                        scic_sds_phy_consume_power_handler(the_phy);
+                        if (scic->power_control.requesters[i] != NULL) {
+                                if (scic->power_control.phys_granted_power <
+                                    scic->oem_parameters.sds1.controller.max_concurrent_dev_spin_up) {
+                                        sci_phy = scic->power_control.requesters[i];
+                                        scic->power_control.requesters[i] = NULL;
+                                        scic->power_control.phys_waiting--;
+                                        scic->power_control.phys_granted_power++;
+                                        scic_sds_phy_consume_power_handler(sci_phy);
                                 } else {
                                         break;
                                 }
@@ -892,56 +893,56 @@ static void scic_sds_controller_power_control_timer_handler(
                  * It doesn't matter if the power list is empty, we need to start the
                  * timer in case another phy becomes ready.
                  */
-                scic_sds_controller_power_control_timer_start(this_controller);
+                scic_sds_controller_power_control_timer_start(scic);
         }
 }
 
 /**
  * This method inserts the phy in the stagger spinup control queue.
- * @this_controller:
+ * @scic:
  *
  *
  */
 void scic_sds_controller_power_control_queue_insert(
-        struct scic_sds_controller *this_controller,
-        struct scic_sds_phy *the_phy)
+        struct scic_sds_controller *scic,
+        struct scic_sds_phy *sci_phy)
 {
-        BUG_ON(the_phy == NULL);
+        BUG_ON(sci_phy == NULL);
 
-        if (this_controller->power_control.phys_granted_power <
-            this_controller->oem_parameters.sds1.controller.max_concurrent_dev_spin_up) {
-                this_controller->power_control.phys_granted_power++;
-                scic_sds_phy_consume_power_handler(the_phy);
+        if (scic->power_control.phys_granted_power <
+            scic->oem_parameters.sds1.controller.max_concurrent_dev_spin_up) {
+                scic->power_control.phys_granted_power++;
+                scic_sds_phy_consume_power_handler(sci_phy);
 
                 /*
                  * stop and start the power_control timer. When the timer fires, the
                  * no_of_phys_granted_power will be set to 0
                  */
-                scic_sds_controller_power_control_timer_restart(this_controller);
+                scic_sds_controller_power_control_timer_restart(scic);
         } else {
                 /* Add the phy in the waiting list */
-                this_controller->power_control.requesters[the_phy->phy_index] = the_phy;
-                this_controller->power_control.phys_waiting++;
+                scic->power_control.requesters[sci_phy->phy_index] = sci_phy;
+                scic->power_control.phys_waiting++;
         }
 }
 
 /**
  * This method removes the phy from the stagger spinup control queue.
- * @this_controller:
+ * @scic:
  *
  *
  */
 void scic_sds_controller_power_control_queue_remove(
-        struct scic_sds_controller *this_controller,
-        struct scic_sds_phy *the_phy)
+        struct scic_sds_controller *scic,
+        struct scic_sds_phy *sci_phy)
 {
-        BUG_ON(the_phy == NULL);
+        BUG_ON(sci_phy == NULL);
 
-        if (this_controller->power_control.requesters[the_phy->phy_index] != NULL) {
-                this_controller->power_control.phys_waiting--;
+        if (scic->power_control.requesters[sci_phy->phy_index] != NULL) {
+                scic->power_control.phys_waiting--;
         }
 
-        this_controller->power_control.requesters[the_phy->phy_index] = NULL;
+        scic->power_control.requesters[sci_phy->phy_index] = NULL;
 }
 
 /*
@@ -952,23 +953,20 @@ void scic_sds_controller_power_control_queue_remove(
 /**
  * This method returns a true value if the completion queue has entries that
  *    can be processed
- * @this_controller:
+ * @scic:
  *
  * bool true if the completion queue has entries to process false if the
  * completion queue has no entries to process
  */
 static bool scic_sds_controller_completion_queue_has_entries(
-        struct scic_sds_controller *this_controller)
+        struct scic_sds_controller *scic)
 {
-        u32 get_value = this_controller->completion_queue_get;
+        u32 get_value = scic->completion_queue_get;
         u32 get_index = get_value & SMU_COMPLETION_QUEUE_GET_POINTER_MASK;
 
-        if (
-                NORMALIZE_GET_POINTER_CYCLE_BIT(get_value)
-                == COMPLETION_QUEUE_CYCLE_BIT(this_controller->completion_queue[get_index])
-                ) {
+        if (NORMALIZE_GET_POINTER_CYCLE_BIT(get_value) ==
+            COMPLETION_QUEUE_CYCLE_BIT(scic->completion_queue[get_index]))
                 return true;
-        }
 
         return false;
 }
@@ -976,19 +974,19 @@ static bool scic_sds_controller_completion_queue_has_entries(
 /**
  * This method processes a task completion notification.  This is called from
  *    within the controller completion handler.
- * @this_controller:
+ * @scic:
  * @completion_entry:
  *
  */
 static void scic_sds_controller_task_completion(
-        struct scic_sds_controller *this_controller,
+        struct scic_sds_controller *scic,
         u32 completion_entry)
 {
         u32 index;
         struct scic_sds_request *io_request;
 
         index = SCU_GET_COMPLETION_INDEX(completion_entry);
-        io_request = this_controller->io_request_table[index];
+        io_request = scic->io_request_table[index];
 
         /* Make sure that we really want to process this IO request */
         if (
@@ -996,7 +994,7 @@ static void scic_sds_controller_task_completion(
                 && (io_request->io_tag != SCI_CONTROLLER_INVALID_IO_TAG)
                 && (
                         scic_sds_io_tag_get_sequence(io_request->io_tag)
-                        == this_controller->io_request_sequence[index]
+                        == scic->io_request_sequence[index]
                         )
                 ) {
                 /* Yep this is a valid io request pass it along to the io request handler */
@@ -1007,12 +1005,12 @@ static void scic_sds_controller_task_completion(
 /**
  * This method processes an SDMA completion event.  This is called from within
  *    the controller completion handler.
- * @this_controller:
+ * @scic:
  * @completion_entry:
  *
  */
 static void scic_sds_controller_sdma_completion(
-        struct scic_sds_controller *this_controller,
+        struct scic_sds_controller *scic,
         u32 completion_entry)
 {
         u32 index;
@@ -1024,8 +1022,8 @@ static void scic_sds_controller_sdma_completion(
         switch (scu_get_command_request_type(completion_entry)) {
         case SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_TC:
         case SCU_CONTEXT_COMMAND_REQUEST_TYPE_DUMP_TC:
-                io_request = this_controller->io_request_table[index];
-                dev_warn(scic_to_dev(this_controller),
+                io_request = scic->io_request_table[index];
+                dev_warn(scic_to_dev(scic),
                          "%s: SCIC SDS Completion type SDMA %x for io request "
                          "%p\n",
                          __func__,
@@ -1039,8 +1037,8 @@ static void scic_sds_controller_sdma_completion(
         case SCU_CONTEXT_COMMAND_REQUEST_TYPE_DUMP_RNC:
         case SCU_CONTEXT_COMMAND_REQUEST_TYPE_OTHER_RNC:
         case SCU_CONTEXT_COMMAND_REQUEST_TYPE_POST_RNC:
-                device = this_controller->device_table[index];
-                dev_warn(scic_to_dev(this_controller),
+                device = scic->device_table[index];
+                dev_warn(scic_to_dev(scic),
                          "%s: SCIC SDS Completion type SDMA %x for remote "
                          "device %p\n",
                          __func__,
@@ -1052,7 +1050,7 @@ static void scic_sds_controller_sdma_completion(
                 break;
 
         default:
-                dev_warn(scic_to_dev(this_controller),
+                dev_warn(scic_to_dev(scic),
                          "%s: SCIC SDS Completion unknown SDMA completion "
                          "type %x\n",
                          __func__,
@@ -1064,14 +1062,14 @@ static void scic_sds_controller_sdma_completion(
 
 /**
  *
- * @this_controller:
+ * @scic:
  * @completion_entry:
  *
  * This method processes an unsolicited frame message.  This is called from
  * within the controller completion handler. none
  */
 static void scic_sds_controller_unsolicited_frame(
-        struct scic_sds_controller *this_controller,
+        struct scic_sds_controller *scic,
         u32 completion_entry)
 {
         u32 index;
@@ -1086,8 +1084,8 @@ static void scic_sds_controller_unsolicited_frame(
         frame_index = SCU_GET_FRAME_INDEX(completion_entry);
 
         frame_header
-                = this_controller->uf_control.buffers.array[frame_index].header;
-        this_controller->uf_control.buffers.array[frame_index].state
+                = scic->uf_control.buffers.array[frame_index].header;
+        scic->uf_control.buffers.array[frame_index].state
                 = UNSOLICITED_FRAME_IN_USE;
 
         if (SCU_GET_FRAME_ERROR(completion_entry)) {
@@ -1095,13 +1093,13 @@ static void scic_sds_controller_unsolicited_frame(
                  * / @todo If the IAF frame or SIGNATURE FIS frame has an error will
                  * /       this cause a problem? We expect the phy initialization will
                  * /       fail if there is an error in the frame. */
-                scic_sds_controller_release_frame(this_controller, frame_index);
+                scic_sds_controller_release_frame(scic, frame_index);
                 return;
         }
 
         if (frame_header->is_address_frame) {
                 index = SCU_GET_PROTOCOL_ENGINE_INDEX(completion_entry);
-                phy = &this_controller->phy_table[index];
+                phy = &scic->phy_table[index];
                 if (phy != NULL) {
                         result = scic_sds_phy_frame_handler(phy, frame_index);
                 }
@@ -1115,18 +1113,18 @@ static void scic_sds_controller_unsolicited_frame(
                          * device that has not yet been created.  In either case forwared
                          * the frame to the PE and let it take care of the frame data. */
                         index = SCU_GET_PROTOCOL_ENGINE_INDEX(completion_entry);
-                        phy = &this_controller->phy_table[index];
+                        phy = &scic->phy_table[index];
                         result = scic_sds_phy_frame_handler(phy, frame_index);
                 } else {
-                        if (index < this_controller->remote_node_entries)
-                                device = this_controller->device_table[index];
+                        if (index < scic->remote_node_entries)
+                                device = scic->device_table[index];
                         else
                                 device = NULL;
 
                         if (device != NULL)
                                 result = scic_sds_remote_device_frame_handler(device, frame_index);
                         else
-                                scic_sds_controller_release_frame(this_controller, frame_index);
+                                scic_sds_controller_release_frame(scic, frame_index);
                 }
         }
 
@@ -1140,12 +1138,12 @@ static void scic_sds_controller_unsolicited_frame(
 /**
  * This method processes an event completion entry.  This is called from within
  *    the controller completion handler.
- * @this_controller:
+ * @scic:
  * @completion_entry:
  *
  */
 static void scic_sds_controller_event_completion(
-        struct scic_sds_controller *this_controller,
+        struct scic_sds_controller *scic,
         u32 completion_entry)
 {
         u32 index;
@@ -1158,11 +1156,11 @@ static void scic_sds_controller_event_completion(
         switch (scu_get_event_type(completion_entry)) {
         case SCU_EVENT_TYPE_SMU_COMMAND_ERROR:
                 /* / @todo The driver did something wrong and we need to fix the condtion. */
-                dev_err(scic_to_dev(this_controller),
+                dev_err(scic_to_dev(scic),
                         "%s: SCIC Controller 0x%p received SMU command error "
                         "0x%x\n",
                         __func__,
-                        this_controller,
+                        scic,
                         completion_entry);
                 break;
 
@@ -1172,16 +1170,16 @@ static void scic_sds_controller_event_completion(
                 /*
                  * / @todo This is a hardware failure and its likely that we want to
                  * /       reset the controller. */
-                dev_err(scic_to_dev(this_controller),
+                dev_err(scic_to_dev(scic),
                         "%s: SCIC Controller 0x%p received fatal controller "
                         "event  0x%x\n",
                         __func__,
-                        this_controller,
+                        scic,
                         completion_entry);
                 break;
 
         case SCU_EVENT_TYPE_TRANSPORT_ERROR:
-                io_request = this_controller->io_request_table[index];
+                io_request = scic->io_request_table[index];
                 scic_sds_io_request_event_handler(io_request, completion_entry);
                 break;
 
@@ -1189,31 +1187,31 @@ static void scic_sds_controller_event_completion(
                 switch (scu_get_event_specifier(completion_entry)) {
                 case SCU_EVENT_SPECIFIC_SMP_RESPONSE_NO_PE:
                 case SCU_EVENT_SPECIFIC_TASK_TIMEOUT:
-                        io_request = this_controller->io_request_table[index];
+                        io_request = scic->io_request_table[index];
                         if (io_request != NULL)
                                 scic_sds_io_request_event_handler(io_request, completion_entry);
                         else
-                                dev_warn(scic_to_dev(this_controller),
+                                dev_warn(scic_to_dev(scic),
                                          "%s: SCIC Controller 0x%p received "
                                          "event 0x%x for io request object "
                                          "that doesnt exist.\n",
                                          __func__,
-                                         this_controller,
+                                         scic,
                                          completion_entry);
 
                         break;
 
                 case SCU_EVENT_SPECIFIC_IT_NEXUS_TIMEOUT:
-                        device = this_controller->device_table[index];
+                        device = scic->device_table[index];
                         if (device != NULL)
                                 scic_sds_remote_device_event_handler(device, completion_entry);
                         else
-                                dev_warn(scic_to_dev(this_controller),
+                                dev_warn(scic_to_dev(scic),
                                          "%s: SCIC Controller 0x%p received "
                                          "event 0x%x for remote device object "
                                          "that doesnt exist.\n",
                                          __func__,
-                                         this_controller,
+                                         scic,
                                          completion_entry);
 
                         break;
@@ -1230,32 +1228,32 @@ static void scic_sds_controller_event_completion(
          * we get the event notification.  This is a type 4 event. */
         case SCU_EVENT_TYPE_OSSP_EVENT:
                 index = SCU_GET_PROTOCOL_ENGINE_INDEX(completion_entry);
-                phy = &this_controller->phy_table[index];
+                phy = &scic->phy_table[index];
                 scic_sds_phy_event_handler(phy, completion_entry);
                 break;
 
         case SCU_EVENT_TYPE_RNC_SUSPEND_TX:
         case SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX:
         case SCU_EVENT_TYPE_RNC_OPS_MISC:
-                if (index < this_controller->remote_node_entries) {
-                        device = this_controller->device_table[index];
+                if (index < scic->remote_node_entries) {
+                        device = scic->device_table[index];
 
                         if (device != NULL)
                                 scic_sds_remote_device_event_handler(device, completion_entry);
                 } else
-                        dev_err(scic_to_dev(this_controller),
+                        dev_err(scic_to_dev(scic),
                                 "%s: SCIC Controller 0x%p received event 0x%x "
                                 "for remote device object 0x%0x that doesnt "
                                 "exist.\n",
                                 __func__,
-                                this_controller,
+                                scic,
                                 completion_entry,
                                 index);
 
                 break;
 
         default:
-                dev_warn(scic_to_dev(this_controller),
+                dev_warn(scic_to_dev(scic),
                          "%s: SCIC Controller received unknown event code %x\n",
                          __func__,
                          completion_entry);
@@ -1265,11 +1263,11 @@ static void scic_sds_controller_event_completion(
 
 /**
  * This method is a private routine for processing the completion queue entries.
- * @this_controller:
+ * @scic:
  *
  */
 static void scic_sds_controller_process_completions(
-        struct scic_sds_controller *this_controller)
+        struct scic_sds_controller *scic)
 {
         u32 completion_count = 0;
         u32 completion_entry;
@@ -1278,60 +1276,60 @@ static void scic_sds_controller_process_completions(
         u32 event_index;
         u32 event_cycle;
 
-        dev_dbg(scic_to_dev(this_controller),
+        dev_dbg(scic_to_dev(scic),
                 "%s: completion queue begining get:0x%08x\n",
                 __func__,
-                this_controller->completion_queue_get);
+                scic->completion_queue_get);
 
         /* Get the component parts of the completion queue */
-        get_index = NORMALIZE_GET_POINTER(this_controller->completion_queue_get);
-        get_cycle = SMU_CQGR_CYCLE_BIT & this_controller->completion_queue_get;
+        get_index = NORMALIZE_GET_POINTER(scic->completion_queue_get);
+        get_cycle = SMU_CQGR_CYCLE_BIT & scic->completion_queue_get;
 
-        event_index = NORMALIZE_EVENT_POINTER(this_controller->completion_queue_get);
-        event_cycle = SMU_CQGR_EVENT_CYCLE_BIT & this_controller->completion_queue_get;
+        event_index = NORMALIZE_EVENT_POINTER(scic->completion_queue_get);
+        event_cycle = SMU_CQGR_EVENT_CYCLE_BIT & scic->completion_queue_get;
 
         while (
                 NORMALIZE_GET_POINTER_CYCLE_BIT(get_cycle)
-                == COMPLETION_QUEUE_CYCLE_BIT(this_controller->completion_queue[get_index])
+                == COMPLETION_QUEUE_CYCLE_BIT(scic->completion_queue[get_index])
                 ) {
                 completion_count++;
 
-                completion_entry = this_controller->completion_queue[get_index];
-                INCREMENT_COMPLETION_QUEUE_GET(this_controller, get_index, get_cycle);
+                completion_entry = scic->completion_queue[get_index];
+                INCREMENT_COMPLETION_QUEUE_GET(scic, get_index, get_cycle);
 
-                dev_dbg(scic_to_dev(this_controller),
+                dev_dbg(scic_to_dev(scic),
                         "%s: completion queue entry:0x%08x\n",
                         __func__,
                         completion_entry);
 
                 switch (SCU_GET_COMPLETION_TYPE(completion_entry)) {
                 case SCU_COMPLETION_TYPE_TASK:
-                        scic_sds_controller_task_completion(this_controller, completion_entry);
+                        scic_sds_controller_task_completion(scic, completion_entry);
                         break;
 
                 case SCU_COMPLETION_TYPE_SDMA:
-                        scic_sds_controller_sdma_completion(this_controller, completion_entry);
+                        scic_sds_controller_sdma_completion(scic, completion_entry);
                         break;
 
                 case SCU_COMPLETION_TYPE_UFI:
-                        scic_sds_controller_unsolicited_frame(this_controller, completion_entry);
+                        scic_sds_controller_unsolicited_frame(scic, completion_entry);
                         break;
 
                 case SCU_COMPLETION_TYPE_EVENT:
-                        INCREMENT_EVENT_QUEUE_GET(this_controller, event_index, event_cycle);
-                        scic_sds_controller_event_completion(this_controller, completion_entry);
+                        INCREMENT_EVENT_QUEUE_GET(scic, event_index, event_cycle);
+                        scic_sds_controller_event_completion(scic, completion_entry);
                         break;
 
                 case SCU_COMPLETION_TYPE_NOTIFY:
                         /*
                          * Presently we do the same thing with a notify event that we do with the
                          * other event codes. */
-                        INCREMENT_EVENT_QUEUE_GET(this_controller, event_index, event_cycle);
-                        scic_sds_controller_event_completion(this_controller, completion_entry);
+                        INCREMENT_EVENT_QUEUE_GET(scic, event_index, event_cycle);
+                        scic_sds_controller_event_completion(scic, completion_entry);
                         break;
 
                 default:
-                        dev_warn(scic_to_dev(this_controller),
+                        dev_warn(scic_to_dev(scic),
                                  "%s: SCIC Controller received unknown "
                                  "completion type %x\n",
                                  __func__,
@@ -1342,21 +1340,23 @@ static void scic_sds_controller_process_completions(
 
         /* Update the get register if we completed one or more entries */
         if (completion_count > 0) {
-                this_controller->completion_queue_get =
-                        SMU_CQGR_GEN_BIT(ENABLE)
-                        | SMU_CQGR_GEN_BIT(EVENT_ENABLE)
-                        | event_cycle | SMU_CQGR_GEN_VAL(EVENT_POINTER, event_index)
-                        | get_cycle   | SMU_CQGR_GEN_VAL(POINTER, get_index);
+                scic->completion_queue_get =
+                        SMU_CQGR_GEN_BIT(ENABLE) |
+                        SMU_CQGR_GEN_BIT(EVENT_ENABLE) |
+                        event_cycle |
+                        SMU_CQGR_GEN_VAL(EVENT_POINTER, event_index) |
+                        get_cycle |
+                        SMU_CQGR_GEN_VAL(POINTER, get_index);
 
-                writel(this_controller->completion_queue_get,
-                        &this_controller->smu_registers->completion_queue_get);
+                writel(scic->completion_queue_get,
+                       &scic->smu_registers->completion_queue_get);
 
         }
 
-        dev_dbg(scic_to_dev(this_controller),
+        dev_dbg(scic_to_dev(scic),
                 "%s: completion queue ending get:0x%08x\n",
                 __func__,
-                this_controller->completion_queue_get);
+                scic->completion_queue_get);
 
 }
 
@@ -1540,29 +1540,29 @@ void scic_sds_controller_remote_device_stopped(struct scic_sds_controller *scic,
 /**
  * This method will write to the SCU PCP register the request value. The method
  *    is used to suspend/resume ports, devices, and phys.
- * @this_controller:
+ * @scic:
  *
  *
  */
 void scic_sds_controller_post_request(
-        struct scic_sds_controller *this_controller,
+        struct scic_sds_controller *scic,
         u32 request)
 {
-        dev_dbg(scic_to_dev(this_controller),
+        dev_dbg(scic_to_dev(scic),
                 "%s: SCIC Controller 0x%p post request 0x%08x\n",
                 __func__,
-                this_controller,
+                scic,
                 request);
 
-        writel(request, &this_controller->smu_registers->post_context_port);
+        writel(request, &scic->smu_registers->post_context_port);
 }
 
 /**
  * This method will copy the soft copy of the task context into the physical
  *    memory accessible by the controller.
- * @this_controller: This parameter specifies the controller for which to copy
+ * @scic: This parameter specifies the controller for which to copy
  *    the task context.
- * @this_request: This parameter specifies the request for which the task
+ * @sci_req: This parameter specifies the request for which the task
  *    context is being copied.
  *
  * After this call is made the SCIC_SDS_IO_REQUEST object will always point to
@@ -1571,43 +1571,40 @@ void scic_sds_controller_post_request(
  * memory). none
  */
 void scic_sds_controller_copy_task_context(
-        struct scic_sds_controller *this_controller,
-        struct scic_sds_request *this_request)
+        struct scic_sds_controller *scic,
+        struct scic_sds_request *sci_req)
 {
         struct scu_task_context *task_context_buffer;
 
         task_context_buffer = scic_sds_controller_get_task_context_buffer(
-                this_controller, this_request->io_tag
-                );
+                scic, sci_req->io_tag);
 
-        memcpy(
-                task_context_buffer,
-                this_request->task_context_buffer,
-                SCI_FIELD_OFFSET(struct scu_task_context, sgl_snapshot_ac)
-                );
+        memcpy(task_context_buffer,
+               sci_req->task_context_buffer,
+               SCI_FIELD_OFFSET(struct scu_task_context, sgl_snapshot_ac));
 
         /*
          * Now that the soft copy of the TC has been copied into the TC
          * table accessible by the silicon.  Thus, any further changes to
          * the TC (e.g. TC termination) occur in the appropriate location. */
-        this_request->task_context_buffer = task_context_buffer;
+        sci_req->task_context_buffer = task_context_buffer;
 }
 
 /**
  * This method returns the task context buffer for the given io tag.
- * @this_controller:
+ * @scic:
  * @io_tag:
  *
  * struct scu_task_context*
  */
 struct scu_task_context *scic_sds_controller_get_task_context_buffer(
-        struct scic_sds_controller *this_controller,
+        struct scic_sds_controller *scic,
         u16 io_tag
         ) {
         u16 task_index = scic_sds_io_tag_get_index(io_tag);
 
-        if (task_index < this_controller->task_context_entries) {
-                return &this_controller->task_context_table[task_index];
+        if (task_index < scic->task_context_entries) {
+                return &scic->task_context_table[task_index];
         }
 
         return NULL;
@@ -1615,7 +1612,7 @@ struct scu_task_context *scic_sds_controller_get_task_context_buffer(
 
 /**
  * This method returnst the sequence value from the io tag value
- * @this_controller:
+ * @scic:
  * @io_tag:
  *
  * u16
@@ -1623,13 +1620,13 @@ struct scu_task_context *scic_sds_controller_get_task_context_buffer(
 
 /**
  * This method returns the IO request associated with the tag value
- * @this_controller:
+ * @scic:
  * @io_tag:
  *
  * SCIC_SDS_IO_REQUEST_T* NULL if there is no valid IO request at the tag value
  */
 struct scic_sds_request *scic_sds_controller_get_io_request_from_tag(
-        struct scic_sds_controller *this_controller,
+        struct scic_sds_controller *scic,
         u16 io_tag
         ) {
         u16 task_index;
@@ -1637,12 +1634,12 @@ struct scic_sds_request *scic_sds_controller_get_io_request_from_tag(
 
         task_index = scic_sds_io_tag_get_index(io_tag);
 
-        if (task_index  < this_controller->task_context_entries) {
-                if (this_controller->io_request_table[task_index] != NULL) {
+        if (task_index  < scic->task_context_entries) {
+                if (scic->io_request_table[task_index] != NULL) {
                         task_sequence = scic_sds_io_tag_get_sequence(io_tag);
 
-                        if (task_sequence == this_controller->io_request_sequence[task_index]) {
-                                return this_controller->io_request_table[task_index];
+                        if (task_sequence == scic->io_request_sequence[task_index]) {
+                                return scic->io_request_table[task_index];
                         }
                 }
         }
@@ -1654,9 +1651,9 @@ struct scic_sds_request *scic_sds_controller_get_io_request_from_tag(
  * This method allocates remote node index and the reserves the remote node
  *    context space for use. This method can fail if there are no more remote
  *    node index available.
- * @this_controller: This is the controller object which contains the set of
+ * @scic: This is the controller object which contains the set of
  *    free remote node ids
- * @the_devce: This is the device object which is requesting the a remote node
+ * @sci_dev: This is the device object which is requesting the a remote node
  *    id
  * @node_id: This is the remote node id that is assinged to the device if one
  *    is available
@@ -1665,19 +1662,19 @@ struct scic_sds_request *scic_sds_controller_get_io_request_from_tag(
  * node index available.
  */
 enum sci_status scic_sds_controller_allocate_remote_node_context(
-        struct scic_sds_controller *this_controller,
-        struct scic_sds_remote_device *the_device,
+        struct scic_sds_controller *scic,
+        struct scic_sds_remote_device *sci_dev,
         u16 *node_id)
 {
         u16 node_index;
-        u32 remote_node_count = scic_sds_remote_device_node_count(the_device);
+        u32 remote_node_count = scic_sds_remote_device_node_count(sci_dev);
 
         node_index = scic_sds_remote_node_table_allocate_remote_node(
-                &this_controller->available_remote_nodes, remote_node_count
+                &scic->available_remote_nodes, remote_node_count
                 );
 
         if (node_index != SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX) {
-                this_controller->device_table[node_index] = the_device;
+                scic->device_table[node_index] = sci_dev;
 
                 *node_id = node_index;
 
@@ -1691,23 +1688,23 @@ enum sci_status scic_sds_controller_allocate_remote_node_context(
  * This method frees the remote node index back to the available pool.  Once
  *    this is done the remote node context buffer is no longer valid and can
  *    not be used.
- * @this_controller:
- * @the_device:
+ * @scic:
+ * @sci_dev:
  * @node_id:
  *
  */
 void scic_sds_controller_free_remote_node_context(
-        struct scic_sds_controller *this_controller,
-        struct scic_sds_remote_device *the_device,
+        struct scic_sds_controller *scic,
+        struct scic_sds_remote_device *sci_dev,
         u16 node_id)
 {
-        u32 remote_node_count = scic_sds_remote_device_node_count(the_device);
+        u32 remote_node_count = scic_sds_remote_device_node_count(sci_dev);
 
-        if (this_controller->device_table[node_id] == the_device) {
-                this_controller->device_table[node_id] = NULL;
+        if (scic->device_table[node_id] == sci_dev) {
+                scic->device_table[node_id] = NULL;
 
                 scic_sds_remote_node_table_release_remote_node_index(
-                        &this_controller->available_remote_nodes, remote_node_count, node_id
+                        &scic->available_remote_nodes, remote_node_count, node_id
                         );
         }
 }
@@ -1715,20 +1712,20 @@ void scic_sds_controller_free_remote_node_context(
 /**
  * This method returns the union scu_remote_node_context for the specified remote
  *    node id.
- * @this_controller:
+ * @scic:
  * @node_id:
  *
  * union scu_remote_node_context*
  */
 union scu_remote_node_context *scic_sds_controller_get_remote_node_context_buffer(
-        struct scic_sds_controller *this_controller,
+        struct scic_sds_controller *scic,
         u16 node_id
         ) {
         if (
-                (node_id < this_controller->remote_node_entries)
-                && (this_controller->device_table[node_id] != NULL)
+                (node_id < scic->remote_node_entries)
+                && (scic->device_table[node_id] != NULL)
                 ) {
-                return &this_controller->remote_node_context_table[node_id];
+                return &scic->remote_node_context_table[node_id];
         }
 
         return NULL;
@@ -1767,18 +1764,18 @@ void scic_sds_controller_copy_sata_response(
  *    re-use by the hardware.  The data contained in the frame header and frame
  *    buffer is no longer valid. The UF queue get pointer is only updated if UF
  *    control indicates this is appropriate.
- * @this_controller:
+ * @scic:
  * @frame_index:
  *
  */
 void scic_sds_controller_release_frame(
-        struct scic_sds_controller *this_controller,
+        struct scic_sds_controller *scic,
         u32 frame_index)
 {
         if (scic_sds_unsolicited_frame_control_release_frame(
-                    &this_controller->uf_control, frame_index) == true)
-                writel(this_controller->uf_control.get,
-                        &this_controller->scu_registers->sdma.unsolicited_frame_get_pointer);
+                    &scic->uf_control, frame_index) == true)
+                writel(scic->uf_control.get,
+                        &scic->scu_registers->sdma.unsolicited_frame_get_pointer);
 }
 
 /**
@@ -2888,11 +2885,11 @@ enum sci_status scic_controller_start(struct scic_sds_controller *scic,
 static void scic_sds_controller_initial_state_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_controller *this_controller;
+        struct scic_sds_controller *scic;
 
-        this_controller = (struct scic_sds_controller *)object;
+        scic = (struct scic_sds_controller *)object;
 
-        sci_base_state_machine_change_state(&this_controller->state_machine,
+        sci_base_state_machine_change_state(&scic->state_machine,
                         SCI_BASE_CONTROLLER_STATE_RESET);
 }
 
@@ -2925,13 +2922,13 @@ static inline void scic_sds_controller_starting_state_exit(
 static void scic_sds_controller_ready_state_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_controller *this_controller;
+        struct scic_sds_controller *scic;
 
-        this_controller = (struct scic_sds_controller *)object;
+        scic = (struct scic_sds_controller *)object;
 
         /* set the default interrupt coalescence number and timeout value. */
         scic_controller_set_interrupt_coalescence(
-                this_controller, 0x10, 250);
+                scic, 0x10, 250);
 }
 
 /**
@@ -2945,12 +2942,12 @@ static void scic_sds_controller_ready_state_enter(
 static void scic_sds_controller_ready_state_exit(
         struct sci_base_object *object)
 {
-        struct scic_sds_controller *this_controller;
+        struct scic_sds_controller *scic;
 
-        this_controller = (struct scic_sds_controller *)object;
+        scic = (struct scic_sds_controller *)object;
 
         /* disable interrupt coalescence. */
-        scic_controller_set_interrupt_coalescence(this_controller, 0, 0);
+        scic_controller_set_interrupt_coalescence(scic, 0, 0);
 }
 
 /**
@@ -2966,14 +2963,14 @@ static void scic_sds_controller_ready_state_exit(
 static void scic_sds_controller_stopping_state_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_controller *this_controller;
+        struct scic_sds_controller *scic;
 
-        this_controller = (struct scic_sds_controller *)object;
+        scic = (struct scic_sds_controller *)object;
 
         /* Stop all of the components for this controller */
-        scic_sds_controller_stop_phys(this_controller);
-        scic_sds_controller_stop_ports(this_controller);
-        scic_sds_controller_stop_devices(this_controller);
+        scic_sds_controller_stop_phys(scic);
+        scic_sds_controller_stop_ports(scic);
+        scic_sds_controller_stop_devices(scic);
 }
 
 /**
diff --git a/drivers/scsi/isci/core/scic_sds_controller.h b/drivers/scsi/isci/core/scic_sds_controller.h
index 9a646e5c7f45..4bb9a43fbe4d 100644
--- a/drivers/scsi/isci/core/scic_sds_controller.h
+++ b/drivers/scsi/isci/core/scic_sds_controller.h
@@ -542,12 +542,12 @@ void scic_sds_controller_copy_sata_response(
 
 enum sci_status scic_sds_controller_allocate_remote_node_context(
         struct scic_sds_controller *this_controller,
-        struct scic_sds_remote_device *the_device,
+        struct scic_sds_remote_device *sci_dev,
         u16 *node_id);
 
 void scic_sds_controller_free_remote_node_context(
         struct scic_sds_controller *this_controller,
-        struct scic_sds_remote_device *the_device,
+        struct scic_sds_remote_device *sci_dev,
         u16 node_id);
 
 union scu_remote_node_context *scic_sds_controller_get_remote_node_context_buffer(
@@ -565,25 +565,25 @@ struct scu_task_context *scic_sds_controller_get_task_context_buffer(
 
 void scic_sds_controller_power_control_queue_insert(
         struct scic_sds_controller *this_controller,
-        struct scic_sds_phy *the_phy);
+        struct scic_sds_phy *sci_phy);
 
 void scic_sds_controller_power_control_queue_remove(
         struct scic_sds_controller *this_controller,
-        struct scic_sds_phy *the_phy);
+        struct scic_sds_phy *sci_phy);
 
 void scic_sds_controller_link_up(
         struct scic_sds_controller *this_controller,
-        struct scic_sds_port *the_port,
-        struct scic_sds_phy *the_phy);
+        struct scic_sds_port *sci_port,
+        struct scic_sds_phy *sci_phy);
 
 void scic_sds_controller_link_down(
         struct scic_sds_controller *this_controller,
-        struct scic_sds_port *the_port,
-        struct scic_sds_phy *the_phy);
+        struct scic_sds_port *sci_port,
+        struct scic_sds_phy *sci_phy);
 
 void scic_sds_controller_remote_device_stopped(
         struct scic_sds_controller *this_controller,
-        struct scic_sds_remote_device *the_device);
+        struct scic_sds_remote_device *sci_dev);
 
 void scic_sds_controller_copy_task_context(
         struct scic_sds_controller *this_controller,
diff --git a/drivers/scsi/isci/core/scic_sds_phy.c b/drivers/scsi/isci/core/scic_sds_phy.c
index 40176f0729c1..34bd3b25ccf6 100644
--- a/drivers/scsi/isci/core/scic_sds_phy.c
+++ b/drivers/scsi/isci/core/scic_sds_phy.c
@@ -84,26 +84,29 @@ enum sas_linkrate sci_phy_linkrate(struct scic_sds_phy *sci_phy)
 
 /**
  * This method will initialize the phy transport layer registers
- * @this_phy:
+ * @sci_phy:
  * @transport_layer_registers
  *
  * enum sci_status
  */
 static enum sci_status scic_sds_phy_transport_layer_initialization(
-        struct scic_sds_phy *this_phy,
+        struct scic_sds_phy *sci_phy,
         struct scu_transport_layer_registers __iomem *transport_layer_registers)
 {
         u32 tl_control;
 
-        this_phy->transport_layer_registers = transport_layer_registers;
+        sci_phy->transport_layer_registers = transport_layer_registers;
 
         writel(SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX,
-                &this_phy->transport_layer_registers->stp_rni);
+                &sci_phy->transport_layer_registers->stp_rni);
 
-        /* Hardware team recommends that we enable the STP prefetch for all transports */
-        tl_control = readl(&this_phy->transport_layer_registers->control);
+        /*
+         * Hardware team recommends that we enable the STP prefetch for all
+         * transports
+         */
+        tl_control = readl(&sci_phy->transport_layer_registers->control);
         tl_control |= SCU_TLCR_GEN_BIT(STP_WRITE_DATA_PREFETCH);
-        writel(tl_control, &this_phy->transport_layer_registers->control);
+        writel(tl_control, &sci_phy->transport_layer_registers->control);
 
         return SCI_SUCCESS;
 }
@@ -284,7 +287,7 @@ static void scic_sds_phy_sata_timeout(void *phy)
  * This method returns the port currently containing this phy. If the phy is
  *    currently contained by the dummy port, then the phy is considered to not
  *    be part of a port.
- * @this_phy: This parameter specifies the phy for which to retrieve the
+ * @sci_phy: This parameter specifies the phy for which to retrieve the
  *    containing port.
  *
  * This method returns a handle to a port that contains the supplied phy.
@@ -293,30 +296,30 @@ static void scic_sds_phy_sata_timeout(void *phy)
  * values indicate a handle/pointer to the port containing the phy.
  */
 struct scic_sds_port *scic_sds_phy_get_port(
-        struct scic_sds_phy *this_phy)
+        struct scic_sds_phy *sci_phy)
 {
-        if (scic_sds_port_get_index(this_phy->owning_port) == SCIC_SDS_DUMMY_PORT)
+        if (scic_sds_port_get_index(sci_phy->owning_port) == SCIC_SDS_DUMMY_PORT)
                 return NULL;
 
-        return this_phy->owning_port;
+        return sci_phy->owning_port;
 }
 
 /**
  * This method will assign a port to the phy object.
- * @out]: this_phy This parameter specifies the phy for which to assign a port
+ * @out]: sci_phy This parameter specifies the phy for which to assign a port
  *    object.
  *
  *
  */
 void scic_sds_phy_set_port(
-        struct scic_sds_phy *this_phy,
-        struct scic_sds_port *the_port)
+        struct scic_sds_phy *sci_phy,
+        struct scic_sds_port *sci_port)
 {
-        this_phy->owning_port = the_port;
+        sci_phy->owning_port = sci_port;
 
-        if (this_phy->bcn_received_while_port_unassigned) {
-                this_phy->bcn_received_while_port_unassigned = false;
-                scic_sds_port_broadcast_change_received(this_phy->owning_port, this_phy);
+        if (sci_phy->bcn_received_while_port_unassigned) {
+                sci_phy->bcn_received_while_port_unassigned = false;
+                scic_sds_port_broadcast_change_received(sci_phy->owning_port, sci_phy);
         }
 }
 
@@ -362,123 +365,125 @@ enum sci_status scic_sds_phy_initialize(
 /**
  * This method assigns the direct attached device ID for this phy.
  *
- * @this_phy The phy for which the direct attached device id is to
+ * @sci_phy The phy for which the direct attached device id is to
  *       be assigned.
  * @device_id The direct attached device ID to assign to the phy.
  *       This will either be the RNi for the device or an invalid RNi if there
  *       is no current device assigned to the phy.
  */
 void scic_sds_phy_setup_transport(
-        struct scic_sds_phy *this_phy,
+        struct scic_sds_phy *sci_phy,
         u32 device_id)
 {
         u32 tl_control;
 
-        writel(device_id, &this_phy->transport_layer_registers->stp_rni);
+        writel(device_id, &sci_phy->transport_layer_registers->stp_rni);
 
         /*
          * The read should guarantee that the first write gets posted
          * before the next write
          */
-        tl_control = readl(&this_phy->transport_layer_registers->control);
+        tl_control = readl(&sci_phy->transport_layer_registers->control);
         tl_control |= SCU_TLCR_GEN_BIT(CLEAR_TCI_NCQ_MAPPING_TABLE);
-        writel(tl_control, &this_phy->transport_layer_registers->control);
+        writel(tl_control, &sci_phy->transport_layer_registers->control);
 }
 
 /**
  *
- * @this_phy: The phy object to be suspended.
+ * @sci_phy: The phy object to be suspended.
  *
  * This function will perform the register reads/writes to suspend the SCU
  * hardware protocol engine. none
  */
 static void scic_sds_phy_suspend(
-        struct scic_sds_phy *this_phy)
+        struct scic_sds_phy *sci_phy)
 {
         u32 scu_sas_pcfg_value;
 
         scu_sas_pcfg_value =
-                readl(&this_phy->link_layer_registers->phy_configuration);
+                readl(&sci_phy->link_layer_registers->phy_configuration);
         scu_sas_pcfg_value |= SCU_SAS_PCFG_GEN_BIT(SUSPEND_PROTOCOL_ENGINE);
         writel(scu_sas_pcfg_value,
-                &this_phy->link_layer_registers->phy_configuration);
+                &sci_phy->link_layer_registers->phy_configuration);
 
-        scic_sds_phy_setup_transport(this_phy, SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX);
+        scic_sds_phy_setup_transport(
+                        sci_phy,
+                        SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX);
 }
 
 /**
  *
- * @this_phy: The phy object to resume.
+ * @sci_phy: The phy object to resume.
  *
  * This function will perform the register reads/writes required to resume the
  * SCU hardware protocol engine. none
  */
 void scic_sds_phy_resume(
-        struct scic_sds_phy *this_phy)
+        struct scic_sds_phy *sci_phy)
 {
         u32 scu_sas_pcfg_value;
 
         scu_sas_pcfg_value =
-                readl(&this_phy->link_layer_registers->phy_configuration);
+                readl(&sci_phy->link_layer_registers->phy_configuration);
         scu_sas_pcfg_value &= ~SCU_SAS_PCFG_GEN_BIT(SUSPEND_PROTOCOL_ENGINE);
         writel(scu_sas_pcfg_value,
-                &this_phy->link_layer_registers->phy_configuration);
+                &sci_phy->link_layer_registers->phy_configuration);
 }
 
 /**
  * This method returns the local sas address assigned to this phy.
- * @this_phy: This parameter specifies the phy for which to retrieve the local
+ * @sci_phy: This parameter specifies the phy for which to retrieve the local
  *    SAS address.
  * @sas_address: This parameter specifies the location into which to copy the
  *    local SAS address.
  *
  */
 void scic_sds_phy_get_sas_address(
-        struct scic_sds_phy *this_phy,
+        struct scic_sds_phy *sci_phy,
         struct sci_sas_address *sas_address)
 {
-        sas_address->high = readl(&this_phy->link_layer_registers->source_sas_address_high);
-        sas_address->low = readl(&this_phy->link_layer_registers->source_sas_address_low);
+        sas_address->high = readl(&sci_phy->link_layer_registers->source_sas_address_high);
+        sas_address->low = readl(&sci_phy->link_layer_registers->source_sas_address_low);
 }
 
 /**
  * This method returns the remote end-point (i.e. attached) sas address
  *    assigned to this phy.
- * @this_phy: This parameter specifies the phy for which to retrieve the remote
+ * @sci_phy: This parameter specifies the phy for which to retrieve the remote
  *    end-point SAS address.
  * @sas_address: This parameter specifies the location into which to copy the
  *    remote end-point SAS address.
  *
  */
 void scic_sds_phy_get_attached_sas_address(
-        struct scic_sds_phy *this_phy,
+        struct scic_sds_phy *sci_phy,
         struct sci_sas_address *sas_address)
 {
         sas_address->high
-                = this_phy->phy_type.sas.identify_address_frame_buffer.sas_address.high;
+                = sci_phy->phy_type.sas.identify_address_frame_buffer.sas_address.high;
         sas_address->low
-                = this_phy->phy_type.sas.identify_address_frame_buffer.sas_address.low;
+                = sci_phy->phy_type.sas.identify_address_frame_buffer.sas_address.low;
 }
 
 /**
  * This method returns the supported protocols assigned to this phy
- * @this_phy:
+ * @sci_phy:
  *
  *
  */
 void scic_sds_phy_get_protocols(
-        struct scic_sds_phy *this_phy,
+        struct scic_sds_phy *sci_phy,
         struct sci_sas_identify_address_frame_protocols *protocols)
 {
         protocols->u.all =
-                (u16)(readl(&this_phy->
+                (u16)(readl(&sci_phy->
                         link_layer_registers->transmit_identification) &
                                 0x0000FFFF);
 }
 
 /**
  *
- * @this_phy: The parameter is the phy object for which the attached phy
+ * @sci_phy: The parameter is the phy object for which the attached phy
  *    protcols are to be returned.
  *
  * This method returns the supported protocols for the attached phy.  If this
@@ -488,15 +493,15 @@ void scic_sds_phy_get_protocols(
  * value.
  */
 void scic_sds_phy_get_attached_phy_protocols(
-        struct scic_sds_phy *this_phy,
+        struct scic_sds_phy *sci_phy,
         struct sci_sas_identify_address_frame_protocols *protocols)
 {
         protocols->u.all = 0;
 
-        if (this_phy->protocol == SCIC_SDS_PHY_PROTOCOL_SAS) {
+        if (sci_phy->protocol == SCIC_SDS_PHY_PROTOCOL_SAS) {
                 protocols->u.all =
-                        this_phy->phy_type.sas.identify_address_frame_buffer.protocols.u.all;
-        } else if (this_phy->protocol == SCIC_SDS_PHY_PROTOCOL_SATA) {
+                        sci_phy->phy_type.sas.identify_address_frame_buffer.protocols.u.all;
+        } else if (sci_phy->protocol == SCIC_SDS_PHY_PROTOCOL_SATA) {
                 protocols->u.bits.stp_target = 1;
         }
 }
@@ -533,54 +538,54 @@ enum sci_status scic_sds_phy_stop(struct scic_sds_phy *sci_phy)
 /**
  * This method will attempt to reset the phy.  This request is only valid when
  *    the phy is in an ready state
- * @this_phy:
+ * @sci_phy:
  *
  * enum sci_status
  */
 enum sci_status scic_sds_phy_reset(
-        struct scic_sds_phy *this_phy)
+        struct scic_sds_phy *sci_phy)
 {
-        return this_phy->state_handlers->reset_handler(this_phy);
+        return sci_phy->state_handlers->reset_handler(sci_phy);
 }
 
 /**
  * This method will process the event code received.
- * @this_phy:
+ * @sci_phy:
  * @event_code:
  *
  * enum sci_status
  */
 enum sci_status scic_sds_phy_event_handler(
-        struct scic_sds_phy *this_phy,
+        struct scic_sds_phy *sci_phy,
         u32 event_code)
 {
-        return this_phy->state_handlers->event_handler(this_phy, event_code);
+        return sci_phy->state_handlers->event_handler(sci_phy, event_code);
 }
 
 /**
  * This method will process the frame index received.
- * @this_phy:
+ * @sci_phy:
  * @frame_index:
  *
  * enum sci_status
  */
 enum sci_status scic_sds_phy_frame_handler(
-        struct scic_sds_phy *this_phy,
+        struct scic_sds_phy *sci_phy,
         u32 frame_index)
 {
-        return this_phy->state_handlers->frame_handler(this_phy, frame_index);
+        return sci_phy->state_handlers->frame_handler(sci_phy, frame_index);
 }
 
 /**
  * This method will give the phy permission to consume power
- * @this_phy:
+ * @sci_phy:
  *
  * enum sci_status
  */
 enum sci_status scic_sds_phy_consume_power_handler(
-        struct scic_sds_phy *this_phy)
+        struct scic_sds_phy *sci_phy)
 {
-        return this_phy->state_handlers->consume_power_handler(this_phy);
+        return sci_phy->state_handlers->consume_power_handler(sci_phy);
 }
 
 /*
@@ -638,7 +643,7 @@ enum sci_status scic_sata_phy_get_properties(
 
 /**
  *
- * @this_phy: The phy object that received SAS PHY DETECTED.
+ * @sci_phy: The phy object that received SAS PHY DETECTED.
  *
  * This method continues the link training for the phy as if it were a SAS PHY
  * instead of a SATA PHY. This is done because the completion queue had a SAS
@@ -646,41 +651,41 @@ enum sci_status scic_sata_phy_get_properties(
  * none
  */
 static void scic_sds_phy_start_sas_link_training(
-        struct scic_sds_phy *this_phy)
+        struct scic_sds_phy *sci_phy)
 {
         u32 phy_control;
 
         phy_control =
-                readl(&this_phy->link_layer_registers->phy_configuration);
+                readl(&sci_phy->link_layer_registers->phy_configuration);
         phy_control |= SCU_SAS_PCFG_GEN_BIT(SATA_SPINUP_HOLD);
         writel(phy_control,
-                &this_phy->link_layer_registers->phy_configuration);
+                &sci_phy->link_layer_registers->phy_configuration);
 
         sci_base_state_machine_change_state(
-                &this_phy->starting_substate_machine,
+                &sci_phy->starting_substate_machine,
                 SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SAS_SPEED_EN
                 );
 
-        this_phy->protocol = SCIC_SDS_PHY_PROTOCOL_SAS;
+        sci_phy->protocol = SCIC_SDS_PHY_PROTOCOL_SAS;
 }
 
 /**
  *
- * @this_phy: The phy object that received a SATA SPINUP HOLD event
+ * @sci_phy: The phy object that received a SATA SPINUP HOLD event
  *
  * This method continues the link training for the phy as if it were a SATA PHY
  * instead of a SAS PHY.  This is done because the completion queue had a SATA
  * SPINUP HOLD event when the state machine was expecting a SAS PHY event. none
  */
 static void scic_sds_phy_start_sata_link_training(
-        struct scic_sds_phy *this_phy)
+        struct scic_sds_phy *sci_phy)
 {
         sci_base_state_machine_change_state(
-                &this_phy->starting_substate_machine,
+                &sci_phy->starting_substate_machine,
                 SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SATA_POWER
                 );
 
-        this_phy->protocol = SCIC_SDS_PHY_PROTOCOL_SATA;
+        sci_phy->protocol = SCIC_SDS_PHY_PROTOCOL_SATA;
 }
 
 /**
@@ -748,24 +753,24 @@ static enum sci_status scic_sds_phy_starting_substate_general_stop_handler(
  * SCI_FAILURE on any unexpected event notifation
  */
 static enum sci_status scic_sds_phy_starting_substate_await_ossp_event_handler(
-        struct scic_sds_phy *this_phy,
+        struct scic_sds_phy *sci_phy,
         u32 event_code)
 {
         u32 result = SCI_SUCCESS;
 
         switch (scu_get_event_code(event_code)) {
         case SCU_EVENT_SAS_PHY_DETECTED:
-                scic_sds_phy_start_sas_link_training(this_phy);
-                this_phy->is_in_link_training = true;
+                scic_sds_phy_start_sas_link_training(sci_phy);
+                sci_phy->is_in_link_training = true;
                 break;
 
         case SCU_EVENT_SATA_SPINUP_HOLD:
-                scic_sds_phy_start_sata_link_training(this_phy);
-                this_phy->is_in_link_training = true;
+                scic_sds_phy_start_sata_link_training(sci_phy);
+                sci_phy->is_in_link_training = true;
                 break;
 
         default:
-                dev_dbg(sciphy_to_dev(this_phy),
+                dev_dbg(sciphy_to_dev(sci_phy),
                         "%s: PHY starting substate machine received "
                         "unexpected event_code %x\n",
                         __func__,
@@ -793,7 +798,7 @@ static enum sci_status scic_sds_phy_starting_substate_await_ossp_event_handler(
  * event notification SCI_FAILURE on any unexpected event notifation
  */
 static enum sci_status scic_sds_phy_starting_substate_await_sas_phy_speed_event_handler(
-        struct scic_sds_phy *this_phy,
+        struct scic_sds_phy *sci_phy,
         u32 event_code)
 {
         u32 result = SCI_SUCCESS;
@@ -808,38 +813,41 @@ static enum sci_status scic_sds_phy_starting_substate_await_sas_phy_speed_event_
         case SCU_EVENT_SAS_15:
         case SCU_EVENT_SAS_15_SSC:
                 scic_sds_phy_complete_link_training(
-                        this_phy, SAS_LINK_RATE_1_5_GBPS, SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_IAF_UF
-                        );
+                        sci_phy,
+                        SAS_LINK_RATE_1_5_GBPS,
+                        SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_IAF_UF);
                 break;
 
         case SCU_EVENT_SAS_30:
         case SCU_EVENT_SAS_30_SSC:
                 scic_sds_phy_complete_link_training(
-                        this_phy, SAS_LINK_RATE_3_0_GBPS, SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_IAF_UF
-                        );
+                        sci_phy,
+                        SAS_LINK_RATE_3_0_GBPS,
+                        SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_IAF_UF);
                 break;
 
         case SCU_EVENT_SAS_60:
         case SCU_EVENT_SAS_60_SSC:
                 scic_sds_phy_complete_link_training(
-                        this_phy, SAS_LINK_RATE_6_0_GBPS, SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_IAF_UF
-                        );
+                        sci_phy,
+                        SAS_LINK_RATE_6_0_GBPS,
+                        SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_IAF_UF);
                 break;
 
         case SCU_EVENT_SATA_SPINUP_HOLD:
                 /*
                  * We were doing SAS PHY link training and received a SATA PHY event
                  * continue OOB/SN as if this were a SATA PHY */
-                scic_sds_phy_start_sata_link_training(this_phy);
+                scic_sds_phy_start_sata_link_training(sci_phy);
                 break;
 
         case SCU_EVENT_LINK_FAILURE:
                 /* Link failure change state back to the starting state */
-                scic_sds_phy_restart_starting_state(this_phy);
+                scic_sds_phy_restart_starting_state(sci_phy);
                 break;
 
         default:
-                dev_warn(sciphy_to_dev(this_phy),
+                dev_warn(sciphy_to_dev(sci_phy),
                          "%s: PHY starting substate machine received "
                          "unexpected event_code %x\n",
                          __func__,
@@ -867,7 +875,7 @@ static enum sci_status scic_sds_phy_starting_substate_await_sas_phy_speed_event_
  * unexpected event notifation
  */
 static enum sci_status scic_sds_phy_starting_substate_await_iaf_uf_event_handler(
-        struct scic_sds_phy *this_phy,
+        struct scic_sds_phy *sci_phy,
         u32 event_code)
 {
         u32 result = SCI_SUCCESS;
@@ -875,25 +883,25 @@ static enum sci_status scic_sds_phy_starting_substate_await_iaf_uf_event_handler
         switch (scu_get_event_code(event_code)) {
         case SCU_EVENT_SAS_PHY_DETECTED:
                 /* Backup the state machine */
-                scic_sds_phy_start_sas_link_training(this_phy);
+                scic_sds_phy_start_sas_link_training(sci_phy);
                 break;
 
         case SCU_EVENT_SATA_SPINUP_HOLD:
                 /*
                  * We were doing SAS PHY link training and received a SATA PHY event
                  * continue OOB/SN as if this were a SATA PHY */
-                scic_sds_phy_start_sata_link_training(this_phy);
+                scic_sds_phy_start_sata_link_training(sci_phy);
                 break;
 
         case SCU_EVENT_RECEIVED_IDENTIFY_TIMEOUT:
         case SCU_EVENT_LINK_FAILURE:
         case SCU_EVENT_HARD_RESET_RECEIVED:
                 /* Start the oob/sn state machine over again */
-                scic_sds_phy_restart_starting_state(this_phy);
+                scic_sds_phy_restart_starting_state(sci_phy);
                 break;
 
         default:
-                dev_warn(sciphy_to_dev(this_phy),
+                dev_warn(sciphy_to_dev(sci_phy),
                          "%s: PHY starting substate machine received "
                          "unexpected event_code %x\n",
                          __func__,
@@ -919,7 +927,7 @@ static enum sci_status scic_sds_phy_starting_substate_await_iaf_uf_event_handler
  * notifation
  */
 static enum sci_status scic_sds_phy_starting_substate_await_sas_power_event_handler(
-        struct scic_sds_phy *this_phy,
+        struct scic_sds_phy *sci_phy,
         u32 event_code)
 {
         u32 result = SCI_SUCCESS;
@@ -927,11 +935,11 @@ static enum sci_status scic_sds_phy_starting_substate_await_sas_power_event_hand
         switch (scu_get_event_code(event_code)) {
         case SCU_EVENT_LINK_FAILURE:
                 /* Link failure change state back to the starting state */
-                scic_sds_phy_restart_starting_state(this_phy);
+                scic_sds_phy_restart_starting_state(sci_phy);
                 break;
 
         default:
-                dev_warn(sciphy_to_dev(this_phy),
+                dev_warn(sciphy_to_dev(sci_phy),
                         "%s: PHY starting substate machine received unexpected "
                         "event_code %x\n",
                         __func__,
@@ -957,7 +965,7 @@ static enum sci_status scic_sds_phy_starting_substate_await_sas_power_event_hand
  * on a link failure event SCI_FAILURE on any unexpected event notifation
  */
 static enum sci_status scic_sds_phy_starting_substate_await_sata_power_event_handler(
-        struct scic_sds_phy *this_phy,
+        struct scic_sds_phy *sci_phy,
         u32 event_code)
 {
         u32 result = SCI_SUCCESS;
@@ -965,7 +973,7 @@ static enum sci_status scic_sds_phy_starting_substate_await_sata_power_event_han
         switch (scu_get_event_code(event_code)) {
         case SCU_EVENT_LINK_FAILURE:
                 /* Link failure change state back to the starting state */
-                scic_sds_phy_restart_starting_state(this_phy);
+                scic_sds_phy_restart_starting_state(sci_phy);
                 break;
 
         case SCU_EVENT_SATA_SPINUP_HOLD:
@@ -976,11 +984,11 @@ static enum sci_status scic_sds_phy_starting_substate_await_sata_power_event_han
                 /*
                  * There has been a change in the phy type before OOB/SN for the
                  * SATA finished start down the SAS link traning path. */
-                scic_sds_phy_start_sas_link_training(this_phy);
+                scic_sds_phy_start_sas_link_training(sci_phy);
                 break;
 
         default:
-                dev_warn(sciphy_to_dev(this_phy),
+                dev_warn(sciphy_to_dev(sci_phy),
                          "%s: PHY starting substate machine received "
                          "unexpected event_code %x\n",
                          __func__,
@@ -1066,7 +1074,7 @@ static enum sci_status scic_sds_phy_starting_substate_await_sata_phy_event_handl
  * valid event notification SCI_FAILURE on any unexpected event notifation
  */
 static enum sci_status scic_sds_phy_starting_substate_await_sata_speed_event_handler(
-        struct scic_sds_phy *this_phy,
+        struct scic_sds_phy *sci_phy,
         u32 event_code)
 {
         u32 result = SCI_SUCCESS;
@@ -1081,44 +1089,41 @@ static enum sci_status scic_sds_phy_starting_substate_await_sata_speed_event_han
         case SCU_EVENT_SATA_15:
         case SCU_EVENT_SATA_15_SSC:
                 scic_sds_phy_complete_link_training(
-                        this_phy,
+                        sci_phy,
                         SAS_LINK_RATE_1_5_GBPS,
-                        SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SIG_FIS_UF
-                        );
+                        SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SIG_FIS_UF);
                 break;
 
         case SCU_EVENT_SATA_30:
         case SCU_EVENT_SATA_30_SSC:
                 scic_sds_phy_complete_link_training(
-                        this_phy,
+                        sci_phy,
                         SAS_LINK_RATE_3_0_GBPS,
-                        SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SIG_FIS_UF
-                        );
+                        SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SIG_FIS_UF);
                 break;
 
         case SCU_EVENT_SATA_60:
         case SCU_EVENT_SATA_60_SSC:
                 scic_sds_phy_complete_link_training(
-                        this_phy,
+                        sci_phy,
                         SAS_LINK_RATE_6_0_GBPS,
-                        SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SIG_FIS_UF
-                        );
+                        SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SIG_FIS_UF);
                 break;
 
         case SCU_EVENT_LINK_FAILURE:
                 /* Link failure change state back to the starting state */
-                scic_sds_phy_restart_starting_state(this_phy);
+                scic_sds_phy_restart_starting_state(sci_phy);
                 break;
 
         case SCU_EVENT_SAS_PHY_DETECTED:
                 /*
                  * There has been a change in the phy type before OOB/SN for the
                  * SATA finished start down the SAS link traning path. */
-                scic_sds_phy_start_sas_link_training(this_phy);
+                scic_sds_phy_start_sas_link_training(sci_phy);
                 break;
 
         default:
-                dev_warn(sciphy_to_dev(this_phy),
+                dev_warn(sciphy_to_dev(sci_phy),
                          "%s: PHY starting substate machine received "
                          "unexpected event_code %x\n",
                          __func__,
@@ -1583,12 +1588,12 @@ static void scic_sds_phy_starting_initial_substate_enter(struct sci_base_object
 static void scic_sds_phy_starting_await_ossp_en_substate_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_phy *this_phy;
+        struct scic_sds_phy *sci_phy;
 
-        this_phy = (struct scic_sds_phy *)object;
+        sci_phy = (struct scic_sds_phy *)object;
 
         scic_sds_phy_set_starting_substate_handlers(
-                this_phy, SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_OSSP_EN
+                sci_phy, SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_OSSP_EN
                 );
 }
 
@@ -1603,12 +1608,12 @@ static void scic_sds_phy_starting_await_ossp_en_substate_enter(
 static void scic_sds_phy_starting_await_sas_speed_en_substate_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_phy *this_phy;
+        struct scic_sds_phy *sci_phy;
 
-        this_phy = (struct scic_sds_phy *)object;
+        sci_phy = (struct scic_sds_phy *)object;
 
         scic_sds_phy_set_starting_substate_handlers(
-                this_phy, SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SAS_SPEED_EN
+                sci_phy, SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SAS_SPEED_EN
                 );
 }
 
@@ -1623,12 +1628,12 @@ static void scic_sds_phy_starting_await_sas_speed_en_substate_enter(
 static void scic_sds_phy_starting_await_iaf_uf_substate_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_phy *this_phy;
+        struct scic_sds_phy *sci_phy;
 
-        this_phy = (struct scic_sds_phy *)object;
+        sci_phy = (struct scic_sds_phy *)object;
 
         scic_sds_phy_set_starting_substate_handlers(
-                this_phy, SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_IAF_UF
+                sci_phy, SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_IAF_UF
                 );
 }
 
@@ -1644,17 +1649,17 @@ static void scic_sds_phy_starting_await_iaf_uf_substate_enter(
 static void scic_sds_phy_starting_await_sas_power_substate_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_phy *this_phy;
+        struct scic_sds_phy *sci_phy;
 
-        this_phy = (struct scic_sds_phy *)object;
+        sci_phy = (struct scic_sds_phy *)object;
 
         scic_sds_phy_set_starting_substate_handlers(
-                this_phy, SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SAS_POWER
+                sci_phy, SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SAS_POWER
                 );
 
         scic_sds_controller_power_control_queue_insert(
-                scic_sds_phy_get_controller(this_phy),
-                this_phy
+                scic_sds_phy_get_controller(sci_phy),
+                sci_phy
                 );
 }
 
@@ -1669,12 +1674,12 @@ static void scic_sds_phy_starting_await_sas_power_substate_enter(
 static void scic_sds_phy_starting_await_sas_power_substate_exit(
         struct sci_base_object *object)
 {
-        struct scic_sds_phy *this_phy;
+        struct scic_sds_phy *sci_phy;
 
-        this_phy = (struct scic_sds_phy *)object;
+        sci_phy = (struct scic_sds_phy *)object;
 
         scic_sds_controller_power_control_queue_remove(
-                scic_sds_phy_get_controller(this_phy), this_phy
+                scic_sds_phy_get_controller(sci_phy), sci_phy
                 );
 }
 
@@ -1690,17 +1695,17 @@ static void scic_sds_phy_starting_await_sas_power_substate_exit(
 static void scic_sds_phy_starting_await_sata_power_substate_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_phy *this_phy;
+        struct scic_sds_phy *sci_phy;
 
-        this_phy = (struct scic_sds_phy *)object;
+        sci_phy = (struct scic_sds_phy *)object;
 
         scic_sds_phy_set_starting_substate_handlers(
-                this_phy, SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SATA_POWER
+                sci_phy, SCIC_SDS_PHY_STARTING_SUBSTATE_AWAIT_SATA_POWER
                 );
 
         scic_sds_controller_power_control_queue_insert(
-                scic_sds_phy_get_controller(this_phy),
-                this_phy
+                scic_sds_phy_get_controller(sci_phy),
+                sci_phy
                 );
 }
 
@@ -1715,13 +1720,13 @@ static void scic_sds_phy_starting_await_sata_power_substate_enter(
 static void scic_sds_phy_starting_await_sata_power_substate_exit(
         struct sci_base_object *object)
 {
-        struct scic_sds_phy *this_phy;
+        struct scic_sds_phy *sci_phy;
 
-        this_phy = (struct scic_sds_phy *)object;
+        sci_phy = (struct scic_sds_phy *)object;
 
         scic_sds_controller_power_control_queue_remove(
-                scic_sds_phy_get_controller(this_phy),
-                this_phy
+                scic_sds_phy_get_controller(sci_phy),
+                sci_phy
                 );
 }
 
@@ -2115,33 +2120,32 @@ static const struct scic_sds_phy_state_handler scic_sds_phy_state_handler_table[
 
 /**
  *
- * @this_phy: This is the struct scic_sds_phy object to stop.
+ * @sci_phy: This is the struct scic_sds_phy object to stop.
  *
  * This method will stop the struct scic_sds_phy object. This does not reset the
  * protocol engine it just suspends it and places it in a state where it will
  * not cause the end device to power up. none
  */
 static void scu_link_layer_stop_protocol_engine(
-        struct scic_sds_phy *this_phy)
+        struct scic_sds_phy *sci_phy)
 {
         u32 scu_sas_pcfg_value;
         u32 enable_spinup_value;
 
         /* Suspend the protocol engine and place it in a sata spinup hold state */
         scu_sas_pcfg_value =
-                readl(&this_phy->link_layer_registers->phy_configuration);
-        scu_sas_pcfg_value |= (
-                SCU_SAS_PCFG_GEN_BIT(OOB_RESET)
-                | SCU_SAS_PCFG_GEN_BIT(SUSPEND_PROTOCOL_ENGINE)
-                | SCU_SAS_PCFG_GEN_BIT(SATA_SPINUP_HOLD)
-                );
+                readl(&sci_phy->link_layer_registers->phy_configuration);
+        scu_sas_pcfg_value |=
+                (SCU_SAS_PCFG_GEN_BIT(OOB_RESET) |
+                 SCU_SAS_PCFG_GEN_BIT(SUSPEND_PROTOCOL_ENGINE) |
+                 SCU_SAS_PCFG_GEN_BIT(SATA_SPINUP_HOLD));
         writel(scu_sas_pcfg_value,
-                &this_phy->link_layer_registers->phy_configuration);
+               &sci_phy->link_layer_registers->phy_configuration);
 
         /* Disable the notify enable spinup primitives */
-        enable_spinup_value = readl(&this_phy->link_layer_registers->notify_enable_spinup_control);
+        enable_spinup_value = readl(&sci_phy->link_layer_registers->notify_enable_spinup_control);
         enable_spinup_value &= ~SCU_ENSPINUP_GEN_BIT(ENABLE);
-        writel(enable_spinup_value, &this_phy->link_layer_registers->notify_enable_spinup_control);
+        writel(enable_spinup_value, &sci_phy->link_layer_registers->notify_enable_spinup_control);
 }
 
 /**
@@ -2150,17 +2154,18 @@ static void scu_link_layer_stop_protocol_engine(
  * This method will start the OOB/SN state machine for this struct scic_sds_phy object.
  */
 static void scu_link_layer_start_oob(
-        struct scic_sds_phy *this_phy)
+        struct scic_sds_phy *sci_phy)
 {
         u32 scu_sas_pcfg_value;
 
         scu_sas_pcfg_value =
-                readl(&this_phy->link_layer_registers->phy_configuration);
+                readl(&sci_phy->link_layer_registers->phy_configuration);
         scu_sas_pcfg_value |= SCU_SAS_PCFG_GEN_BIT(OOB_ENABLE);
         scu_sas_pcfg_value &=
-                ~(SCU_SAS_PCFG_GEN_BIT(OOB_RESET) | SCU_SAS_PCFG_GEN_BIT(HARD_RESET));
+                ~(SCU_SAS_PCFG_GEN_BIT(OOB_RESET) |
+                SCU_SAS_PCFG_GEN_BIT(HARD_RESET));
         writel(scu_sas_pcfg_value,
-                &this_phy->link_layer_registers->phy_configuration);
+               &sci_phy->link_layer_registers->phy_configuration);
 }
 
 /**
@@ -2172,7 +2177,7 @@ static void scu_link_layer_start_oob(
  * hard reset bit set.
  */
 static void scu_link_layer_tx_hard_reset(
-        struct scic_sds_phy *this_phy)
+        struct scic_sds_phy *sci_phy)
 {
         u32 phy_configuration_value;
 
@@ -2180,17 +2185,18 @@ static void scu_link_layer_tx_hard_reset(
          * SAS Phys must wait for the HARD_RESET_TX event notification to transition
          * to the starting state. */
         phy_configuration_value =
-                readl(&this_phy->link_layer_registers->phy_configuration);
+                readl(&sci_phy->link_layer_registers->phy_configuration);
         phy_configuration_value |=
-                (SCU_SAS_PCFG_GEN_BIT(HARD_RESET) | SCU_SAS_PCFG_GEN_BIT(OOB_RESET));
+                (SCU_SAS_PCFG_GEN_BIT(HARD_RESET) |
+                 SCU_SAS_PCFG_GEN_BIT(OOB_RESET));
         writel(phy_configuration_value,
-                &this_phy->link_layer_registers->phy_configuration);
+               &sci_phy->link_layer_registers->phy_configuration);
 
         /* Now take the OOB state machine out of reset */
         phy_configuration_value |= SCU_SAS_PCFG_GEN_BIT(OOB_ENABLE);
         phy_configuration_value &= ~SCU_SAS_PCFG_GEN_BIT(OOB_RESET);
         writel(phy_configuration_value,
-                &this_phy->link_layer_registers->phy_configuration);
+               &sci_phy->link_layer_registers->phy_configuration);
 }
 
 /*
@@ -2209,11 +2215,11 @@ static void scu_link_layer_tx_hard_reset(
 static void scic_sds_phy_initial_state_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_phy *this_phy;
+        struct scic_sds_phy *sci_phy;
 
-        this_phy = (struct scic_sds_phy *)object;
+        sci_phy = (struct scic_sds_phy *)object;
 
-        scic_sds_phy_set_base_state_handlers(this_phy, SCI_BASE_PHY_STATE_INITIAL);
+        scic_sds_phy_set_base_state_handlers(sci_phy, SCI_BASE_PHY_STATE_INITIAL);
 }
 
 /**
@@ -2273,28 +2279,28 @@ static void scic_sds_phy_stopped_state_enter(struct sci_base_object *object)
 static void scic_sds_phy_starting_state_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_phy *this_phy;
+        struct scic_sds_phy *sci_phy;
 
-        this_phy = (struct scic_sds_phy *)object;
+        sci_phy = (struct scic_sds_phy *)object;
 
-        scic_sds_phy_set_base_state_handlers(this_phy, SCI_BASE_PHY_STATE_STARTING);
+        scic_sds_phy_set_base_state_handlers(sci_phy, SCI_BASE_PHY_STATE_STARTING);
 
-        scu_link_layer_stop_protocol_engine(this_phy);
-        scu_link_layer_start_oob(this_phy);
+        scu_link_layer_stop_protocol_engine(sci_phy);
+        scu_link_layer_start_oob(sci_phy);
 
         /* We don't know what kind of phy we are going to be just yet */
-        this_phy->protocol = SCIC_SDS_PHY_PROTOCOL_UNKNOWN;
-        this_phy->bcn_received_while_port_unassigned = false;
+        sci_phy->protocol = SCIC_SDS_PHY_PROTOCOL_UNKNOWN;
+        sci_phy->bcn_received_while_port_unassigned = false;
 
         /* Change over to the starting substate machine to continue */
-        sci_base_state_machine_start(&this_phy->starting_substate_machine);
+        sci_base_state_machine_start(&sci_phy->starting_substate_machine);
 
-        if (this_phy->state_machine.previous_state_id
+        if (sci_phy->state_machine.previous_state_id
             == SCI_BASE_PHY_STATE_READY) {
                 scic_sds_controller_link_down(
-                        scic_sds_phy_get_controller(this_phy),
-                        scic_sds_phy_get_port(this_phy),
-                        this_phy
+                        scic_sds_phy_get_controller(sci_phy),
+                        scic_sds_phy_get_port(sci_phy),
+                        sci_phy
                         );
         }
 }
@@ -2312,16 +2318,16 @@ static void scic_sds_phy_starting_state_enter(
 static void scic_sds_phy_ready_state_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_phy *this_phy;
+        struct scic_sds_phy *sci_phy;
 
-        this_phy = (struct scic_sds_phy *)object;
+        sci_phy = (struct scic_sds_phy *)object;
 
-        scic_sds_phy_set_base_state_handlers(this_phy, SCI_BASE_PHY_STATE_READY);
+        scic_sds_phy_set_base_state_handlers(sci_phy, SCI_BASE_PHY_STATE_READY);
 
         scic_sds_controller_link_up(
-                scic_sds_phy_get_controller(this_phy),
-                scic_sds_phy_get_port(this_phy),
-                this_phy
+                scic_sds_phy_get_controller(sci_phy),
+                scic_sds_phy_get_port(sci_phy),
+                sci_phy
                 );
 }
 
@@ -2336,11 +2342,11 @@ static void scic_sds_phy_ready_state_enter(
 static void scic_sds_phy_ready_state_exit(
         struct sci_base_object *object)
 {
-        struct scic_sds_phy *this_phy;
+        struct scic_sds_phy *sci_phy;
 
-        this_phy = (struct scic_sds_phy *)object;
+        sci_phy = (struct scic_sds_phy *)object;
 
-        scic_sds_phy_suspend(this_phy);
+        scic_sds_phy_suspend(sci_phy);
 }
 
 /**
@@ -2354,26 +2360,28 @@ static void scic_sds_phy_ready_state_exit(
 static void scic_sds_phy_resetting_state_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_phy *this_phy;
+        struct scic_sds_phy *sci_phy;
 
-        this_phy = (struct scic_sds_phy *)object;
+        sci_phy = (struct scic_sds_phy *)object;
 
-        scic_sds_phy_set_base_state_handlers(this_phy, SCI_BASE_PHY_STATE_RESETTING);
+        scic_sds_phy_set_base_state_handlers(sci_phy, SCI_BASE_PHY_STATE_RESETTING);
 
         /*
          * 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 link down notifications. */
-        scic_sds_port_deactivate_phy(this_phy->owning_port, this_phy, false);
+        scic_sds_port_deactivate_phy(sci_phy->owning_port, sci_phy, false);
 
-        if (this_phy->protocol == SCIC_SDS_PHY_PROTOCOL_SAS) {
-                scu_link_layer_tx_hard_reset(this_phy);
+        if (sci_phy->protocol == SCIC_SDS_PHY_PROTOCOL_SAS) {
+                scu_link_layer_tx_hard_reset(sci_phy);
         } else {
                 /*
-                 * 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(&this_phy->state_machine,
-                                                    SCI_BASE_PHY_STATE_STARTING);
+                 * 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);
         }
 }
 
@@ -2388,11 +2396,11 @@ static void scic_sds_phy_resetting_state_enter(
 static void scic_sds_phy_final_state_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_phy *this_phy;
+        struct scic_sds_phy *sci_phy;
 
-        this_phy = (struct scic_sds_phy *)object;
+        sci_phy = (struct scic_sds_phy *)object;
 
-        scic_sds_phy_set_base_state_handlers(this_phy, SCI_BASE_PHY_STATE_FINAL);
+        scic_sds_phy_set_base_state_handlers(sci_phy, SCI_BASE_PHY_STATE_FINAL);
 
         /* Nothing to do here */
 }
diff --git a/drivers/scsi/isci/core/scic_sds_port.c b/drivers/scsi/isci/core/scic_sds_port.c
index 40c1297849f3..a8d7e51bdf7b 100644
--- a/drivers/scsi/isci/core/scic_sds_port.c
+++ b/drivers/scsi/isci/core/scic_sds_port.c
@@ -75,7 +75,7 @@
 
 /**
  *
- * @this_port: This is the port object to which the phy is being assigned.
+ * @sci_port: This is the port object to which the phy is being assigned.
  * @phy_index: This is the phy index that is being assigned to the port.
  *
  * This method will return a true value if the specified phy can be assigned to
@@ -90,30 +90,30 @@
  * port
  */
 bool scic_sds_port_is_valid_phy_assignment(
-        struct scic_sds_port *this_port,
+        struct scic_sds_port *sci_port,
         u32 phy_index)
 {
         /* Initialize to invalid value. */
         u32 existing_phy_index = SCI_MAX_PHYS;
         u32 index;
 
-        if ((this_port->physical_port_index == 1) && (phy_index != 1)) {
+        if ((sci_port->physical_port_index == 1) && (phy_index != 1)) {
                 return false;
         }
 
-        if (this_port->physical_port_index == 3 && phy_index != 3) {
+        if (sci_port->physical_port_index == 3 && phy_index != 3) {
                 return false;
         }
 
         if (
-                (this_port->physical_port_index == 2)
+                (sci_port->physical_port_index == 2)
                 && ((phy_index == 0) || (phy_index == 1))
                 ) {
                 return false;
         }
 
         for (index = 0; index < SCI_MAX_PHYS; index++) {
-                if ((this_port->phy_table[index] != NULL)
+                if ((sci_port->phy_table[index] != NULL)
                     && (index != phy_index)) {
                         existing_phy_index = index;
                 }
@@ -124,9 +124,9 @@ bool scic_sds_port_is_valid_phy_assignment(
          * operating at the same maximum link rate. */
         if (
                 (existing_phy_index < SCI_MAX_PHYS)
-                && (this_port->owning_controller->user_parameters.sds1.phys[
+                && (sci_port->owning_controller->user_parameters.sds1.phys[
                             phy_index].max_speed_generation !=
-                    this_port->owning_controller->user_parameters.sds1.phys[
+                    sci_port->owning_controller->user_parameters.sds1.phys[
                             existing_phy_index].max_speed_generation)
                 )
                 return false;
@@ -137,13 +137,13 @@ bool scic_sds_port_is_valid_phy_assignment(
 /**
  * This method requests a list (mask) of the phys contained in the supplied SAS
  *    port.
- * @this_port: a handle corresponding to the SAS port for which to return the
+ * @sci_port: a handle corresponding to the SAS port for which to return the
  *    phy mask.
  *
  * Return a bit mask indicating which phys are a part of this port. Each bit
  * corresponds to a phy identifier (e.g. bit 0 = phy id 0).
  */
-static u32 scic_sds_port_get_phys(struct scic_sds_port *this_port)
+static u32 scic_sds_port_get_phys(struct scic_sds_port *sci_port)
 {
         u32 index;
         u32 mask;
@@ -151,7 +151,7 @@ static u32 scic_sds_port_get_phys(struct scic_sds_port *this_port)
         mask = 0;
 
         for (index = 0; index < SCI_MAX_PHYS; index++) {
-                if (this_port->phy_table[index] != NULL) {
+                if (sci_port->phy_table[index] != NULL) {
                         mask |= (1 << index);
                 }
         }
@@ -161,7 +161,7 @@ static u32 scic_sds_port_get_phys(struct scic_sds_port *this_port)
 
 /**
  *
- * @this_port: This is the port object for which to determine if the phy mask
+ * @sci_port: This is the port object for which to determine if the phy mask
  *    can be supported.
  *
  * This method will return a true value if the port's phy mask can be supported
@@ -172,25 +172,25 @@ static u32 scic_sds_port_get_phys(struct scic_sds_port *this_port)
  * port false if this is not a valid phy assignment for the port
  */
 static bool scic_sds_port_is_phy_mask_valid(
-        struct scic_sds_port *this_port,
+        struct scic_sds_port *sci_port,
         u32 phy_mask)
 {
-        if (this_port->physical_port_index == 0) {
+        if (sci_port->physical_port_index == 0) {
                 if (((phy_mask & 0x0F) == 0x0F)
                     || ((phy_mask & 0x03) == 0x03)
                     || ((phy_mask & 0x01) == 0x01)
                     || (phy_mask == 0))
                         return true;
-        } else if (this_port->physical_port_index == 1) {
+        } else if (sci_port->physical_port_index == 1) {
                 if (((phy_mask & 0x02) == 0x02)
                     || (phy_mask == 0))
                         return true;
-        } else if (this_port->physical_port_index == 2) {
+        } else if (sci_port->physical_port_index == 2) {
                 if (((phy_mask & 0x0C) == 0x0C)
                     || ((phy_mask & 0x04) == 0x04)
                     || (phy_mask == 0))
                         return true;
-        } else if (this_port->physical_port_index == 3) {
+        } else if (sci_port->physical_port_index == 3) {
                 if (((phy_mask & 0x08) == 0x08)
                     || (phy_mask == 0))
                         return true;
@@ -201,7 +201,7 @@ static bool scic_sds_port_is_phy_mask_valid(
 
 /**
  *
- * @this_port: This parameter specifies the port from which to return a
+ * @sci_port: This parameter specifies the port from which to return a
  *    connected phy.
  *
  * This method retrieves a currently active (i.e. connected) phy contained in
@@ -212,7 +212,7 @@ static bool scic_sds_port_is_phy_mask_valid(
  * object that is active in the port.
  */
 static struct scic_sds_phy *scic_sds_port_get_a_connected_phy(
-        struct scic_sds_port *this_port
+        struct scic_sds_port *sci_port
         ) {
         u32 index;
         struct scic_sds_phy *phy;
@@ -221,10 +221,10 @@ static struct scic_sds_phy *scic_sds_port_get_a_connected_phy(
                 /*
                  * Ensure that the phy is both part of the port and currently
                  * connected to the remote end-point. */
-                phy = this_port->phy_table[index];
+                phy = sci_port->phy_table[index];
                 if (
                         (phy != NULL)
-                        && scic_sds_port_active_phy(this_port, phy)
+                        && scic_sds_port_active_phy(sci_port, phy)
                         ) {
                         return phy;
                 }
@@ -304,50 +304,50 @@ static enum sci_status scic_sds_port_clear_phy(
 
 /**
  * scic_sds_port_add_phy() -
- * @this_port: This parameter specifies the port in which the phy will be added.
- * @the_phy: This parameter is the phy which is to be added to the port.
+ * @sci_port: This parameter specifies the port in which the phy will be added.
+ * @sci_phy: This parameter is the phy which is to be added to the port.
  *
  * This method will add a PHY to the selected port. This method returns an
  * enum sci_status. SCI_SUCCESS the phy has been added to the port. Any other status
  * is failre to add the phy to the port.
  */
 enum sci_status scic_sds_port_add_phy(
-        struct scic_sds_port *this_port,
-        struct scic_sds_phy *the_phy)
+        struct scic_sds_port *sci_port,
+        struct scic_sds_phy *sci_phy)
 {
-        return this_port->state_handlers->add_phy_handler(
-                       this_port, the_phy);
+        return sci_port->state_handlers->add_phy_handler(
+                       sci_port, sci_phy);
 }
 
 
 /**
  * scic_sds_port_remove_phy() -
- * @this_port: This parameter specifies the port in which the phy will be added.
- * @the_phy: This parameter is the phy which is to be added to the port.
+ * @sci_port: This parameter specifies the port in which the phy will be added.
+ * @sci_phy: This parameter is the phy which is to be added to the port.
  *
  * This method will remove the PHY from the selected PORT. This method returns
  * an enum sci_status. SCI_SUCCESS the phy has been removed from the port. Any other
  * status is failre to add the phy to the port.
  */
 enum sci_status scic_sds_port_remove_phy(
-        struct scic_sds_port *this_port,
-        struct scic_sds_phy *the_phy)
+        struct scic_sds_port *sci_port,
+        struct scic_sds_phy *sci_phy)
 {
-        return this_port->state_handlers->remove_phy_handler(
-                       this_port, the_phy);
+        return sci_port->state_handlers->remove_phy_handler(
+                       sci_port, sci_phy);
 }
 
 /**
  * This method requests the SAS address for the supplied SAS port from the SCI
  *    implementation.
- * @this_port: a handle corresponding to the SAS port for which to return the
+ * @sci_port: a handle corresponding to the SAS port for which to return the
  *    SAS address.
  * @sas_address: This parameter specifies a pointer to a SAS address structure
  *    into which the core will copy the SAS address for the port.
  *
  */
 void scic_sds_port_get_sas_address(
-        struct scic_sds_port *this_port,
+        struct scic_sds_port *sci_port,
         struct sci_sas_address *sas_address)
 {
         u32 index;
@@ -356,15 +356,15 @@ void scic_sds_port_get_sas_address(
         sas_address->low  = 0;
 
         for (index = 0; index < SCI_MAX_PHYS; index++) {
-                if (this_port->phy_table[index] != NULL) {
-                        scic_sds_phy_get_sas_address(this_port->phy_table[index], sas_address);
+                if (sci_port->phy_table[index] != NULL) {
+                        scic_sds_phy_get_sas_address(sci_port->phy_table[index], sas_address);
                 }
         }
 }
 
 /**
  * This method will indicate which protocols are supported by this port.
- * @this_port: a handle corresponding to the SAS port for which to return the
+ * @sci_port: a handle corresponding to the SAS port for which to return the
  *    supported protocols.
  * @protocols: This parameter specifies a pointer to an IAF protocol field
  *    structure into which the core will copy the protocol values for the port.
@@ -373,7 +373,7 @@ void scic_sds_port_get_sas_address(
  *
  */
 static void scic_sds_port_get_protocols(
-        struct scic_sds_port *this_port,
+        struct scic_sds_port *sci_port,
         struct sci_sas_identify_address_frame_protocols *protocols)
 {
         u8 index;
@@ -381,8 +381,8 @@ static void scic_sds_port_get_protocols(
         protocols->u.all = 0;
 
         for (index = 0; index < SCI_MAX_PHYS; index++) {
-                if (this_port->phy_table[index] != NULL) {
-                        scic_sds_phy_get_protocols(this_port->phy_table[index], protocols);
+                if (sci_port->phy_table[index] != NULL) {
+                        scic_sds_phy_get_protocols(sci_port->phy_table[index], protocols);
                 }
         }
 }
@@ -390,7 +390,7 @@ static void scic_sds_port_get_protocols(
 /**
  * This method requests the SAS address for the device directly attached to
  *    this SAS port.
- * @this_port: a handle corresponding to the SAS port for which to return the
+ * @sci_port: a handle corresponding to the SAS port for which to return the
  *    SAS address.
  * @sas_address: This parameter specifies a pointer to a SAS address structure
  *    into which the core will copy the SAS address for the device directly
@@ -398,7 +398,7 @@ static void scic_sds_port_get_protocols(
  *
  */
 void scic_sds_port_get_attached_sas_address(
-        struct scic_sds_port *this_port,
+        struct scic_sds_port *sci_port,
         struct sci_sas_address *sas_address)
 {
         struct sci_sas_identify_address_frame_protocols protocols;
@@ -407,7 +407,7 @@ void scic_sds_port_get_attached_sas_address(
         /*
          * Ensure that the phy is both part of the port and currently
          * connected to the remote end-point. */
-        phy = scic_sds_port_get_a_connected_phy(this_port);
+        phy = scic_sds_port_get_a_connected_phy(sci_port);
         if (phy != NULL) {
                 scic_sds_phy_get_attached_phy_protocols(phy, &protocols);
 
@@ -426,7 +426,7 @@ void scic_sds_port_get_attached_sas_address(
 /**
  * This method will indicate which protocols are supported by this remote
  *    device.
- * @this_port: a handle corresponding to the SAS port for which to return the
+ * @sci_port: a handle corresponding to the SAS port for which to return the
  *    supported protocols.
  * @protocols: This parameter specifies a pointer to an IAF protocol field
  *    structure into which the core will copy the protocol values for the port.
@@ -435,7 +435,7 @@ void scic_sds_port_get_attached_sas_address(
  *
  */
 void scic_sds_port_get_attached_protocols(
-        struct scic_sds_port *this_port,
+        struct scic_sds_port *sci_port,
         struct sci_sas_identify_address_frame_protocols *protocols)
 {
         struct scic_sds_phy *phy;
@@ -443,7 +443,7 @@ void scic_sds_port_get_attached_protocols(
         /*
          * Ensure that the phy is both part of the port and currently
          * connected to the remote end-point. */
-        phy = scic_sds_port_get_a_connected_phy(this_port);
+        phy = scic_sds_port_get_a_connected_phy(sci_port);
         if (phy != NULL)
                 scic_sds_phy_get_attached_phy_protocols(phy, protocols);
         else
@@ -548,7 +548,7 @@ static void scic_sds_port_destroy_dummy_resources(struct scic_sds_port *sci_port
  * This method performs initialization of the supplied port. Initialization
  *    includes: - state machine initialization - member variable initialization
  *    - configuring the phy_mask
- * @this_port:
+ * @sci_port:
  * @transport_layer_registers:
  * @port_task_scheduler_registers:
  * @port_configuration_regsiter:
@@ -557,14 +557,14 @@ static void scic_sds_port_destroy_dummy_resources(struct scic_sds_port *sci_port
  * if the phy being added to the port
  */
 enum sci_status scic_sds_port_initialize(
-        struct scic_sds_port *this_port,
+        struct scic_sds_port *sci_port,
         void __iomem *port_task_scheduler_registers,
         void __iomem *port_configuration_regsiter,
         void __iomem *viit_registers)
 {
-        this_port->port_task_scheduler_registers  = port_task_scheduler_registers;
-        this_port->port_pe_configuration_register = port_configuration_regsiter;
-        this_port->viit_registers                 = viit_registers;
+        sci_port->port_task_scheduler_registers  = port_task_scheduler_registers;
+        sci_port->port_pe_configuration_register = port_configuration_regsiter;
+        sci_port->viit_registers                 = viit_registers;
 
         return SCI_SUCCESS;
 }
@@ -622,27 +622,27 @@ enum sci_status scic_port_hard_reset(
 /**
  * This method assigns the direct attached device ID for this port.
  *
- * @param[in] this_port The port for which the direct attached device id is to
+ * @param[in] sci_port The port for which the direct attached device id is to
  *       be assigned.
  * @param[in] device_id The direct attached device ID to assign to the port.
  *       This will be the RNi for the device
  */
 void scic_sds_port_setup_transports(
-        struct scic_sds_port *this_port,
+        struct scic_sds_port *sci_port,
         u32 device_id)
 {
         u8 index;
 
         for (index = 0; index < SCI_MAX_PHYS; index++) {
-                if (this_port->active_phy_mask & (1 << index))
-                        scic_sds_phy_setup_transport(this_port->phy_table[index], device_id);
+                if (sci_port->active_phy_mask & (1 << index))
+                        scic_sds_phy_setup_transport(sci_port->phy_table[index], device_id);
         }
 }
 
 /**
  *
- * @this_port: This is the port on which the phy should be enabled.
- * @the_phy: This is the specific phy which to enable.
+ * @sci_port: This is the port on which the phy should be enabled.
+ * @sci_phy: This is the specific phy which to enable.
  * @do_notify_user: This parameter specifies whether to inform the user (via
  *    scic_cb_port_link_up()) as to the fact that a new phy as become ready.
  *
@@ -696,8 +696,8 @@ void scic_sds_port_deactivate_phy(struct scic_sds_port *sci_port,
 
 /**
  *
- * @this_port: This is the port on which the phy should be disabled.
- * @the_phy: This is the specific phy which to disabled.
+ * @sci_port: This is the port on which the phy should be disabled.
+ * @sci_phy: This is the specific phy which to disabled.
  *
  * This function will disable the phy and report that the phy is not valid for
  * this port object. None
@@ -766,18 +766,18 @@ static void scic_sds_port_general_link_up_handler(struct scic_sds_port *sci_port
  * This method returns false if the port only has a single phy object assigned.
  *     If there are no phys or more than one phy then the method will return
  *    true.
- * @this_port: The port for which the wide port condition is to be checked.
+ * @sci_port: The port for which the wide port condition is to be checked.
  *
  * bool true Is returned if this is a wide ported port. false Is returned if
  * this is a narrow port.
  */
-static bool scic_sds_port_is_wide(struct scic_sds_port *this_port)
+static bool scic_sds_port_is_wide(struct scic_sds_port *sci_port)
 {
         u32 index;
         u32 phy_count = 0;
 
         for (index = 0; index < SCI_MAX_PHYS; index++) {
-                if (this_port->phy_table[index] != NULL) {
+                if (sci_port->phy_table[index] != NULL) {
                         phy_count++;
                 }
         }
@@ -790,8 +790,8 @@ static bool scic_sds_port_is_wide(struct scic_sds_port *this_port)
  *    port wants the PHY to continue on to the link up state then the port
  *    layer must return true.  If the port object returns false the phy object
  *    must halt its attempt to go link up.
- * @this_port: The port associated with the phy object.
- * @the_phy: The phy object that is trying to go link up.
+ * @sci_port: The port associated with the phy object.
+ * @sci_phy: The phy object that is trying to go link up.
  *
  * true if the phy object can continue to the link up condition. true Is
  * returned if this phy can continue to the ready state. false Is returned if
@@ -800,19 +800,19 @@ static bool scic_sds_port_is_wide(struct scic_sds_port *this_port)
  * devices this could become an invalid port configuration.
  */
 bool scic_sds_port_link_detected(
-        struct scic_sds_port *this_port,
-        struct scic_sds_phy *the_phy)
+        struct scic_sds_port *sci_port,
+        struct scic_sds_phy *sci_phy)
 {
         struct sci_sas_identify_address_frame_protocols protocols;
 
-        scic_sds_phy_get_attached_phy_protocols(the_phy, &protocols);
+        scic_sds_phy_get_attached_phy_protocols(sci_phy, &protocols);
 
         if (
-                (this_port->logical_port_index != SCIC_SDS_DUMMY_PORT)
+                (sci_port->logical_port_index != SCIC_SDS_DUMMY_PORT)
                 && (protocols.u.bits.stp_target)
-                && scic_sds_port_is_wide(this_port)
+                && scic_sds_port_is_wide(sci_port)
                 ) {
-                scic_sds_port_invalid_link_up(this_port, the_phy);
+                scic_sds_port_invalid_link_up(sci_port, sci_phy);
 
                 return false;
         }
@@ -823,65 +823,65 @@ bool scic_sds_port_link_detected(
 /**
  * This method is the entry point for the phy to inform the port that it is now
  *    in a ready state
- * @this_port:
+ * @sci_port:
  *
  *
  */
 void scic_sds_port_link_up(
-        struct scic_sds_port *this_port,
-        struct scic_sds_phy *the_phy)
+        struct scic_sds_port *sci_port,
+        struct scic_sds_phy *sci_phy)
 {
-        the_phy->is_in_link_training = false;
+        sci_phy->is_in_link_training = false;
 
-        this_port->state_handlers->link_up_handler(this_port, the_phy);
+        sci_port->state_handlers->link_up_handler(sci_port, sci_phy);
 }
 
 /**
  * This method is the entry point for the phy to inform the port that it is no
  *    longer in a ready state
- * @this_port:
+ * @sci_port:
  *
  *
  */
 void scic_sds_port_link_down(
-        struct scic_sds_port *this_port,
-        struct scic_sds_phy *the_phy)
+        struct scic_sds_port *sci_port,
+        struct scic_sds_phy *sci_phy)
 {
-        this_port->state_handlers->link_down_handler(this_port, the_phy);
+        sci_port->state_handlers->link_down_handler(sci_port, sci_phy);
 }
 
 /**
  * This method is called to start an IO request on this port.
- * @this_port:
- * @the_device:
- * @the_io_request:
+ * @sci_port:
+ * @sci_dev:
+ * @sci_req:
  *
  * enum sci_status
  */
 enum sci_status scic_sds_port_start_io(
-        struct scic_sds_port *this_port,
-        struct scic_sds_remote_device *the_device,
-        struct scic_sds_request *the_io_request)
+        struct scic_sds_port *sci_port,
+        struct scic_sds_remote_device *sci_dev,
+        struct scic_sds_request *sci_req)
 {
-        return this_port->state_handlers->start_io_handler(
-                       this_port, the_device, the_io_request);
+        return sci_port->state_handlers->start_io_handler(
+                       sci_port, sci_dev, sci_req);
 }
 
 /**
  * This method is called to complete an IO request to the port.
- * @this_port:
- * @the_device:
- * @the_io_request:
+ * @sci_port:
+ * @sci_dev:
+ * @sci_req:
  *
  * enum sci_status
  */
 enum sci_status scic_sds_port_complete_io(
-        struct scic_sds_port *this_port,
-        struct scic_sds_remote_device *the_device,
-        struct scic_sds_request *the_io_request)
+        struct scic_sds_port *sci_port,
+        struct scic_sds_remote_device *sci_dev,
+        struct scic_sds_request *sci_req)
 {
-        return this_port->state_handlers->complete_io_handler(
-                       this_port, the_device, the_io_request);
+        return sci_port->state_handlers->complete_io_handler(
+                       sci_port, sci_dev, sci_req);
 }
 
 /**
@@ -945,40 +945,40 @@ static void scic_sds_port_timeout_handler(void *port)
  *
  *
  */
-static void scic_sds_port_update_viit_entry(struct scic_sds_port *this_port)
+static void scic_sds_port_update_viit_entry(struct scic_sds_port *sci_port)
 {
         struct sci_sas_address sas_address;
 
-        scic_sds_port_get_sas_address(this_port, &sas_address);
+        scic_sds_port_get_sas_address(sci_port, &sas_address);
 
         writel(sas_address.high,
-                &this_port->viit_registers->initiator_sas_address_hi);
+                &sci_port->viit_registers->initiator_sas_address_hi);
         writel(sas_address.low,
-                &this_port->viit_registers->initiator_sas_address_lo);
+                &sci_port->viit_registers->initiator_sas_address_lo);
 
         /* This value get cleared just in case its not already cleared */
-        writel(0, &this_port->viit_registers->reserved);
+        writel(0, &sci_port->viit_registers->reserved);
 
         /* We are required to update the status register last */
         writel(SCU_VIIT_ENTRY_ID_VIIT |
                SCU_VIIT_IPPT_INITIATOR |
-               ((1 << this_port->physical_port_index) << SCU_VIIT_ENTRY_LPVIE_SHIFT) |
+               ((1 << sci_port->physical_port_index) << SCU_VIIT_ENTRY_LPVIE_SHIFT) |
                SCU_VIIT_STATUS_ALL_VALID,
-               &this_port->viit_registers->status);
+               &sci_port->viit_registers->status);
 }
 
 /**
  * This method returns the maximum allowed speed for data transfers on this
  *    port.  This maximum allowed speed evaluates to the maximum speed of the
  *    slowest phy in the port.
- * @this_port: This parameter specifies the port for which to retrieve the
+ * @sci_port: This parameter specifies the port for which to retrieve the
  *    maximum allowed speed.
  *
  * This method returns the maximum negotiated speed of the slowest phy in the
  * port.
  */
 enum sas_linkrate scic_sds_port_get_max_allowed_speed(
-        struct scic_sds_port *this_port)
+        struct scic_sds_port *sci_port)
 {
         u16 index;
         enum sas_linkrate max_allowed_speed = SAS_LINK_RATE_6_0_GBPS;
@@ -988,10 +988,10 @@ enum sas_linkrate scic_sds_port_get_max_allowed_speed(
          * Loop through all of the phys in this port and find the phy with the
          * lowest maximum link rate. */
         for (index = 0; index < SCI_MAX_PHYS; index++) {
-                phy = this_port->phy_table[index];
+                phy = sci_port->phy_table[index];
                 if (
                         (phy != NULL)
-                        && (scic_sds_port_active_phy(this_port, phy) == true)
+                        && (scic_sds_port_active_phy(sci_port, phy) == true)
                         && (phy->max_negotiated_speed < max_allowed_speed)
                         )
                         max_allowed_speed = phy->max_negotiated_speed;
@@ -1003,8 +1003,8 @@ enum sas_linkrate scic_sds_port_get_max_allowed_speed(
 
 /**
  * This method passes the event to core user.
- * @this_port: The port that a BCN happens.
- * @this_phy: The phy that receives BCN.
+ * @sci_port: The port that a BCN happens.
+ * @sci_phy: The phy that receives BCN.
  *
  */
 void scic_sds_port_broadcast_change_received(
@@ -1022,7 +1022,7 @@ void scic_sds_port_broadcast_change_received(
 /**
  * This API methhod enables the broadcast change notification from underneath
  *    hardware.
- * @this_port: The port that a BCN had been disabled from.
+ * @sci_port: The port that a BCN had been disabled from.
  *
  */
 void scic_port_enable_broadcast_change_notification(
@@ -1134,25 +1134,25 @@ static enum sci_status scic_sds_port_ready_substate_remove_phy_handler(
 
 /**
  *
- * @this_port: This is the struct scic_sds_port object that which has a phy that has
+ * @sci_port: This is the struct scic_sds_port object that which has a phy that has
  *    gone link up.
- * @the_phy: This is the struct scic_sds_phy object that has gone link up.
+ * @sci_phy: This is the struct scic_sds_phy object that has gone link up.
  *
  * This method is the ready waiting substate link up handler for the
  * struct scic_sds_port object.  This methos will report the link up condition for
  * this port and will transition to the ready operational substate. none
  */
 static void scic_sds_port_ready_waiting_substate_link_up_handler(
-        struct scic_sds_port *this_port,
-        struct scic_sds_phy *the_phy)
+        struct scic_sds_port *sci_port,
+        struct scic_sds_phy *sci_phy)
 {
         /*
          * Since this is the first phy going link up for the port we can just enable
          * it and continue. */
-        scic_sds_port_activate_phy(this_port, the_phy, true);
+        scic_sds_port_activate_phy(sci_port, sci_phy, true);
 
         sci_base_state_machine_change_state(
-                &this_port->ready_substate_machine,
+                &sci_port->ready_substate_machine,
                 SCIC_SDS_PORT_READY_SUBSTATE_OPERATIONAL
                 );
 }
@@ -1224,19 +1224,19 @@ sci_status scic_sds_port_ready_operational_substate_reset_handler(
 
 /**
  * scic_sds_port_ready_operational_substate_link_up_handler() -
- * @this_port: This is the struct scic_sds_port object that which has a phy that has
+ * @sci_port: This is the struct scic_sds_port object that which has a phy that has
  *    gone link up.
- * @the_phy: This is the struct scic_sds_phy object that has gone link up.
+ * @sci_phy: This is the struct scic_sds_phy object that has gone link up.
  *
  * This method is the ready operational substate link up handler for the
  * struct scic_sds_port object. This function notifies the SCI User that the phy has
  * gone link up. none
  */
 static void scic_sds_port_ready_operational_substate_link_up_handler(
-        struct scic_sds_port *this_port,
-        struct scic_sds_phy *the_phy)
+        struct scic_sds_port *sci_port,
+        struct scic_sds_phy *sci_phy)
 {
-        scic_sds_port_general_link_up_handler(this_port, the_phy, true);
+        scic_sds_port_general_link_up_handler(sci_port, sci_phy, true);
 }
 
 /**
@@ -1534,7 +1534,7 @@ scic_sds_port_ready_substate_handler_table[SCIC_SDS_PORT_READY_MAX_SUBSTATES] =
 
 /**
  *
- * @this_port: This is the struct scic_sds_port object to suspend.
+ * @sci_port: This is the struct scic_sds_port object to suspend.
  *
  * This method will susped the port task scheduler for this port object. none
  */
@@ -1602,7 +1602,7 @@ static void scic_sds_port_abort_dummy_request(struct scic_sds_port *sci_port)
 
 /**
  *
- * @this_port: This is the struct scic_sds_port object to resume.
+ * @sci_port: This is the struct scic_sds_port object to resume.
  *
  * This method will resume the port task scheduler for this port object. none
  */
@@ -1633,20 +1633,20 @@ scic_sds_port_resume_port_task_scheduler(struct scic_sds_port *port)
 static void scic_sds_port_ready_substate_waiting_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_port *this_port = (struct scic_sds_port *)object;
+        struct scic_sds_port *sci_port = (struct scic_sds_port *)object;
 
         scic_sds_port_set_ready_state_handlers(
-                this_port, SCIC_SDS_PORT_READY_SUBSTATE_WAITING
+                sci_port, SCIC_SDS_PORT_READY_SUBSTATE_WAITING
                 );
 
-        scic_sds_port_suspend_port_task_scheduler(this_port);
+        scic_sds_port_suspend_port_task_scheduler(sci_port);
 
-        this_port->not_ready_reason = SCIC_PORT_NOT_READY_NO_ACTIVE_PHYS;
+        sci_port->not_ready_reason = SCIC_PORT_NOT_READY_NO_ACTIVE_PHYS;
 
-        if (this_port->active_phy_mask != 0) {
+        if (sci_port->active_phy_mask != 0) {
                 /* At least one of the phys on the port is ready */
                 sci_base_state_machine_change_state(
-                        &this_port->ready_substate_machine,
+                        &sci_port->ready_substate_machine,
                         SCIC_SDS_PORT_READY_SUBSTATE_OPERATIONAL
                         );
         }
@@ -1766,9 +1766,9 @@ static void scic_sds_port_ready_substate_configuring_enter(
 static void scic_sds_port_ready_substate_configuring_exit(
         struct sci_base_object *object)
 {
-        struct scic_sds_port *this_port = (struct scic_sds_port *)object;
+        struct scic_sds_port *sci_port = (struct scic_sds_port *)object;
 
-        scic_sds_port_suspend_port_task_scheduler(this_port);
+        scic_sds_port_suspend_port_task_scheduler(sci_port);
 }
 
 /* --------------------------------------------------------------------------- */
@@ -2160,7 +2160,7 @@ scic_sds_port_state_handler_table[SCI_BASE_PORT_MAX_STATES] =
 
 /**
  *
- * @this_port: This is the port object which to suspend.
+ * @sci_port: This is the port object which to suspend.
  *
  * This method will enable the SCU Port Task Scheduler for this port object but
  * will leave the port task scheduler in a suspended state. none
@@ -2177,7 +2177,7 @@ scic_sds_port_enable_port_task_scheduler(struct scic_sds_port *port)
 
 /**
  *
- * @this_port: This is the port object which to resume.
+ * @sci_port: This is the port object which to resume.
  *
  * This method will disable the SCU port task scheduler for this port object.
  * none
@@ -2263,23 +2263,23 @@ static void scic_sds_port_invalidate_dummy_remote_node(struct scic_sds_port *sci
 static void scic_sds_port_stopped_state_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_port *this_port;
+        struct scic_sds_port *sci_port;
 
-        this_port = (struct scic_sds_port *)object;
+        sci_port = (struct scic_sds_port *)object;
 
         scic_sds_port_set_base_state_handlers(
-                this_port, SCI_BASE_PORT_STATE_STOPPED
+                sci_port, SCI_BASE_PORT_STATE_STOPPED
                 );
 
         if (
                 SCI_BASE_PORT_STATE_STOPPING
-                == this_port->state_machine.previous_state_id
+                == sci_port->state_machine.previous_state_id
                 ) {
                 /*
                  * If we enter this state becasuse of a request to stop
                  * the port then we want to disable the hardwares port
                  * task scheduler. */
-                scic_sds_port_disable_port_task_scheduler(this_port);
+                scic_sds_port_disable_port_task_scheduler(sci_port);
         }
 }
 
@@ -2294,12 +2294,12 @@ static void scic_sds_port_stopped_state_enter(
 static void scic_sds_port_stopped_state_exit(
         struct sci_base_object *object)
 {
-        struct scic_sds_port *this_port;
+        struct scic_sds_port *sci_port;
 
-        this_port = (struct scic_sds_port *)object;
+        sci_port = (struct scic_sds_port *)object;
 
         /* Enable and suspend the port task scheduler */
-        scic_sds_port_enable_port_task_scheduler(this_port);
+        scic_sds_port_enable_port_task_scheduler(sci_port);
 }
 
 /**
@@ -2360,12 +2360,12 @@ static void scic_sds_port_ready_state_exit(struct sci_base_object *object)
 static void scic_sds_port_resetting_state_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_port *this_port;
+        struct scic_sds_port *sci_port;
 
-        this_port = (struct scic_sds_port *)object;
+        sci_port = (struct scic_sds_port *)object;
 
         scic_sds_port_set_base_state_handlers(
-                this_port, SCI_BASE_PORT_STATE_RESETTING
+                sci_port, SCI_BASE_PORT_STATE_RESETTING
                 );
 }
 
@@ -2397,12 +2397,12 @@ static inline void scic_sds_port_resetting_state_exit(
 static void scic_sds_port_stopping_state_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_port *this_port;
+        struct scic_sds_port *sci_port;
 
-        this_port = (struct scic_sds_port *)object;
+        sci_port = (struct scic_sds_port *)object;
 
         scic_sds_port_set_base_state_handlers(
-                this_port, SCI_BASE_PORT_STATE_STOPPING
+                sci_port, SCI_BASE_PORT_STATE_STOPPING
                 );
 }
 
diff --git a/drivers/scsi/isci/core/scic_sds_port.h b/drivers/scsi/isci/core/scic_sds_port.h
index c7741e81336e..964e3885dbf2 100644
--- a/drivers/scsi/isci/core/scic_sds_port.h
+++ b/drivers/scsi/isci/core/scic_sds_port.h
@@ -378,77 +378,77 @@ static inline void scic_sds_port_decrement_request_count(struct scic_sds_port *s
         (((port)->active_phy_mask & (1 << (phy)->phy_index)) != 0)
 
 void scic_sds_port_construct(
-        struct scic_sds_port *this_port,
+        struct scic_sds_port *sci_port,
         u8 port_index,
-        struct scic_sds_controller *owning_controller);
+        struct scic_sds_controller *scic);
 
 enum sci_status scic_sds_port_initialize(
-        struct scic_sds_port *this_port,
+        struct scic_sds_port *sci_port,
         void __iomem *port_task_scheduler_registers,
         void __iomem *port_configuration_regsiter,
         void __iomem *viit_registers);
 
 enum sci_status scic_sds_port_add_phy(
-        struct scic_sds_port *this_port,
-        struct scic_sds_phy *the_phy);
+        struct scic_sds_port *sci_port,
+        struct scic_sds_phy *sci_phy);
 
 enum sci_status scic_sds_port_remove_phy(
-        struct scic_sds_port *this_port,
-        struct scic_sds_phy *the_phy);
+        struct scic_sds_port *sci_port,
+        struct scic_sds_phy *sci_phy);
 
 void scic_sds_port_setup_transports(
-        struct scic_sds_port *this_port,
+        struct scic_sds_port *sci_port,
         u32 device_id);
 
 
 void scic_sds_port_deactivate_phy(
-        struct scic_sds_port *this_port,
-        struct scic_sds_phy *phy,
+        struct scic_sds_port *sci_port,
+        struct scic_sds_phy *sci_phy,
         bool do_notify_user);
 
 bool scic_sds_port_link_detected(
-        struct scic_sds_port *this_port,
-        struct scic_sds_phy *phy);
+        struct scic_sds_port *sci_port,
+        struct scic_sds_phy *sci_phy);
 
 void scic_sds_port_link_up(
-        struct scic_sds_port *this_port,
-        struct scic_sds_phy *phy);
+        struct scic_sds_port *sci_port,
+        struct scic_sds_phy *sci_phy);
 
 void scic_sds_port_link_down(
-        struct scic_sds_port *this_port,
-        struct scic_sds_phy *phy);
+        struct scic_sds_port *sci_port,
+        struct scic_sds_phy *sci_phy);
 
 enum sci_status scic_sds_port_start_io(
-        struct scic_sds_port *this_port,
-        struct scic_sds_remote_device *the_device,
-        struct scic_sds_request *the_io_request);
+        struct scic_sds_port *sci_port,
+        struct scic_sds_remote_device *sci_dev,
+        struct scic_sds_request *sci_req);
 
 enum sci_status scic_sds_port_complete_io(
-        struct scic_sds_port *this_port,
-        struct scic_sds_remote_device *the_device,
-        struct scic_sds_request *the_io_request);
+        struct scic_sds_port *sci_port,
+        struct scic_sds_remote_device *sci_dev,
+        struct scic_sds_request *sci_req);
 
 enum sas_linkrate scic_sds_port_get_max_allowed_speed(
-        struct scic_sds_port *this_port);
+        struct scic_sds_port *sci_port);
 
 void scic_sds_port_broadcast_change_received(
-        struct scic_sds_port *this_port,
-        struct scic_sds_phy *this_phy);
+        struct scic_sds_port *sci_port,
+        struct scic_sds_phy *sci_phy);
 
 bool scic_sds_port_is_valid_phy_assignment(
-        struct scic_sds_port *this_port,
+        struct scic_sds_port *sci_port,
         u32 phy_index);
 
 void scic_sds_port_get_sas_address(
-        struct scic_sds_port *this_port,
+        struct scic_sds_port *sci_port,
         struct sci_sas_address *sas_address);
 
 void scic_sds_port_get_attached_sas_address(
-        struct scic_sds_port *this_port,
+        struct scic_sds_port *sci_port,
         struct sci_sas_address *sas_address);
 
 void scic_sds_port_get_attached_protocols(
-        struct scic_sds_port *this_port,
+        struct scic_sds_port *sci_port,
         struct sci_sas_identify_address_frame_protocols *protocols);
 
 #endif /* _SCIC_SDS_PORT_H_ */
diff --git a/drivers/scsi/isci/core/scic_sds_remote_device.c b/drivers/scsi/isci/core/scic_sds_remote_device.c
index 0976faeb4064..fa7828d4d975 100644
--- a/drivers/scsi/isci/core/scic_sds_remote_device.c
+++ b/drivers/scsi/isci/core/scic_sds_remote_device.c
@@ -149,17 +149,17 @@ enum sci_status scic_remote_device_da_construct(
 
 
 static void scic_sds_remote_device_get_info_from_smp_discover_response(
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         struct smp_response_discover *discover_response)
 {
-        /* decode discover_response to set sas_address to this_device. */
-        this_device->device_address.high =
+        /* decode discover_response to set sas_address to sci_dev. */
+        sci_dev->device_address.high =
                 discover_response->attached_sas_address.high;
 
-        this_device->device_address.low =
+        sci_dev->device_address.low =
                 discover_response->attached_sas_address.low;
 
-        this_device->target_protocols.u.all = discover_response->protocols.u.all;
+        sci_dev->target_protocols.u.all = discover_response->protocols.u.all;
 }
 
 
@@ -168,15 +168,15 @@ enum sci_status scic_remote_device_ea_construct(
         struct smp_response_discover *discover_response)
 {
         enum sci_status status;
-        struct scic_sds_controller *the_controller;
+        struct scic_sds_controller *scic;
 
-        the_controller = scic_sds_port_get_controller(sci_dev->owning_port);
+        scic = scic_sds_port_get_controller(sci_dev->owning_port);
 
         scic_sds_remote_device_get_info_from_smp_discover_response(
                 sci_dev, discover_response);
 
         status = scic_sds_controller_allocate_remote_node_context(
-                the_controller, sci_dev, &sci_dev->rnc->remote_node_index);
+                scic, sci_dev, &sci_dev->rnc->remote_node_index);
 
         if (status == SCI_SUCCESS) {
                 if (sci_dev->target_protocols.u.bits.attached_ssp_target) {
@@ -294,32 +294,32 @@ bool scic_remote_device_is_atapi(struct scic_sds_remote_device *sci_dev)
 
 /**
  *
- * @this_device: The remote device for which the suspend is being requested.
+ * @sci_dev: The remote device for which the suspend is being requested.
  *
  * This method invokes the remote device suspend state handler. enum sci_status
  */
 enum sci_status scic_sds_remote_device_suspend(
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         u32 suspend_type)
 {
-        return this_device->state_handlers->suspend_handler(this_device, suspend_type);
+        return sci_dev->state_handlers->suspend_handler(sci_dev, suspend_type);
 }
 
 /**
  *
- * @this_device: The remote device for which the resume is being requested.
+ * @sci_dev: The remote device for which the resume is being requested.
  *
  * This method invokes the remote device resume state handler. enum sci_status
  */
 enum sci_status scic_sds_remote_device_resume(
-        struct scic_sds_remote_device *this_device)
+        struct scic_sds_remote_device *sci_dev)
 {
-        return this_device->state_handlers->resume_handler(this_device);
+        return sci_dev->state_handlers->resume_handler(sci_dev);
 }
 
 /**
  *
- * @this_device: The remote device for which the event handling is being
+ * @sci_dev: The remote device for which the event handling is being
  *    requested.
  * @frame_index: This is the frame index that is being processed.
  *
@@ -327,31 +327,31 @@ enum sci_status scic_sds_remote_device_resume(
  * enum sci_status
  */
 enum sci_status scic_sds_remote_device_frame_handler(
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         u32 frame_index)
 {
-        return this_device->state_handlers->frame_handler(this_device, frame_index);
+        return sci_dev->state_handlers->frame_handler(sci_dev, frame_index);
 }
 
 /**
  *
- * @this_device: The remote device for which the event handling is being
+ * @sci_dev: The remote device for which the event handling is being
  *    requested.
  * @event_code: This is the event code that is to be processed.
  *
  * This method invokes the remote device event handler. enum sci_status
  */
 enum sci_status scic_sds_remote_device_event_handler(
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         u32 event_code)
 {
-        return this_device->state_handlers->event_handler(this_device, event_code);
+        return sci_dev->state_handlers->event_handler(sci_dev, event_code);
 }
 
 /**
  *
  * @controller: The controller that is starting the io request.
- * @this_device: The remote device for which the start io handling is being
+ * @sci_dev: The remote device for which the start io handling is being
  *    requested.
  * @io_request: The io request that is being started.
  *
@@ -359,17 +359,17 @@ enum sci_status scic_sds_remote_device_event_handler(
  */
 enum sci_status scic_sds_remote_device_start_io(
         struct scic_sds_controller *controller,
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         struct scic_sds_request *io_request)
 {
-        return this_device->state_handlers->start_io_handler(
-                       this_device, io_request);
+        return sci_dev->state_handlers->start_io_handler(
+                       sci_dev, io_request);
 }
 
 /**
  *
  * @controller: The controller that is completing the io request.
- * @this_device: The remote device for which the complete io handling is being
+ * @sci_dev: The remote device for which the complete io handling is being
  *    requested.
  * @io_request: The io request that is being completed.
  *
@@ -377,17 +377,17 @@ enum sci_status scic_sds_remote_device_start_io(
  */
 enum sci_status scic_sds_remote_device_complete_io(
         struct scic_sds_controller *controller,
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         struct scic_sds_request *io_request)
 {
-        return this_device->state_handlers->complete_io_handler(
-                       this_device, io_request);
+        return sci_dev->state_handlers->complete_io_handler(
+                       sci_dev, io_request);
 }
 
 /**
  *
  * @controller: The controller that is starting the task request.
- * @this_device: The remote device for which the start task handling is being
+ * @sci_dev: The remote device for which the start task handling is being
  *    requested.
  * @io_request: The task request that is being started.
  *
@@ -395,17 +395,17 @@ enum sci_status scic_sds_remote_device_complete_io(
  */
 enum sci_status scic_sds_remote_device_start_task(
         struct scic_sds_controller *controller,
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         struct scic_sds_request *io_request)
 {
-        return this_device->state_handlers->start_task_handler(
-                       this_device, io_request);
+        return sci_dev->state_handlers->start_task_handler(
+                       sci_dev, io_request);
 }
 
 /**
  *
  * @controller: The controller that is completing the task request.
- * @this_device: The remote device for which the complete task handling is
+ * @sci_dev: The remote device for which the complete task handling is
  *    being requested.
  * @io_request: The task request that is being completed.
  *
@@ -414,22 +414,22 @@ enum sci_status scic_sds_remote_device_start_task(
 
 /**
  *
- * @this_device:
+ * @sci_dev:
  * @request:
  *
  * This method takes the request and bulids an appropriate SCU context for the
  * request and then requests the controller to post the request. none
  */
 void scic_sds_remote_device_post_request(
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         u32 request)
 {
         u32 context;
 
-        context = scic_sds_remote_device_build_command_context(this_device, request);
+        context = scic_sds_remote_device_build_command_context(sci_dev, request);
 
         scic_sds_controller_post_request(
-                scic_sds_remote_device_get_controller(this_device),
+                scic_sds_remote_device_get_controller(sci_dev),
                 context
                 );
 }
@@ -437,22 +437,22 @@ void scic_sds_remote_device_post_request(
 #if !defined(DISABLE_ATAPI)
 /**
  *
- * @this_device: The device to be checked.
+ * @sci_dev: The device to be checked.
  *
  * This method check the signature fis of a stp device to decide whether a
  * device is atapi or not. true if a device is atapi device. False if a device
  * is not atapi.
  */
 bool scic_sds_remote_device_is_atapi(
-        struct scic_sds_remote_device *this_device)
+        struct scic_sds_remote_device *sci_dev)
 {
-        if (!this_device->target_protocols.u.bits.attached_stp_target)
+        if (!sci_dev->target_protocols.u.bits.attached_stp_target)
                 return false;
-        else if (this_device->is_direct_attached) {
+        else if (sci_dev->is_direct_attached) {
                 struct scic_sds_phy *phy;
                 struct scic_sata_phy_properties properties;
                 struct sata_fis_reg_d2h *signature_fis;
-                phy = scic_sds_port_get_a_connected_phy(this_device->owning_port);
+                phy = scic_sds_port_get_a_connected_phy(sci_dev->owning_port);
                 scic_sata_phy_get_properties(phy, &properties);
 
                 /* decode the signature fis. */
@@ -506,16 +506,16 @@ static void scic_sds_cb_remote_device_rnc_destruct_complete(
 static void scic_sds_remote_device_resume_complete_handler(
         void *user_parameter)
 {
-        struct scic_sds_remote_device *this_device;
+        struct scic_sds_remote_device *sci_dev;
 
-        this_device = (struct scic_sds_remote_device *)user_parameter;
+        sci_dev = (struct scic_sds_remote_device *)user_parameter;
 
         if (
-                sci_base_state_machine_get_state(&this_device->state_machine)
+                sci_base_state_machine_get_state(&sci_dev->state_machine)
                 != SCI_BASE_REMOTE_DEVICE_STATE_READY
                 ) {
                 sci_base_state_machine_change_state(
-                        &this_device->state_machine,
+                        &sci_dev->state_machine,
                         SCI_BASE_REMOTE_DEVICE_STATE_READY
                         );
         }
@@ -532,16 +532,16 @@ static void scic_sds_remote_device_resume_complete_handler(
  * requests and task requests of all types. none
  */
 void scic_sds_remote_device_start_request(
-        struct scic_sds_remote_device *this_device,
-        struct scic_sds_request *the_request,
+        struct scic_sds_remote_device *sci_dev,
+        struct scic_sds_request *sci_req,
         enum sci_status status)
 {
         /* We still have a fault in starting the io complete it on the port */
         if (status == SCI_SUCCESS)
-                scic_sds_remote_device_increment_request_count(this_device);
+                scic_sds_remote_device_increment_request_count(sci_dev);
         else{
-                this_device->owning_port->state_handlers->complete_io_handler(
-                        this_device->owning_port, this_device, the_request
+                sci_dev->owning_port->state_handlers->complete_io_handler(
+                        sci_dev->owning_port, sci_dev, sci_req
                         );
         }
 }
@@ -576,7 +576,7 @@ void scic_sds_remote_device_continue_request(void *dev)
 /**
  * This method will terminate all of the IO requests in the controllers IO
  *    request table that were targeted for this device.
- * @this_device: This parameter specifies the remote device for which to
+ * @sci_dev: This parameter specifies the remote device for which to
  *    attempt to terminate all requests.
  *
  * This method returns an indication as to whether all requests were
@@ -584,24 +584,24 @@ void scic_sds_remote_device_continue_request(void *dev)
  * this method will return the failure.
  */
 static enum sci_status scic_sds_remote_device_terminate_requests(
-        struct scic_sds_remote_device *this_device)
+        struct scic_sds_remote_device *sci_dev)
 {
         enum sci_status status           = SCI_SUCCESS;
         enum sci_status terminate_status = SCI_SUCCESS;
-        struct scic_sds_request *the_request;
+        struct scic_sds_request *sci_req;
         u32 index;
-        u32 request_count    = this_device->started_request_count;
+        u32 request_count    = sci_dev->started_request_count;
 
         for (index = 0;
              (index < SCI_MAX_IO_REQUESTS) && (request_count > 0);
              index++) {
-                the_request = this_device->owning_port->owning_controller->io_request_table[index];
+                sci_req = sci_dev->owning_port->owning_controller->io_request_table[index];
 
-                if ((the_request != NULL) && (the_request->target_device == this_device)) {
+                if ((sci_req != NULL) && (sci_req->target_device == sci_dev)) {
                         terminate_status = scic_controller_terminate_request(
-                                this_device->owning_port->owning_controller,
-                                this_device,
-                                the_request
+                                sci_dev->owning_port->owning_controller,
+                                sci_dev,
+                                sci_req
                                 );
 
                         if (terminate_status != SCI_SUCCESS)
@@ -684,7 +684,7 @@ enum sci_status scic_sds_remote_device_default_resume_handler(
  * returns a failure. enum sci_status SCI_FAILURE_INVALID_STATE
  */
 static enum sci_status  scic_sds_remote_device_core_event_handler(
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         u32 event_code,
         bool is_ready_state)
 {
@@ -694,7 +694,7 @@ static enum sci_status  scic_sds_remote_device_core_event_handler(
         case SCU_EVENT_TYPE_RNC_OPS_MISC:
         case SCU_EVENT_TYPE_RNC_SUSPEND_TX:
         case SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX:
-                status = scic_sds_remote_node_context_event_handler(this_device->rnc, event_code);
+                status = scic_sds_remote_node_context_event_handler(sci_dev->rnc, event_code);
                 break;
         case SCU_EVENT_TYPE_PTX_SCHEDULE_EVENT:
 
@@ -702,13 +702,13 @@ static enum sci_status  scic_sds_remote_device_core_event_handler(
                         status = SCI_SUCCESS;
 
                         /* Suspend the associated RNC */
-                        scic_sds_remote_node_context_suspend(this_device->rnc,
+                        scic_sds_remote_node_context_suspend(sci_dev->rnc,
                                                               SCI_SOFTWARE_SUSPENSION,
                                                               NULL, NULL);
 
-                        dev_dbg(scirdev_to_dev(this_device),
+                        dev_dbg(scirdev_to_dev(sci_dev),
                                 "%s: device: %p event code: %x: %s\n",
-                                __func__, this_device, event_code,
+                                __func__, sci_dev, event_code,
                                 (is_ready_state)
                                 ? "I_T_Nexus_Timeout event"
                                 : "I_T_Nexus_Timeout event in wrong state");
@@ -718,9 +718,9 @@ static enum sci_status  scic_sds_remote_device_core_event_handler(
         /* Else, fall through and treat as unhandled... */
 
         default:
-                dev_dbg(scirdev_to_dev(this_device),
+                dev_dbg(scirdev_to_dev(sci_dev),
                         "%s: device: %p event code: %x: %s\n",
-                        __func__, this_device, event_code,
+                        __func__, sci_dev, event_code,
                         (is_ready_state)
                         ? "unexpected event"
                         : "unexpected event in wrong state");
@@ -742,10 +742,10 @@ static enum sci_status  scic_sds_remote_device_core_event_handler(
  * returns a failure. enum sci_status SCI_FAILURE_INVALID_STATE
  */
 static enum sci_status  scic_sds_remote_device_default_event_handler(
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         u32 event_code)
 {
-        return scic_sds_remote_device_core_event_handler(this_device,
+        return scic_sds_remote_device_core_event_handler(sci_dev,
                                                           event_code,
                                                           false);
 }
@@ -762,20 +762,20 @@ static enum sci_status  scic_sds_remote_device_default_event_handler(
  * SCI_FAILURE_INVALID_STATE
  */
 enum sci_status scic_sds_remote_device_default_frame_handler(
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         u32 frame_index)
 {
-        dev_warn(scirdev_to_dev(this_device),
+        dev_warn(scirdev_to_dev(sci_dev),
                  "%s: SCIC Remote Device requested to handle frame %x "
                  "while in wrong state %d\n",
                  __func__,
                  frame_index,
                  sci_base_state_machine_get_state(
-                         &this_device->state_machine));
+                         &sci_dev->state_machine));
 
         /* Return the frame back to the controller */
         scic_sds_controller_release_frame(
-                scic_sds_remote_device_get_controller(this_device), frame_index
+                scic_sds_remote_device_get_controller(sci_dev), frame_index
                 );
 
         return SCI_FAILURE_INVALID_STATE;
@@ -815,7 +815,7 @@ enum sci_status scic_sds_remote_device_default_continue_request_handler(
  * unsolicited frame to that object. enum sci_status SCI_FAILURE_INVALID_STATE
  */
 enum sci_status scic_sds_remote_device_general_frame_handler(
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         u32 frame_index)
 {
         enum sci_status result;
@@ -823,22 +823,22 @@ enum sci_status scic_sds_remote_device_general_frame_handler(
         struct scic_sds_request *io_request;
 
         result = scic_sds_unsolicited_frame_control_get_header(
-                &(scic_sds_remote_device_get_controller(this_device)->uf_control),
+                &(scic_sds_remote_device_get_controller(sci_dev)->uf_control),
                 frame_index,
                 (void **)&frame_header
                 );
 
         if (SCI_SUCCESS == result) {
                 io_request = scic_sds_controller_get_io_request_from_tag(
-                        scic_sds_remote_device_get_controller(this_device), frame_header->tag);
+                        scic_sds_remote_device_get_controller(sci_dev), frame_header->tag);
 
                 if ((io_request == NULL)
-                    || (io_request->target_device != this_device)) {
+                    || (io_request->target_device != sci_dev)) {
                         /*
                          * We could not map this tag to a valid IO request
                          * Just toss the frame and continue */
                         scic_sds_controller_release_frame(
-                                scic_sds_remote_device_get_controller(this_device), frame_index
+                                scic_sds_remote_device_get_controller(sci_dev), frame_index
                                 );
                 } else {
                         /* The IO request is now in charge of releasing the frame */
@@ -852,17 +852,17 @@ enum sci_status scic_sds_remote_device_general_frame_handler(
 
 /**
  *
- * @[in]: this_device This is the device object that is receiving the event.
+ * @[in]: sci_dev This is the device object that is receiving the event.
  * @[in]: event_code The event code to process.
  *
  * This is a common method for handling events reported to the remote device
  * from the controller object. enum sci_status
  */
 enum sci_status scic_sds_remote_device_general_event_handler(
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         u32 event_code)
 {
-        return scic_sds_remote_device_core_event_handler(this_device,
+        return scic_sds_remote_device_core_event_handler(sci_dev,
                                                           event_code,
                                                           true);
 }
@@ -1093,7 +1093,7 @@ static enum sci_status scic_sds_remote_device_ready_state_complete_request_handl
 
 /**
  *
- * @this_device: The struct scic_sds_remote_device which is cast into a
+ * @sci_dev: The struct scic_sds_remote_device which is cast into a
  *    struct scic_sds_remote_device.
  *
  * This method will stop a struct scic_sds_remote_device that is already in the
@@ -1536,10 +1536,10 @@ static void scic_sds_remote_device_ready_state_exit(
 static void scic_sds_remote_device_stopping_state_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)object;
+        struct scic_sds_remote_device *sci_dev = (struct scic_sds_remote_device *)object;
 
         SET_STATE_HANDLER(
-                this_device,
+                sci_dev,
                 scic_sds_remote_device_state_handler_table,
                 SCI_BASE_REMOTE_DEVICE_STATE_STOPPING
                 );
@@ -1556,10 +1556,10 @@ static void scic_sds_remote_device_stopping_state_enter(
 static void scic_sds_remote_device_failed_state_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)object;
+        struct scic_sds_remote_device *sci_dev = (struct scic_sds_remote_device *)object;
 
         SET_STATE_HANDLER(
-                this_device,
+                sci_dev,
                 scic_sds_remote_device_state_handler_table,
                 SCI_BASE_REMOTE_DEVICE_STATE_FAILED
                 );
@@ -1576,16 +1576,16 @@ static void scic_sds_remote_device_failed_state_enter(
 static void scic_sds_remote_device_resetting_state_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)object;
+        struct scic_sds_remote_device *sci_dev = (struct scic_sds_remote_device *)object;
 
         SET_STATE_HANDLER(
-                this_device,
+                sci_dev,
                 scic_sds_remote_device_state_handler_table,
                 SCI_BASE_REMOTE_DEVICE_STATE_RESETTING
                 );
 
         scic_sds_remote_node_context_suspend(
-                this_device->rnc, SCI_SOFTWARE_SUSPENSION, NULL, NULL);
+                sci_dev->rnc, SCI_SOFTWARE_SUSPENSION, NULL, NULL);
 }
 
 /**
@@ -1599,9 +1599,9 @@ static void scic_sds_remote_device_resetting_state_enter(
 static void scic_sds_remote_device_resetting_state_exit(
         struct sci_base_object *object)
 {
-        struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)object;
+        struct scic_sds_remote_device *sci_dev = (struct scic_sds_remote_device *)object;
 
-        scic_sds_remote_node_context_resume(this_device->rnc, NULL, NULL);
+        scic_sds_remote_node_context_resume(sci_dev->rnc, NULL, NULL);
 }
 
 /**
@@ -1615,10 +1615,10 @@ static void scic_sds_remote_device_resetting_state_exit(
 static void scic_sds_remote_device_final_state_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_remote_device *this_device = (struct scic_sds_remote_device *)object;
+        struct scic_sds_remote_device *sci_dev = (struct scic_sds_remote_device *)object;
 
         SET_STATE_HANDLER(
-                this_device,
+                sci_dev,
                 scic_sds_remote_device_state_handler_table,
                 SCI_BASE_REMOTE_DEVICE_STATE_FINAL
                 );
diff --git a/drivers/scsi/isci/core/scic_sds_remote_device.h b/drivers/scsi/isci/core/scic_sds_remote_device.h
index ebb0ac8ef3a6..5d3df92212eb 100644
--- a/drivers/scsi/isci/core/scic_sds_remote_device.h
+++ b/drivers/scsi/isci/core/scic_sds_remote_device.h
@@ -350,25 +350,25 @@ typedef enum sci_status (*scic_sds_remote_device_high_priority_request_complete_
         enum sci_io_status);
 
 typedef enum sci_status (*scic_sds_remote_device_handler_t)(
-        struct scic_sds_remote_device *this_device);
+        struct scic_sds_remote_device *sci_dev);
 
 typedef enum sci_status (*scic_sds_remote_device_suspend_handler_t)(
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         u32 suspend_type);
 
 typedef enum sci_status (*scic_sds_remote_device_resume_handler_t)(
-        struct scic_sds_remote_device *this_device);
+        struct scic_sds_remote_device *sci_dev);
 
 typedef enum sci_status (*scic_sds_remote_device_frame_handler_t)(
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         u32 frame_index);
 
 typedef enum sci_status (*scic_sds_remote_device_event_handler_t)(
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         u32 event_code);
 
 typedef void (*scic_sds_remote_device_ready_not_ready_handler_t)(
-        struct scic_sds_remote_device *this_device);
+        struct scic_sds_remote_device *sci_dev);
 
 /**
  * struct scic_sds_remote_device_state_handler - This structure conains the
@@ -461,8 +461,8 @@ extern const struct sci_base_state scic_sds_smp_remote_device_ready_substate_tab
  *
  * This macro incrments the request count for this device
  */
-#define scic_sds_remote_device_increment_request_count(this_device) \
-        ((this_device)->started_request_count++)
+#define scic_sds_remote_device_increment_request_count(sci_dev) \
+        ((sci_dev)->started_request_count++)
 
 /**
  * scic_sds_remote_device_decrement_request_count() -
@@ -470,33 +470,33 @@ extern const struct sci_base_state scic_sds_smp_remote_device_ready_substate_tab
  * This macro decrements the request count for this device.  This count will
  * never decrment past 0.
  */
-#define scic_sds_remote_device_decrement_request_count(this_device) \
-        ((this_device)->started_request_count > 0 ? \
-         (this_device)->started_request_count-- : 0)
+#define scic_sds_remote_device_decrement_request_count(sci_dev) \
+        ((sci_dev)->started_request_count > 0 ? \
+         (sci_dev)->started_request_count-- : 0)
 
 /**
  * scic_sds_remote_device_get_request_count() -
  *
  * This is a helper macro to return the current device request count.
  */
-#define scic_sds_remote_device_get_request_count(this_device) \
-        ((this_device)->started_request_count)
+#define scic_sds_remote_device_get_request_count(sci_dev) \
+        ((sci_dev)->started_request_count)
 
 /**
  * scic_sds_remote_device_get_port() -
  *
  * This macro returns the owning port of this remote device obejct.
  */
-#define scic_sds_remote_device_get_port(this_device) \
-        ((this_device)->owning_port)
+#define scic_sds_remote_device_get_port(sci_dev) \
+        ((sci_dev)->owning_port)
 
 /**
  * scic_sds_remote_device_get_controller() -
  *
  * This macro returns the controller object that contains this device object
  */
-#define scic_sds_remote_device_get_controller(this_device) \
-        scic_sds_port_get_controller(scic_sds_remote_device_get_port(this_device))
+#define scic_sds_remote_device_get_controller(sci_dev) \
+        scic_sds_port_get_controller(scic_sds_remote_device_get_port(sci_dev))
 
 /**
  * scic_sds_remote_device_set_state_handlers() -
@@ -504,26 +504,26 @@ extern const struct sci_base_state scic_sds_smp_remote_device_ready_substate_tab
  * This macro sets the remote device state handlers pointer and is set on entry
  * to each device state.
  */
-#define scic_sds_remote_device_set_state_handlers(this_device, handlers) \
-        ((this_device)->state_handlers = (handlers))
+#define scic_sds_remote_device_set_state_handlers(sci_dev, handlers) \
+        ((sci_dev)->state_handlers = (handlers))
 
 /**
  * scic_sds_remote_device_get_port() -
  *
  * This macro returns the owning port of this device
  */
-#define scic_sds_remote_device_get_port(this_device) \
-        ((this_device)->owning_port)
+#define scic_sds_remote_device_get_port(sci_dev) \
+        ((sci_dev)->owning_port)
 
 /**
  * scic_sds_remote_device_get_sequence() -
  *
  * This macro returns the remote device sequence value
  */
-#define scic_sds_remote_device_get_sequence(this_device) \
+#define scic_sds_remote_device_get_sequence(sci_dev) \
         (\
-                scic_sds_remote_device_get_controller(this_device)-> \
-                remote_device_sequence[(this_device)->rnc->remote_node_index] \
+                scic_sds_remote_device_get_controller(sci_dev)-> \
+                remote_device_sequence[(sci_dev)->rnc->remote_node_index] \
         )
 
 /**
@@ -531,11 +531,11 @@ extern const struct sci_base_state scic_sds_smp_remote_device_ready_substate_tab
  *
  * This macro returns the controllers protocol engine group
  */
-#define scic_sds_remote_device_get_controller_peg(this_device) \
+#define scic_sds_remote_device_get_controller_peg(sci_dev) \
         (\
                 scic_sds_controller_get_protocol_engine_group(\
                         scic_sds_port_get_controller(\
-                                scic_sds_remote_device_get_port(this_device) \
+                                scic_sds_remote_device_get_port(sci_dev) \
                                 ) \
                         ) \
         )
@@ -545,16 +545,16 @@ extern const struct sci_base_state scic_sds_smp_remote_device_ready_substate_tab
  *
  * This macro returns the port index for the devices owning port
  */
-#define scic_sds_remote_device_get_port_index(this_device) \
-        (scic_sds_port_get_index(scic_sds_remote_device_get_port(this_device)))
+#define scic_sds_remote_device_get_port_index(sci_dev) \
+        (scic_sds_port_get_index(scic_sds_remote_device_get_port(sci_dev)))
 
 /**
  * scic_sds_remote_device_get_index() -
  *
  * This macro returns the remote node index for this device object
  */
-#define scic_sds_remote_device_get_index(this_device) \
-        ((this_device)->rnc->remote_node_index)
+#define scic_sds_remote_device_get_index(sci_dev) \
+        ((sci_dev)->rnc->remote_node_index)
 
 /**
  * scic_sds_remote_device_build_command_context() -
@@ -579,61 +579,61 @@ extern const struct sci_base_state scic_sds_smp_remote_device_ready_substate_tab
         ((device)->working_request = (request))
 
 enum sci_status scic_sds_remote_device_frame_handler(
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         u32 frame_index);
 
 enum sci_status scic_sds_remote_device_event_handler(
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         u32 event_code);
 
 enum sci_status scic_sds_remote_device_start_io(
         struct scic_sds_controller *controller,
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         struct scic_sds_request *io_request);
 
 enum sci_status scic_sds_remote_device_complete_io(
         struct scic_sds_controller *controller,
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         struct scic_sds_request *io_request);
 
 enum sci_status scic_sds_remote_device_resume(
-        struct scic_sds_remote_device *this_device);
+        struct scic_sds_remote_device *sci_dev);
 
 enum sci_status scic_sds_remote_device_suspend(
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         u32 suspend_type);
 
 enum sci_status scic_sds_remote_device_start_task(
         struct scic_sds_controller *controller,
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         struct scic_sds_request *io_request);
 
 void scic_sds_remote_device_post_request(
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         u32 request);
 
 #if !defined(DISABLE_ATAPI)
 bool scic_sds_remote_device_is_atapi(
-        struct scic_sds_remote_device *this_device);
+        struct scic_sds_remote_device *sci_dev);
 #else /* !defined(DISABLE_ATAPI) */
-#define scic_sds_remote_device_is_atapi(this_device) false
+#define scic_sds_remote_device_is_atapi(sci_dev) false
 #endif /* !defined(DISABLE_ATAPI) */
 
 void scic_sds_remote_device_start_request(
-        struct scic_sds_remote_device *this_device,
-        struct scic_sds_request *the_request,
+        struct scic_sds_remote_device *sci_dev,
+        struct scic_sds_request *sci_req,
         enum sci_status status);
 
 void scic_sds_remote_device_continue_request(void *sci_dev);
 
 enum sci_status scic_sds_remote_device_default_start_handler(
-        struct scic_sds_remote_device *this_device);
+        struct scic_sds_remote_device *sci_dev);
 
 enum sci_status scic_sds_remote_device_default_fail_handler(
-        struct scic_sds_remote_device *this_device);
+        struct scic_sds_remote_device *sci_dev);
 
 enum sci_status scic_sds_remote_device_default_destruct_handler(
-        struct scic_sds_remote_device *this_device);
+        struct scic_sds_remote_device *sci_dev);
 
 enum sci_status scic_sds_remote_device_default_reset_handler(
         struct scic_sds_remote_device *device);
@@ -654,15 +654,15 @@ enum sci_status scic_sds_remote_device_default_continue_request_handler(
         struct scic_sds_request *request);
 
 enum sci_status scic_sds_remote_device_default_suspend_handler(
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         u32 suspend_type);
 
 enum sci_status scic_sds_remote_device_default_resume_handler(
-        struct scic_sds_remote_device *this_device);
+        struct scic_sds_remote_device *sci_dev);
 
 
 enum sci_status scic_sds_remote_device_default_frame_handler(
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         u32 frame_index);
 
 enum sci_status scic_sds_remote_device_ready_state_stop_handler(
@@ -672,14 +672,14 @@ enum sci_status scic_sds_remote_device_ready_state_reset_handler(
         struct scic_sds_remote_device *device);
 
 enum sci_status scic_sds_remote_device_general_frame_handler(
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         u32 frame_index);
 
 enum sci_status scic_sds_remote_device_general_event_handler(
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         u32 event_code);
 
 enum sci_status scic_sds_ssp_remote_device_ready_suspended_substate_resume_handler(
-        struct scic_sds_remote_device *this_device);
+        struct scic_sds_remote_device *sci_dev);
 
 #endif /* _SCIC_SDS_REMOTE_DEVICE_H_ */
diff --git a/drivers/scsi/isci/core/scic_sds_remote_node_context.c b/drivers/scsi/isci/core/scic_sds_remote_node_context.c
index 81e4ab34dd30..e329296fa386 100644
--- a/drivers/scsi/isci/core/scic_sds_remote_node_context.c
+++ b/drivers/scsi/isci/core/scic_sds_remote_node_context.c
@@ -67,7 +67,7 @@
 
 /**
  *
- * @this_rnc: The RNC for which the is posted request is being made.
+ * @sci_rnc: The RNC for which the is posted request is being made.
  *
  * This method will return true if the RNC is not in the initial state.  In all
  * other states the RNC is considered active and this will return true. The
@@ -79,16 +79,16 @@
 
 /**
  *
- * @this_rnc: The state of the remote node context object to check.
+ * @sci_rnc: The state of the remote node context object to check.
  *
  * This method will return true if the remote node context is in a READY state
  * otherwise it will return false bool true if the remote node context is in
  * the ready state. false if the remote node context is not in the ready state.
  */
 bool scic_sds_remote_node_context_is_ready(
-        struct scic_sds_remote_node_context *this_rnc)
+        struct scic_sds_remote_node_context *sci_rnc)
 {
-        u32 current_state = sci_base_state_machine_get_state(&this_rnc->state_machine);
+        u32 current_state = sci_base_state_machine_get_state(&sci_rnc->state_machine);
 
         if (current_state == SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE) {
                 return true;
@@ -99,36 +99,36 @@ bool scic_sds_remote_node_context_is_ready(
 
 /**
  *
- * @this_device: The remote device to use to construct the RNC buffer.
+ * @sci_dev: The remote device to use to construct the RNC buffer.
  * @rnc: The buffer into which the remote device data will be copied.
  *
  * This method will construct the RNC buffer for this remote device object. none
  */
 static void scic_sds_remote_node_context_construct_buffer(
-        struct scic_sds_remote_node_context *this_rnc)
+        struct scic_sds_remote_node_context *sci_rnc)
 {
         union scu_remote_node_context *rnc;
-        struct scic_sds_controller *the_controller;
+        struct scic_sds_controller *scic;
 
-        the_controller = scic_sds_remote_device_get_controller(this_rnc->device);
+        scic = scic_sds_remote_device_get_controller(sci_rnc->device);
 
         rnc = scic_sds_controller_get_remote_node_context_buffer(
-                the_controller, this_rnc->remote_node_index);
+                scic, sci_rnc->remote_node_index);
 
         memset(
                 rnc,
                 0x00,
                 sizeof(union scu_remote_node_context)
-                * scic_sds_remote_device_node_count(this_rnc->device)
+                * scic_sds_remote_device_node_count(sci_rnc->device)
                 );
 
-        rnc->ssp.remote_node_index = this_rnc->remote_node_index;
-        rnc->ssp.remote_node_port_width = this_rnc->device->device_port_width;
+        rnc->ssp.remote_node_index = sci_rnc->remote_node_index;
+        rnc->ssp.remote_node_port_width = sci_rnc->device->device_port_width;
         rnc->ssp.logical_port_index =
-                scic_sds_remote_device_get_port_index(this_rnc->device);
+                scic_sds_remote_device_get_port_index(sci_rnc->device);
 
-        rnc->ssp.remote_sas_address_hi = SCIC_SWAP_DWORD(this_rnc->device->device_address.high);
-        rnc->ssp.remote_sas_address_lo = SCIC_SWAP_DWORD(this_rnc->device->device_address.low);
+        rnc->ssp.remote_sas_address_hi = SCIC_SWAP_DWORD(sci_rnc->device->device_address.high);
+        rnc->ssp.remote_sas_address_lo = SCIC_SWAP_DWORD(sci_rnc->device->device_address.low);
 
         rnc->ssp.nexus_loss_timer_enable = true;
         rnc->ssp.check_bit               = false;
@@ -140,24 +140,24 @@ static void scic_sds_remote_node_context_construct_buffer(
 
 
         if (
-                this_rnc->device->target_protocols.u.bits.attached_sata_device
-                || this_rnc->device->target_protocols.u.bits.attached_stp_target
+                sci_rnc->device->target_protocols.u.bits.attached_sata_device
+                || sci_rnc->device->target_protocols.u.bits.attached_stp_target
                 ) {
                 rnc->ssp.connection_occupancy_timeout =
-                        the_controller->user_parameters.sds1.stp_max_occupancy_timeout;
+                        scic->user_parameters.sds1.stp_max_occupancy_timeout;
                 rnc->ssp.connection_inactivity_timeout =
-                        the_controller->user_parameters.sds1.stp_inactivity_timeout;
+                        scic->user_parameters.sds1.stp_inactivity_timeout;
         } else {
                 rnc->ssp.connection_occupancy_timeout  =
-                        the_controller->user_parameters.sds1.ssp_max_occupancy_timeout;
+                        scic->user_parameters.sds1.ssp_max_occupancy_timeout;
                 rnc->ssp.connection_inactivity_timeout =
-                        the_controller->user_parameters.sds1.ssp_inactivity_timeout;
+                        scic->user_parameters.sds1.ssp_inactivity_timeout;
         }
 
         rnc->ssp.initial_arbitration_wait_time = 0;
 
         /* Open Address Frame Parameters */
-        rnc->ssp.oaf_connection_rate = this_rnc->device->connection_rate;
+        rnc->ssp.oaf_connection_rate = sci_rnc->device->connection_rate;
         rnc->ssp.oaf_features = 0;
         rnc->ssp.oaf_source_zone_group = 0;
         rnc->ssp.oaf_more_compatibility_features = 0;
@@ -165,8 +165,8 @@ static void scic_sds_remote_node_context_construct_buffer(
 
 /**
  *
- * @this_rnc:
- * @the_callback:
+ * @sci_rnc:
+ * @callback:
  * @callback_parameter:
  *
  * This method will setup the remote node context object so it will transition
@@ -174,52 +174,52 @@ static void scic_sds_remote_node_context_construct_buffer(
  * transition to its final state then this function does nothing. none
  */
 static void scic_sds_remote_node_context_setup_to_resume(
-        struct scic_sds_remote_node_context *this_rnc,
-        scics_sds_remote_node_context_callback the_callback,
+        struct scic_sds_remote_node_context *sci_rnc,
+        scics_sds_remote_node_context_callback callback,
         void *callback_parameter)
 {
-        if (this_rnc->destination_state != SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_FINAL) {
-                this_rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_READY;
-                this_rnc->user_callback     = the_callback;
-                this_rnc->user_cookie       = callback_parameter;
+        if (sci_rnc->destination_state != SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_FINAL) {
+                sci_rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_READY;
+                sci_rnc->user_callback     = callback;
+                sci_rnc->user_cookie       = callback_parameter;
         }
 }
 
 /**
  *
- * @this_rnc:
- * @the_callback:
+ * @sci_rnc:
+ * @callback:
  * @callback_parameter:
  *
  * This method will setup the remote node context object so it will transistion
  * to its final state. none
  */
 static void scic_sds_remote_node_context_setup_to_destory(
-        struct scic_sds_remote_node_context *this_rnc,
-        scics_sds_remote_node_context_callback the_callback,
+        struct scic_sds_remote_node_context *sci_rnc,
+        scics_sds_remote_node_context_callback callback,
         void *callback_parameter)
 {
-        this_rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_FINAL;
-        this_rnc->user_callback     = the_callback;
-        this_rnc->user_cookie       = callback_parameter;
+        sci_rnc->destination_state = SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_FINAL;
+        sci_rnc->user_callback     = callback;
+        sci_rnc->user_cookie       = callback_parameter;
 }
 
 /**
  *
- * @this_rnc:
- * @the_callback:
+ * @sci_rnc:
+ * @callback:
  *
  * This method will continue to resume a remote node context.  This is used in
  * the states where a resume is requested while a resume is in progress.
  */
 static enum sci_status scic_sds_remote_node_context_continue_to_resume_handler(
-        struct scic_sds_remote_node_context *this_rnc,
-        scics_sds_remote_node_context_callback the_callback,
+        struct scic_sds_remote_node_context *sci_rnc,
+        scics_sds_remote_node_context_callback callback,
         void *callback_parameter)
 {
-        if (this_rnc->destination_state == SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_READY) {
-                this_rnc->user_callback = the_callback;
-                this_rnc->user_cookie   = callback_parameter;
+        if (sci_rnc->destination_state == SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_READY) {
+                sci_rnc->user_callback = callback;
+                sci_rnc->user_cookie   = callback_parameter;
 
                 return SCI_SUCCESS;
         }
@@ -230,16 +230,16 @@ static enum sci_status scic_sds_remote_node_context_continue_to_resume_handler(
 /* --------------------------------------------------------------------------- */
 
 static enum sci_status scic_sds_remote_node_context_default_destruct_handler(
-        struct scic_sds_remote_node_context *this_rnc,
-        scics_sds_remote_node_context_callback the_callback,
+        struct scic_sds_remote_node_context *sci_rnc,
+        scics_sds_remote_node_context_callback callback,
         void *callback_parameter)
 {
-        dev_warn(scirdev_to_dev(this_rnc->device),
+        dev_warn(scirdev_to_dev(sci_rnc->device),
                  "%s: SCIC Remote Node Context 0x%p requested to stop while "
                  "in unexpected state %d\n",
                  __func__,
-                 this_rnc,
-                 sci_base_state_machine_get_state(&this_rnc->state_machine));
+                 sci_rnc,
+                 sci_base_state_machine_get_state(&sci_rnc->state_machine));
 
         /*
          * We have decided that the destruct request on the remote node context can not fail
@@ -248,101 +248,101 @@ static enum sci_status scic_sds_remote_node_context_default_destruct_handler(
 }
 
 static enum sci_status scic_sds_remote_node_context_default_suspend_handler(
-        struct scic_sds_remote_node_context *this_rnc,
+        struct scic_sds_remote_node_context *sci_rnc,
         u32 suspend_type,
-        scics_sds_remote_node_context_callback the_callback,
+        scics_sds_remote_node_context_callback callback,
         void *callback_parameter)
 {
-        dev_warn(scirdev_to_dev(this_rnc->device),
+        dev_warn(scirdev_to_dev(sci_rnc->device),
                  "%s: SCIC Remote Node Context 0x%p requested to suspend "
                  "while in wrong state %d\n",
                  __func__,
-                 this_rnc,
-                 sci_base_state_machine_get_state(&this_rnc->state_machine));
+                 sci_rnc,
+                 sci_base_state_machine_get_state(&sci_rnc->state_machine));
 
         return SCI_FAILURE_INVALID_STATE;
 }
 
 static enum sci_status scic_sds_remote_node_context_default_resume_handler(
-        struct scic_sds_remote_node_context *this_rnc,
-        scics_sds_remote_node_context_callback the_callback,
+        struct scic_sds_remote_node_context *sci_rnc,
+        scics_sds_remote_node_context_callback callback,
         void *callback_parameter)
 {
-        dev_warn(scirdev_to_dev(this_rnc->device),
+        dev_warn(scirdev_to_dev(sci_rnc->device),
                  "%s: SCIC Remote Node Context 0x%p requested to resume "
                  "while in wrong state %d\n",
                  __func__,
-                 this_rnc,
-                 sci_base_state_machine_get_state(&this_rnc->state_machine));
+                 sci_rnc,
+                 sci_base_state_machine_get_state(&sci_rnc->state_machine));
 
         return SCI_FAILURE_INVALID_STATE;
 }
 
 static enum sci_status scic_sds_remote_node_context_default_start_io_handler(
-        struct scic_sds_remote_node_context *this_rnc,
-        struct scic_sds_request *the_request)
+        struct scic_sds_remote_node_context *sci_rnc,
+        struct scic_sds_request *sci_req)
 {
-        dev_warn(scirdev_to_dev(this_rnc->device),
+        dev_warn(scirdev_to_dev(sci_rnc->device),
                  "%s: SCIC Remote Node Context 0x%p requested to start io "
                  "0x%p while in wrong state %d\n",
                  __func__,
-                 this_rnc,
-                 the_request,
-                 sci_base_state_machine_get_state(&this_rnc->state_machine));
+                 sci_rnc,
+                 sci_req,
+                 sci_base_state_machine_get_state(&sci_rnc->state_machine));
 
         return SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED;
 }
 
 static enum sci_status scic_sds_remote_node_context_default_start_task_handler(
-        struct scic_sds_remote_node_context *this_rnc,
-        struct scic_sds_request *the_request)
+        struct scic_sds_remote_node_context *sci_rnc,
+        struct scic_sds_request *sci_req)
 {
-        dev_warn(scirdev_to_dev(this_rnc->device),
+        dev_warn(scirdev_to_dev(sci_rnc->device),
                  "%s: SCIC Remote Node Context 0x%p requested to start "
                  "task 0x%p while in wrong state %d\n",
                  __func__,
-                 this_rnc,
-                 the_request,
-                 sci_base_state_machine_get_state(&this_rnc->state_machine));
+                 sci_rnc,
+                 sci_req,
+                 sci_base_state_machine_get_state(&sci_rnc->state_machine));
 
         return SCI_FAILURE;
 }
 
 static enum sci_status scic_sds_remote_node_context_default_event_handler(
-        struct scic_sds_remote_node_context *this_rnc,
+        struct scic_sds_remote_node_context *sci_rnc,
         u32 event_code)
 {
-        dev_warn(scirdev_to_dev(this_rnc->device),
+        dev_warn(scirdev_to_dev(sci_rnc->device),
                  "%s: SCIC Remote Node Context 0x%p requested to process "
                  "event 0x%x while in wrong state %d\n",
                  __func__,
-                 this_rnc,
+                 sci_rnc,
                  event_code,
-                 sci_base_state_machine_get_state(&this_rnc->state_machine));
+                 sci_base_state_machine_get_state(&sci_rnc->state_machine));
 
         return SCI_FAILURE_INVALID_STATE;
 }
 
 /**
  *
- * @this_rnc: The rnc for which the task request is targeted.
- * @the_request: The request which is going to be started.
+ * @sci_rnc: The rnc for which the task request is targeted.
+ * @sci_req: The request which is going to be started.
  *
  * This method determines if the task request can be started by the SCU
  * hardware. When the RNC is in the ready state any task can be started.
  * enum sci_status SCI_SUCCESS
  */
 static enum sci_status scic_sds_remote_node_context_success_start_task_handler(
-        struct scic_sds_remote_node_context *this_rnc,
-        struct scic_sds_request *the_request)
+        struct scic_sds_remote_node_context *sci_rnc,
+        struct scic_sds_request *sci_req)
 {
         return SCI_SUCCESS;
 }
 
 /**
  *
- * @this_rnc:
- * @the_callback:
+ * @sci_rnc:
+ * @callback:
  * @callback_parameter:
  *
  * This method handles destruct calls from the various state handlers.  The
@@ -351,16 +351,16 @@ static enum sci_status scic_sds_remote_node_context_success_start_task_handler(
  * callback. enum sci_status
  */
 static enum sci_status scic_sds_remote_node_context_general_destruct_handler(
-        struct scic_sds_remote_node_context *this_rnc,
-        scics_sds_remote_node_context_callback the_callback,
+        struct scic_sds_remote_node_context *sci_rnc,
+        scics_sds_remote_node_context_callback callback,
         void *callback_parameter)
 {
         scic_sds_remote_node_context_setup_to_destory(
-                this_rnc, the_callback, callback_parameter
+                sci_rnc, callback, callback_parameter
                 );
 
         sci_base_state_machine_change_state(
-                &this_rnc->state_machine,
+                &sci_rnc->state_machine,
                 SCIC_SDS_REMOTE_NODE_CONTEXT_INVALIDATING_STATE
                 );
 
@@ -370,19 +370,19 @@ static enum sci_status scic_sds_remote_node_context_general_destruct_handler(
 /* --------------------------------------------------------------------------- */
 
 static enum sci_status scic_sds_remote_node_context_initial_state_resume_handler(
-        struct scic_sds_remote_node_context *this_rnc,
-        scics_sds_remote_node_context_callback the_callback,
+        struct scic_sds_remote_node_context *sci_rnc,
+        scics_sds_remote_node_context_callback callback,
         void *callback_parameter)
 {
-        if (this_rnc->remote_node_index != SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX) {
+        if (sci_rnc->remote_node_index != SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX) {
                 scic_sds_remote_node_context_setup_to_resume(
-                        this_rnc, the_callback, callback_parameter
+                        sci_rnc, callback, callback_parameter
                         );
 
-                scic_sds_remote_node_context_construct_buffer(this_rnc);
+                scic_sds_remote_node_context_construct_buffer(sci_rnc);
 
                 sci_base_state_machine_change_state(
-                        &this_rnc->state_machine,
+                        &sci_rnc->state_machine,
                         SCIC_SDS_REMOTE_NODE_CONTEXT_POSTING_STATE
                         );
 
@@ -395,7 +395,7 @@ static enum sci_status scic_sds_remote_node_context_initial_state_resume_handler
 /* --------------------------------------------------------------------------- */
 
 static enum sci_status scic_sds_remote_node_context_posting_state_event_handler(
-        struct scic_sds_remote_node_context *this_rnc,
+        struct scic_sds_remote_node_context *sci_rnc,
         u32 event_code)
 {
         enum sci_status status;
@@ -405,19 +405,19 @@ static enum sci_status scic_sds_remote_node_context_posting_state_event_handler(
                 status = SCI_SUCCESS;
 
                 sci_base_state_machine_change_state(
-                        &this_rnc->state_machine,
+                        &sci_rnc->state_machine,
                         SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE
                         );
                 break;
 
         default:
                 status = SCI_FAILURE;
-                dev_warn(scirdev_to_dev(this_rnc->device),
+                dev_warn(scirdev_to_dev(sci_rnc->device),
                          "%s: SCIC Remote Node Context 0x%p requested to "
                          "process unexpected event 0x%x while in posting "
                          "state\n",
                          __func__,
-                         this_rnc,
+                         sci_rnc,
                          event_code);
                 break;
         }
@@ -428,19 +428,19 @@ static enum sci_status scic_sds_remote_node_context_posting_state_event_handler(
 /* --------------------------------------------------------------------------- */
 
 static enum sci_status scic_sds_remote_node_context_invalidating_state_destruct_handler(
-        struct scic_sds_remote_node_context *this_rnc,
-        scics_sds_remote_node_context_callback the_callback,
+        struct scic_sds_remote_node_context *sci_rnc,
+        scics_sds_remote_node_context_callback callback,
         void *callback_parameter)
 {
         scic_sds_remote_node_context_setup_to_destory(
-                this_rnc, the_callback, callback_parameter
+                sci_rnc, callback, callback_parameter
                 );
 
         return SCI_SUCCESS;
 }
 
 static enum sci_status scic_sds_remote_node_context_invalidating_state_event_handler(
-        struct scic_sds_remote_node_context *this_rnc,
+        struct scic_sds_remote_node_context *sci_rnc,
         u32 event_code)
 {
         enum sci_status status;
@@ -448,14 +448,14 @@ static enum sci_status scic_sds_remote_node_context_invalidating_state_event_han
         if (scu_get_event_code(event_code) == SCU_EVENT_POST_RNC_INVALIDATE_COMPLETE) {
                 status = SCI_SUCCESS;
 
-                if (this_rnc->destination_state == SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_FINAL) {
+                if (sci_rnc->destination_state == SCIC_SDS_REMOTE_NODE_DESTINATION_STATE_FINAL) {
                         sci_base_state_machine_change_state(
-                                &this_rnc->state_machine,
+                                &sci_rnc->state_machine,
                                 SCIC_SDS_REMOTE_NODE_CONTEXT_INITIAL_STATE
                                 );
                 } else {
                         sci_base_state_machine_change_state(
-                                &this_rnc->state_machine,
+                                &sci_rnc->state_machine,
                                 SCIC_SDS_REMOTE_NODE_CONTEXT_POSTING_STATE
                                 );
                 }
@@ -466,25 +466,25 @@ static enum sci_status scic_sds_remote_node_context_invalidating_state_event_han
                         /*
                          * We really dont care if the hardware is going to suspend
                          * the device since it's being invalidated anyway */
-                        dev_dbg(scirdev_to_dev(this_rnc->device),
+                        dev_dbg(scirdev_to_dev(sci_rnc->device),
                                 "%s: SCIC Remote Node Context 0x%p was "
                                 "suspeneded by hardware while being "
                                 "invalidated.\n",
                                 __func__,
-                                this_rnc);
+                                sci_rnc);
                         status = SCI_SUCCESS;
                         break;
 
                 default:
-                        dev_warn(scirdev_to_dev(this_rnc->device),
+                        dev_warn(scirdev_to_dev(sci_rnc->device),
                                  "%s: SCIC Remote Node Context 0x%p "
                                  "requested to process event 0x%x while "
                                  "in state %d.\n",
                                  __func__,
-                                 this_rnc,
+                                 sci_rnc,
                                  event_code,
                                  sci_base_state_machine_get_state(
-                                         &this_rnc->state_machine));
+                                         &sci_rnc->state_machine));
                         status = SCI_FAILURE;
                         break;
                 }
@@ -497,7 +497,7 @@ static enum sci_status scic_sds_remote_node_context_invalidating_state_event_han
 
 
 static enum sci_status scic_sds_remote_node_context_resuming_state_event_handler(
-        struct scic_sds_remote_node_context *this_rnc,
+        struct scic_sds_remote_node_context *sci_rnc,
         u32 event_code)
 {
         enum sci_status status;
@@ -506,7 +506,7 @@ static enum sci_status scic_sds_remote_node_context_resuming_state_event_handler
                 status = SCI_SUCCESS;
 
                 sci_base_state_machine_change_state(
-                        &this_rnc->state_machine,
+                        &sci_rnc->state_machine,
                         SCIC_SDS_REMOTE_NODE_CONTEXT_READY_STATE
                         );
         } else {
@@ -516,23 +516,23 @@ static enum sci_status scic_sds_remote_node_context_resuming_state_event_handler
                         /*
                          * We really dont care if the hardware is going to suspend
                          * the device since it's being resumed anyway */
-                        dev_dbg(scirdev_to_dev(this_rnc->device),
+                        dev_dbg(scirdev_to_dev(sci_rnc->device),
                                 "%s: SCIC Remote Node Context 0x%p was "
                                 "suspeneded by hardware while being resumed.\n",
                                 __func__,
-                                this_rnc);
+                                sci_rnc);
                         status = SCI_SUCCESS;
                         break;
 
                 default:
-                        dev_warn(scirdev_to_dev(this_rnc->device),
+                        dev_warn(scirdev_to_dev(sci_rnc->device),
                                  "%s: SCIC Remote Node Context 0x%p requested "
                                  "to process event 0x%x while in state %d.\n",
                                  __func__,
-                                 this_rnc,
+                                 sci_rnc,
                                  event_code,
                                  sci_base_state_machine_get_state(
-                                         &this_rnc->state_machine));
+                                         &sci_rnc->state_machine));
                         status = SCI_FAILURE;
                         break;
                 }
@@ -545,32 +545,32 @@ static enum sci_status scic_sds_remote_node_context_resuming_state_event_handler
 
 /**
  *
- * @this_rnc: The remote node context object being suspended.
- * @the_callback: The callback when the suspension is complete.
+ * @sci_rnc: The remote node context object being suspended.
+ * @callback: The callback when the suspension is complete.
  * @callback_parameter: The parameter that is to be passed into the callback.
  *
  * This method will handle the suspend requests from the ready state.
  * SCI_SUCCESS
  */
 static enum sci_status scic_sds_remote_node_context_ready_state_suspend_handler(
-        struct scic_sds_remote_node_context *this_rnc,
+        struct scic_sds_remote_node_context *sci_rnc,
         u32 suspend_type,
-        scics_sds_remote_node_context_callback the_callback,
+        scics_sds_remote_node_context_callback callback,
         void *callback_parameter)
 {
-        this_rnc->user_callback   = the_callback;
-        this_rnc->user_cookie     = callback_parameter;
-        this_rnc->suspension_code = suspend_type;
+        sci_rnc->user_callback   = callback;
+        sci_rnc->user_cookie     = callback_parameter;
+        sci_rnc->suspension_code = suspend_type;
 
         if (suspend_type == SCI_SOFTWARE_SUSPENSION) {
                 scic_sds_remote_device_post_request(
-                        this_rnc->device,
+                        sci_rnc->device,
                         SCU_CONTEXT_COMMAND_POST_RNC_SUSPEND_TX
                         );
         }
 
         sci_base_state_machine_change_state(
-                &this_rnc->state_machine,
+                &sci_rnc->state_machine,
                 SCIC_SDS_REMOTE_NODE_CONTEXT_AWAIT_SUSPENSION_STATE
                 );
 
@@ -579,23 +579,23 @@ static enum sci_status scic_sds_remote_node_context_ready_state_suspend_handler(
 
 /**
  *
- * @this_rnc: The rnc for which the io request is targeted.
- * @the_request: The request which is going to be started.
+ * @sci_rnc: The rnc for which the io request is targeted.
+ * @sci_req: The request which is going to be started.
  *
  * This method determines if the io request can be started by the SCU hardware.
  * When the RNC is in the ready state any io request can be started. enum sci_status
  * SCI_SUCCESS
  */
 static enum sci_status scic_sds_remote_node_context_ready_state_start_io_handler(
-        struct scic_sds_remote_node_context *this_rnc,
-        struct scic_sds_request *the_request)
+        struct scic_sds_remote_node_context *sci_rnc,
+        struct scic_sds_request *sci_req)
 {
         return SCI_SUCCESS;
 }
 
 
 static enum sci_status scic_sds_remote_node_context_ready_state_event_handler(
-        struct scic_sds_remote_node_context *this_rnc,
+        struct scic_sds_remote_node_context *sci_rnc,
         u32 event_code)
 {
         enum sci_status status;
@@ -603,33 +603,33 @@ static enum sci_status scic_sds_remote_node_context_ready_state_event_handler(
         switch (scu_get_event_type(event_code)) {
         case SCU_EVENT_TL_RNC_SUSPEND_TX:
                 sci_base_state_machine_change_state(
-                        &this_rnc->state_machine,
+                        &sci_rnc->state_machine,
                         SCIC_SDS_REMOTE_NODE_CONTEXT_TX_SUSPENDED_STATE
                         );
 
-                this_rnc->suspension_code = scu_get_event_specifier(event_code);
+                sci_rnc->suspension_code = scu_get_event_specifier(event_code);
                 status = SCI_SUCCESS;
                 break;
 
         case SCU_EVENT_TL_RNC_SUSPEND_TX_RX:
                 sci_base_state_machine_change_state(
-                        &this_rnc->state_machine,
+                        &sci_rnc->state_machine,
                         SCIC_SDS_REMOTE_NODE_CONTEXT_TX_RX_SUSPENDED_STATE
                         );
 
-                this_rnc->suspension_code = scu_get_event_specifier(event_code);
+                sci_rnc->suspension_code = scu_get_event_specifier(event_code);
                 status = SCI_SUCCESS;
                 break;
 
         default:
-                dev_warn(scirdev_to_dev(this_rnc->device),
+                dev_warn(scirdev_to_dev(sci_rnc->device),
                         "%s: SCIC Remote Node Context 0x%p requested to "
                         "process event 0x%x while in state %d.\n",
                         __func__,
-                        this_rnc,
+                        sci_rnc,
                         event_code,
                         sci_base_state_machine_get_state(
-                                &this_rnc->state_machine));
+                                &sci_rnc->state_machine));
 
                 status = SCI_FAILURE;
                 break;
@@ -641,41 +641,41 @@ static enum sci_status scic_sds_remote_node_context_ready_state_event_handler(
 /* --------------------------------------------------------------------------- */
 
 static enum sci_status scic_sds_remote_node_context_tx_suspended_state_resume_handler(
-        struct scic_sds_remote_node_context *this_rnc,
-        scics_sds_remote_node_context_callback the_callback,
+        struct scic_sds_remote_node_context *sci_rnc,
+        scics_sds_remote_node_context_callback callback,
         void *callback_parameter)
 {
         enum sci_status status;
         struct smp_discover_response_protocols protocols;
 
         scic_sds_remote_node_context_setup_to_resume(
-                this_rnc, the_callback, callback_parameter
+                sci_rnc, callback, callback_parameter
                 );
 
         /* TODO: consider adding a resume action of NONE, INVALIDATE, WRITE_TLCR */
 
-        scic_remote_device_get_protocols(this_rnc->device, &protocols);
+        scic_remote_device_get_protocols(sci_rnc->device, &protocols);
 
         if (
                 (protocols.u.bits.attached_ssp_target == 1)
                 || (protocols.u.bits.attached_smp_target == 1)
                 ) {
                 sci_base_state_machine_change_state(
-                        &this_rnc->state_machine,
+                        &sci_rnc->state_machine,
                         SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE
                         );
 
                 status = SCI_SUCCESS;
         } else if (protocols.u.bits.attached_stp_target == 1) {
-                if (this_rnc->device->is_direct_attached) {
+                if (sci_rnc->device->is_direct_attached) {
                         /* @todo Fix this since I am being silly in writing to the STPTLDARNI register. */
                         sci_base_state_machine_change_state(
-                                &this_rnc->state_machine,
+                                &sci_rnc->state_machine,
                                 SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE
                                 );
                 } else {
                         sci_base_state_machine_change_state(
-                                &this_rnc->state_machine,
+                                &sci_rnc->state_machine,
                                 SCIC_SDS_REMOTE_NODE_CONTEXT_INVALIDATING_STATE
                                 );
                 }
@@ -690,8 +690,8 @@ static enum sci_status scic_sds_remote_node_context_tx_suspended_state_resume_ha
 
 /**
  *
- * @this_rnc: The remote node context which is to receive the task request.
- * @the_request: The task request to be transmitted to to the remote target
+ * @sci_rnc: The remote node context which is to receive the task request.
+ * @sci_req: The task request to be transmitted to to the remote target
  *    device.
  *
  * This method will report a success or failure attempt to start a new task
@@ -700,10 +700,10 @@ static enum sci_status scic_sds_remote_node_context_tx_suspended_state_resume_ha
  * enum sci_status SCI_SUCCESS
  */
 static enum sci_status scic_sds_remote_node_context_suspended_start_task_handler(
-        struct scic_sds_remote_node_context *this_rnc,
-        struct scic_sds_request *the_request)
+        struct scic_sds_remote_node_context *sci_rnc,
+        struct scic_sds_request *sci_req)
 {
-        scic_sds_remote_node_context_resume(this_rnc, NULL, NULL);
+        scic_sds_remote_node_context_resume(sci_rnc, NULL, NULL);
 
         return SCI_SUCCESS;
 }
@@ -711,16 +711,16 @@ static enum sci_status scic_sds_remote_node_context_suspended_start_task_handler
 /* --------------------------------------------------------------------------- */
 
 static enum sci_status scic_sds_remote_node_context_tx_rx_suspended_state_resume_handler(
-        struct scic_sds_remote_node_context *this_rnc,
-        scics_sds_remote_node_context_callback the_callback,
+        struct scic_sds_remote_node_context *sci_rnc,
+        scics_sds_remote_node_context_callback callback,
         void *callback_parameter)
 {
         scic_sds_remote_node_context_setup_to_resume(
-                this_rnc, the_callback, callback_parameter
+                sci_rnc, callback, callback_parameter
                 );
 
         sci_base_state_machine_change_state(
-                &this_rnc->state_machine,
+                &sci_rnc->state_machine,
                 SCIC_SDS_REMOTE_NODE_CONTEXT_RESUMING_STATE
                 );
 
@@ -735,12 +735,12 @@ static enum sci_status scic_sds_remote_node_context_tx_rx_suspended_state_resume
  *
  */
 static enum sci_status scic_sds_remote_node_context_await_suspension_state_resume_handler(
-        struct scic_sds_remote_node_context *this_rnc,
-        scics_sds_remote_node_context_callback the_callback,
+        struct scic_sds_remote_node_context *sci_rnc,
+        scics_sds_remote_node_context_callback callback,
         void *callback_parameter)
 {
         scic_sds_remote_node_context_setup_to_resume(
-                this_rnc, the_callback, callback_parameter
+                sci_rnc, callback, callback_parameter
                 );
 
         return SCI_SUCCESS;
@@ -748,8 +748,8 @@ static enum sci_status scic_sds_remote_node_context_await_suspension_state_resum
 
 /**
  *
- * @this_rnc: The remote node context which is to receive the task request.
- * @the_request: The task request to be transmitted to to the remote target
+ * @sci_rnc: The remote node context which is to receive the task request.
+ * @sci_req: The task request to be transmitted to to the remote target
  *    device.
  *
  * This method will report a success or failure attempt to start a new task
@@ -758,14 +758,14 @@ static enum sci_status scic_sds_remote_node_context_await_suspension_state_resum
  * enum sci_status SCI_SUCCESS
  */
 static enum sci_status scic_sds_remote_node_context_await_suspension_state_start_task_handler(
-        struct scic_sds_remote_node_context *this_rnc,
-        struct scic_sds_request *the_request)
+        struct scic_sds_remote_node_context *sci_rnc,
+        struct scic_sds_request *sci_req)
 {
         return SCI_SUCCESS;
 }
 
 static enum sci_status scic_sds_remote_node_context_await_suspension_state_event_handler(
-        struct scic_sds_remote_node_context *this_rnc,
+        struct scic_sds_remote_node_context *sci_rnc,
         u32 event_code)
 {
         enum sci_status status;
@@ -773,33 +773,33 @@ static enum sci_status scic_sds_remote_node_context_await_suspension_state_event
         switch (scu_get_event_type(event_code)) {
         case SCU_EVENT_TL_RNC_SUSPEND_TX:
                 sci_base_state_machine_change_state(
-                        &this_rnc->state_machine,
+                        &sci_rnc->state_machine,
                         SCIC_SDS_REMOTE_NODE_CONTEXT_TX_SUSPENDED_STATE
                         );
 
-                this_rnc->suspension_code = scu_get_event_specifier(event_code);
+                sci_rnc->suspension_code = scu_get_event_specifier(event_code);
                 status = SCI_SUCCESS;
                 break;
 
         case SCU_EVENT_TL_RNC_SUSPEND_TX_RX:
                 sci_base_state_machine_change_state(
-                        &this_rnc->state_machine,
+                        &sci_rnc->state_machine,
                         SCIC_SDS_REMOTE_NODE_CONTEXT_TX_RX_SUSPENDED_STATE
                         );
 
-                this_rnc->suspension_code = scu_get_event_specifier(event_code);
+                sci_rnc->suspension_code = scu_get_event_specifier(event_code);
                 status = SCI_SUCCESS;
                 break;
 
         default:
-                dev_warn(scirdev_to_dev(this_rnc->device),
+                dev_warn(scirdev_to_dev(sci_rnc->device),
                          "%s: SCIC Remote Node Context 0x%p requested to "
                          "process event 0x%x while in state %d.\n",
                          __func__,
-                         this_rnc,
+                         sci_rnc,
                          event_code,
                          sci_base_state_machine_get_state(
-                                 &this_rnc->state_machine));
+                                 &sci_rnc->state_machine));
 
                 status = SCI_FAILURE;
                 break;
@@ -929,41 +929,41 @@ static void scic_sds_remote_node_context_continue_state_transitions(
 
 /**
  *
- * @this_rnc: The remote node context object that is to be validated.
+ * @sci_rnc: The remote node context object that is to be validated.
  *
  * This method will mark the rnc buffer as being valid and post the request to
  * the hardware. none
  */
 static void scic_sds_remote_node_context_validate_context_buffer(
-        struct scic_sds_remote_node_context *this_rnc)
+        struct scic_sds_remote_node_context *sci_rnc)
 {
         union scu_remote_node_context *rnc_buffer;
 
         rnc_buffer = scic_sds_controller_get_remote_node_context_buffer(
-                scic_sds_remote_device_get_controller(this_rnc->device),
-                this_rnc->remote_node_index
+                scic_sds_remote_device_get_controller(sci_rnc->device),
+                sci_rnc->remote_node_index
                 );
 
         rnc_buffer->ssp.is_valid = true;
 
         if (
-                !this_rnc->device->is_direct_attached
-                && this_rnc->device->target_protocols.u.bits.attached_stp_target
+                !sci_rnc->device->is_direct_attached
+                && sci_rnc->device->target_protocols.u.bits.attached_stp_target
                 ) {
                 scic_sds_remote_device_post_request(
-                        this_rnc->device,
+                        sci_rnc->device,
                         SCU_CONTEXT_COMMAND_POST_RNC_96
                         );
         } else {
                 scic_sds_remote_device_post_request(
-                        this_rnc->device,
+                        sci_rnc->device,
                         SCU_CONTEXT_COMMAND_POST_RNC_32
                         );
 
-                if (this_rnc->device->is_direct_attached) {
+                if (sci_rnc->device->is_direct_attached) {
                         scic_sds_port_setup_transports(
-                                this_rnc->device->owning_port,
-                                this_rnc->remote_node_index
+                                sci_rnc->device->owning_port,
+                                sci_rnc->remote_node_index
                                 );
                 }
         }
@@ -971,24 +971,24 @@ static void scic_sds_remote_node_context_validate_context_buffer(
 
 /**
  *
- * @this_rnc: The remote node context object that is to be invalidated.
+ * @sci_rnc: The remote node context object that is to be invalidated.
  *
  * This method will update the RNC buffer and post the invalidate request. none
  */
 static void scic_sds_remote_node_context_invalidate_context_buffer(
-        struct scic_sds_remote_node_context *this_rnc)
+        struct scic_sds_remote_node_context *sci_rnc)
 {
         union scu_remote_node_context *rnc_buffer;
 
         rnc_buffer = scic_sds_controller_get_remote_node_context_buffer(
-                scic_sds_remote_device_get_controller(this_rnc->device),
-                this_rnc->remote_node_index
+                scic_sds_remote_device_get_controller(sci_rnc->device),
+                sci_rnc->remote_node_index
                 );
 
         rnc_buffer->ssp.is_valid = false;
 
         scic_sds_remote_device_post_request(
-                this_rnc->device,
+                sci_rnc->device,
                 SCU_CONTEXT_COMMAND_POST_RNC_INVALIDATE
                 );
 }
@@ -1037,17 +1037,17 @@ static void scic_sds_remote_node_context_initial_state_enter(
 static void scic_sds_remote_node_context_posting_state_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_remote_node_context *this_rnc;
+        struct scic_sds_remote_node_context *sci_rnc;
 
-        this_rnc = (struct scic_sds_remote_node_context *)object;
+        sci_rnc = (struct scic_sds_remote_node_context *)object;
 
         SET_STATE_HANDLER(
-                this_rnc,
+                sci_rnc,
                 scic_sds_remote_node_context_state_handler_table,
                 SCIC_SDS_REMOTE_NODE_CONTEXT_POSTING_STATE
                 );
 
-        scic_sds_remote_node_context_validate_context_buffer(this_rnc);
+        scic_sds_remote_node_context_validate_context_buffer(sci_rnc);
 }
 
 /**
diff --git a/drivers/scsi/isci/core/scic_sds_remote_node_context.h b/drivers/scsi/isci/core/scic_sds_remote_node_context.h
index e21abe2c6523..a103f155bcc4 100644
--- a/drivers/scsi/isci/core/scic_sds_remote_node_context.h
+++ b/drivers/scsi/isci/core/scic_sds_remote_node_context.h
@@ -86,25 +86,25 @@ struct scic_sds_remote_node_context;
 typedef void (*scics_sds_remote_node_context_callback)(void *);
 
 typedef enum sci_status (*scic_sds_remote_node_context_operation)(
-        struct scic_sds_remote_node_context *this_rnc,
-        scics_sds_remote_node_context_callback the_callback,
+        struct scic_sds_remote_node_context *sci_rnc,
+        scics_sds_remote_node_context_callback callback,
         void *callback_parameter
         );
 
 typedef enum sci_status (*scic_sds_remote_node_context_suspend_operation)(
-        struct scic_sds_remote_node_context *this_rnc,
+        struct scic_sds_remote_node_context *sci_rnc,
         u32 suspension_type,
-        scics_sds_remote_node_context_callback the_callback,
+        scics_sds_remote_node_context_callback callback,
         void *callback_parameter
         );
 
 typedef enum sci_status (*scic_sds_remote_node_context_io_request)(
-        struct scic_sds_remote_node_context *this_rnc,
-        struct scic_sds_request *the_request
+        struct scic_sds_remote_node_context *sci_rnc,
+        struct scic_sds_request *sci_req
         );
 
 typedef enum sci_status (*scic_sds_remote_node_context_event_handler)(
-        struct scic_sds_remote_node_context *this_rnc,
+        struct scic_sds_remote_node_context *sci_rnc,
         u32 event_code
         );
 
@@ -286,7 +286,7 @@ void scic_sds_remote_node_context_construct(
 
 
 bool scic_sds_remote_node_context_is_ready(
-        struct scic_sds_remote_node_context *this_rnc);
+        struct scic_sds_remote_node_context *sci_rnc);
 
 #define scic_sds_remote_node_context_get_remote_node_index(rcn) \
         ((rnc)->remote_node_index)
diff --git a/drivers/scsi/isci/core/scic_sds_request.c b/drivers/scsi/isci/core/scic_sds_request.c
index a6ee155c6825..8a608f01ceda 100644
--- a/drivers/scsi/isci/core/scic_sds_request.c
+++ b/drivers/scsi/isci/core/scic_sds_request.c
@@ -226,7 +226,7 @@ static u32 scic_sds_ssp_request_get_object_size(void)
 
 /**
  * This method returns the sgl element pair for the specificed sgl_pair index.
- * @this_request: This parameter specifies the IO request for which to retrieve
+ * @sci_req: This parameter specifies the IO request for which to retrieve
  *    the Scatter-Gather List element pair.
  * @sgl_pair_index: This parameter specifies the index into the SGL element
  *    pair to be retrieved.
@@ -234,12 +234,12 @@ static u32 scic_sds_ssp_request_get_object_size(void)
  * This method returns a pointer to an struct scu_sgl_element_pair.
  */
 static struct scu_sgl_element_pair *scic_sds_request_get_sgl_element_pair(
-        struct scic_sds_request *this_request,
+        struct scic_sds_request *sci_req,
         u32 sgl_pair_index
         ) {
         struct scu_task_context *task_context;
 
-        task_context = (struct scu_task_context *)this_request->task_context_buffer;
+        task_context = (struct scu_task_context *)sci_req->task_context_buffer;
 
         if (sgl_pair_index == 0) {
                 return &task_context->sgl_pair_ab;
@@ -247,12 +247,12 @@ static struct scu_sgl_element_pair *scic_sds_request_get_sgl_element_pair(
                 return &task_context->sgl_pair_cd;
         }
 
-        return &this_request->sgl_element_pair_buffer[sgl_pair_index - 2];
+        return &sci_req->sgl_element_pair_buffer[sgl_pair_index - 2];
 }
 
 /**
  * This function will build the SGL list for an IO request.
- * @this_request: This parameter specifies the IO request for which to build
+ * @sci_req: This parameter specifies the IO request for which to build
  *    the Scatter-Gather List.
  *
  */
@@ -325,36 +325,36 @@ void scic_sds_request_build_sgl(struct scic_sds_request *sds_request)
 
 /**
  * This method build the remainder of the IO request object.
- * @this_request: This parameter specifies the request object being constructed.
+ * @sci_req: This parameter specifies the request object being constructed.
  *
  * The scic_sds_general_request_construct() must be called before this call is
  * valid. none
  */
 static void scic_sds_ssp_io_request_assign_buffers(
-        struct scic_sds_request *this_request)
+        struct scic_sds_request *sci_req)
 {
-        this_request->command_buffer =
-                scic_sds_ssp_request_get_command_buffer(this_request);
-        this_request->response_buffer =
-                scic_sds_ssp_request_get_response_buffer(this_request);
-        this_request->sgl_element_pair_buffer =
-                scic_sds_ssp_request_get_sgl_element_buffer(this_request);
-        this_request->sgl_element_pair_buffer =
-                PTR_ALIGN(this_request->sgl_element_pair_buffer,
+        sci_req->command_buffer =
+                scic_sds_ssp_request_get_command_buffer(sci_req);
+        sci_req->response_buffer =
+                scic_sds_ssp_request_get_response_buffer(sci_req);
+        sci_req->sgl_element_pair_buffer =
+                scic_sds_ssp_request_get_sgl_element_buffer(sci_req);
+        sci_req->sgl_element_pair_buffer =
+                PTR_ALIGN(sci_req->sgl_element_pair_buffer,
                           sizeof(struct scu_sgl_element_pair));
 
-        if (this_request->was_tag_assigned_by_user == false) {
-                this_request->task_context_buffer =
-                        scic_sds_ssp_request_get_task_context_buffer(this_request);
-                this_request->task_context_buffer =
-                        PTR_ALIGN(this_request->task_context_buffer,
+        if (sci_req->was_tag_assigned_by_user == false) {
+                sci_req->task_context_buffer =
+                        scic_sds_ssp_request_get_task_context_buffer(sci_req);
+                sci_req->task_context_buffer =
+                        PTR_ALIGN(sci_req->task_context_buffer,
                                   SMP_CACHE_BYTES);
         }
 }
 
 /**
  * This method constructs the SSP Command IU data for this io request object.
- * @this_request: This parameter specifies the request object for which the SSP
+ * @sci_req: This parameter specifies the request object for which the SSP
  *    command information unit is being built.
  *
  */
@@ -401,7 +401,7 @@ static void scic_sds_io_request_build_ssp_command_iu(
 
 /**
  * This method constructs the SSP Task IU data for this io request object.
- * @this_request:
+ * @sci_req:
  *
  */
 static void scic_sds_task_request_build_ssp_task_iu(
@@ -430,7 +430,7 @@ static void scic_sds_task_request_build_ssp_task_iu(
 
 /**
  * This method is will fill in the SCU Task Context for any type of SSP request.
- * @this_request:
+ * @sci_req:
  * @task_context:
  *
  */
@@ -474,7 +474,7 @@ static void scu_ssp_reqeust_construct_task_context(
 
         task_context->address_modifier = 0;
 
-        /* task_context->type.ssp.tag = this_request->io_tag; */
+        /* task_context->type.ssp.tag = sci_req->io_tag; */
         task_context->task_phase = 0x01;
 
         if (sds_request->was_tag_assigned_by_user) {
@@ -530,7 +530,7 @@ static void scu_ssp_reqeust_construct_task_context(
 
 /**
  * This method is will fill in the SCU Task Context for a SSP IO request.
- * @this_request:
+ * @sci_req:
  *
  */
 static void scu_ssp_io_request_construct_task_context(
@@ -568,24 +568,24 @@ static void scu_ssp_io_request_construct_task_context(
 /**
  * This method will fill in the remainder of the io request object for SSP Task
  *    requests.
- * @this_request:
+ * @sci_req:
  *
  */
 static void scic_sds_ssp_task_request_assign_buffers(
-        struct scic_sds_request *this_request)
+        struct scic_sds_request *sci_req)
 {
         /* Assign all of the buffer pointers */
-        this_request->command_buffer =
-                scic_sds_ssp_task_request_get_command_buffer(this_request);
-        this_request->response_buffer =
-                scic_sds_ssp_task_request_get_response_buffer(this_request);
-        this_request->sgl_element_pair_buffer = NULL;
-
-        if (this_request->was_tag_assigned_by_user == false) {
-                this_request->task_context_buffer =
-                        scic_sds_ssp_task_request_get_task_context_buffer(this_request);
-                this_request->task_context_buffer =
-                        PTR_ALIGN(this_request->task_context_buffer, SMP_CACHE_BYTES);
+        sci_req->command_buffer =
+                scic_sds_ssp_task_request_get_command_buffer(sci_req);
+        sci_req->response_buffer =
+                scic_sds_ssp_task_request_get_response_buffer(sci_req);
+        sci_req->sgl_element_pair_buffer = NULL;
+
+        if (sci_req->was_tag_assigned_by_user == false) {
+                sci_req->task_context_buffer =
+                        scic_sds_ssp_task_request_get_task_context_buffer(sci_req);
+                sci_req->task_context_buffer =
+                        PTR_ALIGN(sci_req->task_context_buffer, SMP_CACHE_BYTES);
         }
 }
 
@@ -598,18 +598,18 @@ static void scic_sds_ssp_task_request_assign_buffers(
  *    (i.e. non-raw frame) is being utilized to perform task management. -#
  *    control_frame == 1.  This ensures that the proper endianess is set so
  *    that the bytes are transmitted in the right order for a task frame.
- * @this_request: This parameter specifies the task request object being
+ * @sci_req: This parameter specifies the task request object being
  *    constructed.
  *
  */
 static void scu_ssp_task_request_construct_task_context(
-        struct scic_sds_request *this_request)
+        struct scic_sds_request *sci_req)
 {
         struct scu_task_context *task_context;
 
-        task_context = scic_sds_request_get_task_context(this_request);
+        task_context = scic_sds_request_get_task_context(sci_req);
 
-        scu_ssp_reqeust_construct_task_context(this_request, task_context);
+        scu_ssp_reqeust_construct_task_context(sci_req, task_context);
 
         task_context->control_frame                = 1;
         task_context->priority                     = SCU_TASK_PRIORITY_HIGH;
@@ -623,7 +623,7 @@ static void scu_ssp_task_request_construct_task_context(
 /**
  * This method constructs the SSP Command IU data for this ssp passthrough
  *    comand request object.
- * @this_request: This parameter specifies the request object for which the SSP
+ * @sci_req: This parameter specifies the request object for which the SSP
  *    command information unit is being built.
  *
  * enum sci_status, returns invalid parameter is cdb > 16
@@ -632,7 +632,7 @@ static void scu_ssp_task_request_construct_task_context(
 
 /**
  * This method constructs the SATA request object.
- * @this_request:
+ * @sci_req:
  * @sat_protocol:
  * @transfer_length:
  * @data_direction:
@@ -964,7 +964,7 @@ scic_sds_io_request_tc_completion(struct scic_sds_request *request, u32 completi
 
 /**
  *
- * @this_request: The SCIC_SDS_IO_REQUEST_T object for which the start
+ * @sci_req: The SCIC_SDS_IO_REQUEST_T object for which the start
  *    operation is to be executed.
  * @frame_index: The frame index returned by the hardware for the reqeust
  *    object.
@@ -992,7 +992,7 @@ enum sci_status scic_sds_io_request_frame_handler(
 
 /**
  *
- * @this_request: The SCIC_SDS_IO_REQUEST_T object for which the task start
+ * @sci_req: The SCIC_SDS_IO_REQUEST_T object for which the task start
  *    operation is to be executed.
  *
  * This method invokes the core state task complete handler for the
@@ -1007,7 +1007,7 @@ enum sci_status scic_sds_io_request_frame_handler(
 /**
  * This method copies response data for requests returning response data
  *    instead of sense data.
- * @this_request: This parameter specifies the request object for which to copy
+ * @sci_req: This parameter specifies the request object for which to copy
  *    the response data.
  *
  */
@@ -1161,14 +1161,14 @@ enum sci_status scic_sds_request_started_state_abort_handler(
  *    TC (task context) completions for normal IO request (i.e. Task/Abort
  *    Completions of type 0).  This method will update the
  *    SCIC_SDS_IO_REQUEST_T::status field.
- * @this_request: This parameter specifies the request for which a completion
+ * @sci_req: This parameter specifies the request for which a completion
  *    occurred.
  * @completion_code: This parameter specifies the completion code received from
  *    the SCU.
  *
  */
 enum sci_status scic_sds_request_started_state_tc_completion_handler(
-        struct scic_sds_request *this_request,
+        struct scic_sds_request *sci_req,
         u32 completion_code)
 {
         u8 data_present;
@@ -1181,7 +1181,7 @@ enum sci_status scic_sds_request_started_state_tc_completion_handler(
         switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
         case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
                 scic_sds_request_set_status(
-                        this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+                        sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
                         );
                 break;
 
@@ -1194,20 +1194,20 @@ enum sci_status scic_sds_request_started_state_tc_completion_handler(
                  * response stats to see if this is truly a failed request or a good
                  * request that just got completed early. */
                 struct sci_ssp_response_iu *response = (struct sci_ssp_response_iu *)
-                                                  this_request->response_buffer;
+                                                  sci_req->response_buffer;
                 scic_word_copy_with_swap(
-                        this_request->response_buffer,
-                        this_request->response_buffer,
+                        sci_req->response_buffer,
+                        sci_req->response_buffer,
                         sizeof(struct sci_ssp_response_iu) / sizeof(u32)
                         );
 
                 if (response->status == 0) {
                         scic_sds_request_set_status(
-                                this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS_IO_DONE_EARLY
+                                sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS_IO_DONE_EARLY
                                 );
                 } else {
                         scic_sds_request_set_status(
-                                this_request,
+                                sci_req,
                                 SCU_TASK_DONE_CHECK_RESPONSE,
                                 SCI_FAILURE_IO_RESPONSE_VALID
                                 );
@@ -1217,13 +1217,13 @@ enum sci_status scic_sds_request_started_state_tc_completion_handler(
 
         case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_CHECK_RESPONSE):
                 scic_word_copy_with_swap(
-                        this_request->response_buffer,
-                        this_request->response_buffer,
+                        sci_req->response_buffer,
+                        sci_req->response_buffer,
                         sizeof(struct sci_ssp_response_iu) / sizeof(u32)
                         );
 
                 scic_sds_request_set_status(
-                        this_request,
+                        sci_req,
                         SCU_TASK_DONE_CHECK_RESPONSE,
                         SCI_FAILURE_IO_RESPONSE_VALID
                         );
@@ -1234,19 +1234,19 @@ enum sci_status scic_sds_request_started_state_tc_completion_handler(
                  * / @todo With TASK_DONE_RESP_LEN_ERR is the response frame guaranteed
                  * /       to be received before this completion status is posted? */
                 response_buffer =
-                        (struct sci_ssp_response_iu *)this_request->response_buffer;
+                        (struct sci_ssp_response_iu *)sci_req->response_buffer;
                 data_present =
                         response_buffer->data_present & SCI_SSP_RESPONSE_IU_DATA_PRESENT_MASK;
 
                 if ((data_present == 0x01) || (data_present == 0x02)) {
                         scic_sds_request_set_status(
-                                this_request,
+                                sci_req,
                                 SCU_TASK_DONE_CHECK_RESPONSE,
                                 SCI_FAILURE_IO_RESPONSE_VALID
                                 );
                 } else {
                         scic_sds_request_set_status(
-                                this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+                                sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
                                 );
                 }
                 break;
@@ -1263,15 +1263,15 @@ enum sci_status scic_sds_request_started_state_tc_completion_handler(
         case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_UNEXP_SDBFIS):
         case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_REG_ERR):
         case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_SDB_ERR):
-                if (this_request->protocol == SCIC_STP_PROTOCOL) {
+                if (sci_req->protocol == SCIC_STP_PROTOCOL) {
                         scic_sds_request_set_status(
-                                this_request,
+                                sci_req,
                                 SCU_GET_COMPLETION_TL_STATUS(completion_code) >> SCU_COMPLETION_TL_STATUS_SHIFT,
                                 SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED
                                 );
                 } else {
                         scic_sds_request_set_status(
-                                this_request,
+                                sci_req,
                                 SCU_GET_COMPLETION_TL_STATUS(completion_code) >> SCU_COMPLETION_TL_STATUS_SHIFT,
                                 SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
                                 );
@@ -1290,7 +1290,7 @@ enum sci_status scic_sds_request_started_state_tc_completion_handler(
         case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_PROTOCOL_NOT_SUPPORTED):
         case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_OPEN_REJECT_CONNECTION_RATE_NOT_SUPPORTED):
                 scic_sds_request_set_status(
-                        this_request,
+                        sci_req,
                         SCU_GET_COMPLETION_TL_STATUS(completion_code) >> SCU_COMPLETION_TL_STATUS_SHIFT,
                         SCI_FAILURE_REMOTE_DEVICE_RESET_REQUIRED
                         );
@@ -1314,7 +1314,7 @@ enum sci_status scic_sds_request_started_state_tc_completion_handler(
         case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_RNCNV_OUTBOUND):
         default:
                 scic_sds_request_set_status(
-                        this_request,
+                        sci_req,
                         SCU_GET_COMPLETION_TL_STATUS(completion_code) >> SCU_COMPLETION_TL_STATUS_SHIFT,
                         SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
                         );
@@ -1326,7 +1326,7 @@ enum sci_status scic_sds_request_started_state_tc_completion_handler(
          */
 
         /* In all cases we will treat this as the completion of the IO request. */
-        sci_base_state_machine_change_state(&this_request->state_machine,
+        sci_base_state_machine_change_state(&sci_req->state_machine,
                 SCI_BASE_REQUEST_STATE_COMPLETED);
         return SCI_SUCCESS;
 }
@@ -1340,7 +1340,7 @@ enum sci_status scic_sds_request_started_state_tc_completion_handler(
  * logged. enum sci_status SCI_SUCCESS SCI_FAILURE_INVALID_PARAMETER_VALUE
  */
 static enum sci_status scic_sds_request_started_state_frame_handler(
-        struct scic_sds_request *this_request,
+        struct scic_sds_request *sci_req,
         u32 frame_index)
 {
         enum sci_status status;
@@ -1348,7 +1348,7 @@ static enum sci_status scic_sds_request_started_state_frame_handler(
 
         /* / @todo If this is a response frame we must record that we received it */
         status = scic_sds_unsolicited_frame_control_get_header(
-                &(scic_sds_request_get_controller(this_request)->uf_control),
+                &(scic_sds_request_get_controller(sci_req)->uf_control),
                 frame_index,
                 (void **)&frame_header
                 );
@@ -1357,37 +1357,37 @@ static enum sci_status scic_sds_request_started_state_frame_handler(
                 struct sci_ssp_response_iu *response_buffer;
 
                 status = scic_sds_unsolicited_frame_control_get_buffer(
-                        &(scic_sds_request_get_controller(this_request)->uf_control),
+                        &(scic_sds_request_get_controller(sci_req)->uf_control),
                         frame_index,
                         (void **)&response_buffer
                         );
 
                 scic_word_copy_with_swap(
-                        this_request->response_buffer,
+                        sci_req->response_buffer,
                         (u32 *)response_buffer,
                         sizeof(struct sci_ssp_response_iu)
                         );
 
-                response_buffer = (struct sci_ssp_response_iu *)this_request->response_buffer;
+                response_buffer = (struct sci_ssp_response_iu *)sci_req->response_buffer;
 
                 if ((response_buffer->data_present == 0x01) ||
                     (response_buffer->data_present == 0x02)) {
                         scic_sds_request_set_status(
-                                this_request,
+                                sci_req,
                                 SCU_TASK_DONE_CHECK_RESPONSE,
                                 SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
                                 );
                 } else
                         scic_sds_request_set_status(
-                                this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+                                sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
                                 );
         } else
                 /* This was not a response frame why did it get forwarded? */
-                dev_err(scic_to_dev(this_request->owning_controller),
+                dev_err(scic_to_dev(sci_req->owning_controller),
                         "%s: SCIC IO Request 0x%p received unexpected "
                         "frame %d type 0x%02x\n",
                         __func__,
-                        this_request,
+                        sci_req,
                         frame_index,
                         frame_header->frame_type);
 
@@ -1395,7 +1395,7 @@ static enum sci_status scic_sds_request_started_state_frame_handler(
          * In any case we are done with this frame buffer return it to the
          * controller */
         scic_sds_controller_release_frame(
-                this_request->owning_controller, frame_index
+                sci_req->owning_controller, frame_index
                 );
 
         return SCI_SUCCESS;
@@ -1460,17 +1460,17 @@ static enum sci_status scic_sds_request_aborting_state_abort_handler(
  * transitions to the completed state. enum sci_status SCI_SUCCESS
  */
 static enum sci_status scic_sds_request_aborting_state_tc_completion_handler(
-        struct scic_sds_request *this_request,
+        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):
         case (SCU_TASK_DONE_TASK_ABORT << SCU_COMPLETION_TL_STATUS_SHIFT):
                 scic_sds_request_set_status(
-                        this_request, SCU_TASK_DONE_TASK_ABORT, SCI_FAILURE_IO_TERMINATED
+                        sci_req, SCU_TASK_DONE_TASK_ABORT, SCI_FAILURE_IO_TERMINATED
                         );
 
-                sci_base_state_machine_change_state(&this_request->state_machine,
+                sci_base_state_machine_change_state(&sci_req->state_machine,
                         SCI_BASE_REQUEST_STATE_COMPLETED);
                 break;
 
@@ -1491,13 +1491,13 @@ static enum sci_status scic_sds_request_aborting_state_tc_completion_handler(
  * completion. enum sci_status SCI_SUCCESS
  */
 static enum sci_status scic_sds_request_aborting_state_frame_handler(
-        struct scic_sds_request *this_request,
+        struct scic_sds_request *sci_req,
         u32 frame_index)
 {
         /* TODO: Is it even possible to get an unsolicited frame in the aborting state? */
 
         scic_sds_controller_release_frame(
-                this_request->owning_controller, frame_index);
+                sci_req->owning_controller, frame_index);
 
         return SCI_SUCCESS;
 }
@@ -1539,10 +1539,10 @@ static const struct scic_sds_io_request_state_handler scic_sds_request_state_han
 static void scic_sds_request_initial_state_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+        struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
 
         SET_STATE_HANDLER(
-                this_request,
+                sci_req,
                 scic_sds_request_state_handler_table,
                 SCI_BASE_REQUEST_STATE_INITIAL
                 );
@@ -1559,10 +1559,10 @@ static void scic_sds_request_initial_state_enter(
 static void scic_sds_request_constructed_state_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+        struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
 
         SET_STATE_HANDLER(
-                this_request,
+                sci_req,
                 scic_sds_request_state_handler_table,
                 SCI_BASE_REQUEST_STATE_CONSTRUCTED
                 );
@@ -1580,10 +1580,10 @@ static void scic_sds_request_constructed_state_enter(
 static void scic_sds_request_started_state_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+        struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
 
         SET_STATE_HANDLER(
-                this_request,
+                sci_req,
                 scic_sds_request_state_handler_table,
                 SCI_BASE_REQUEST_STATE_STARTED
                 );
@@ -1591,8 +1591,8 @@ static void scic_sds_request_started_state_enter(
         /*
          * Most of the request state machines have a started substate machine so
          * start its execution on the entry to the started state. */
-        if (this_request->has_started_substate_machine == true)
-                sci_base_state_machine_start(&this_request->started_substate_machine);
+        if (sci_req->has_started_substate_machine == true)
+                sci_base_state_machine_start(&sci_req->started_substate_machine);
 }
 
 /**
@@ -1608,10 +1608,10 @@ static void scic_sds_request_started_state_enter(
 static void scic_sds_request_started_state_exit(
         struct sci_base_object *object)
 {
-        struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+        struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
 
-        if (this_request->has_started_substate_machine == true)
-                sci_base_state_machine_stop(&this_request->started_substate_machine);
+        if (sci_req->has_started_substate_machine == true)
+                sci_base_state_machine_stop(&sci_req->started_substate_machine);
 }
 
 /**
@@ -1660,13 +1660,13 @@ static void scic_sds_request_completed_state_enter(
 static void scic_sds_request_aborting_state_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+        struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
 
         /* Setting the abort bit in the Task Context is required by the silicon. */
-        this_request->task_context_buffer->abort = 1;
+        sci_req->task_context_buffer->abort = 1;
 
         SET_STATE_HANDLER(
-                this_request,
+                sci_req,
                 scic_sds_request_state_handler_table,
                 SCI_BASE_REQUEST_STATE_ABORTING
                 );
@@ -1684,10 +1684,10 @@ static void scic_sds_request_aborting_state_enter(
 static void scic_sds_request_final_state_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+        struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
 
         SET_STATE_HANDLER(
-                this_request,
+                sci_req,
                 scic_sds_request_state_handler_table,
                 SCI_BASE_REQUEST_STATE_FINAL
                 );
diff --git a/drivers/scsi/isci/core/scic_sds_request.h b/drivers/scsi/isci/core/scic_sds_request.h
index 423567a62901..0bb1da81ce85 100644
--- a/drivers/scsi/isci/core/scic_sds_request.h
+++ b/drivers/scsi/isci/core/scic_sds_request.h
@@ -336,32 +336,32 @@ extern const struct sci_base_state scic_sds_io_request_started_task_mgmt_substat
  *
  * This macro will return the controller for this io request object
  */
-#define scic_sds_request_get_controller(this_request) \
-        ((this_request)->owning_controller)
+#define scic_sds_request_get_controller(sci_req) \
+        ((sci_req)->owning_controller)
 
 /**
  * scic_sds_request_get_device() -
  *
  * This macro will return the device for this io request object
  */
-#define scic_sds_request_get_device(this_request) \
-        ((this_request)->target_device)
+#define scic_sds_request_get_device(sci_req) \
+        ((sci_req)->target_device)
 
 /**
  * scic_sds_request_get_port() -
  *
  * This macro will return the port for this io request object
  */
-#define scic_sds_request_get_port(this_request) \
-        scic_sds_remote_device_get_port(scic_sds_request_get_device(this_request))
+#define scic_sds_request_get_port(sci_req)      \
+        scic_sds_remote_device_get_port(scic_sds_request_get_device(sci_req))
 
 /**
  * scic_sds_request_get_post_context() -
  *
  * This macro returns the constructed post context result for the io request.
  */
-#define scic_sds_request_get_post_context(this_request) \
-        ((this_request)->post_context)
+#define scic_sds_request_get_post_context(sci_req)      \
+        ((sci_req)->post_context)
 
 /**
  * scic_sds_request_get_task_context() -
@@ -433,41 +433,41 @@ scic_sds_io_request_tc_completion(struct scic_sds_request *request, u32 completi
  * ***************************************************************************** */
 
 void scic_sds_request_build_sgl(
-        struct scic_sds_request *this_request);
+        struct scic_sds_request *sci_req);
 
 
 
 void scic_sds_stp_request_assign_buffers(
-        struct scic_sds_request *this_request);
+        struct scic_sds_request *sci_req);
 
 void scic_sds_smp_request_assign_buffers(
-        struct scic_sds_request *this_request);
+        struct scic_sds_request *sci_req);
 
 /* --------------------------------------------------------------------------- */
 
 enum sci_status scic_sds_request_start(
-        struct scic_sds_request *this_request);
+        struct scic_sds_request *sci_req);
 
 enum sci_status scic_sds_io_request_terminate(
-        struct scic_sds_request *this_request);
+        struct scic_sds_request *sci_req);
 
 enum sci_status scic_sds_io_request_complete(
-        struct scic_sds_request *this_request);
+        struct scic_sds_request *sci_req);
 
 void scic_sds_io_request_copy_response(
-        struct scic_sds_request *this_request);
+        struct scic_sds_request *sci_req);
 
 enum sci_status scic_sds_io_request_event_handler(
-        struct scic_sds_request *this_request,
+        struct scic_sds_request *sci_req,
         u32 event_code);
 
 enum sci_status scic_sds_io_request_frame_handler(
-        struct scic_sds_request *this_request,
+        struct scic_sds_request *sci_req,
         u32 frame_index);
 
 
 enum sci_status scic_sds_task_request_terminate(
-        struct scic_sds_request *this_request);
+        struct scic_sds_request *sci_req);
 
 /*
  * *****************************************************************************
@@ -475,10 +475,10 @@ enum sci_status scic_sds_task_request_terminate(
  * ***************************************************************************** */
 
 enum sci_status scic_sds_request_started_state_abort_handler(
-        struct scic_sds_request *request);
+        struct scic_sds_request *sci_req);
 
 enum sci_status scic_sds_request_started_state_tc_completion_handler(
-        struct scic_sds_request *this_request,
+        struct scic_sds_request *sci_req,
         u32 completion_code);
 
 #endif /* _SCIC_SDS_IO_REQUEST_H_ */
diff --git a/drivers/scsi/isci/core/scic_sds_smp_remote_device.c b/drivers/scsi/isci/core/scic_sds_smp_remote_device.c
index 88c359548c1b..471cb7d1142d 100644
--- a/drivers/scsi/isci/core/scic_sds_smp_remote_device.c
+++ b/drivers/scsi/isci/core/scic_sds_smp_remote_device.c
@@ -142,15 +142,15 @@ scic_sds_smp_remote_device_ready_cmd_substate_complete_io_handler(
         struct scic_sds_request *request)
 {
         enum sci_status status;
-        struct scic_sds_request *the_request;
+        struct scic_sds_request *sci_req;
 
-        the_request = (struct scic_sds_request *)request;
+        sci_req = (struct scic_sds_request *)request;
 
-        status = scic_sds_io_request_complete(the_request);
+        status = scic_sds_io_request_complete(sci_req);
 
         if (status == SCI_SUCCESS) {
                 status = scic_sds_port_complete_io(
-                        device->owning_port, device, the_request);
+                        device->owning_port, device, sci_req);
 
                 if (status == SCI_SUCCESS) {
                         scic_sds_remote_device_decrement_request_count(device);
@@ -165,7 +165,7 @@ scic_sds_smp_remote_device_ready_cmd_substate_complete_io_handler(
                                 "failed with status %d.\n",
                                 __func__,
                                 device,
-                                the_request,
+                                sci_req,
                                 device->owning_port,
                                 status);
         }
@@ -175,13 +175,13 @@ scic_sds_smp_remote_device_ready_cmd_substate_complete_io_handler(
 
 /**
  * This is frame handler for smp device ready cmd substate.
- * @this_device: This is the device object that is receiving the frame.
+ * @sci_dev: This is the device object that is receiving the frame.
  * @frame_index: The index for the frame received.
  *
  * enum sci_status
  */
 static enum sci_status scic_sds_smp_remote_device_ready_cmd_substate_frame_handler(
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         u32 frame_index)
 {
         enum sci_status status;
@@ -191,7 +191,7 @@ static enum sci_status scic_sds_smp_remote_device_ready_cmd_substate_frame_handl
          * / in this state.  All unsolicited frames are forwarded to the io request
          * / object. */
         status = scic_sds_io_request_frame_handler(
-                this_device->working_request,
+                sci_dev->working_request,
                 frame_index
                 );
 
diff --git a/drivers/scsi/isci/core/scic_sds_smp_request.c b/drivers/scsi/isci/core/scic_sds_smp_request.c
index 70bc8d2cf048..f53f21b8b9c0 100644
--- a/drivers/scsi/isci/core/scic_sds_smp_request.c
+++ b/drivers/scsi/isci/core/scic_sds_smp_request.c
@@ -67,7 +67,7 @@
 #include "scu_task_context.h"
 
 static void scu_smp_request_construct_task_context(
-        struct scic_sds_request *this_request,
+        struct scic_sds_request *sci_req,
         struct smp_request *smp_request);
 
 /**
@@ -118,27 +118,27 @@ u32 scic_sds_smp_request_get_object_size(void)
 
 /**
  * This method build the remainder of the IO request object.
- * @this_request: This parameter specifies the request object being constructed.
+ * @sci_req: This parameter specifies the request object being constructed.
  *
  * The scic_sds_general_request_construct() must be called before this call is
  * valid. none
  */
 
 void scic_sds_smp_request_assign_buffers(
-        struct scic_sds_request *this_request)
+        struct scic_sds_request *sci_req)
 {
         /* Assign all of the buffer pointers */
-        this_request->command_buffer =
-                scic_sds_smp_request_get_command_buffer(this_request);
-        this_request->response_buffer =
-                scic_sds_smp_request_get_response_buffer(this_request);
-        this_request->sgl_element_pair_buffer = NULL;
-
-        if (this_request->was_tag_assigned_by_user == false) {
-                this_request->task_context_buffer =
-                        scic_sds_smp_request_get_task_context_buffer(this_request);
-                this_request->task_context_buffer =
-                        PTR_ALIGN(this_request->task_context_buffer, SMP_CACHE_BYTES);
+        sci_req->command_buffer =
+                scic_sds_smp_request_get_command_buffer(sci_req);
+        sci_req->response_buffer =
+                scic_sds_smp_request_get_response_buffer(sci_req);
+        sci_req->sgl_element_pair_buffer = NULL;
+
+        if (sci_req->was_tag_assigned_by_user == false) {
+                sci_req->task_context_buffer =
+                        scic_sds_smp_request_get_task_context_buffer(sci_req);
+                sci_req->task_context_buffer =
+                        PTR_ALIGN(sci_req->task_context_buffer, SMP_CACHE_BYTES);
         }
 
 }
@@ -163,7 +163,7 @@ void scic_sds_smp_request_assign_buffers(
  *    (i.e. non-raw frame) is being utilized to perform task management. -#
  *    control_frame == 1.  This ensures that the proper endianess is set so
  *    that the bytes are transmitted in the right order for a smp request frame.
- * @this_request: This parameter specifies the smp request object being
+ * @sci_req: This parameter specifies the smp request object being
  *    constructed.
  *
  */
@@ -295,7 +295,7 @@ static void scu_smp_request_construct_task_context(
  *    for a response frame.  It will copy the response data, release the
  *    unsolicited frame, and transition the request to the
  *    SCI_BASE_REQUEST_STATE_COMPLETED state.
- * @this_request: This parameter specifies the request for which the
+ * @sci_req: This parameter specifies the request for which the
  *    unsolicited frame was received.
  * @frame_index: This parameter indicates the unsolicited frame index that
  *    should contain the response.
@@ -305,16 +305,16 @@ static void scu_smp_request_construct_task_context(
  * indicates successful processing of the TC response.
  */
 static enum sci_status scic_sds_smp_request_await_response_frame_handler(
-        struct scic_sds_request *this_request,
+        struct scic_sds_request *sci_req,
         u32 frame_index)
 {
         enum sci_status status;
         void *frame_header;
-        struct smp_response_header *this_frame_header;
-        u8 *user_smp_buffer = this_request->response_buffer;
+        struct smp_response_header *rsp_hdr;
+        u8 *user_smp_buffer = sci_req->response_buffer;
 
         status = scic_sds_unsolicited_frame_control_get_header(
-                &(scic_sds_request_get_controller(this_request)->uf_control),
+                &(scic_sds_request_get_controller(sci_req)->uf_control),
                 frame_index,
                 &frame_header
                 );
@@ -325,13 +325,13 @@ static enum sci_status scic_sds_smp_request_await_response_frame_handler(
                 frame_header,
                 sizeof(struct smp_response_header) / sizeof(u32)
                 );
-        this_frame_header = (struct smp_response_header *)user_smp_buffer;
+        rsp_hdr = (struct smp_response_header *)user_smp_buffer;
 
-        if (this_frame_header->smp_frame_type == SMP_FRAME_TYPE_RESPONSE) {
+        if (rsp_hdr->smp_frame_type == SMP_FRAME_TYPE_RESPONSE) {
                 void *smp_response_buffer;
 
                 status = scic_sds_unsolicited_frame_control_get_buffer(
-                        &(scic_sds_request_get_controller(this_request)->uf_control),
+                        &(scic_sds_request_get_controller(sci_req)->uf_control),
                         frame_index,
                         &smp_response_buffer
                         );
@@ -341,23 +341,23 @@ static enum sci_status scic_sds_smp_request_await_response_frame_handler(
                         smp_response_buffer,
                         sizeof(union smp_response_body) / sizeof(u32)
                         );
-                if (this_frame_header->function == SMP_FUNCTION_DISCOVER) {
-                        struct smp_response *this_smp_response;
+                if (rsp_hdr->function == SMP_FUNCTION_DISCOVER) {
+                        struct smp_response *smp_resp;
 
-                        this_smp_response = (struct smp_response *)user_smp_buffer;
+                        smp_resp = (struct smp_response *)user_smp_buffer;
 
                         /*
                          * Some expanders only report an attached SATA device, and
                          * not an STP target.  Since the core depends on the STP
                          * target attribute to correctly build I/O, set the bit now
                          * if necessary. */
-                        if (this_smp_response->response.discover.protocols.u.bits.attached_sata_device
-                            && !this_smp_response->response.discover.protocols.u.bits.attached_stp_target) {
-                                this_smp_response->response.discover.protocols.u.bits.attached_stp_target = 1;
+                        if (smp_resp->response.discover.protocols.u.bits.attached_sata_device
+                            && !smp_resp->response.discover.protocols.u.bits.attached_stp_target) {
+                                smp_resp->response.discover.protocols.u.bits.attached_stp_target = 1;
 
-                                dev_dbg(scic_to_dev(this_request->owning_controller),
+                                dev_dbg(scic_to_dev(sci_req->owning_controller),
                                         "%s: scic_sds_smp_request_await_response_frame_handler(0x%p) Found SATA dev, setting STP bit.\n",
-                                        __func__, this_request);
+                                        __func__, sci_req);
                         }
                 }
 
@@ -367,40 +367,40 @@ static enum sci_status scic_sds_smp_request_await_response_frame_handler(
 
                 /*
                  * copy the smp response to framework smp request's response buffer.
-                 * scic_sds_smp_request_copy_response(this_request); */
+                 * scic_sds_smp_request_copy_response(sci_req); */
 
                 scic_sds_request_set_status(
-                        this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+                        sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
                         );
 
                 sci_base_state_machine_change_state(
-                        &this_request->started_substate_machine,
+                        &sci_req->started_substate_machine,
                         SCIC_SDS_SMP_REQUEST_STARTED_SUBSTATE_AWAIT_TC_COMPLETION
                         );
         } else {
                 /* This was not a response frame why did it get forwarded? */
-                dev_err(scic_to_dev(this_request->owning_controller),
+                dev_err(scic_to_dev(sci_req->owning_controller),
                         "%s: SCIC SMP Request 0x%p received unexpected frame "
                         "%d type 0x%02x\n",
                         __func__,
-                        this_request,
+                        sci_req,
                         frame_index,
-                        this_frame_header->smp_frame_type);
+                        rsp_hdr->smp_frame_type);
 
                 scic_sds_request_set_status(
-                        this_request,
+                        sci_req,
                         SCU_TASK_DONE_SMP_FRM_TYPE_ERR,
                         SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
                         );
 
                 sci_base_state_machine_change_state(
-                        &this_request->state_machine,
+                        &sci_req->state_machine,
                         SCI_BASE_REQUEST_STATE_COMPLETED
                         );
         }
 
         scic_sds_controller_release_frame(
-                this_request->owning_controller, frame_index
+                sci_req->owning_controller, frame_index
                 );
 
         return SCI_SUCCESS;
@@ -411,7 +411,7 @@ static enum sci_status scic_sds_smp_request_await_response_frame_handler(
  * This method processes an abnormal TC completion while the SMP request is
  *    waiting for a response frame.  It decides what happened to the IO based
  *    on TC completion status.
- * @this_request: This parameter specifies the request for which the TC
+ * @sci_req: This parameter specifies the request for which the TC
  *    completion was received.
  * @completion_code: This parameter indicates the completion status information
  *    for the TC.
@@ -420,7 +420,7 @@ static enum sci_status scic_sds_smp_request_await_response_frame_handler(
  * this method always returns success.
  */
 static enum sci_status scic_sds_smp_request_await_response_tc_completion_handler(
-        struct scic_sds_request *this_request,
+        struct scic_sds_request *sci_req,
         u32 completion_code)
 {
         switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
@@ -429,11 +429,11 @@ static enum sci_status scic_sds_smp_request_await_response_tc_completion_handler
                  * In the AWAIT RESPONSE state, any TC completion is unexpected.
                  * but if the TC has success status, we complete the IO anyway. */
                 scic_sds_request_set_status(
-                        this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+                        sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
                         );
 
                 sci_base_state_machine_change_state(
-                        &this_request->state_machine,
+                        &sci_req->state_machine,
                         SCI_BASE_REQUEST_STATE_COMPLETED);
                 break;
 
@@ -447,11 +447,11 @@ static enum sci_status scic_sds_smp_request_await_response_tc_completion_handler
                  * break the connection and set TC completion with one of these SMP_XXX_XX_ERR
                  * status. For these type of error, we ask scic user to retry the request. */
                 scic_sds_request_set_status(
-                        this_request, SCU_TASK_DONE_SMP_RESP_TO_ERR, SCI_FAILURE_RETRY_REQUIRED
+                        sci_req, SCU_TASK_DONE_SMP_RESP_TO_ERR, SCI_FAILURE_RETRY_REQUIRED
                         );
 
                 sci_base_state_machine_change_state(
-                        &this_request->state_machine,
+                        &sci_req->state_machine,
                         SCI_BASE_REQUEST_STATE_COMPLETED);
                 break;
 
@@ -460,13 +460,13 @@ static enum sci_status scic_sds_smp_request_await_response_tc_completion_handler
                  * 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(
-                        this_request,
+                        sci_req,
                         SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
                         SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
                         );
 
                 sci_base_state_machine_change_state(
-                        &this_request->state_machine,
+                        &sci_req->state_machine,
                         SCI_BASE_REQUEST_STATE_COMPLETED);
                 break;
         }
@@ -480,7 +480,7 @@ static enum sci_status scic_sds_smp_request_await_response_tc_completion_handler
  *    determine if the SMP request was sent successfully. If the SMP request
  *    was sent successfully, then the state for the SMP request transits to
  *    waiting for a response frame.
- * @this_request: This parameter specifies the request for which the TC
+ * @sci_req: This parameter specifies the request for which the TC
  *    completion was received.
  * @completion_code: This parameter indicates the completion status information
  *    for the TC.
@@ -489,17 +489,17 @@ static enum sci_status scic_sds_smp_request_await_response_tc_completion_handler
  * this method always returns success.
  */
 static enum sci_status scic_sds_smp_request_await_tc_completion_tc_completion_handler(
-        struct scic_sds_request *this_request,
+        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(
-                        this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+                        sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
                         );
 
                 sci_base_state_machine_change_state(
-                        &this_request->state_machine,
+                        &sci_req->state_machine,
                         SCI_BASE_REQUEST_STATE_COMPLETED);
                 break;
 
@@ -508,13 +508,13 @@ static enum sci_status scic_sds_smp_request_await_tc_completion_tc_completion_ha
                  * 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(
-                        this_request,
+                        sci_req,
                         SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
                         SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
                         );
 
                 sci_base_state_machine_change_state(
-                        &this_request->state_machine,
+                        &sci_req->state_machine,
                         SCI_BASE_REQUEST_STATE_COMPLETED);
                 break;
         }
@@ -547,10 +547,10 @@ static const struct scic_sds_io_request_state_handler scic_sds_smp_request_start
 static void scic_sds_smp_request_started_await_response_substate_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+        struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
 
         SET_STATE_HANDLER(
-                this_request,
+                sci_req,
                 scic_sds_smp_request_started_substate_handler_table,
                 SCIC_SDS_SMP_REQUEST_STARTED_SUBSTATE_AWAIT_RESPONSE
                 );
@@ -568,10 +568,10 @@ static void scic_sds_smp_request_started_await_response_substate_enter(
 static void scic_sds_smp_request_started_await_tc_completion_substate_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+        struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
 
         SET_STATE_HANDLER(
-                this_request,
+                sci_req,
                 scic_sds_smp_request_started_substate_handler_table,
                 SCIC_SDS_SMP_REQUEST_STARTED_SUBSTATE_AWAIT_TC_COMPLETION
                 );
diff --git a/drivers/scsi/isci/core/scic_sds_smp_request.h b/drivers/scsi/isci/core/scic_sds_smp_request.h
index bcad282ce753..8f34ffe2c236 100644
--- a/drivers/scsi/isci/core/scic_sds_smp_request.h
+++ b/drivers/scsi/isci/core/scic_sds_smp_request.h
@@ -62,8 +62,7 @@
 u32 scic_sds_smp_request_get_object_size(void);
 
 
-void scic_sds_smp_request_copy_response(
-        struct scic_sds_request *this_request);
+void scic_sds_smp_request_copy_response(struct scic_sds_request *sci_req);
 
 #endif /* _SCIC_SDS_SMP_REQUEST_T_ */
 
diff --git a/drivers/scsi/isci/core/scic_sds_ssp_request.c b/drivers/scsi/isci/core/scic_sds_ssp_request.c
index 4d3a21b6ac03..03676682e6ef 100644
--- a/drivers/scsi/isci/core/scic_sds_ssp_request.c
+++ b/drivers/scsi/isci/core/scic_sds_ssp_request.c
@@ -67,7 +67,7 @@
  *    determine if the RAW task management frame was sent successfully. If the
  *    raw frame was sent successfully, then the state for the task request
  *    transitions to waiting for a response frame.
- * @this_request: This parameter specifies the request for which the TC
+ * @sci_req: This parameter specifies the request for which the TC
  *    completion was received.
  * @completion_code: This parameter indicates the completion status information
  *    for the TC.
@@ -76,17 +76,17 @@
  * this method always returns success.
  */
 static enum sci_status scic_sds_ssp_task_request_await_tc_completion_tc_completion_handler(
-        struct scic_sds_request *this_request,
+        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(
-                        this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+                        sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
                         );
 
                 sci_base_state_machine_change_state(
-                        &this_request->started_substate_machine,
+                        &sci_req->started_substate_machine,
                         SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATE_AWAIT_TC_RESPONSE
                         );
                 break;
@@ -97,15 +97,15 @@ static enum sci_status scic_sds_ssp_task_request_await_tc_completion_tc_completi
                  * timeout if the task IU wasn't received successfully.
                  * There is a potential for receiving multiple task responses if we
                  * decide to send the task IU again. */
-                dev_warn(scic_to_dev(this_request->owning_controller),
+                dev_warn(scic_to_dev(sci_req->owning_controller),
                          "%s: TaskRequest:0x%p CompletionCode:%x - "
                          "ACK/NAK timeout\n",
                          __func__,
-                         this_request,
+                         sci_req,
                          completion_code);
 
                 sci_base_state_machine_change_state(
-                        &this_request->started_substate_machine,
+                        &sci_req->started_substate_machine,
                         SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATE_AWAIT_TC_RESPONSE
                         );
                 break;
@@ -115,12 +115,12 @@ static enum sci_status scic_sds_ssp_task_request_await_tc_completion_tc_completi
                  * 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(
-                        this_request,
+                        sci_req,
                         SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
                         SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
                         );
 
-                sci_base_state_machine_change_state(&this_request->state_machine,
+                sci_base_state_machine_change_state(&sci_req->state_machine,
                         SCI_BASE_REQUEST_STATE_COMPLETED);
                 break;
         }
@@ -132,7 +132,7 @@ static enum sci_status scic_sds_ssp_task_request_await_tc_completion_tc_completi
  * This method is responsible for processing a terminate/abort request for this
  *    TC while the request is waiting for the task management response
  *    unsolicited frame.
- * @this_request: This parameter specifies the request for which the
+ * @sci_req: This parameter specifies the request for which the
  *    termination was requested.
  *
  * This method returns an indication as to whether the abort request was
@@ -155,7 +155,7 @@ static enum sci_status scic_sds_ssp_task_request_await_tc_response_abort_handler
  *    waiting for a response frame.  It will copy the response data, release
  *    the unsolicited frame, and transition the request to the
  *    SCI_BASE_REQUEST_STATE_COMPLETED state.
- * @this_request: This parameter specifies the request for which the
+ * @sci_req: This parameter specifies the request for which the
  *    unsolicited frame was received.
  * @frame_index: This parameter indicates the unsolicited frame index that
  *    should contain the response.
@@ -202,10 +202,10 @@ static const struct scic_sds_io_request_state_handler scic_sds_ssp_task_request_
 static void scic_sds_io_request_started_task_mgmt_await_tc_completion_substate_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+        struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
 
         SET_STATE_HANDLER(
-                this_request,
+                sci_req,
                 scic_sds_ssp_task_request_started_substate_handler_table,
                 SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATE_AWAIT_TC_COMPLETION
                 );
@@ -223,10 +223,10 @@ static void scic_sds_io_request_started_task_mgmt_await_tc_completion_substate_e
 static void scic_sds_io_request_started_task_mgmt_await_task_response_substate_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+        struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
 
         SET_STATE_HANDLER(
-                this_request,
+                sci_req,
                 scic_sds_ssp_task_request_started_substate_handler_table,
                 SCIC_SDS_IO_REQUEST_STARTED_TASK_MGMT_SUBSTATE_AWAIT_TC_RESPONSE
                 );
diff --git a/drivers/scsi/isci/core/scic_sds_stp_packet_request.c b/drivers/scsi/isci/core/scic_sds_stp_packet_request.c
index 25c68cef298e..e4d2bf56f491 100644
--- a/drivers/scsi/isci/core/scic_sds_stp_packet_request.c
+++ b/drivers/scsi/isci/core/scic_sds_stp_packet_request.c
@@ -75,16 +75,16 @@
 /**
  * This method will fill in the SCU Task Context for a PACKET fis. And
  *    construct the request STARTED sub-state machine for Packet Protocol IO.
- * @this_request: This parameter specifies the stp packet request object being
+ * @sci_req: This parameter specifies the stp packet request object being
  *    constructed.
  *
  */
 enum sci_status scic_sds_stp_packet_request_construct(
-        struct scic_sds_request *this_request)
+        struct scic_sds_request *sci_req)
 {
         struct sata_fis_reg_h2d *h2d_fis =
                 scic_stp_io_request_get_h2d_reg_address(
-                        this_request
+                        sci_req
                         );
 
         /*
@@ -92,17 +92,17 @@ enum sci_status scic_sds_stp_packet_request_construct(
          * need to make change to Packet Fis features field. */
         h2d_fis->features = h2d_fis->features | ATA_PACKET_FEATURE_DMA;
 
-        scic_sds_stp_non_ncq_request_construct(this_request);
+        scic_sds_stp_non_ncq_request_construct(sci_req);
 
         /* Build the Packet Fis task context structure */
         scu_stp_raw_request_construct_task_context(
-                (struct scic_sds_stp_request *)this_request,
-                this_request->task_context_buffer
+                (struct scic_sds_stp_request *)sci_req,
+                sci_req->task_context_buffer
                 );
 
         sci_base_state_machine_construct(
-                &this_request->started_substate_machine,
-                &this_request->parent.parent,
+                &sci_req->started_substate_machine,
+                &sci_req->parent.parent,
                 scic_sds_stp_packet_request_started_substate_table,
                 SCIC_SDS_STP_PACKET_REQUEST_STARTED_PACKET_PHASE_AWAIT_TC_COMPLETION_SUBSTATE
                 );
@@ -119,24 +119,24 @@ enum sci_status scic_sds_stp_packet_request_construct(
  *    utilized to perform task management. -# control_frame == 1.  This ensures
  *    that the proper endianess is set so that the bytes are transmitted in the
  *    right order for a smp request frame.
- * @this_request: This parameter specifies the smp request object being
+ * @sci_req: This parameter specifies the smp request object being
  *    constructed.
  * @task_context: The task_context to be reconstruct for packet request command
  *    phase.
  *
  */
 void scu_stp_packet_request_command_phase_construct_task_context(
-        struct scic_sds_request *this_request,
+        struct scic_sds_request *sci_req,
         struct scu_task_context *task_context)
 {
         void *atapi_cdb;
         u32 atapi_cdb_length;
-        struct scic_sds_stp_request *stp_request = (struct scic_sds_stp_request *)this_request;
+        struct scic_sds_stp_request *stp_request = (struct scic_sds_stp_request *)sci_req;
 
         /*
          * reference: SSTL 1.13.4.2
          * task_type, sata_direction */
-        if (scic_cb_io_request_get_data_direction(this_request->user_request)
+        if (scic_cb_io_request_get_data_direction(sci_req->user_request)
              == SCI_IO_REQUEST_DATA_OUT) {
                 task_context->task_type = SCU_TASK_TYPE_PACKET_DMA_OUT;
                 task_context->sata_direction = 0;
@@ -152,15 +152,15 @@ void scu_stp_packet_request_command_phase_construct_task_context(
         /*
          * Copy in the command IU with CDB so that the commandIU address doesn't
          * change. */
-        memset(this_request->command_buffer, 0, sizeof(struct sata_fis_reg_h2d));
+        memset(sci_req->command_buffer, 0, sizeof(struct sata_fis_reg_h2d));
 
         atapi_cdb =
-                scic_cb_stp_packet_io_request_get_cdb_address(this_request->user_request);
+                scic_cb_stp_packet_io_request_get_cdb_address(sci_req->user_request);
 
         atapi_cdb_length =
-                scic_cb_stp_packet_io_request_get_cdb_length(this_request->user_request);
+                scic_cb_stp_packet_io_request_get_cdb_length(sci_req->user_request);
 
-        memcpy(((u8 *)this_request->command_buffer + sizeof(u32)), atapi_cdb, atapi_cdb_length);
+        memcpy(((u8 *)sci_req->command_buffer + sizeof(u32)), atapi_cdb, atapi_cdb_length);
 
         atapi_cdb_length =
                 max(atapi_cdb_length, stp_request->type.packet.device_preferred_cdb_length);
@@ -175,18 +175,18 @@ void scu_stp_packet_request_command_phase_construct_task_context(
         /* retry counter */
         task_context->stp_retry_count = 0;
 
-        if (scic_cb_request_is_initial_construction(this_request->user_request)) {
+        if (scic_cb_request_is_initial_construction(sci_req->user_request)) {
                 /* data transfer size. */
                 task_context->transfer_length_bytes =
-                        scic_cb_io_request_get_transfer_length(this_request->user_request);
+                        scic_cb_io_request_get_transfer_length(sci_req->user_request);
 
                 /* setup sgl */
-                scic_sds_request_build_sgl(this_request);
+                scic_sds_request_build_sgl(sci_req);
         } else {
                 /* data transfer size, need to be 4 bytes aligned. */
                 task_context->transfer_length_bytes = (SCSI_FIXED_SENSE_DATA_BASE_LENGTH + 2);
 
-                scic_sds_stp_packet_internal_request_sense_build_sgl(this_request);
+                scic_sds_stp_packet_internal_request_sense_build_sgl(sci_req);
         }
 }
 
@@ -194,24 +194,24 @@ void scu_stp_packet_request_command_phase_construct_task_context(
  * This method will fill in the SCU Task Context for a DATA fis containing CDB
  *    in Raw Frame type. The TC for previous Packet fis was already there, we
  *    only need to change the H2D fis content.
- * @this_request: This parameter specifies the smp request object being
+ * @sci_req: This parameter specifies the smp request object being
  *    constructed.
  * @task_context: The task_context to be reconstruct for packet request command
  *    phase.
  *
  */
 void scu_stp_packet_request_command_phase_reconstruct_raw_frame_task_context(
-        struct scic_sds_request *this_request,
+        struct scic_sds_request *sci_req,
         struct scu_task_context *task_context)
 {
         void *atapi_cdb =
-                scic_cb_stp_packet_io_request_get_cdb_address(this_request->user_request);
+                scic_cb_stp_packet_io_request_get_cdb_address(sci_req->user_request);
 
         u32 atapi_cdb_length =
-                scic_cb_stp_packet_io_request_get_cdb_length(this_request->user_request);
+                scic_cb_stp_packet_io_request_get_cdb_length(sci_req->user_request);
 
-        memset(this_request->command_buffer, 0, sizeof(struct sata_fis_reg_h2d));
-        memcpy(((u8 *)this_request->command_buffer + sizeof(u32)), atapi_cdb, atapi_cdb_length);
+        memset(sci_req->command_buffer, 0, sizeof(struct sata_fis_reg_h2d));
+        memcpy(((u8 *)sci_req->command_buffer + sizeof(u32)), atapi_cdb, atapi_cdb_length);
 
         memset(&(task_context->type.stp), 0, sizeof(struct stp_task_context));
         task_context->type.stp.fis_type = SATA_FIS_TYPE_DATA;
@@ -227,12 +227,12 @@ void scu_stp_packet_request_command_phase_reconstruct_raw_frame_task_context(
  * *@brief This methods decode the D2H status FIS and retrieve the sense data,
  *          then pass the sense data to user request.
  *
- ***@param[in] this_request The request receive D2H status FIS.
+ ***@param[in] sci_req The request receive D2H status FIS.
  ***@param[in] status_fis The D2H status fis to be processed.
  *
  */
 enum sci_status scic_sds_stp_packet_request_process_status_fis(
-        struct scic_sds_request *this_request,
+        struct scic_sds_request *sci_req,
         struct sata_fis_reg_d2h *status_fis)
 {
         enum sci_status status = SCI_SUCCESS;
@@ -249,7 +249,7 @@ enum sci_status scic_sds_stp_packet_request_process_status_fis(
  *          command using this request response buffer, only one sge is
  *          needed.
  *
- ***@param[in] this_request The request receive request sense data.
+ ***@param[in] sci_req The request receive request sense data.
  *
  */
 void scic_sds_stp_packet_internal_request_sense_build_sgl(
@@ -284,7 +284,7 @@ void scic_sds_stp_packet_internal_request_sense_build_sgl(
  *    determine if the Packet FIS was sent successfully. If the Packet FIS was
  *    sent successfully, then the state for the Packet request transits to
  *    waiting for a PIO SETUP frame.
- * @this_request: This parameter specifies the request for which the TC
+ * @sci_req: This parameter specifies the request for which the TC
  *    completion was received.
  * @completion_code: This parameter indicates the completion status information
  *    for the TC.
@@ -293,7 +293,7 @@ void scic_sds_stp_packet_internal_request_sense_build_sgl(
  * this method always returns success.
  */
 enum sci_status scic_sds_stp_packet_request_packet_phase_await_tc_completion_tc_completion_handler(
-        struct scic_sds_request *this_request,
+        struct scic_sds_request *sci_req,
         u32 completion_code)
 {
         enum sci_status status = SCI_SUCCESS;
@@ -301,11 +301,11 @@ enum sci_status scic_sds_stp_packet_request_packet_phase_await_tc_completion_tc_
         switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
         case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
                 scic_sds_request_set_status(
-                        this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+                        sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
                         );
 
                 sci_base_state_machine_change_state(
-                        &this_request->started_substate_machine,
+                        &sci_req->started_substate_machine,
                         SCIC_SDS_STP_PACKET_REQUEST_STARTED_PACKET_PHASE_AWAIT_PIO_SETUP_SUBSTATE
                         );
                 break;
@@ -315,13 +315,13 @@ enum sci_status scic_sds_stp_packet_request_packet_phase_await_tc_completion_tc_
                  * 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(
-                        this_request,
+                        sci_req,
                         SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
                         SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
                         );
 
                 sci_base_state_machine_change_state(
-                        &this_request->parent.state_machine,
+                        &sci_req->parent.state_machine,
                         SCI_BASE_REQUEST_STATE_COMPLETED
                         );
                 break;
@@ -336,7 +336,7 @@ enum sci_status scic_sds_stp_packet_request_packet_phase_await_tc_completion_tc_
  *    waiting for a PIO SETUP FIS.  It will release the unsolicited frame, and
  *    transition the request to the COMMAND_PHASE_AWAIT_TC_COMPLETION_SUBSTATE
  *    state.
- * @this_request: This parameter specifies the request for which the
+ * @sci_req: This parameter specifies the request for which the
  *    unsolicited frame was received.
  * @frame_index: This parameter indicates the unsolicited frame index that
  *    should contain the response.
@@ -352,12 +352,12 @@ enum sci_status scic_sds_stp_packet_request_packet_phase_await_pio_setup_frame_h
         enum sci_status status;
         struct sata_fis_header *frame_header;
         u32 *frame_buffer;
-        struct scic_sds_stp_request *this_request;
+        struct scic_sds_stp_request *sci_req;
 
-        this_request = (struct scic_sds_stp_request *)request;
+        sci_req = (struct scic_sds_stp_request *)request;
 
         status = scic_sds_unsolicited_frame_control_get_header(
-                &(this_request->parent.owning_controller->uf_control),
+                &(sci_req->parent.owning_controller->uf_control),
                 frame_index,
                 (void **)&frame_header
                 );
@@ -369,7 +369,7 @@ enum sci_status scic_sds_stp_packet_request_packet_phase_await_pio_setup_frame_h
                  * Get from the frame buffer the PIO Setup Data, although we don't need
                  * any info from this pio setup fis. */
                 scic_sds_unsolicited_frame_control_get_buffer(
-                        &(this_request->parent.owning_controller->uf_control),
+                        &(sci_req->parent.owning_controller->uf_control),
                         frame_index,
                         (void **)&frame_buffer
                         );
@@ -378,23 +378,23 @@ enum sci_status scic_sds_stp_packet_request_packet_phase_await_pio_setup_frame_h
                  * 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 */
-                this_request->type.packet.device_preferred_cdb_length =
+                sci_req->type.packet.device_preferred_cdb_length =
                         (u16)((struct sata_fis_pio_setup *)(&frame_buffer[-1]))->transfter_count;
 
                 /* Frame has been decoded return it to the controller */
                 scic_sds_controller_release_frame(
-                        this_request->parent.owning_controller, frame_index
+                        sci_req->parent.owning_controller, frame_index
                         );
 
                 sci_base_state_machine_change_state(
-                        &this_request->parent.started_substate_machine,
+                        &sci_req->parent.started_substate_machine,
                         SCIC_SDS_STP_PACKET_REQUEST_STARTED_COMMAND_PHASE_AWAIT_TC_COMPLETION_SUBSTATE
                         );
         } else
                 dev_err(scic_to_dev(request->owning_controller),
                         "%s: SCIC IO Request 0x%p could not get frame header "
                         "for frame index %d, status %x\n",
-                        __func__, this_request, frame_index, status);
+                        __func__, sci_req, frame_index, status);
 
         return status;
 }
@@ -406,7 +406,7 @@ enum sci_status scic_sds_stp_packet_request_packet_phase_await_pio_setup_frame_h
  *    successfully, then the state for the packet request transits to COMPLETE
  *    state. If not successfuly, the request transits to
  *    COMMAND_PHASE_AWAIT_D2H_FIS_SUBSTATE.
- * @this_request: This parameter specifies the request for which the TC
+ * @sci_req: This parameter specifies the request for which the TC
  *    completion was received.
  * @completion_code: This parameter indicates the completion status information
  *    for the TC.
@@ -415,64 +415,64 @@ enum sci_status scic_sds_stp_packet_request_packet_phase_await_pio_setup_frame_h
  * this method always returns success.
  */
 enum sci_status scic_sds_stp_packet_request_command_phase_await_tc_completion_tc_completion_handler(
-        struct scic_sds_request *this_request,
+        struct scic_sds_request *sci_req,
         u32 completion_code)
 {
         enum sci_status status = SCI_SUCCESS;
         u8 sat_packet_protocol =
-                scic_cb_request_get_sat_protocol(this_request->user_request);
+                scic_cb_request_get_sat_protocol(sci_req->user_request);
 
         switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
         case (SCU_TASK_DONE_GOOD << SCU_COMPLETION_TL_STATUS_SHIFT):
                 scic_sds_request_set_status(
-                        this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+                        sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
                         );
 
                 if (sat_packet_protocol == SAT_PROTOCOL_PACKET_DMA_DATA_IN
                      || sat_packet_protocol == SAT_PROTOCOL_PACKET_DMA_DATA_OUT
                      )
                         sci_base_state_machine_change_state(
-                                &this_request->parent.state_machine,
+                                &sci_req->parent.state_machine,
                                 SCI_BASE_REQUEST_STATE_COMPLETED
                                 );
                 else
                         sci_base_state_machine_change_state(
-                                &this_request->started_substate_machine,
+                                &sci_req->started_substate_machine,
                                 SCIC_SDS_STP_PACKET_REQUEST_STARTED_COMMAND_PHASE_AWAIT_D2H_FIS_SUBSTATE
                                 );
                 break;
 
         case (SCU_TASK_DONE_UNEXP_FIS << SCU_COMPLETION_TL_STATUS_SHIFT):
-                if (scic_io_request_get_number_of_bytes_transferred(this_request) <
-                    scic_cb_io_request_get_transfer_length(this_request->user_request)) {
+                if (scic_io_request_get_number_of_bytes_transferred(sci_req) <
+                    scic_cb_io_request_get_transfer_length(sci_req->user_request)) {
                         scic_sds_request_set_status(
-                                this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS_IO_DONE_EARLY
+                                sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS_IO_DONE_EARLY
                                 );
 
                         sci_base_state_machine_change_state(
-                                &this_request->parent.state_machine,
+                                &sci_req->parent.state_machine,
                                 SCI_BASE_REQUEST_STATE_COMPLETED
                                 );
 
-                        status = this_request->sci_status;
+                        status = sci_req->sci_status;
                 }
                 break;
 
         case (SCU_TASK_DONE_EXCESS_DATA << SCU_COMPLETION_TL_STATUS_SHIFT):
                 /* In this case, there is no UF coming after. compelte the IO now. */
                 scic_sds_request_set_status(
-                        this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+                        sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
                         );
 
                 sci_base_state_machine_change_state(
-                        &this_request->parent.state_machine,
+                        &sci_req->parent.state_machine,
                         SCI_BASE_REQUEST_STATE_COMPLETED
                         );
 
                 break;
 
         default:
-                if (this_request->sci_status != SCI_SUCCESS) {  /* The io status was set already. This means an UF for the status
+                if (sci_req->sci_status != SCI_SUCCESS) {  /* The io status was set already. This means an UF for the status
                                                                  * fis was received already.
                                                                  */
 
@@ -480,28 +480,28 @@ enum sci_status scic_sds_stp_packet_request_command_phase_await_tc_completion_tc
                          * A device suspension event is expected, we need to have the device
                          * coming out of suspension, then complete the IO. */
                         sci_base_state_machine_change_state(
-                                &this_request->started_substate_machine,
+                                &sci_req->started_substate_machine,
                                 SCIC_SDS_STP_PACKET_REQUEST_STARTED_COMPLETION_DELAY_SUBSTATE
                                 );
 
                         /* change the device state to ATAPI_ERROR. */
                         sci_base_state_machine_change_state(
-                                &this_request->target_device->ready_substate_machine,
+                                &sci_req->target_device->ready_substate_machine,
                                 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_ATAPI_ERROR
                                 );
 
-                        status = this_request->sci_status;
+                        status = sci_req->sci_status;
                 } else {  /* If receiving any non-sucess TC status, no UF received yet, then an UF for
                            * the status fis is coming after.
                            */
                         scic_sds_request_set_status(
-                                this_request,
+                                sci_req,
                                 SCU_TASK_DONE_CHECK_RESPONSE,
                                 SCI_FAILURE_IO_RESPONSE_VALID
                                 );
 
                         sci_base_state_machine_change_state(
-                                &this_request->started_substate_machine,
+                                &sci_req->started_substate_machine,
                                 SCIC_SDS_STP_PACKET_REQUEST_STARTED_COMMAND_PHASE_AWAIT_D2H_FIS_SUBSTATE
                                 );
                 }
@@ -514,7 +514,7 @@ enum sci_status scic_sds_stp_packet_request_command_phase_await_tc_completion_tc
 
 /**
  * This method processes an unsolicited frame.
- * @this_request: This parameter specifies the request for which the
+ * @sci_req: This parameter specifies the request for which the
  *    unsolicited frame was received.
  * @frame_index: This parameter indicates the unsolicited frame index that
  *    should contain the response.
@@ -530,12 +530,12 @@ enum sci_status scic_sds_stp_packet_request_command_phase_common_frame_handler(
         enum sci_status status;
         struct sata_fis_header *frame_header;
         u32 *frame_buffer;
-        struct scic_sds_stp_request *this_request;
+        struct scic_sds_stp_request *sci_req;
 
-        this_request = (struct scic_sds_stp_request *)request;
+        sci_req = (struct scic_sds_stp_request *)request;
 
         status = scic_sds_unsolicited_frame_control_get_header(
-                &(this_request->parent.owning_controller->uf_control),
+                &(sci_req->parent.owning_controller->uf_control),
                 frame_index,
                 (void **)&frame_header
                 );
@@ -547,18 +547,18 @@ enum sci_status scic_sds_stp_packet_request_command_phase_common_frame_handler(
                  * Get from the frame buffer the PIO Setup Data, although we don't need
                  * any info from this pio setup fis. */
                 scic_sds_unsolicited_frame_control_get_buffer(
-                        &(this_request->parent.owning_controller->uf_control),
+                        &(sci_req->parent.owning_controller->uf_control),
                         frame_index,
                         (void **)&frame_buffer
                         );
 
                 scic_sds_controller_copy_sata_response(
-                        &this_request->d2h_reg_fis, (u32 *)frame_header, frame_buffer
+                        &sci_req->d2h_reg_fis, (u32 *)frame_header, frame_buffer
                         );
 
                 /* Frame has been decoded return it to the controller */
                 scic_sds_controller_release_frame(
-                        this_request->parent.owning_controller, frame_index
+                        sci_req->parent.owning_controller, frame_index
                         );
         }
 
@@ -568,7 +568,7 @@ enum sci_status scic_sds_stp_packet_request_command_phase_common_frame_handler(
 /**
  * This method processes an unsolicited frame while the packet request is
  *    expecting TC completion. It will process the FIS and construct sense data.
- * @this_request: This parameter specifies the request for which the
+ * @sci_req: This parameter specifies the request for which the
  *    unsolicited frame was received.
  * @frame_index: This parameter indicates the unsolicited frame index that
  *    should contain the response.
@@ -581,7 +581,7 @@ enum sci_status scic_sds_stp_packet_request_command_phase_await_tc_completion_fr
         struct scic_sds_request *request,
         u32 frame_index)
 {
-        struct scic_sds_stp_request *this_request = (struct scic_sds_stp_request *)request;
+        struct scic_sds_stp_request *sci_req = (struct scic_sds_stp_request *)request;
 
         enum sci_status status =
                 scic_sds_stp_packet_request_command_phase_common_frame_handler(
@@ -590,17 +590,17 @@ enum sci_status scic_sds_stp_packet_request_command_phase_await_tc_completion_fr
         if (status == SCI_SUCCESS) {
                 /* The command has completed with error status from target device. */
                 status = scic_sds_stp_packet_request_process_status_fis(
-                        request, &this_request->d2h_reg_fis);
+                        request, &sci_req->d2h_reg_fis);
 
                 if (status != SCI_SUCCESS) {
                         scic_sds_request_set_status(
-                                &this_request->parent,
+                                &sci_req->parent,
                                 SCU_TASK_DONE_CHECK_RESPONSE,
                                 status
                                 );
                 } else
                         scic_sds_request_set_status(
-                                &this_request->parent, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+                                &sci_req->parent, SCU_TASK_DONE_GOOD, SCI_SUCCESS
                                 );
         }
 
@@ -611,7 +611,7 @@ enum sci_status scic_sds_stp_packet_request_command_phase_await_tc_completion_fr
 /**
  * This method processes an unsolicited frame while the packet request is
  *    expecting TC completion. It will process the FIS and construct sense data.
- * @this_request: This parameter specifies the request for which the
+ * @sci_req: This parameter specifies the request for which the
  *    unsolicited frame was received.
  * @frame_index: This parameter indicates the unsolicited frame index that
  *    should contain the response.
@@ -628,12 +628,12 @@ enum sci_status scic_sds_stp_packet_request_command_phase_await_d2h_fis_frame_ha
                 scic_sds_stp_packet_request_command_phase_common_frame_handler(
                         request, frame_index);
 
-        struct scic_sds_stp_request *this_request = (struct scic_sds_stp_request *)request;
+        struct scic_sds_stp_request *sci_req = (struct scic_sds_stp_request *)request;
 
         if (status == SCI_SUCCESS) {
                 /* The command has completed with error status from target device. */
                 status = scic_sds_stp_packet_request_process_status_fis(
-                        request, &this_request->d2h_reg_fis);
+                        request, &sci_req->d2h_reg_fis);
 
                 if (status != SCI_SUCCESS) {
                         scic_sds_request_set_status(
@@ -696,26 +696,26 @@ const struct scic_sds_io_request_state_handler scic_sds_stp_packet_request_start
 void scic_sds_stp_packet_request_started_packet_phase_await_tc_completion_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+        struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
 
         SET_STATE_HANDLER(
-                this_request,
+                sci_req,
                 scic_sds_stp_packet_request_started_substate_handler_table,
                 SCIC_SDS_STP_PACKET_REQUEST_STARTED_PACKET_PHASE_AWAIT_TC_COMPLETION_SUBSTATE
                 );
 
         scic_sds_remote_device_set_working_request(
-                this_request->target_device, this_request
+                sci_req->target_device, sci_req
                 );
 }
 
 void scic_sds_stp_packet_request_started_packet_phase_await_pio_setup_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+        struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
 
         SET_STATE_HANDLER(
-                this_request,
+                sci_req,
                 scic_sds_stp_packet_request_started_substate_handler_table,
                 SCIC_SDS_STP_PACKET_REQUEST_STARTED_PACKET_PHASE_AWAIT_PIO_SETUP_SUBSTATE
                 );
@@ -724,9 +724,9 @@ void scic_sds_stp_packet_request_started_packet_phase_await_pio_setup_enter(
 void scic_sds_stp_packet_request_started_command_phase_await_tc_completion_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+        struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
         u8 sat_packet_protocol =
-                scic_cb_request_get_sat_protocol(this_request->user_request);
+                scic_cb_request_get_sat_protocol(sci_req->user_request);
 
         struct scu_task_context *task_context;
         enum sci_status status;
@@ -735,25 +735,25 @@ void scic_sds_stp_packet_request_started_command_phase_await_tc_completion_enter
          * Recycle the TC and reconstruct it for sending out data fis containing
          * CDB. */
         task_context = scic_sds_controller_get_task_context_buffer(
-                this_request->owning_controller, this_request->io_tag);
+                sci_req->owning_controller, sci_req->io_tag);
 
         if (sat_packet_protocol == SAT_PROTOCOL_PACKET_NON_DATA)
                 scu_stp_packet_request_command_phase_reconstruct_raw_frame_task_context(
-                        this_request, task_context);
+                        sci_req, task_context);
         else
                 scu_stp_packet_request_command_phase_construct_task_context(
-                        this_request, task_context);
+                        sci_req, task_context);
 
         /* send the new TC out. */
-        status = this_request->owning_controller->state_handlers->parent.continue_io_handler(
-                &this_request->owning_controller->parent,
-                &this_request->target_device->parent,
-                &this_request->parent
+        status = sci_req->owning_controller->state_handlers->parent.continue_io_handler(
+                &sci_req->owning_controller->parent,
+                &sci_req->target_device->parent,
+                &sci_req->parent
                 );
 
         if (status == SCI_SUCCESS)
                 SET_STATE_HANDLER(
-                        this_request,
+                        sci_req,
                         scic_sds_stp_packet_request_started_substate_handler_table,
                         SCIC_SDS_STP_PACKET_REQUEST_STARTED_COMMAND_PHASE_AWAIT_TC_COMPLETION_SUBSTATE
                         );
@@ -762,10 +762,10 @@ void scic_sds_stp_packet_request_started_command_phase_await_tc_completion_enter
 void scic_sds_stp_packet_request_started_command_phase_await_d2h_fis_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+        struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
 
         SET_STATE_HANDLER(
-                this_request,
+                sci_req,
                 scic_sds_stp_packet_request_started_substate_handler_table,
                 SCIC_SDS_STP_PACKET_REQUEST_STARTED_COMMAND_PHASE_AWAIT_D2H_FIS_SUBSTATE
                 );
@@ -774,10 +774,10 @@ void scic_sds_stp_packet_request_started_command_phase_await_d2h_fis_enter(
 void scic_sds_stp_packet_request_started_completion_delay_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+        struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
 
         SET_STATE_HANDLER(
-                this_request,
+                sci_req,
                 scic_sds_stp_packet_request_started_substate_handler_table,
                 SCIC_SDS_STP_PACKET_REQUEST_STARTED_COMPLETION_DELAY_SUBSTATE
                 );
diff --git a/drivers/scsi/isci/core/scic_sds_stp_packet_request.h b/drivers/scsi/isci/core/scic_sds_stp_packet_request.h
index eebfff32216b..f6ff5a6f6645 100644
--- a/drivers/scsi/isci/core/scic_sds_stp_packet_request.h
+++ b/drivers/scsi/isci/core/scic_sds_stp_packet_request.h
@@ -113,14 +113,14 @@ extern const struct scic_sds_io_request_state_handler scic_sds_stp_packet_reques
 
 #if !defined(DISABLE_ATAPI)
 enum sci_status scic_sds_stp_packet_request_construct(
-        struct scic_sds_request *this_request);
+        struct scic_sds_request *sci_req);
 #else  /* !defined(DISABLE_ATAPI) */
 #define scic_sds_stp_packet_request_construct(request) SCI_FAILURE
 #endif /* !defined(DISABLE_ATAPI) */
 
 #if !defined(DISABLE_ATAPI)
 void scu_stp_packet_request_command_phase_construct_task_context(
-        struct scic_sds_request *this_request,
+        struct scic_sds_request *sci_req,
         struct scu_task_context *task_context);
 #else  /* !defined(DISABLE_ATAPI) */
 #define scu_stp_packet_request_command_phase_construct_task_context(reqeust, tc)
@@ -128,7 +128,7 @@ void scu_stp_packet_request_command_phase_construct_task_context(
 
 #if !defined(DISABLE_ATAPI)
 void scu_stp_packet_request_command_phase_reconstruct_raw_frame_task_context(
-        struct scic_sds_request *this_request,
+        struct scic_sds_request *sci_req,
         struct scu_task_context *task_context);
 #else  /* !defined(DISABLE_ATAPI) */
 #define scu_stp_packet_request_command_phase_reconstruct_raw_frame_task_context(reqeust, tc)
@@ -136,7 +136,7 @@ void scu_stp_packet_request_command_phase_reconstruct_raw_frame_task_context(
 
 #if !defined(DISABLE_ATAPI)
 enum sci_status scic_sds_stp_packet_request_process_status_fis(
-        struct scic_sds_request *this_request,
+        struct scic_sds_request *sci_req,
         struct sata_fis_reg_d2h *status_fis);
 #else  /* !defined(DISABLE_ATAPI) */
 #define scic_sds_stp_packet_request_process_status_fis(reqeust, fis) SCI_FAILURE
@@ -144,7 +144,7 @@ enum sci_status scic_sds_stp_packet_request_process_status_fis(
 
 #if !defined(DISABLE_ATAPI)
 void scic_sds_stp_packet_internal_request_sense_build_sgl(
-        struct scic_sds_request *this_request);
+        struct scic_sds_request *sci_req);
 #else  /* !defined(DISABLE_ATAPI) */
 #define scic_sds_stp_packet_internal_request_sense_build_sgl(request)
 #endif /* !defined(DISABLE_ATAPI) */
diff --git a/drivers/scsi/isci/core/scic_sds_stp_remote_device.c b/drivers/scsi/isci/core/scic_sds_stp_remote_device.c
index a5b1fe3229ce..b15357b2ce08 100644
--- a/drivers/scsi/isci/core/scic_sds_stp_remote_device.c
+++ b/drivers/scsi/isci/core/scic_sds_stp_remote_device.c
@@ -252,18 +252,18 @@ out:
  * resume the RNC right away. enum sci_status
  */
 static enum sci_status scic_sds_stp_remote_device_ready_idle_substate_event_handler(
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         u32 event_code)
 {
         enum sci_status status;
 
-        status = scic_sds_remote_device_general_event_handler(this_device, event_code);
+        status = scic_sds_remote_device_general_event_handler(sci_dev, event_code);
 
         if (status == SCI_SUCCESS) {
                 if (scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX
                     || scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX) {
                         status = scic_sds_remote_node_context_resume(
-                                this_device->rnc, NULL, NULL);
+                                sci_dev->rnc, NULL, NULL);
                 }
         }
 
@@ -312,21 +312,21 @@ static enum sci_status scic_sds_stp_remote_device_ready_ncq_substate_start_io_ha
 /**
  * This method will handle events received while the STP device is in the ready
  *    command substate.
- * @this_device: This is the device object that is receiving the event.
+ * @sci_dev: This is the device object that is receiving the event.
  * @event_code: The event code to process.
  *
  * enum sci_status
  */
 
 static enum sci_status scic_sds_stp_remote_device_ready_ncq_substate_frame_handler(
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         u32 frame_index)
 {
         enum sci_status status;
         struct sata_fis_header *frame_header;
 
         status = scic_sds_unsolicited_frame_control_get_header(
-                &(scic_sds_remote_device_get_controller(this_device)->uf_control),
+                &(scic_sds_remote_device_get_controller(sci_dev)->uf_control),
                 frame_index,
                 (void **)&frame_header
                 );
@@ -334,7 +334,7 @@ static enum sci_status scic_sds_stp_remote_device_ready_ncq_substate_frame_handl
         if (status == SCI_SUCCESS) {
                 if (frame_header->fis_type == SATA_FIS_TYPE_SETDEVBITS &&
                     (frame_header->status & ATA_STATUS_REG_ERROR_BIT)) {
-                        this_device->not_ready_reason =
+                        sci_dev->not_ready_reason =
                                 SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED;
 
                         /*
@@ -343,7 +343,7 @@ static enum sci_status scic_sds_stp_remote_device_ready_ncq_substate_frame_handl
                          */
 
                         sci_base_state_machine_change_state(
-                                &this_device->ready_substate_machine,
+                                &sci_dev->ready_substate_machine,
                                 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR
                                 );
                 } else if (frame_header->fis_type == SATA_FIS_TYPE_REGD2H &&
@@ -353,11 +353,11 @@ static enum sci_status scic_sds_stp_remote_device_ready_ncq_substate_frame_handl
                          * Some devices return D2H FIS when an NCQ error is detected.
                          * Treat this like an SDB error FIS ready reason.
                          */
-                        this_device->not_ready_reason =
+                        sci_dev->not_ready_reason =
                                 SCIC_REMOTE_DEVICE_NOT_READY_SATA_SDB_ERROR_FIS_RECEIVED;
 
                         sci_base_state_machine_change_state(
-                                &this_device->ready_substate_machine,
+                                &sci_dev->ready_substate_machine,
                                 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_NCQ_ERROR
                                 );
                 } else {
@@ -365,7 +365,7 @@ static enum sci_status scic_sds_stp_remote_device_ready_ncq_substate_frame_handl
                 }
 
                 scic_sds_controller_release_frame(
-                        scic_sds_remote_device_get_controller(this_device), frame_index
+                        scic_sds_remote_device_get_controller(sci_dev), frame_index
                         );
         }
 
@@ -393,20 +393,20 @@ static enum sci_status scic_sds_stp_remote_device_ready_cmd_substate_start_io_ha
 }
 
 static enum sci_status scic_sds_stp_remote_device_ready_cmd_substate_suspend_handler(
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         u32 suspend_type)
 {
         enum sci_status status;
 
         status = scic_sds_remote_node_context_suspend(
-                this_device->rnc, suspend_type, NULL, NULL
+                sci_dev->rnc, suspend_type, NULL, NULL
                 );
 
         return status;
 }
 
 static enum sci_status scic_sds_stp_remote_device_ready_cmd_substate_frame_handler(
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         u32 frame_index)
 {
         enum sci_status status;
@@ -416,7 +416,7 @@ static enum sci_status scic_sds_stp_remote_device_ready_cmd_substate_frame_handl
          * / in this state.  All unsolicited frames are forwarded to the io request
          * / object. */
         status = scic_sds_io_request_frame_handler(
-                this_device->working_request,
+                sci_dev->working_request,
                 frame_index
                 );
 
@@ -461,14 +461,14 @@ static enum sci_status scic_sds_stp_remote_device_ready_await_reset_substate_com
         struct scic_sds_remote_device *device,
         struct scic_sds_request *request)
 {
-        struct scic_sds_request *the_request = (struct scic_sds_request *)request;
+        struct scic_sds_request *sci_req = (struct scic_sds_request *)request;
         enum sci_status status;
 
-        status = scic_sds_io_request_complete(the_request);
+        status = scic_sds_io_request_complete(sci_req);
 
         if (status == SCI_SUCCESS) {
                 status = scic_sds_port_complete_io(
-                        device->owning_port, device, the_request
+                        device->owning_port, device, sci_req
                         );
 
                 if (status == SCI_SUCCESS)
@@ -482,7 +482,7 @@ static enum sci_status scic_sds_stp_remote_device_ready_await_reset_substate_com
                         __func__,
                         device->owning_port,
                         device,
-                        the_request,
+                        sci_req,
                         status);
 
         return status;
@@ -505,20 +505,20 @@ static enum sci_status scic_sds_stp_remote_device_ready_await_reset_substate_com
  * this device. enum sci_status
  */
 enum sci_status scic_sds_stp_remote_device_ready_atapi_error_substate_event_handler(
-        struct scic_sds_remote_device *this_device,
+        struct scic_sds_remote_device *sci_dev,
         u32 event_code)
 {
         enum sci_status status;
 
-        status = scic_sds_remote_device_general_event_handler(this_device, event_code);
+        status = scic_sds_remote_device_general_event_handler(sci_dev, event_code);
 
         if (status == SCI_SUCCESS) {
                 if (scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX
                     || scu_get_event_type(event_code) == SCU_EVENT_TYPE_RNC_SUSPEND_TX_RX) {
                         status = scic_sds_remote_node_context_resume(
-                                this_device->rnc,
-                                this_device->working_request->state_handlers->parent.complete_handler,
-                                (void *)this_device->working_request
+                                sci_dev->rnc,
+                                sci_dev->working_request->state_handlers->parent.complete_handler,
+                                (void *)sci_dev->working_request
                                 );
                 }
         }
@@ -673,30 +673,30 @@ scic_sds_stp_remote_device_ready_idle_substate_resume_complete_handler(void *use
 static void scic_sds_stp_remote_device_ready_idle_substate_enter(
         struct sci_base_object *device)
 {
-        struct scic_sds_remote_device *this_device;
+        struct scic_sds_remote_device *sci_dev;
 
-        this_device = (struct scic_sds_remote_device *)device;
+        sci_dev = (struct scic_sds_remote_device *)device;
 
         SET_STATE_HANDLER(
-                this_device,
+                sci_dev,
                 scic_sds_stp_remote_device_ready_substate_handler_table,
                 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_IDLE
                 );
 
-        this_device->working_request = NULL;
+        sci_dev->working_request = NULL;
 
-        if (scic_sds_remote_node_context_is_ready(this_device->rnc)) {
+        if (scic_sds_remote_node_context_is_ready(sci_dev->rnc)) {
                 /*
                  * Since the RNC is ready, it's alright to finish completion
                  * processing (e.g. signal the remote device is ready). */
                 scic_sds_stp_remote_device_ready_idle_substate_resume_complete_handler(
-                        this_device
+                        sci_dev
                         );
         } else {
                 scic_sds_remote_node_context_resume(
-                        this_device->rnc,
+                        sci_dev->rnc,
                         scic_sds_stp_remote_device_ready_idle_substate_resume_complete_handler,
-                        this_device
+                        sci_dev
                         );
         }
 }
@@ -759,12 +759,12 @@ static void scic_sds_stp_remote_device_ready_ncq_error_substate_enter(struct sci
 static void scic_sds_stp_remote_device_ready_await_reset_substate_enter(
         struct sci_base_object *device)
 {
-        struct scic_sds_remote_device *this_device;
+        struct scic_sds_remote_device *sci_dev;
 
-        this_device = (struct scic_sds_remote_device *)device;
+        sci_dev = (struct scic_sds_remote_device *)device;
 
         SET_STATE_HANDLER(
-                this_device,
+                sci_dev,
                 scic_sds_stp_remote_device_ready_substate_handler_table,
                 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_AWAIT_RESET
                 );
@@ -785,12 +785,12 @@ static void scic_sds_stp_remote_device_ready_await_reset_substate_enter(
 void scic_sds_stp_remote_device_ready_atapi_error_substate_enter(
         struct sci_base_object *device)
 {
-        struct scic_sds_remote_device *this_device;
+        struct scic_sds_remote_device *sci_dev;
 
-        this_device = (struct scic_sds_remote_device *)device;
+        sci_dev = (struct scic_sds_remote_device *)device;
 
         SET_STATE_HANDLER(
-                this_device,
+                sci_dev,
                 scic_sds_stp_remote_device_ready_substate_handler_table,
                 SCIC_SDS_STP_REMOTE_DEVICE_READY_SUBSTATE_ATAPI_ERROR
                 );
diff --git a/drivers/scsi/isci/core/scic_sds_stp_request.c b/drivers/scsi/isci/core/scic_sds_stp_request.c
index e4ca4e40ae87..ab01f8d5506b 100644
--- a/drivers/scsi/isci/core/scic_sds_stp_request.c
+++ b/drivers/scsi/isci/core/scic_sds_stp_request.c
@@ -156,7 +156,7 @@ void scic_sds_stp_request_assign_buffers(struct scic_sds_request *sci_req)
 /**
  * This method is will fill in the SCU Task Context for any type of SATA
  *    request.  This is called from the various SATA constructors.
- * @this_request: The general IO request object which is to be used in
+ * @sci_req: The general IO request object which is to be used in
  *    constructing the SCU task context.
  * @task_context: The buffer pointer for the SCU task context which is being
  *    constructed.
@@ -262,15 +262,15 @@ static void scu_sata_reqeust_construct_task_context(
 
 /**
  *
- * @this_request:
+ * @sci_req:
  *
  * This method will perform any general sata request construction. What part of
  * SATA IO request construction is general? none
  */
 static void scic_sds_stp_non_ncq_request_construct(
-        struct scic_sds_request *this_request)
+        struct scic_sds_request *sci_req)
 {
-        this_request->has_started_substate_machine = true;
+        sci_req->has_started_substate_machine = true;
 }
 
 /**
@@ -338,7 +338,7 @@ enum sci_status scic_sds_stp_ncq_request_construct(struct scic_sds_request *sci_
 
 /**
  * scu_stp_raw_request_construct_task_context -
- * @this_request: This parameter specifies the STP request object for which to
+ * @sci_req: This parameter specifies the STP request object for which to
  *    construct a RAW command frame task context.
  * @task_context: This parameter specifies the SCU specific task context buffer
  *    to construct.
@@ -347,10 +347,10 @@ enum sci_status scic_sds_stp_ncq_request_construct(struct scic_sds_request *sci_
  * utilizing the raw frame method. none
  */
 static void scu_stp_raw_request_construct_task_context(
-        struct scic_sds_stp_request *this_request,
+        struct scic_sds_stp_request *sci_req,
         struct scu_task_context *task_context)
 {
-        scu_sata_reqeust_construct_task_context(&this_request->parent, task_context);
+        scu_sata_reqeust_construct_task_context(&sci_req->parent, task_context);
 
         task_context->control_frame         = 0;
         task_context->priority              = SCU_TASK_PRIORITY_NORMAL;
@@ -386,7 +386,7 @@ void *scic_stp_io_request_get_d2h_reg_address(
 
 /**
  *
- * @this_request:
+ * @sci_req:
  *
  * Get the next SGL element from the request. - Check on which SGL element pair
  * we are working - if working on SLG pair element A - advance to element B -
@@ -430,7 +430,7 @@ static struct scu_sgl_element *scic_sds_stp_request_pio_get_next_sgl(struct scic
 
 /**
  *
- * @this_request:
+ * @sci_req:
  * @completion_code:
  *
  * This method processes a TC completion.  The expected TC completion is for
@@ -439,17 +439,17 @@ static struct scu_sgl_element *scic_sds_stp_request_pio_get_next_sgl(struct scic
  * SCI_SUCCESS This value is always returned.
  */
 static enum sci_status scic_sds_stp_request_non_data_await_h2d_tc_completion_handler(
-        struct scic_sds_request *this_request,
+        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(
-                        this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+                        sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
                         );
 
                 sci_base_state_machine_change_state(
-                        &this_request->started_substate_machine,
+                        &sci_req->started_substate_machine,
                         SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_D2H_SUBSTATE
                         );
                 break;
@@ -459,13 +459,13 @@ static enum sci_status scic_sds_stp_request_non_data_await_h2d_tc_completion_han
                  * 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(
-                        this_request,
+                        sci_req,
                         SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
                         SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
                         );
 
                 sci_base_state_machine_change_state(
-                        &this_request->state_machine, SCI_BASE_REQUEST_STATE_COMPLETED);
+                        &sci_req->state_machine, SCI_BASE_REQUEST_STATE_COMPLETED);
                 break;
         }
 
@@ -491,10 +491,10 @@ static enum sci_status scic_sds_stp_request_non_data_await_d2h_frame_handler(
         enum sci_status status;
         struct sata_fis_header *frame_header;
         u32 *frame_buffer;
-        struct scic_sds_stp_request *this_request = (struct scic_sds_stp_request *)request;
+        struct scic_sds_stp_request *sci_req = (struct scic_sds_stp_request *)request;
 
         status = scic_sds_unsolicited_frame_control_get_header(
-                &this_request->parent.owning_controller->uf_control,
+                &sci_req->parent.owning_controller->uf_control,
                 frame_index,
                 (void **)&frame_header
                 );
@@ -503,18 +503,18 @@ static enum sci_status scic_sds_stp_request_non_data_await_d2h_frame_handler(
                 switch (frame_header->fis_type) {
                 case SATA_FIS_TYPE_REGD2H:
                         scic_sds_unsolicited_frame_control_get_buffer(
-                                &this_request->parent.owning_controller->uf_control,
+                                &sci_req->parent.owning_controller->uf_control,
                                 frame_index,
                                 (void **)&frame_buffer
                                 );
 
                         scic_sds_controller_copy_sata_response(
-                                &this_request->d2h_reg_fis, (u32 *)frame_header, frame_buffer
+                                &sci_req->d2h_reg_fis, (u32 *)frame_header, frame_buffer
                                 );
 
                         /* The command has completed with error */
                         scic_sds_request_set_status(
-                                &this_request->parent,
+                                &sci_req->parent,
                                 SCU_TASK_DONE_CHECK_RESPONSE,
                                 SCI_FAILURE_IO_RESPONSE_VALID
                                 );
@@ -524,10 +524,10 @@ static enum sci_status scic_sds_stp_request_non_data_await_d2h_frame_handler(
                         dev_warn(scic_to_dev(request->owning_controller),
                                  "%s: IO Request:0x%p Frame Id:%d protocol "
                                  "violation occurred\n",
-                                 __func__, this_request, frame_index);
+                                 __func__, sci_req, frame_index);
 
                         scic_sds_request_set_status(
-                                &this_request->parent,
+                                &sci_req->parent,
                                 SCU_TASK_DONE_UNEXP_FIS,
                                 SCI_FAILURE_PROTOCOL_VIOLATION
                                 );
@@ -535,18 +535,18 @@ static enum sci_status scic_sds_stp_request_non_data_await_d2h_frame_handler(
                 }
 
                 sci_base_state_machine_change_state(
-                        &this_request->parent.state_machine,
+                        &sci_req->parent.state_machine,
                         SCI_BASE_REQUEST_STATE_COMPLETED
                         );
 
                 /* Frame has been decoded return it to the controller */
                 scic_sds_controller_release_frame(
-                        this_request->parent.owning_controller, frame_index);
+                        sci_req->parent.owning_controller, frame_index);
         } else
                 dev_err(scic_to_dev(request->owning_controller),
                         "%s: SCIC IO Request 0x%p could not get frame header "
                         "for frame index %d, status %x\n",
-                        __func__, this_request, frame_index, status);
+                        __func__, sci_req, frame_index, status);
 
         return status;
 }
@@ -567,26 +567,26 @@ static const struct scic_sds_io_request_state_handler scic_sds_stp_request_start
 static void scic_sds_stp_request_started_non_data_await_h2d_completion_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+        struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
 
         SET_STATE_HANDLER(
-                this_request,
+                sci_req,
                 scic_sds_stp_request_started_non_data_substate_handler_table,
                 SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_H2D_COMPLETION_SUBSTATE
                 );
 
         scic_sds_remote_device_set_working_request(
-                this_request->target_device, this_request
+                sci_req->target_device, sci_req
                 );
 }
 
 static void scic_sds_stp_request_started_non_data_await_d2h_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+        struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
 
         SET_STATE_HANDLER(
-                this_request,
+                sci_req,
                 scic_sds_stp_request_started_non_data_substate_handler_table,
                 SCIC_SDS_STP_REQUEST_STARTED_NON_DATA_AWAIT_D2H_SUBSTATE
                 );
@@ -624,7 +624,7 @@ enum sci_status scic_sds_stp_non_data_request_construct(struct scic_sds_request
 
 /**
  *
- * @this_request:
+ * @sci_req:
  * @length:
  *
  * This function will transmit DATA_FIS from (current sgl + offset) for input
@@ -633,24 +633,24 @@ enum sci_status scic_sds_stp_non_data_request_construct(struct scic_sds_request
  */
 
 static enum sci_status scic_sds_stp_request_pio_data_out_trasmit_data_frame(
-        struct scic_sds_request *this_request,
+        struct scic_sds_request *sci_req,
         u32 length)
 {
-        struct scic_sds_stp_request *this_sds_stp_request = (struct scic_sds_stp_request *)this_request;
+        struct scic_sds_stp_request *stp_req = (struct scic_sds_stp_request *)sci_req;
         struct scu_sgl_element *current_sgl;
 
         /*
          * Recycle the TC and reconstruct it for sending out DATA FIS containing
          * for the data from current_sgl+offset for the input length */
         struct scu_task_context *task_context = scic_sds_controller_get_task_context_buffer(
-                this_request->owning_controller,
-                this_request->io_tag
+                sci_req->owning_controller,
+                sci_req->io_tag
                 );
 
-        if (this_sds_stp_request->type.pio.request_current.sgl_set == SCU_SGL_ELEMENT_PAIR_A)
-                current_sgl = &(this_sds_stp_request->type.pio.request_current.sgl_pair->A);
+        if (stp_req->type.pio.request_current.sgl_set == SCU_SGL_ELEMENT_PAIR_A)
+                current_sgl = &(stp_req->type.pio.request_current.sgl_pair->A);
         else
-                current_sgl = &(this_sds_stp_request->type.pio.request_current.sgl_pair->B);
+                current_sgl = &(stp_req->type.pio.request_current.sgl_pair->B);
 
         /* update the TC */
         task_context->command_iu_upper = current_sgl->address_upper;
@@ -659,17 +659,17 @@ static enum sci_status scic_sds_stp_request_pio_data_out_trasmit_data_frame(
         task_context->type.stp.fis_type = SATA_FIS_TYPE_DATA;
 
         /* send the new TC out. */
-        return scic_controller_continue_io(this_request);
+        return scic_controller_continue_io(sci_req);
 }
 
 /**
  *
- * @this_request:
+ * @sci_req:
  *
  * enum sci_status
  */
 static enum sci_status scic_sds_stp_request_pio_data_out_transmit_data(
-        struct scic_sds_request *this_sds_request)
+        struct scic_sds_request *sci_req)
 {
 
         struct scu_sgl_element *current_sgl;
@@ -677,45 +677,45 @@ static enum sci_status scic_sds_stp_request_pio_data_out_transmit_data(
         u32 remaining_bytes_in_current_sgl = 0;
         enum sci_status status = SCI_SUCCESS;
 
-        struct scic_sds_stp_request *this_sds_stp_request = (struct scic_sds_stp_request *)this_sds_request;
+        struct scic_sds_stp_request *stp_req = (struct scic_sds_stp_request *)sci_req;
 
-        sgl_offset = this_sds_stp_request->type.pio.request_current.sgl_offset;
+        sgl_offset = stp_req->type.pio.request_current.sgl_offset;
 
-        if (this_sds_stp_request->type.pio.request_current.sgl_set == SCU_SGL_ELEMENT_PAIR_A) {
-                current_sgl = &(this_sds_stp_request->type.pio.request_current.sgl_pair->A);
-                remaining_bytes_in_current_sgl = this_sds_stp_request->type.pio.request_current.sgl_pair->A.length - sgl_offset;
+        if (stp_req->type.pio.request_current.sgl_set == SCU_SGL_ELEMENT_PAIR_A) {
+                current_sgl = &(stp_req->type.pio.request_current.sgl_pair->A);
+                remaining_bytes_in_current_sgl = stp_req->type.pio.request_current.sgl_pair->A.length - sgl_offset;
         } else {
-                current_sgl = &(this_sds_stp_request->type.pio.request_current.sgl_pair->B);
-                remaining_bytes_in_current_sgl = this_sds_stp_request->type.pio.request_current.sgl_pair->B.length - sgl_offset;
+                current_sgl = &(stp_req->type.pio.request_current.sgl_pair->B);
+                remaining_bytes_in_current_sgl = stp_req->type.pio.request_current.sgl_pair->B.length - sgl_offset;
         }
 
 
-        if (this_sds_stp_request->type.pio.pio_transfer_bytes > 0) {
-                if (this_sds_stp_request->type.pio.pio_transfer_bytes >= remaining_bytes_in_current_sgl) {
+        if (stp_req->type.pio.pio_transfer_bytes > 0) {
+                if (stp_req->type.pio.pio_transfer_bytes >= remaining_bytes_in_current_sgl) {
                         /* recycle the TC and send the H2D Data FIS from (current sgl + sgl_offset) and length = remaining_bytes_in_current_sgl */
-                        status = scic_sds_stp_request_pio_data_out_trasmit_data_frame(this_sds_request, remaining_bytes_in_current_sgl);
+                        status = scic_sds_stp_request_pio_data_out_trasmit_data_frame(sci_req, remaining_bytes_in_current_sgl);
                         if (status == SCI_SUCCESS) {
-                                this_sds_stp_request->type.pio.pio_transfer_bytes -= remaining_bytes_in_current_sgl;
+                                stp_req->type.pio.pio_transfer_bytes -= remaining_bytes_in_current_sgl;
 
                                 /* update the current sgl, sgl_offset and save for future */
-                                current_sgl = scic_sds_stp_request_pio_get_next_sgl(this_sds_stp_request);
+                                current_sgl = scic_sds_stp_request_pio_get_next_sgl(stp_req);
                                 sgl_offset = 0;
                         }
-                } else if (this_sds_stp_request->type.pio.pio_transfer_bytes < remaining_bytes_in_current_sgl) {
+                } else if (stp_req->type.pio.pio_transfer_bytes < remaining_bytes_in_current_sgl) {
                         /* recycle the TC and send the H2D Data FIS from (current sgl + sgl_offset) and length = type.pio.pio_transfer_bytes */
-                        scic_sds_stp_request_pio_data_out_trasmit_data_frame(this_sds_request, this_sds_stp_request->type.pio.pio_transfer_bytes);
+                        scic_sds_stp_request_pio_data_out_trasmit_data_frame(sci_req, stp_req->type.pio.pio_transfer_bytes);
 
                         if (status == SCI_SUCCESS) {
                                 /* Sgl offset will be adjusted and saved for future */
-                                sgl_offset += this_sds_stp_request->type.pio.pio_transfer_bytes;
-                                current_sgl->address_lower += this_sds_stp_request->type.pio.pio_transfer_bytes;
-                                this_sds_stp_request->type.pio.pio_transfer_bytes = 0;
+                                sgl_offset += stp_req->type.pio.pio_transfer_bytes;
+                                current_sgl->address_lower += stp_req->type.pio.pio_transfer_bytes;
+                                stp_req->type.pio.pio_transfer_bytes = 0;
                         }
                 }
         }
 
         if (status == SCI_SUCCESS) {
-                this_sds_stp_request->type.pio.request_current.sgl_offset = sgl_offset;
+                stp_req->type.pio.request_current.sgl_offset = sgl_offset;
         }
 
         return status;
@@ -772,13 +772,13 @@ scic_sds_stp_request_pio_data_in_copy_data_buffer(struct scic_sds_stp_request *s
 
 /**
  *
- * @this_request: The PIO DATA IN request that is to receive the data.
+ * @sci_req: The PIO DATA IN request that is to receive the data.
  * @data_buffer: The buffer to copy from.
  *
  * Copy the data buffer to the io request data region. enum sci_status
  */
 static enum sci_status scic_sds_stp_request_pio_data_in_copy_data(
-        struct scic_sds_stp_request *this_request,
+        struct scic_sds_stp_request *sci_req,
         u8 *data_buffer)
 {
         enum sci_status status;
@@ -786,19 +786,19 @@ static enum sci_status scic_sds_stp_request_pio_data_in_copy_data(
         /*
          * If there is less than 1K remaining in the transfer request
          * copy just the data for the transfer */
-        if (this_request->type.pio.pio_transfer_bytes < SCU_MAX_FRAME_BUFFER_SIZE) {
+        if (sci_req->type.pio.pio_transfer_bytes < SCU_MAX_FRAME_BUFFER_SIZE) {
                 status = scic_sds_stp_request_pio_data_in_copy_data_buffer(
-                        this_request, data_buffer, this_request->type.pio.pio_transfer_bytes);
+                        sci_req, data_buffer, sci_req->type.pio.pio_transfer_bytes);
 
                 if (status == SCI_SUCCESS)
-                        this_request->type.pio.pio_transfer_bytes = 0;
+                        sci_req->type.pio.pio_transfer_bytes = 0;
         } else {
                 /* We are transfering the whole frame so copy */
                 status = scic_sds_stp_request_pio_data_in_copy_data_buffer(
-                        this_request, data_buffer, SCU_MAX_FRAME_BUFFER_SIZE);
+                        sci_req, data_buffer, SCU_MAX_FRAME_BUFFER_SIZE);
 
                 if (status == SCI_SUCCESS)
-                        this_request->type.pio.pio_transfer_bytes -= SCU_MAX_FRAME_BUFFER_SIZE;
+                        sci_req->type.pio.pio_transfer_bytes -= SCU_MAX_FRAME_BUFFER_SIZE;
         }
 
         return status;
@@ -806,13 +806,13 @@ static enum sci_status scic_sds_stp_request_pio_data_in_copy_data(
 
 /**
  *
- * @this_request:
+ * @sci_req:
  * @completion_code:
  *
  * enum sci_status
  */
 static enum sci_status scic_sds_stp_request_pio_await_h2d_completion_tc_completion_handler(
-        struct scic_sds_request *this_request,
+        struct scic_sds_request *sci_req,
         u32 completion_code)
 {
         enum sci_status status = SCI_SUCCESS;
@@ -820,11 +820,11 @@ static enum sci_status scic_sds_stp_request_pio_await_h2d_completion_tc_completi
         switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
         case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
                 scic_sds_request_set_status(
-                        this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+                        sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
                         );
 
                 sci_base_state_machine_change_state(
-                        &this_request->started_substate_machine,
+                        &sci_req->started_substate_machine,
                         SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE
                         );
                 break;
@@ -834,13 +834,13 @@ static enum sci_status scic_sds_stp_request_pio_await_h2d_completion_tc_completi
                  * 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(
-                        this_request,
+                        sci_req,
                         SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
                         SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
                         );
 
                 sci_base_state_machine_change_state(
-                        &this_request->state_machine,
+                        &sci_req->state_machine,
                         SCI_BASE_REQUEST_STATE_COMPLETED
                         );
                 break;
@@ -851,7 +851,7 @@ static enum sci_status scic_sds_stp_request_pio_await_h2d_completion_tc_completi
 
 /**
  *
- * @this_request:
+ * @sci_req:
  * @frame_index:
  *
  * enum sci_status
@@ -863,12 +863,12 @@ static enum sci_status scic_sds_stp_request_pio_await_frame_frame_handler(
         enum sci_status status;
         struct sata_fis_header *frame_header;
         u32 *frame_buffer;
-        struct scic_sds_stp_request *this_request;
+        struct scic_sds_stp_request *sci_req;
 
-        this_request = (struct scic_sds_stp_request *)request;
+        sci_req = (struct scic_sds_stp_request *)request;
 
         status = scic_sds_unsolicited_frame_control_get_header(
-                &(this_request->parent.owning_controller->uf_control),
+                &(sci_req->parent.owning_controller->uf_control),
                 frame_index,
                 (void **)&frame_header
                 );
@@ -878,7 +878,7 @@ static enum sci_status scic_sds_stp_request_pio_await_frame_frame_handler(
                 case SATA_FIS_TYPE_PIO_SETUP:
                         /* Get from the frame buffer the PIO Setup Data */
                         scic_sds_unsolicited_frame_control_get_buffer(
-                                &(this_request->parent.owning_controller->uf_control),
+                                &(sci_req->parent.owning_controller->uf_control),
                                 frame_index,
                                 (void **)&frame_buffer
                                 );
@@ -887,30 +887,30 @@ static enum sci_status scic_sds_stp_request_pio_await_frame_frame_handler(
                          * 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 */
-                        this_request->type.pio.pio_transfer_bytes =
+                        sci_req->type.pio.pio_transfer_bytes =
                                 (u16)((struct sata_fis_pio_setup *)(&frame_buffer[-1]))->transfter_count;
-                        this_request->type.pio.ending_status =
+                        sci_req->type.pio.ending_status =
                                 (u8)((struct sata_fis_pio_setup *)(&frame_buffer[-1]))->ending_status;
 
                         scic_sds_controller_copy_sata_response(
-                                &this_request->d2h_reg_fis, (u32 *)frame_header, frame_buffer
+                                &sci_req->d2h_reg_fis, (u32 *)frame_header, frame_buffer
                                 );
 
-                        this_request->d2h_reg_fis.status =
-                                this_request->type.pio.ending_status;
+                        sci_req->d2h_reg_fis.status =
+                                sci_req->type.pio.ending_status;
 
                         /* The next state is dependent on whether the request was PIO Data-in or Data out */
-                        if (this_request->type.pio.sat_protocol == SAT_PROTOCOL_PIO_DATA_IN) {
+                        if (sci_req->type.pio.sat_protocol == SAT_PROTOCOL_PIO_DATA_IN) {
                                 sci_base_state_machine_change_state(
-                                        &this_request->parent.started_substate_machine,
+                                        &sci_req->parent.started_substate_machine,
                                         SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_IN_AWAIT_DATA_SUBSTATE
                                         );
-                        } else if (this_request->type.pio.sat_protocol == SAT_PROTOCOL_PIO_DATA_OUT) {
+                        } else if (sci_req->type.pio.sat_protocol == SAT_PROTOCOL_PIO_DATA_OUT) {
                                 /* Transmit data */
                                 status = scic_sds_stp_request_pio_data_out_transmit_data(request);
                                 if (status == SCI_SUCCESS) {
                                         sci_base_state_machine_change_state(
-                                                &this_request->parent.started_substate_machine,
+                                                &sci_req->parent.started_substate_machine,
                                                 SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_OUT_TRANSMIT_DATA_SUBSTATE
                                                 );
                                 }
@@ -919,7 +919,7 @@ static enum sci_status scic_sds_stp_request_pio_await_frame_frame_handler(
 
                 case SATA_FIS_TYPE_SETDEVBITS:
                         sci_base_state_machine_change_state(
-                                &this_request->parent.started_substate_machine,
+                                &sci_req->parent.started_substate_machine,
                                 SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE
                                 );
                         break;
@@ -927,22 +927,22 @@ static enum sci_status scic_sds_stp_request_pio_await_frame_frame_handler(
                 case SATA_FIS_TYPE_REGD2H:
                         if ((frame_header->status & ATA_STATUS_REG_BSY_BIT) == 0) {
                                 scic_sds_unsolicited_frame_control_get_buffer(
-                                        &(this_request->parent.owning_controller->uf_control),
+                                        &(sci_req->parent.owning_controller->uf_control),
                                         frame_index,
                                         (void **)&frame_buffer
                                         );
 
                                 scic_sds_controller_copy_sata_response(
-                                        &this_request->d2h_reg_fis, (u32 *)frame_header, frame_buffer);
+                                        &sci_req->d2h_reg_fis, (u32 *)frame_header, frame_buffer);
 
                                 scic_sds_request_set_status(
-                                        &this_request->parent,
+                                        &sci_req->parent,
                                         SCU_TASK_DONE_CHECK_RESPONSE,
                                         SCI_FAILURE_IO_RESPONSE_VALID
                                         );
 
                                 sci_base_state_machine_change_state(
-                                        &this_request->parent.state_machine,
+                                        &sci_req->parent.state_machine,
                                         SCI_BASE_REQUEST_STATE_COMPLETED
                                         );
                         } else {
@@ -954,7 +954,7 @@ static enum sci_status scic_sds_stp_request_pio_await_frame_frame_handler(
                                         "D2H Register FIS with BSY status "
                                         "0x%x\n",
                                         __func__,
-                                        this_request,
+                                        sci_req,
                                         frame_header->status);
                         }
                         break;
@@ -965,21 +965,21 @@ static enum sci_status scic_sds_stp_request_pio_await_frame_frame_handler(
 
                 /* Frame is decoded return it to the controller */
                 scic_sds_controller_release_frame(
-                        this_request->parent.owning_controller,
+                        sci_req->parent.owning_controller,
                         frame_index
                         );
         } else
                 dev_err(scic_to_dev(request->owning_controller),
                         "%s: SCIC IO Request 0x%p could not get frame header "
                         "for frame index %d, status %x\n",
-                        __func__, this_request, frame_index, status);
+                        __func__, sci_req, frame_index, status);
 
         return status;
 }
 
 /**
  *
- * @this_request:
+ * @sci_req:
  * @frame_index:
  *
  * enum sci_status
@@ -991,33 +991,33 @@ static enum sci_status scic_sds_stp_request_pio_data_in_await_data_frame_handler
         enum sci_status status;
         struct sata_fis_header *frame_header;
         struct sata_fis_data *frame_buffer;
-        struct scic_sds_stp_request *this_request;
+        struct scic_sds_stp_request *sci_req;
 
-        this_request = (struct scic_sds_stp_request *)request;
+        sci_req = (struct scic_sds_stp_request *)request;
 
         status = scic_sds_unsolicited_frame_control_get_header(
-                &(this_request->parent.owning_controller->uf_control),
+                &(sci_req->parent.owning_controller->uf_control),
                 frame_index,
                 (void **)&frame_header
                 );
 
         if (status == SCI_SUCCESS) {
                 if (frame_header->fis_type == SATA_FIS_TYPE_DATA) {
-                        if (this_request->type.pio.request_current.sgl_pair == NULL) {
-                                this_request->parent.saved_rx_frame_index = frame_index;
-                                this_request->type.pio.pio_transfer_bytes = 0;
+                        if (sci_req->type.pio.request_current.sgl_pair == NULL) {
+                                sci_req->parent.saved_rx_frame_index = frame_index;
+                                sci_req->type.pio.pio_transfer_bytes = 0;
                         } else {
                                 status = scic_sds_unsolicited_frame_control_get_buffer(
-                                        &(this_request->parent.owning_controller->uf_control),
+                                        &(sci_req->parent.owning_controller->uf_control),
                                         frame_index,
                                         (void **)&frame_buffer
                                         );
 
-                                status = scic_sds_stp_request_pio_data_in_copy_data(this_request, (u8 *)frame_buffer);
+                                status = scic_sds_stp_request_pio_data_in_copy_data(sci_req, (u8 *)frame_buffer);
 
                                 /* Frame is decoded return it to the controller */
                                 scic_sds_controller_release_frame(
-                                        this_request->parent.owning_controller,
+                                        sci_req->parent.owning_controller,
                                         frame_index
                                         );
                         }
@@ -1027,17 +1027,17 @@ static enum sci_status scic_sds_stp_request_pio_data_in_await_data_frame_handler
                          * for this data transfer */
                         if (
                                 (status == SCI_SUCCESS)
-                                && (this_request->type.pio.pio_transfer_bytes == 0)
+                                && (sci_req->type.pio.pio_transfer_bytes == 0)
                                 ) {
-                                if ((this_request->type.pio.ending_status & ATA_STATUS_REG_BSY_BIT) == 0) {
+                                if ((sci_req->type.pio.ending_status & ATA_STATUS_REG_BSY_BIT) == 0) {
                                         scic_sds_request_set_status(
-                                                &this_request->parent,
+                                                &sci_req->parent,
                                                 SCU_TASK_DONE_CHECK_RESPONSE,
                                                 SCI_FAILURE_IO_RESPONSE_VALID
                                                 );
 
                                         sci_base_state_machine_change_state(
-                                                &this_request->parent.state_machine,
+                                                &sci_req->parent.state_machine,
                                                 SCI_BASE_REQUEST_STATE_COMPLETED
                                                 );
                                 } else {
@@ -1053,24 +1053,24 @@ static enum sci_status scic_sds_stp_request_pio_data_in_await_data_frame_handler
                                 "with fis type 0x%02x when expecting a data "
                                 "fis.\n",
                                 __func__,
-                                this_request,
+                                sci_req,
                                 frame_index,
                                 frame_header->fis_type);
 
                         scic_sds_request_set_status(
-                                &this_request->parent,
+                                &sci_req->parent,
                                 SCU_TASK_DONE_GOOD,
                                 SCI_FAILURE_IO_REQUIRES_SCSI_ABORT
                                 );
 
                         sci_base_state_machine_change_state(
-                                &this_request->parent.state_machine,
+                                &sci_req->parent.state_machine,
                                 SCI_BASE_REQUEST_STATE_COMPLETED
                                 );
 
                         /* Frame is decoded return it to the controller */
                         scic_sds_controller_release_frame(
-                                this_request->parent.owning_controller,
+                                sci_req->parent.owning_controller,
                                 frame_index
                                 );
                 }
@@ -1078,7 +1078,7 @@ static enum sci_status scic_sds_stp_request_pio_data_in_await_data_frame_handler
                 dev_err(scic_to_dev(request->owning_controller),
                         "%s: SCIC IO Request 0x%p could not get frame header "
                         "for frame index %d, status %x\n",
-                        __func__, this_request, frame_index, status);
+                        __func__, sci_req, frame_index, status);
 
         return status;
 }
@@ -1086,31 +1086,31 @@ static enum sci_status scic_sds_stp_request_pio_data_in_await_data_frame_handler
 
 /**
  *
- * @this_request:
+ * @sci_req:
  * @completion_code:
  *
  * enum sci_status
  */
 static enum sci_status scic_sds_stp_request_pio_data_out_await_data_transmit_completion_tc_completion_handler(
 
-        struct scic_sds_request *this_request,
+        struct scic_sds_request *sci_req,
         u32 completion_code)
 {
         enum sci_status status                     = SCI_SUCCESS;
         bool all_frames_transferred     = false;
 
-        struct scic_sds_stp_request *this_scic_sds_stp_request = (struct scic_sds_stp_request *)this_request;
+        struct scic_sds_stp_request *stp_req = (struct scic_sds_stp_request *)sci_req;
 
         switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
         case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
                 /* Transmit data */
-                if (this_scic_sds_stp_request->type.pio.pio_transfer_bytes != 0) {
-                        status = scic_sds_stp_request_pio_data_out_transmit_data(this_request);
+                if (stp_req->type.pio.pio_transfer_bytes != 0) {
+                        status = scic_sds_stp_request_pio_data_out_transmit_data(sci_req);
                         if (status == SCI_SUCCESS) {
-                                if (this_scic_sds_stp_request->type.pio.pio_transfer_bytes == 0)
+                                if (stp_req->type.pio.pio_transfer_bytes == 0)
                                         all_frames_transferred = true;
                         }
-                } else if (this_scic_sds_stp_request->type.pio.pio_transfer_bytes == 0) {
+                } else if (stp_req->type.pio.pio_transfer_bytes == 0) {
                         /*
                          * this will happen if the all data is written at the
                          * first time after the pio setup fis is received
@@ -1124,7 +1124,7 @@ static enum sci_status scic_sds_stp_request_pio_data_out_await_data_transmit_com
                          * Change the state to SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_IN_AWAIT_FRAME_SUBSTATE
                          * and wait for PIO_SETUP fis / or D2H REg fis. */
                         sci_base_state_machine_change_state(
-                                &this_request->started_substate_machine,
+                                &sci_req->started_substate_machine,
                                 SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE
                                 );
                 }
@@ -1135,13 +1135,13 @@ static enum sci_status scic_sds_stp_request_pio_data_out_await_data_transmit_com
                  * 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(
-                        this_request,
+                        sci_req,
                         SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
                         SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
                         );
 
                 sci_base_state_machine_change_state(
-                        &this_request->state_machine,
+                        &sci_req->state_machine,
                         SCI_BASE_REQUEST_STATE_COMPLETED
                         );
                 break;
@@ -1217,25 +1217,25 @@ static const struct scic_sds_io_request_state_handler scic_sds_stp_request_start
 static void scic_sds_stp_request_started_pio_await_h2d_completion_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+        struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
 
         SET_STATE_HANDLER(
-                this_request,
+                sci_req,
                 scic_sds_stp_request_started_pio_substate_handler_table,
                 SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_H2D_COMPLETION_SUBSTATE
                 );
 
         scic_sds_remote_device_set_working_request(
-                this_request->target_device, this_request);
+                sci_req->target_device, sci_req);
 }
 
 static void scic_sds_stp_request_started_pio_await_frame_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+        struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
 
         SET_STATE_HANDLER(
-                this_request,
+                sci_req,
                 scic_sds_stp_request_started_pio_substate_handler_table,
                 SCIC_SDS_STP_REQUEST_STARTED_PIO_AWAIT_FRAME_SUBSTATE
                 );
@@ -1244,10 +1244,10 @@ static void scic_sds_stp_request_started_pio_await_frame_enter(
 static void scic_sds_stp_request_started_pio_data_in_await_data_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+        struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
 
         SET_STATE_HANDLER(
-                this_request,
+                sci_req,
                 scic_sds_stp_request_started_pio_substate_handler_table,
                 SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_IN_AWAIT_DATA_SUBSTATE
                 );
@@ -1256,10 +1256,10 @@ static void scic_sds_stp_request_started_pio_data_in_await_data_enter(
 static void scic_sds_stp_request_started_pio_data_out_transmit_data_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+        struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
 
         SET_STATE_HANDLER(
-                this_request,
+                sci_req,
                 scic_sds_stp_request_started_pio_substate_handler_table,
                 SCIC_SDS_STP_REQUEST_STARTED_PIO_DATA_OUT_TRANSMIT_DATA_SUBSTATE
                 );
@@ -1333,13 +1333,13 @@ static void scic_sds_stp_request_udma_complete_request(
 
 /**
  *
- * @this_request:
+ * @sci_req:
  * @frame_index:
  *
  * enum sci_status
  */
 static enum sci_status scic_sds_stp_request_udma_general_frame_handler(
-        struct scic_sds_request *this_request,
+        struct scic_sds_request *sci_req,
         u32 frame_index)
 {
         enum sci_status status;
@@ -1347,7 +1347,7 @@ static enum sci_status scic_sds_stp_request_udma_general_frame_handler(
         u32 *frame_buffer;
 
         status = scic_sds_unsolicited_frame_control_get_header(
-                &this_request->owning_controller->uf_control,
+                &sci_req->owning_controller->uf_control,
                 frame_index,
                 (void **)&frame_header
                 );
@@ -1357,20 +1357,20 @@ static enum sci_status scic_sds_stp_request_udma_general_frame_handler(
                 && (frame_header->fis_type == SATA_FIS_TYPE_REGD2H)
                 ) {
                 scic_sds_unsolicited_frame_control_get_buffer(
-                        &this_request->owning_controller->uf_control,
+                        &sci_req->owning_controller->uf_control,
                         frame_index,
                         (void **)&frame_buffer
                         );
 
                 scic_sds_controller_copy_sata_response(
-                        &((struct scic_sds_stp_request *)this_request)->d2h_reg_fis,
+                        &((struct scic_sds_stp_request *)sci_req)->d2h_reg_fis,
                         (u32 *)frame_header,
                         frame_buffer
                         );
         }
 
         scic_sds_controller_release_frame(
-                this_request->owning_controller, frame_index);
+                sci_req->owning_controller, frame_index);
 
         return status;
 }
@@ -1378,7 +1378,7 @@ static enum sci_status scic_sds_stp_request_udma_general_frame_handler(
 /**
  * This method process TC completions while in the state where we are waiting
  *    for TC completions.
- * @this_request:
+ * @sci_req:
  * @completion_code:
  *
  * enum sci_status
@@ -1388,12 +1388,12 @@ static enum sci_status scic_sds_stp_request_udma_await_tc_completion_tc_completi
         u32 completion_code)
 {
         enum sci_status status = SCI_SUCCESS;
-        struct scic_sds_stp_request *this_request = (struct scic_sds_stp_request *)request;
+        struct scic_sds_stp_request *sci_req = (struct scic_sds_stp_request *)request;
 
         switch (SCU_GET_COMPLETION_TL_STATUS(completion_code)) {
         case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_GOOD):
                 scic_sds_stp_request_udma_complete_request(
-                        &this_request->parent, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+                        &sci_req->parent, SCU_TASK_DONE_GOOD, SCI_SUCCESS
                         );
                 break;
 
@@ -1402,14 +1402,14 @@ static enum sci_status scic_sds_stp_request_udma_await_tc_completion_tc_completi
                 /*
                  * We must check ther response buffer to see if the D2H Register FIS was
                  * received before we got the TC completion. */
-                if (this_request->d2h_reg_fis.fis_type == SATA_FIS_TYPE_REGD2H) {
+                if (sci_req->d2h_reg_fis.fis_type == SATA_FIS_TYPE_REGD2H) {
                         scic_sds_remote_device_suspend(
-                                this_request->parent.target_device,
+                                sci_req->parent.target_device,
                                 SCU_EVENT_SPECIFIC(SCU_NORMALIZE_COMPLETION_STATUS(completion_code))
                                 );
 
                         scic_sds_stp_request_udma_complete_request(
-                                &this_request->parent,
+                                &sci_req->parent,
                                 SCU_TASK_DONE_CHECK_RESPONSE,
                                 SCI_FAILURE_IO_RESPONSE_VALID
                                 );
@@ -1418,7 +1418,7 @@ static enum sci_status scic_sds_stp_request_udma_await_tc_completion_tc_completi
                          * If we have an error completion status for the TC then we can expect a
                          * D2H register FIS from the device so we must change state to wait for it */
                         sci_base_state_machine_change_state(
-                                &this_request->parent.started_substate_machine,
+                                &sci_req->parent.started_substate_machine,
                                 SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_D2H_REG_FIS_SUBSTATE
                                 );
                 }
@@ -1434,14 +1434,14 @@ static enum sci_status scic_sds_stp_request_udma_await_tc_completion_tc_completi
         case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_CMD_LL_R_ERR):
         case SCU_MAKE_COMPLETION_STATUS(SCU_TASK_DONE_CRC_ERR):
                 scic_sds_remote_device_suspend(
-                        this_request->parent.target_device,
+                        sci_req->parent.target_device,
                         SCU_EVENT_SPECIFIC(SCU_NORMALIZE_COMPLETION_STATUS(completion_code))
                         );
         /* Fall through to the default case */
         default:
                 /* All other completion status cause the IO to be complete. */
                 scic_sds_stp_request_udma_complete_request(
-                        &this_request->parent,
+                        &sci_req->parent,
                         SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
                         SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
                         );
@@ -1452,17 +1452,17 @@ static enum sci_status scic_sds_stp_request_udma_await_tc_completion_tc_completi
 }
 
 static enum sci_status scic_sds_stp_request_udma_await_d2h_reg_fis_frame_handler(
-        struct scic_sds_request *this_request,
+        struct scic_sds_request *sci_req,
         u32 frame_index)
 {
         enum sci_status status;
 
         /* Use the general frame handler to copy the resposne data */
-        status = scic_sds_stp_request_udma_general_frame_handler(this_request, frame_index);
+        status = scic_sds_stp_request_udma_general_frame_handler(sci_req, frame_index);
 
         if (status == SCI_SUCCESS) {
                 scic_sds_stp_request_udma_complete_request(
-                        this_request,
+                        sci_req,
                         SCU_TASK_DONE_CHECK_RESPONSE,
                         SCI_FAILURE_IO_RESPONSE_VALID
                         );
@@ -1488,10 +1488,10 @@ static const struct scic_sds_io_request_state_handler scic_sds_stp_request_start
 static void scic_sds_stp_request_started_udma_await_tc_completion_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+        struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
 
         SET_STATE_HANDLER(
-                this_request,
+                sci_req,
                 scic_sds_stp_request_started_udma_substate_handler_table,
                 SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_TC_COMPLETION_SUBSTATE
                 );
@@ -1507,10 +1507,10 @@ static void scic_sds_stp_request_started_udma_await_tc_completion_enter(
 static void scic_sds_stp_request_started_udma_await_d2h_reg_fis_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+        struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
 
         SET_STATE_HANDLER(
-                this_request,
+                sci_req,
                 scic_sds_stp_request_started_udma_substate_handler_table,
                 SCIC_SDS_STP_REQUEST_STARTED_UDMA_AWAIT_D2H_REG_FIS_SUBSTATE
                 );
@@ -1548,7 +1548,7 @@ enum sci_status scic_sds_stp_udma_request_construct(struct scic_sds_request *sci
 
 /**
  *
- * @this_request:
+ * @sci_req:
  * @completion_code:
  *
  * This method processes a TC completion.  The expected TC completion is for
@@ -1557,17 +1557,17 @@ enum sci_status scic_sds_stp_udma_request_construct(struct scic_sds_request *sci
  * SCI_SUCCESS This value is always returned.
  */
 static enum sci_status scic_sds_stp_request_soft_reset_await_h2d_asserted_tc_completion_handler(
-        struct scic_sds_request *this_request,
+        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(
-                        this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+                        sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
                         );
 
                 sci_base_state_machine_change_state(
-                        &this_request->started_substate_machine,
+                        &sci_req->started_substate_machine,
                         SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_DIAGNOSTIC_COMPLETION_SUBSTATE
                         );
                 break;
@@ -1577,13 +1577,13 @@ static enum sci_status scic_sds_stp_request_soft_reset_await_h2d_asserted_tc_com
                  * 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(
-                        this_request,
+                        sci_req,
                         SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
                         SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
                         );
 
                 sci_base_state_machine_change_state(
-                        &this_request->state_machine, SCI_BASE_REQUEST_STATE_COMPLETED);
+                        &sci_req->state_machine, SCI_BASE_REQUEST_STATE_COMPLETED);
                 break;
         }
 
@@ -1592,7 +1592,7 @@ static enum sci_status scic_sds_stp_request_soft_reset_await_h2d_asserted_tc_com
 
 /**
  *
- * @this_request:
+ * @sci_req:
  * @completion_code:
  *
  * This method processes a TC completion.  The expected TC completion is for
@@ -1601,17 +1601,17 @@ static enum sci_status scic_sds_stp_request_soft_reset_await_h2d_asserted_tc_com
  * SCI_SUCCESS This value is always returned.
  */
 static enum sci_status scic_sds_stp_request_soft_reset_await_h2d_diagnostic_tc_completion_handler(
-        struct scic_sds_request *this_request,
+        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(
-                        this_request, SCU_TASK_DONE_GOOD, SCI_SUCCESS
+                        sci_req, SCU_TASK_DONE_GOOD, SCI_SUCCESS
                         );
 
                 sci_base_state_machine_change_state(
-                        &this_request->started_substate_machine,
+                        &sci_req->started_substate_machine,
                         SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_D2H_RESPONSE_FRAME_SUBSTATE
                         );
                 break;
@@ -1621,12 +1621,12 @@ static enum sci_status scic_sds_stp_request_soft_reset_await_h2d_diagnostic_tc_c
                  * 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(
-                        this_request,
+                        sci_req,
                         SCU_NORMALIZE_COMPLETION_STATUS(completion_code),
                         SCI_FAILURE_CONTROLLER_SPECIFIC_IO_ERR
                         );
 
-                sci_base_state_machine_change_state(&this_request->state_machine,
+                sci_base_state_machine_change_state(&sci_req->state_machine,
                                 SCI_BASE_REQUEST_STATE_COMPLETED);
                 break;
         }
@@ -1653,10 +1653,10 @@ static enum sci_status scic_sds_stp_request_soft_reset_await_d2h_frame_handler(
         enum sci_status status;
         struct sata_fis_header *frame_header;
         u32 *frame_buffer;
-        struct scic_sds_stp_request *this_request = (struct scic_sds_stp_request *)request;
+        struct scic_sds_stp_request *sci_req = (struct scic_sds_stp_request *)request;
 
         status = scic_sds_unsolicited_frame_control_get_header(
-                &(this_request->parent.owning_controller->uf_control),
+                &(sci_req->parent.owning_controller->uf_control),
                 frame_index,
                 (void **)&frame_header
                 );
@@ -1665,18 +1665,18 @@ static enum sci_status scic_sds_stp_request_soft_reset_await_d2h_frame_handler(
                 switch (frame_header->fis_type) {
                 case SATA_FIS_TYPE_REGD2H:
                         scic_sds_unsolicited_frame_control_get_buffer(
-                                &(this_request->parent.owning_controller->uf_control),
+                                &(sci_req->parent.owning_controller->uf_control),
                                 frame_index,
                                 (void **)&frame_buffer
                                 );
 
                         scic_sds_controller_copy_sata_response(
-                                &this_request->d2h_reg_fis, (u32 *)frame_header, frame_buffer
+                                &sci_req->d2h_reg_fis, (u32 *)frame_header, frame_buffer
                                 );
 
                         /* The command has completed with error */
                         scic_sds_request_set_status(
-                                &this_request->parent,
+                                &sci_req->parent,
                                 SCU_TASK_DONE_CHECK_RESPONSE,
                                 SCI_FAILURE_IO_RESPONSE_VALID
                                 );
@@ -1687,11 +1687,11 @@ static enum sci_status scic_sds_stp_request_soft_reset_await_d2h_frame_handler(
                                  "%s: IO Request:0x%p Frame Id:%d protocol "
                                  "violation occurred\n",
                                  __func__,
-                                 this_request,
+                                 sci_req,
                                  frame_index);
 
                         scic_sds_request_set_status(
-                                &this_request->parent,
+                                &sci_req->parent,
                                 SCU_TASK_DONE_UNEXP_FIS,
                                 SCI_FAILURE_PROTOCOL_VIOLATION
                                 );
@@ -1699,18 +1699,18 @@ static enum sci_status scic_sds_stp_request_soft_reset_await_d2h_frame_handler(
                 }
 
                 sci_base_state_machine_change_state(
-                        &this_request->parent.state_machine,
+                        &sci_req->parent.state_machine,
                         SCI_BASE_REQUEST_STATE_COMPLETED);
 
                 /* Frame has been decoded return it to the controller */
                 scic_sds_controller_release_frame(
-                        this_request->parent.owning_controller, frame_index
+                        sci_req->parent.owning_controller, frame_index
                         );
         } else
                 dev_err(scic_to_dev(request->owning_controller),
                         "%s: SCIC IO Request 0x%p could not get frame header "
                         "for frame index %d, status %x\n",
-                        __func__, this_request, frame_index, status);
+                        __func__, sci_req, frame_index, status);
 
         return status;
 }
@@ -1735,40 +1735,40 @@ static const struct scic_sds_io_request_state_handler scic_sds_stp_request_start
 static void scic_sds_stp_request_started_soft_reset_await_h2d_asserted_completion_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+        struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
 
         SET_STATE_HANDLER(
-                this_request,
+                sci_req,
                 scic_sds_stp_request_started_soft_reset_substate_handler_table,
                 SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_ASSERTED_COMPLETION_SUBSTATE
                 );
 
         scic_sds_remote_device_set_working_request(
-                this_request->target_device, this_request
+                sci_req->target_device, sci_req
                 );
 }
 
 static void scic_sds_stp_request_started_soft_reset_await_h2d_diagnostic_completion_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+        struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
         struct scu_task_context *task_context;
         struct sata_fis_reg_h2d *h2d_fis;
         enum sci_status status;
 
         /* Clear the SRST bit */
-        h2d_fis = scic_stp_io_request_get_h2d_reg_address(this_request);
+        h2d_fis = scic_stp_io_request_get_h2d_reg_address(sci_req);
         h2d_fis->control = 0;
 
         /* Clear the TC control bit */
         task_context = scic_sds_controller_get_task_context_buffer(
-                this_request->owning_controller, this_request->io_tag);
+                sci_req->owning_controller, sci_req->io_tag);
         task_context->control_frame = 0;
 
-        status = scic_controller_continue_io(this_request);
+        status = scic_controller_continue_io(sci_req);
         if (status == SCI_SUCCESS) {
                 SET_STATE_HANDLER(
-                        this_request,
+                        sci_req,
                         scic_sds_stp_request_started_soft_reset_substate_handler_table,
                         SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_H2D_DIAGNOSTIC_COMPLETION_SUBSTATE
                         );
@@ -1778,10 +1778,10 @@ static void scic_sds_stp_request_started_soft_reset_await_h2d_diagnostic_complet
 static void scic_sds_stp_request_started_soft_reset_await_d2h_response_enter(
         struct sci_base_object *object)
 {
-        struct scic_sds_request *this_request = (struct scic_sds_request *)object;
+        struct scic_sds_request *sci_req = (struct scic_sds_request *)object;
 
         SET_STATE_HANDLER(
-                this_request,
+                sci_req,
                 scic_sds_stp_request_started_soft_reset_substate_handler_table,
                 SCIC_SDS_STP_REQUEST_STARTED_SOFT_RESET_AWAIT_D2H_RESPONSE_FRAME_SUBSTATE
                 );
diff --git a/drivers/scsi/isci/core/scic_sds_stp_request.h b/drivers/scsi/isci/core/scic_sds_stp_request.h
index a6c02d3cba50..6724c1d759df 100644
--- a/drivers/scsi/isci/core/scic_sds_stp_request.h
+++ b/drivers/scsi/isci/core/scic_sds_stp_request.h
@@ -177,18 +177,18 @@ enum sci_status scic_sds_stp_pio_request_construct(
         bool copy_rx_frame);
 
 enum sci_status scic_sds_stp_udma_request_construct(
-        struct scic_sds_request *this_request,
+        struct scic_sds_request *sci_req,
         u32 transfer_length,
         enum dma_data_direction dir);
 
 enum sci_status scic_sds_stp_non_data_request_construct(
-        struct scic_sds_request *this_request);
+        struct scic_sds_request *sci_req);
 
 enum sci_status scic_sds_stp_soft_reset_request_construct(
-        struct scic_sds_request *this_request);
+        struct scic_sds_request *sci_req);
 
 enum sci_status scic_sds_stp_ncq_request_construct(
-        struct scic_sds_request *this_request,
+        struct scic_sds_request *sci_req,
         u32 transfer_length,
         enum dma_data_direction dir);