iwlegacy: rename priv to il

Make code shorter.

Signed-off-by: Stanislaw Gruszka <sgruszka@redhat.com>

1 files changed, 79 insertions, 79 deletions

diff --git a/drivers/net/wireless/iwlegacy/iwl-eeprom.c b/drivers/net/wireless/iwlegacy/iwl-eeprom.c
index 1075f1d7f01..5edec73a505 100644
--- a/drivers/net/wireless/iwlegacy/iwl-eeprom.c
+++ b/drivers/net/wireless/iwlegacy/iwl-eeprom.c
@@ -87,7 +87,7 @@
  * is contained in the eeprom map itself.
  *
  * During init, we copy the eeprom information and channel map
- * information into priv->channel_info_24/52 and priv->channel_map_24/52
+ * information into il->channel_info_24/52 and il->channel_map_24/52
  *
  * channel_map_24/52 provides the index in the channel_info array for a
  * given channel.  We have to have two separate maps as there is channel
@@ -142,18 +142,18 @@ static const u8 iwlegacy_eeprom_band_7[] = {       /* 5.2 ht40 channel */
  *
 ******************************************************************************/
 
-static int il_eeprom_verify_signature(struct il_priv *priv)
+static int il_eeprom_verify_signature(struct il_priv *il)
 {
-        u32 gp = il_read32(priv, CSR_EEPROM_GP) & CSR_EEPROM_GP_VALID_MSK;
+        u32 gp = il_read32(il, CSR_EEPROM_GP) & CSR_EEPROM_GP_VALID_MSK;
         int ret = 0;
 
-        IL_DEBUG_EEPROM(priv, "EEPROM signature=0x%08x\n", gp);
+        IL_DEBUG_EEPROM(il, "EEPROM signature=0x%08x\n", gp);
         switch (gp) {
         case CSR_EEPROM_GP_GOOD_SIG_EEP_LESS_THAN_4K:
         case CSR_EEPROM_GP_GOOD_SIG_EEP_MORE_THAN_4K:
                 break;
         default:
-                IL_ERR(priv, "bad EEPROM signature,"
+                IL_ERR(il, "bad EEPROM signature,"
                         "EEPROM_GP=0x%08x\n", gp);
                 ret = -ENOENT;
                 break;
@@ -162,59 +162,59 @@ static int il_eeprom_verify_signature(struct il_priv *priv)
 }
 
 const u8
-*il_eeprom_query_addr(const struct il_priv *priv, size_t offset)
+*il_eeprom_query_addr(const struct il_priv *il, size_t offset)
 {
-        BUG_ON(offset >= priv->cfg->base_params->eeprom_size);
-        return &priv->eeprom[offset];
+        BUG_ON(offset >= il->cfg->base_params->eeprom_size);
+        return &il->eeprom[offset];
 }
 EXPORT_SYMBOL(il_eeprom_query_addr);
 
-u16 il_eeprom_query16(const struct il_priv *priv, size_t offset)
+u16 il_eeprom_query16(const struct il_priv *il, size_t offset)
 {
-        if (!priv->eeprom)
+        if (!il->eeprom)
                 return 0;
-        return (u16)priv->eeprom[offset] | ((u16)priv->eeprom[offset + 1] << 8);
+        return (u16)il->eeprom[offset] | ((u16)il->eeprom[offset + 1] << 8);
 }
 EXPORT_SYMBOL(il_eeprom_query16);
 
 /**
  * il_eeprom_init - read EEPROM contents
  *
- * Load the EEPROM contents from adapter into priv->eeprom
+ * Load the EEPROM contents from adapter into il->eeprom
  *
  * NOTE:  This routine uses the non-debug IO access functions.
  */
-int il_eeprom_init(struct il_priv *priv)
+int il_eeprom_init(struct il_priv *il)
 {
         __le16 *e;
-        u32 gp = il_read32(priv, CSR_EEPROM_GP);
+        u32 gp = il_read32(il, CSR_EEPROM_GP);
         int sz;
         int ret;
         u16 addr;
 
         /* allocate eeprom */
-        sz = priv->cfg->base_params->eeprom_size;
-        IL_DEBUG_EEPROM(priv, "NVM size = %d\n", sz);
-        priv->eeprom = kzalloc(sz, GFP_KERNEL);
-        if (!priv->eeprom) {
+        sz = il->cfg->base_params->eeprom_size;
+        IL_DEBUG_EEPROM(il, "NVM size = %d\n", sz);
+        il->eeprom = kzalloc(sz, GFP_KERNEL);
+        if (!il->eeprom) {
                 ret = -ENOMEM;
                 goto alloc_err;
         }
-        e = (__le16 *)priv->eeprom;
+        e = (__le16 *)il->eeprom;
 
-        priv->cfg->ops->lib->apm_ops.init(priv);
+        il->cfg->ops->lib->apm_ops.init(il);
 
-        ret = il_eeprom_verify_signature(priv);
+        ret = il_eeprom_verify_signature(il);
         if (ret < 0) {
-                IL_ERR(priv, "EEPROM not found, EEPROM_GP=0x%08x\n", gp);
+                IL_ERR(il, "EEPROM not found, EEPROM_GP=0x%08x\n", gp);
                 ret = -ENOENT;
                 goto err;
         }
 
         /* Make sure driver (instead of uCode) is allowed to read EEPROM */
-        ret = priv->cfg->ops->lib->eeprom_ops.acquire_semaphore(priv);
+        ret = il->cfg->ops->lib->eeprom_ops.acquire_semaphore(il);
         if (ret < 0) {
-                IL_ERR(priv, "Failed to acquire EEPROM semaphore.\n");
+                IL_ERR(il, "Failed to acquire EEPROM semaphore.\n");
                 ret = -ENOENT;
                 goto err;
         }
@@ -223,95 +223,95 @@ int il_eeprom_init(struct il_priv *priv)
         for (addr = 0; addr < sz; addr += sizeof(u16)) {
                 u32 r;
 
-                _il_write32(priv, CSR_EEPROM_REG,
+                _il_write32(il, CSR_EEPROM_REG,
                              CSR_EEPROM_REG_MSK_ADDR & (addr << 1));
 
-                ret = il_poll_bit(priv, CSR_EEPROM_REG,
+                ret = il_poll_bit(il, CSR_EEPROM_REG,
                                           CSR_EEPROM_REG_READ_VALID_MSK,
                                           CSR_EEPROM_REG_READ_VALID_MSK,
                                           IL_EEPROM_ACCESS_TIMEOUT);
                 if (ret < 0) {
-                        IL_ERR(priv, "Time out reading EEPROM[%d]\n",
+                        IL_ERR(il, "Time out reading EEPROM[%d]\n",
                                                         addr);
                         goto done;
                 }
-                r = _il_read_direct32(priv, CSR_EEPROM_REG);
+                r = _il_read_direct32(il, CSR_EEPROM_REG);
                 e[addr / 2] = cpu_to_le16(r >> 16);
         }
 
-        IL_DEBUG_EEPROM(priv, "NVM Type: %s, version: 0x%x\n",
+        IL_DEBUG_EEPROM(il, "NVM Type: %s, version: 0x%x\n",
                        "EEPROM",
-                       il_eeprom_query16(priv, EEPROM_VERSION));
+                       il_eeprom_query16(il, EEPROM_VERSION));
 
         ret = 0;
 done:
-        priv->cfg->ops->lib->eeprom_ops.release_semaphore(priv);
+        il->cfg->ops->lib->eeprom_ops.release_semaphore(il);
 
 err:
         if (ret)
-                il_eeprom_free(priv);
+                il_eeprom_free(il);
         /* Reset chip to save power until we load uCode during "up". */
-        il_apm_stop(priv);
+        il_apm_stop(il);
 alloc_err:
         return ret;
 }
 EXPORT_SYMBOL(il_eeprom_init);
 
-void il_eeprom_free(struct il_priv *priv)
+void il_eeprom_free(struct il_priv *il)
 {
-        kfree(priv->eeprom);
-        priv->eeprom = NULL;
+        kfree(il->eeprom);
+        il->eeprom = NULL;
 }
 EXPORT_SYMBOL(il_eeprom_free);
 
-static void il_init_band_reference(const struct il_priv *priv,
+static void il_init_band_reference(const struct il_priv *il,
                         int eep_band, int *eeprom_ch_count,
                         const struct il_eeprom_channel **eeprom_ch_info,
                         const u8 **eeprom_ch_index)
 {
-        u32 offset = priv->cfg->ops->lib->
+        u32 offset = il->cfg->ops->lib->
                         eeprom_ops.regulatory_bands[eep_band - 1];
         switch (eep_band) {
         case 1:         /* 2.4GHz band */
                 *eeprom_ch_count = ARRAY_SIZE(iwlegacy_eeprom_band_1);
                 *eeprom_ch_info = (struct il_eeprom_channel *)
-                                il_eeprom_query_addr(priv, offset);
+                                il_eeprom_query_addr(il, offset);
                 *eeprom_ch_index = iwlegacy_eeprom_band_1;
                 break;
         case 2:         /* 4.9GHz band */
                 *eeprom_ch_count = ARRAY_SIZE(iwlegacy_eeprom_band_2);
                 *eeprom_ch_info = (struct il_eeprom_channel *)
-                                il_eeprom_query_addr(priv, offset);
+                                il_eeprom_query_addr(il, offset);
                 *eeprom_ch_index = iwlegacy_eeprom_band_2;
                 break;
         case 3:         /* 5.2GHz band */
                 *eeprom_ch_count = ARRAY_SIZE(iwlegacy_eeprom_band_3);
                 *eeprom_ch_info = (struct il_eeprom_channel *)
-                                il_eeprom_query_addr(priv, offset);
+                                il_eeprom_query_addr(il, offset);
                 *eeprom_ch_index = iwlegacy_eeprom_band_3;
                 break;
         case 4:         /* 5.5GHz band */
                 *eeprom_ch_count = ARRAY_SIZE(iwlegacy_eeprom_band_4);
                 *eeprom_ch_info = (struct il_eeprom_channel *)
-                                il_eeprom_query_addr(priv, offset);
+                                il_eeprom_query_addr(il, offset);
                 *eeprom_ch_index = iwlegacy_eeprom_band_4;
                 break;
         case 5:         /* 5.7GHz band */
                 *eeprom_ch_count = ARRAY_SIZE(iwlegacy_eeprom_band_5);
                 *eeprom_ch_info = (struct il_eeprom_channel *)
-                                il_eeprom_query_addr(priv, offset);
+                                il_eeprom_query_addr(il, offset);
                 *eeprom_ch_index = iwlegacy_eeprom_band_5;
                 break;
         case 6:         /* 2.4GHz ht40 channels */
                 *eeprom_ch_count = ARRAY_SIZE(iwlegacy_eeprom_band_6);
                 *eeprom_ch_info = (struct il_eeprom_channel *)
-                                il_eeprom_query_addr(priv, offset);
+                                il_eeprom_query_addr(il, offset);
                 *eeprom_ch_index = iwlegacy_eeprom_band_6;
                 break;
         case 7:         /* 5 GHz ht40 channels */
                 *eeprom_ch_count = ARRAY_SIZE(iwlegacy_eeprom_band_7);
                 *eeprom_ch_info = (struct il_eeprom_channel *)
-                                il_eeprom_query_addr(priv, offset);
+                                il_eeprom_query_addr(il, offset);
                 *eeprom_ch_index = iwlegacy_eeprom_band_7;
                 break;
         default:
@@ -322,11 +322,11 @@ static void il_init_band_reference(const struct il_priv *priv,
 #define CHECK_AND_PRINT(x) ((eeprom_ch->flags & EEPROM_CHANNEL_##x) \
                             ? # x " " : "")
 /**
- * il_mod_ht40_chan_info - Copy ht40 channel info into driver's priv.
+ * il_mod_ht40_chan_info - Copy ht40 channel info into driver's il.
  *
  * Does not set up a command, or touch hardware.
  */
-static int il_mod_ht40_chan_info(struct il_priv *priv,
+static int il_mod_ht40_chan_info(struct il_priv *il,
                               enum ieee80211_band band, u16 channel,
                               const struct il_eeprom_channel *eeprom_ch,
                               u8 clear_ht40_extension_channel)
@@ -334,12 +334,12 @@ static int il_mod_ht40_chan_info(struct il_priv *priv,
         struct il_channel_info *ch_info;
 
         ch_info = (struct il_channel_info *)
-                        il_get_channel_info(priv, band, channel);
+                        il_get_channel_info(il, band, channel);
 
         if (!il_is_channel_valid(ch_info))
                 return -1;
 
-        IL_DEBUG_EEPROM(priv, "HT40 Ch. %d [%sGHz] %s%s%s%s%s(0x%02x %ddBm):"
+        IL_DEBUG_EEPROM(il, "HT40 Ch. %d [%sGHz] %s%s%s%s%s(0x%02x %ddBm):"
                         " Ad-Hoc %ssupported\n",
                         ch_info->channel,
                         il_is_channel_a_band(ch_info) ?
@@ -371,7 +371,7 @@ static int il_mod_ht40_chan_info(struct il_priv *priv,
 /**
  * il_init_channel_map - Set up driver's info for all possible channels
  */
-int il_init_channel_map(struct il_priv *priv)
+int il_init_channel_map(struct il_priv *il)
 {
         int eeprom_ch_count = 0;
         const u8 *eeprom_ch_index = NULL;
@@ -379,39 +379,39 @@ int il_init_channel_map(struct il_priv *priv)
         int band, ch;
         struct il_channel_info *ch_info;
 
-        if (priv->channel_count) {
-                IL_DEBUG_EEPROM(priv, "Channel map already initialized.\n");
+        if (il->channel_count) {
+                IL_DEBUG_EEPROM(il, "Channel map already initialized.\n");
                 return 0;
         }
 
-        IL_DEBUG_EEPROM(priv, "Initializing regulatory info from EEPROM\n");
+        IL_DEBUG_EEPROM(il, "Initializing regulatory info from EEPROM\n");
 
-        priv->channel_count =
+        il->channel_count =
             ARRAY_SIZE(iwlegacy_eeprom_band_1) +
             ARRAY_SIZE(iwlegacy_eeprom_band_2) +
             ARRAY_SIZE(iwlegacy_eeprom_band_3) +
             ARRAY_SIZE(iwlegacy_eeprom_band_4) +
             ARRAY_SIZE(iwlegacy_eeprom_band_5);
 
-        IL_DEBUG_EEPROM(priv, "Parsing data for %d channels.\n",
-                        priv->channel_count);
+        IL_DEBUG_EEPROM(il, "Parsing data for %d channels.\n",
+                        il->channel_count);
 
-        priv->channel_info = kzalloc(sizeof(struct il_channel_info) *
-                                     priv->channel_count, GFP_KERNEL);
-        if (!priv->channel_info) {
-                IL_ERR(priv, "Could not allocate channel_info\n");
-                priv->channel_count = 0;
+        il->channel_info = kzalloc(sizeof(struct il_channel_info) *
+                                     il->channel_count, GFP_KERNEL);
+        if (!il->channel_info) {
+                IL_ERR(il, "Could not allocate channel_info\n");
+                il->channel_count = 0;
                 return -ENOMEM;
         }
 
-        ch_info = priv->channel_info;
+        ch_info = il->channel_info;
 
         /* Loop through the 5 EEPROM bands adding them in order to the
          * channel map we maintain (that contains additional information than
          * what just in the EEPROM) */
         for (band = 1; band <= 5; band++) {
 
-                il_init_band_reference(priv, band, &eeprom_ch_count,
+                il_init_band_reference(il, band, &eeprom_ch_count,
                                         &eeprom_ch_info, &eeprom_ch_index);
 
                 /* Loop through each band adding each of the channels */
@@ -433,7 +433,7 @@ int il_init_channel_map(struct il_priv *priv)
                                         IEEE80211_CHAN_NO_HT40;
 
                         if (!(il_is_channel_valid(ch_info))) {
-                                IL_DEBUG_EEPROM(priv,
+                                IL_DEBUG_EEPROM(il,
                                                "Ch. %d Flags %x [%sGHz] - "
                                                "No traffic\n",
                                                ch_info->channel,
@@ -450,7 +450,7 @@ int il_init_channel_map(struct il_priv *priv)
                         ch_info->scan_power = eeprom_ch_info[ch].max_power_avg;
                         ch_info->min_power = 0;
 
-                        IL_DEBUG_EEPROM(priv, "Ch. %d [%sGHz] "
+                        IL_DEBUG_EEPROM(il, "Ch. %d [%sGHz] "
                                        "%s%s%s%s%s%s(0x%02x %ddBm):"
                                        " Ad-Hoc %ssupported\n",
                                        ch_info->channel,
@@ -475,9 +475,9 @@ int il_init_channel_map(struct il_priv *priv)
         }
 
         /* Check if we do have HT40 channels */
-        if (priv->cfg->ops->lib->eeprom_ops.regulatory_bands[5] ==
+        if (il->cfg->ops->lib->eeprom_ops.regulatory_bands[5] ==
             EEPROM_REGULATORY_BAND_NO_HT40 &&
-            priv->cfg->ops->lib->eeprom_ops.regulatory_bands[6] ==
+            il->cfg->ops->lib->eeprom_ops.regulatory_bands[6] ==
             EEPROM_REGULATORY_BAND_NO_HT40)
                 return 0;
 
@@ -485,7 +485,7 @@ int il_init_channel_map(struct il_priv *priv)
         for (band = 6; band <= 7; band++) {
                 enum ieee80211_band ieeeband;
 
-                il_init_band_reference(priv, band, &eeprom_ch_count,
+                il_init_band_reference(il, band, &eeprom_ch_count,
                                         &eeprom_ch_info, &eeprom_ch_index);
 
                 /* EEPROM band 6 is 2.4, band 7 is 5 GHz */
@@ -495,13 +495,13 @@ int il_init_channel_map(struct il_priv *priv)
                 /* Loop through each band adding each of the channels */
                 for (ch = 0; ch < eeprom_ch_count; ch++) {
                         /* Set up driver's info for lower half */
-                        il_mod_ht40_chan_info(priv, ieeeband,
+                        il_mod_ht40_chan_info(il, ieeeband,
                                                 eeprom_ch_index[ch],
                                                 &eeprom_ch_info[ch],
                                                 IEEE80211_CHAN_NO_HT40PLUS);
 
                         /* Set up driver's info for upper half */
-                        il_mod_ht40_chan_info(priv, ieeeband,
+                        il_mod_ht40_chan_info(il, ieeeband,
                                                 eeprom_ch_index[ch] + 4,
                                                 &eeprom_ch_info[ch],
                                                 IEEE80211_CHAN_NO_HT40MINUS);
@@ -515,34 +515,34 @@ EXPORT_SYMBOL(il_init_channel_map);
 /*
  * il_free_channel_map - undo allocations in il_init_channel_map
  */
-void il_free_channel_map(struct il_priv *priv)
+void il_free_channel_map(struct il_priv *il)
 {
-        kfree(priv->channel_info);
-        priv->channel_count = 0;
+        kfree(il->channel_info);
+        il->channel_count = 0;
 }
 EXPORT_SYMBOL(il_free_channel_map);
 
 /**
- * il_get_channel_info - Find driver's private channel info
+ * il_get_channel_info - Find driver's ilate channel info
  *
  * Based on band and channel number.
  */
 const struct
-il_channel_info *il_get_channel_info(const struct il_priv *priv,
+il_channel_info *il_get_channel_info(const struct il_priv *il,
                                         enum ieee80211_band band, u16 channel)
 {
         int i;
 
         switch (band) {
         case IEEE80211_BAND_5GHZ:
-                for (i = 14; i < priv->channel_count; i++) {
-                        if (priv->channel_info[i].channel == channel)
-                                return &priv->channel_info[i];
+                for (i = 14; i < il->channel_count; i++) {
+                        if (il->channel_info[i].channel == channel)
+                                return &il->channel_info[i];
                 }
                 break;
         case IEEE80211_BAND_2GHZ:
                 if (channel >= 1 && channel <= 14)
-                        return &priv->channel_info[channel - 1];
+                        return &il->channel_info[channel - 1];
                 break;
         default:
                 BUG();