isci: retire scic_sds_ and scic_ prefixes

The distinction between scic_sds_ scic_ and sci_ are no longer relevant
so just unify the prefixes on sci_.  The distinction between isci_ and
sci_ is historically significant, and useful for comparing the old
'core' to the current Linux driver. 'sci_' represents the former core as
well as the routines that are closer to the hardware and protocol than
their 'isci_' brethren. sci == sas controller interface.

Also unwind the 'sds1' out of the parameter structs.

Reported-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Dan Williams <dan.j.williams@intel.com>

1 files changed, 57 insertions, 57 deletions

diff --git a/drivers/scsi/isci/remote_node_table.c b/drivers/scsi/isci/remote_node_table.c
index 6b9465a5a217..301b3141945e 100644
--- a/drivers/scsi/isci/remote_node_table.c
+++ b/drivers/scsi/isci/remote_node_table.c
@@ -74,8 +74,8 @@
  * just bit position. u32 This is the absolute bit position for an available
  * group.
  */
-static u32 scic_sds_remote_node_table_get_group_index(
-        struct scic_remote_node_table *remote_node_table,
+static u32 sci_remote_node_table_get_group_index(
+        struct sci_remote_node_table *remote_node_table,
         u32 group_table_index)
 {
         u32 dword_index;
@@ -108,8 +108,8 @@ static u32 scic_sds_remote_node_table_get_group_index(
  * This method will clear the group index entry in the specified group index
  * table. none
  */
-static void scic_sds_remote_node_table_clear_group_index(
-        struct scic_remote_node_table *remote_node_table,
+static void sci_remote_node_table_clear_group_index(
+        struct sci_remote_node_table *remote_node_table,
         u32 group_table_index,
         u32 group_index)
 {
@@ -138,8 +138,8 @@ static void scic_sds_remote_node_table_clear_group_index(
  * This method will set the group index bit entry in the specified gropu index
  * table. none
  */
-static void scic_sds_remote_node_table_set_group_index(
-        struct scic_remote_node_table *remote_node_table,
+static void sci_remote_node_table_set_group_index(
+        struct sci_remote_node_table *remote_node_table,
         u32 group_table_index,
         u32 group_index)
 {
@@ -167,8 +167,8 @@ static void scic_sds_remote_node_table_set_group_index(
  * This method will set the remote to available in the remote node allocation
  * table. none
  */
-static void scic_sds_remote_node_table_set_node_index(
-        struct scic_remote_node_table *remote_node_table,
+static void sci_remote_node_table_set_node_index(
+        struct sci_remote_node_table *remote_node_table,
         u32 remote_node_index)
 {
         u32 dword_location;
@@ -200,8 +200,8 @@ static void scic_sds_remote_node_table_set_node_index(
  * This method clears the remote node index from the table of available remote
  * nodes. none
  */
-static void scic_sds_remote_node_table_clear_node_index(
-        struct scic_remote_node_table *remote_node_table,
+static void sci_remote_node_table_clear_node_index(
+        struct sci_remote_node_table *remote_node_table,
         u32 remote_node_index)
 {
         u32 dword_location;
@@ -231,8 +231,8 @@ static void scic_sds_remote_node_table_clear_node_index(
  *
  * This method clears the entire table slot at the specified slot index. none
  */
-static void scic_sds_remote_node_table_clear_group(
-        struct scic_remote_node_table *remote_node_table,
+static void sci_remote_node_table_clear_group(
+        struct sci_remote_node_table *remote_node_table,
         u32 group_index)
 {
         u32 dword_location;
@@ -258,8 +258,8 @@ static void scic_sds_remote_node_table_clear_group(
  *
  * THis method sets an entire remote node group in the remote node table.
  */
-static void scic_sds_remote_node_table_set_group(
-        struct scic_remote_node_table *remote_node_table,
+static void sci_remote_node_table_set_group(
+        struct sci_remote_node_table *remote_node_table,
         u32 group_index)
 {
         u32 dword_location;
@@ -288,8 +288,8 @@ static void scic_sds_remote_node_table_set_group(
  * This method will return the group value for the specified group index. The
  * bit values at the specified remote node group index.
  */
-static u8 scic_sds_remote_node_table_get_group_value(
-        struct scic_remote_node_table *remote_node_table,
+static u8 sci_remote_node_table_get_group_value(
+        struct sci_remote_node_table *remote_node_table,
         u32 group_index)
 {
         u32 dword_location;
@@ -313,8 +313,8 @@ static u8 scic_sds_remote_node_table_get_group_value(
  *
  * This method will initialize the remote node table for use. none
  */
-void scic_sds_remote_node_table_initialize(
-        struct scic_remote_node_table *remote_node_table,
+void sci_remote_node_table_initialize(
+        struct sci_remote_node_table *remote_node_table,
         u32 remote_node_entries)
 {
         u32 index;
@@ -342,7 +342,7 @@ void scic_sds_remote_node_table_initialize(
 
         /* Initialize each full DWORD to a FULL SET of remote nodes */
         for (index = 0; index < remote_node_entries; index++) {
-                scic_sds_remote_node_table_set_node_index(remote_node_table, index);
+                sci_remote_node_table_set_node_index(remote_node_table, index);
         }
 
         remote_node_table->group_array_size = (u16)
@@ -353,14 +353,14 @@ void scic_sds_remote_node_table_initialize(
                 /*
                  * These are all guaranteed to be full slot values so fill them in the
                  * available sets of 3 remote nodes */
-                scic_sds_remote_node_table_set_group_index(remote_node_table, 2, index);
+                sci_remote_node_table_set_group_index(remote_node_table, 2, index);
         }
 
         /* Now fill in any remainders that we may find */
         if ((remote_node_entries % SCU_STP_REMOTE_NODE_COUNT) == 2) {
-                scic_sds_remote_node_table_set_group_index(remote_node_table, 1, index);
+                sci_remote_node_table_set_group_index(remote_node_table, 1, index);
         } else if ((remote_node_entries % SCU_STP_REMOTE_NODE_COUNT) == 1) {
-                scic_sds_remote_node_table_set_group_index(remote_node_table, 0, index);
+                sci_remote_node_table_set_group_index(remote_node_table, 0, index);
         }
 }
 
@@ -379,8 +379,8 @@ void scic_sds_remote_node_table_initialize(
  * updated. The RNi value or an invalid remote node context if an RNi can not
  * be found.
  */
-static u16 scic_sds_remote_node_table_allocate_single_remote_node(
-        struct scic_remote_node_table *remote_node_table,
+static u16 sci_remote_node_table_allocate_single_remote_node(
+        struct sci_remote_node_table *remote_node_table,
         u32 group_table_index)
 {
         u8 index;
@@ -388,12 +388,12 @@ static u16 scic_sds_remote_node_table_allocate_single_remote_node(
         u32 group_index;
         u16 remote_node_index = SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX;
 
-        group_index = scic_sds_remote_node_table_get_group_index(
+        group_index = sci_remote_node_table_get_group_index(
                 remote_node_table, group_table_index);
 
         /* We could not find an available slot in the table selector 0 */
         if (group_index != SCIC_SDS_REMOTE_NODE_TABLE_INVALID_INDEX) {
-                group_value = scic_sds_remote_node_table_get_group_value(
+                group_value = sci_remote_node_table_get_group_value(
                         remote_node_table, group_index);
 
                 for (index = 0; index < SCU_STP_REMOTE_NODE_COUNT; index++) {
@@ -402,16 +402,16 @@ static u16 scic_sds_remote_node_table_allocate_single_remote_node(
                                 remote_node_index = (u16)(group_index * SCU_STP_REMOTE_NODE_COUNT
                                                           + index);
 
-                                scic_sds_remote_node_table_clear_group_index(
+                                sci_remote_node_table_clear_group_index(
                                         remote_node_table, group_table_index, group_index
                                         );
 
-                                scic_sds_remote_node_table_clear_node_index(
+                                sci_remote_node_table_clear_node_index(
                                         remote_node_table, remote_node_index
                                         );
 
                                 if (group_table_index > 0) {
-                                        scic_sds_remote_node_table_set_group_index(
+                                        sci_remote_node_table_set_group_index(
                                                 remote_node_table, group_table_index - 1, group_index
                                                 );
                                 }
@@ -436,24 +436,24 @@ static u16 scic_sds_remote_node_table_allocate_single_remote_node(
  * The remote node index that represents three consecutive remote node entries
  * or an invalid remote node context if none can be found.
  */
-static u16 scic_sds_remote_node_table_allocate_triple_remote_node(
-        struct scic_remote_node_table *remote_node_table,
+static u16 sci_remote_node_table_allocate_triple_remote_node(
+        struct sci_remote_node_table *remote_node_table,
         u32 group_table_index)
 {
         u32 group_index;
         u16 remote_node_index = SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX;
 
-        group_index = scic_sds_remote_node_table_get_group_index(
+        group_index = sci_remote_node_table_get_group_index(
                 remote_node_table, group_table_index);
 
         if (group_index != SCIC_SDS_REMOTE_NODE_TABLE_INVALID_INDEX) {
                 remote_node_index = (u16)group_index * SCU_STP_REMOTE_NODE_COUNT;
 
-                scic_sds_remote_node_table_clear_group_index(
+                sci_remote_node_table_clear_group_index(
                         remote_node_table, group_table_index, group_index
                         );
 
-                scic_sds_remote_node_table_clear_group(
+                sci_remote_node_table_clear_group(
                         remote_node_table, group_index
                         );
         }
@@ -473,31 +473,31 @@ static u16 scic_sds_remote_node_table_allocate_triple_remote_node(
  * SCU_SSP_REMOTE_NODE_COUNT(1) or SCU_STP_REMOTE_NODE_COUNT(3). u16 This is
  * the remote node index that is returned or an invalid remote node context.
  */
-u16 scic_sds_remote_node_table_allocate_remote_node(
-        struct scic_remote_node_table *remote_node_table,
+u16 sci_remote_node_table_allocate_remote_node(
+        struct sci_remote_node_table *remote_node_table,
         u32 remote_node_count)
 {
         u16 remote_node_index = SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX;
 
         if (remote_node_count == SCU_SSP_REMOTE_NODE_COUNT) {
                 remote_node_index =
-                        scic_sds_remote_node_table_allocate_single_remote_node(
+                        sci_remote_node_table_allocate_single_remote_node(
                                 remote_node_table, 0);
 
                 if (remote_node_index == SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX) {
                         remote_node_index =
-                                scic_sds_remote_node_table_allocate_single_remote_node(
+                                sci_remote_node_table_allocate_single_remote_node(
                                         remote_node_table, 1);
                 }
 
                 if (remote_node_index == SCIC_SDS_REMOTE_NODE_CONTEXT_INVALID_INDEX) {
                         remote_node_index =
-                                scic_sds_remote_node_table_allocate_single_remote_node(
+                                sci_remote_node_table_allocate_single_remote_node(
                                         remote_node_table, 2);
                 }
         } else if (remote_node_count == SCU_STP_REMOTE_NODE_COUNT) {
                 remote_node_index =
-                        scic_sds_remote_node_table_allocate_triple_remote_node(
+                        sci_remote_node_table_allocate_triple_remote_node(
                                 remote_node_table, 2);
         }
 
@@ -511,8 +511,8 @@ u16 scic_sds_remote_node_table_allocate_remote_node(
  * This method will free a single remote node index back to the remote node
  * table.  This routine will update the remote node groups
  */
-static void scic_sds_remote_node_table_release_single_remote_node(
-        struct scic_remote_node_table *remote_node_table,
+static void sci_remote_node_table_release_single_remote_node(
+        struct sci_remote_node_table *remote_node_table,
         u16 remote_node_index)
 {
         u32 group_index;
@@ -520,7 +520,7 @@ static void scic_sds_remote_node_table_release_single_remote_node(
 
         group_index = remote_node_index / SCU_STP_REMOTE_NODE_COUNT;
 
-        group_value = scic_sds_remote_node_table_get_group_value(remote_node_table, group_index);
+        group_value = sci_remote_node_table_get_group_value(remote_node_table, group_index);
 
         /*
          * Assert that we are not trying to add an entry to a slot that is already
@@ -531,22 +531,22 @@ static void scic_sds_remote_node_table_release_single_remote_node(
                 /*
                  * There are no entries in this slot so it must be added to the single
                  * slot table. */
-                scic_sds_remote_node_table_set_group_index(remote_node_table, 0, group_index);
+                sci_remote_node_table_set_group_index(remote_node_table, 0, group_index);
         } else if ((group_value & (group_value - 1)) == 0) {
                 /*
                  * There is only one entry in this slot so it must be moved from the
                  * single slot table to the dual slot table */
-                scic_sds_remote_node_table_clear_group_index(remote_node_table, 0, group_index);
-                scic_sds_remote_node_table_set_group_index(remote_node_table, 1, group_index);
+                sci_remote_node_table_clear_group_index(remote_node_table, 0, group_index);
+                sci_remote_node_table_set_group_index(remote_node_table, 1, group_index);
         } else {
                 /*
                  * There are two entries in the slot so it must be moved from the dual
                  * slot table to the tripple slot table. */
-                scic_sds_remote_node_table_clear_group_index(remote_node_table, 1, group_index);
-                scic_sds_remote_node_table_set_group_index(remote_node_table, 2, group_index);
+                sci_remote_node_table_clear_group_index(remote_node_table, 1, group_index);
+                sci_remote_node_table_set_group_index(remote_node_table, 2, group_index);
         }
 
-        scic_sds_remote_node_table_set_node_index(remote_node_table, remote_node_index);
+        sci_remote_node_table_set_node_index(remote_node_table, remote_node_index);
 }
 
 /**
@@ -557,19 +557,19 @@ static void scic_sds_remote_node_table_release_single_remote_node(
  * This method will release a group of three consecutive remote nodes back to
  * the free remote nodes.
  */
-static void scic_sds_remote_node_table_release_triple_remote_node(
-        struct scic_remote_node_table *remote_node_table,
+static void sci_remote_node_table_release_triple_remote_node(
+        struct sci_remote_node_table *remote_node_table,
         u16 remote_node_index)
 {
         u32 group_index;
 
         group_index = remote_node_index / SCU_STP_REMOTE_NODE_COUNT;
 
-        scic_sds_remote_node_table_set_group_index(
+        sci_remote_node_table_set_group_index(
                 remote_node_table, 2, group_index
                 );
 
-        scic_sds_remote_node_table_set_group(remote_node_table, group_index);
+        sci_remote_node_table_set_group(remote_node_table, group_index);
 }
 
 /**
@@ -582,16 +582,16 @@ static void scic_sds_remote_node_table_release_triple_remote_node(
  * This method will release the remote node index back into the remote node
  * table free pool.
  */
-void scic_sds_remote_node_table_release_remote_node_index(
-        struct scic_remote_node_table *remote_node_table,
+void sci_remote_node_table_release_remote_node_index(
+        struct sci_remote_node_table *remote_node_table,
         u32 remote_node_count,
         u16 remote_node_index)
 {
         if (remote_node_count == SCU_SSP_REMOTE_NODE_COUNT) {
-                scic_sds_remote_node_table_release_single_remote_node(
+                sci_remote_node_table_release_single_remote_node(
                         remote_node_table, remote_node_index);
         } else if (remote_node_count == SCU_STP_REMOTE_NODE_COUNT) {
-                scic_sds_remote_node_table_release_triple_remote_node(
+                sci_remote_node_table_release_triple_remote_node(
                         remote_node_table, remote_node_index);
         }
 }