iwlwifi: rename restricted_mem to targ_mem

This patch renames restricted_mem suffix with more proper
name targ_mem for function accessing memory on the nic in target mode

Signed-off-by: Tomas Winkler <tomas.winkler@intel.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>

1 files changed, 17 insertions, 17 deletions

diff --git a/drivers/net/wireless/iwlwifi/iwl4965-base.c b/drivers/net/wireless/iwlwifi/iwl4965-base.c
index e74f71fdaf92..5d19ce9bb1aa 100644
--- a/drivers/net/wireless/iwlwifi/iwl4965-base.c
+++ b/drivers/net/wireless/iwlwifi/iwl4965-base.c
@@ -4785,7 +4785,7 @@ static void iwl_dump_nic_error_log(struct iwl_priv *priv)
                 return;
         }
 
-        count = iwl_read_restricted_mem(priv, base);
+        count = iwl_read_targ_mem(priv, base);
 
         if (ERROR_START_OFFSET <= count * ERROR_ELEM_SIZE) {
                 IWL_ERROR("Start IWL Error Log Dump:\n");
@@ -4793,15 +4793,15 @@ static void iwl_dump_nic_error_log(struct iwl_priv *priv)
                           priv->status, priv->config, count);
         }
 
-        desc = iwl_read_restricted_mem(priv, base + 1 * sizeof(u32));
-        blink1 = iwl_read_restricted_mem(priv, base + 3 * sizeof(u32));
-        blink2 = iwl_read_restricted_mem(priv, base + 4 * sizeof(u32));
-        ilink1 = iwl_read_restricted_mem(priv, base + 5 * sizeof(u32));
-        ilink2 = iwl_read_restricted_mem(priv, base + 6 * sizeof(u32));
-        data1 = iwl_read_restricted_mem(priv, base + 7 * sizeof(u32));
-        data2 = iwl_read_restricted_mem(priv, base + 8 * sizeof(u32));
-        line = iwl_read_restricted_mem(priv, base + 9 * sizeof(u32));
-        time = iwl_read_restricted_mem(priv, base + 11 * sizeof(u32));
+        desc = iwl_read_targ_mem(priv, base + 1 * sizeof(u32));
+        blink1 = iwl_read_targ_mem(priv, base + 3 * sizeof(u32));
+        blink2 = iwl_read_targ_mem(priv, base + 4 * sizeof(u32));
+        ilink1 = iwl_read_targ_mem(priv, base + 5 * sizeof(u32));
+        ilink2 = iwl_read_targ_mem(priv, base + 6 * sizeof(u32));
+        data1 = iwl_read_targ_mem(priv, base + 7 * sizeof(u32));
+        data2 = iwl_read_targ_mem(priv, base + 8 * sizeof(u32));
+        line = iwl_read_targ_mem(priv, base + 9 * sizeof(u32));
+        time = iwl_read_targ_mem(priv, base + 11 * sizeof(u32));
 
         IWL_ERROR("Desc               Time       "
                   "data1      data2      line\n");
@@ -4845,14 +4845,14 @@ static void iwl_print_event_log(struct iwl_priv *priv, u32 start_idx,
         /* "time" is actually "data" for mode 0 (no timestamp).
          * place event id # at far right for easier visual parsing. */
         for (i = 0; i < num_events; i++) {
-                ev = iwl_read_restricted_mem(priv, ptr);
+                ev = iwl_read_targ_mem(priv, ptr);
                 ptr += sizeof(u32);
-                time = iwl_read_restricted_mem(priv, ptr);
+                time = iwl_read_targ_mem(priv, ptr);
                 ptr += sizeof(u32);
                 if (mode == 0)
                         IWL_ERROR("0x%08x\t%04u\n", time, ev); /* data, ev */
                 else {
-                        data = iwl_read_restricted_mem(priv, ptr);
+                        data = iwl_read_targ_mem(priv, ptr);
                         ptr += sizeof(u32);
                         IWL_ERROR("%010u\t0x%08x\t%04u\n", time, data, ev);
                 }
@@ -4882,10 +4882,10 @@ static void iwl_dump_nic_event_log(struct iwl_priv *priv)
         }
 
         /* event log header */
-        capacity = iwl_read_restricted_mem(priv, base);
-        mode = iwl_read_restricted_mem(priv, base + (1 * sizeof(u32)));
-        num_wraps = iwl_read_restricted_mem(priv, base + (2 * sizeof(u32)));
-        next_entry = iwl_read_restricted_mem(priv, base + (3 * sizeof(u32)));
+        capacity = iwl_read_targ_mem(priv, base);
+        mode = iwl_read_targ_mem(priv, base + (1 * sizeof(u32)));
+        num_wraps = iwl_read_targ_mem(priv, base + (2 * sizeof(u32)));
+        next_entry = iwl_read_targ_mem(priv, base + (3 * sizeof(u32)));
 
         size = num_wraps ? capacity : next_entry;