iwlwifi: 3954 renames iwl3945_rate_scale_priv to iwl3945_rs_sta

This patch renames iwl3945_rate_scale_priv to iwl3945_rs_sta as it
better represents the purpose of this variable.

Signed-off-by: Tomas Winkler <tomas.winkler@intel.com>
Signed-off-by: Zhu Yi <yi.zhu@intel.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 104 insertions, 102 deletions

diff --git a/drivers/net/wireless/iwlwifi/iwl-3945-rs.c b/drivers/net/wireless/iwlwifi/iwl-3945-rs.c
index d79f18c41957..80d31ae51e77 100644
--- a/drivers/net/wireless/iwlwifi/iwl-3945-rs.c
+++ b/drivers/net/wireless/iwlwifi/iwl-3945-rs.c
@@ -52,7 +52,7 @@ struct iwl3945_rate_scale_data {
         unsigned long stamp;
 };
 
-struct iwl3945_rate_scale_priv {
+struct iwl3945_rs_sta {
         spinlock_t lock;
         s32 *expected_tpt;
         unsigned long last_partial_flush;
@@ -181,7 +181,7 @@ static void iwl3945_clear_window(struct iwl3945_rate_scale_data *window)
  * not flushed.  If there were any that were not flushed, then
  * reschedule the rate flushing routine.
  */
-static int iwl3945_rate_scale_flush_windows(struct iwl3945_rate_scale_priv *rs_priv)
+static int iwl3945_rate_scale_flush_windows(struct iwl3945_rs_sta *rs_sta)
 {
         int unflushed = 0;
         int i;
@@ -193,19 +193,19 @@ static int iwl3945_rate_scale_flush_windows(struct iwl3945_rate_scale_priv *rs_p
          * since we flushed, clear out the gathered statistics
          */
         for (i = 0; i < IWL_RATE_COUNT; i++) {
-                if (!rs_priv->win[i].counter)
+                if (!rs_sta->win[i].counter)
                         continue;
 
-                spin_lock_irqsave(&rs_priv->lock, flags);
-                if (time_after(jiffies, rs_priv->win[i].stamp +
+                spin_lock_irqsave(&rs_sta->lock, flags);
+                if (time_after(jiffies, rs_sta->win[i].stamp +
                                IWL_RATE_WIN_FLUSH)) {
                         IWL_DEBUG_RATE("flushing %d samples of rate "
                                        "index %d\n",
-                                       rs_priv->win[i].counter, i);
-                        iwl3945_clear_window(&rs_priv->win[i]);
+                                       rs_sta->win[i].counter, i);
+                        iwl3945_clear_window(&rs_sta->win[i]);
                 } else
                         unflushed++;
-                spin_unlock_irqrestore(&rs_priv->lock, flags);
+                spin_unlock_irqrestore(&rs_sta->lock, flags);
         }
 
         return unflushed;
@@ -216,28 +216,28 @@ static int iwl3945_rate_scale_flush_windows(struct iwl3945_rate_scale_priv *rs_p
 
 static void iwl3945_bg_rate_scale_flush(unsigned long data)
 {
-        struct iwl3945_rate_scale_priv *rs_priv = (void *)data;
+        struct iwl3945_rs_sta *rs_sta = (void *)data;
         int unflushed = 0;
         unsigned long flags;
         u32 packet_count, duration, pps;
 
         IWL_DEBUG_RATE("enter\n");
 
-        unflushed = iwl3945_rate_scale_flush_windows(rs_priv);
+        unflushed = iwl3945_rate_scale_flush_windows(rs_sta);
 
-        spin_lock_irqsave(&rs_priv->lock, flags);
+        spin_lock_irqsave(&rs_sta->lock, flags);
 
-        rs_priv->flush_pending = 0;
+        rs_sta->flush_pending = 0;
 
         /* Number of packets Rx'd since last time this timer ran */
-        packet_count = (rs_priv->tx_packets - rs_priv->last_tx_packets) + 1;
+        packet_count = (rs_sta->tx_packets - rs_sta->last_tx_packets) + 1;
 
-        rs_priv->last_tx_packets = rs_priv->tx_packets + 1;
+        rs_sta->last_tx_packets = rs_sta->tx_packets + 1;
 
         if (unflushed) {
                 duration =
-                    jiffies_to_msecs(jiffies - rs_priv->last_partial_flush);
-/*              duration = jiffies_to_msecs(rs_priv->flush_time); */
+                    jiffies_to_msecs(jiffies - rs_sta->last_partial_flush);
+/*              duration = jiffies_to_msecs(rs_sta->flush_time); */
 
                 IWL_DEBUG_RATE("Tx'd %d packets in %dms\n",
                                packet_count, duration);
@@ -255,23 +255,23 @@ static void iwl3945_bg_rate_scale_flush(unsigned long data)
                 } else
                         duration = IWL_RATE_FLUSH_MAX;
 
-                rs_priv->flush_time = msecs_to_jiffies(duration);
+                rs_sta->flush_time = msecs_to_jiffies(duration);
 
                 IWL_DEBUG_RATE("new flush period: %d msec ave %d\n",
                                duration, packet_count);
 
-                mod_timer(&rs_priv->rate_scale_flush, jiffies +
-                          rs_priv->flush_time);
+                mod_timer(&rs_sta->rate_scale_flush, jiffies +
+                          rs_sta->flush_time);
 
-                rs_priv->last_partial_flush = jiffies;
+                rs_sta->last_partial_flush = jiffies;
         }
 
         /* If there weren't any unflushed entries, we don't schedule the timer
          * to run again */
 
-        rs_priv->last_flush = jiffies;
+        rs_sta->last_flush = jiffies;
 
-        spin_unlock_irqrestore(&rs_priv->lock, flags);
+        spin_unlock_irqrestore(&rs_sta->lock, flags);
 
         IWL_DEBUG_RATE("leave\n");
 }
@@ -283,7 +283,7 @@ static void iwl3945_bg_rate_scale_flush(unsigned long data)
  * at this rate.  window->data contains the bitmask of successful
  * packets.
  */
-static void iwl3945_collect_tx_data(struct iwl3945_rate_scale_priv *rs_priv,
+static void iwl3945_collect_tx_data(struct iwl3945_rs_sta *rs_sta,
                                 struct iwl3945_rate_scale_data *window,
                                 int success, int retries)
 {
@@ -295,7 +295,7 @@ static void iwl3945_collect_tx_data(struct iwl3945_rate_scale_priv *rs_priv,
         }
 
         while (retries--) {
-                spin_lock_irqsave(&rs_priv->lock, flags);
+                spin_lock_irqsave(&rs_sta->lock, flags);
 
                 /* If we have filled up the window then subtract one from the
                  * success counter if the high-bit is counting toward
@@ -323,7 +323,7 @@ static void iwl3945_collect_tx_data(struct iwl3945_rate_scale_priv *rs_priv,
                 /* Tag this window as having been updated */
                 window->stamp = jiffies;
 
-                spin_unlock_irqrestore(&rs_priv->lock, flags);
+                spin_unlock_irqrestore(&rs_sta->lock, flags);
         }
 }
 
@@ -373,49 +373,49 @@ static void rs_clear(void *priv)
 
 static void *rs_alloc_sta(void *priv, gfp_t gfp)
 {
-        struct iwl3945_rate_scale_priv *rs_priv;
+        struct iwl3945_rs_sta *rs_sta;
         int i;
 
         IWL_DEBUG_RATE("enter\n");
 
-        rs_priv = kzalloc(sizeof(struct iwl3945_rate_scale_priv), gfp);
-        if (!rs_priv) {
+        rs_sta = kzalloc(sizeof(struct iwl3945_rs_sta), gfp);
+        if (!rs_sta) {
                 IWL_DEBUG_RATE("leave: ENOMEM\n");
                 return NULL;
         }
 
-        spin_lock_init(&rs_priv->lock);
+        spin_lock_init(&rs_sta->lock);
 
-        rs_priv->start_rate = IWL_RATE_INVALID;
+        rs_sta->start_rate = IWL_RATE_INVALID;
 
         /* default to just 802.11b */
-        rs_priv->expected_tpt = iwl3945_expected_tpt_b;
+        rs_sta->expected_tpt = iwl3945_expected_tpt_b;
 
-        rs_priv->last_partial_flush = jiffies;
-        rs_priv->last_flush = jiffies;
-        rs_priv->flush_time = IWL_RATE_FLUSH;
-        rs_priv->last_tx_packets = 0;
-        rs_priv->ibss_sta_added = 0;
+        rs_sta->last_partial_flush = jiffies;
+        rs_sta->last_flush = jiffies;
+        rs_sta->flush_time = IWL_RATE_FLUSH;
+        rs_sta->last_tx_packets = 0;
+        rs_sta->ibss_sta_added = 0;
 
-        init_timer(&rs_priv->rate_scale_flush);
-        rs_priv->rate_scale_flush.data = (unsigned long)rs_priv;
-        rs_priv->rate_scale_flush.function = &iwl3945_bg_rate_scale_flush;
+        init_timer(&rs_sta->rate_scale_flush);
+        rs_sta->rate_scale_flush.data = (unsigned long)rs_sta;
+        rs_sta->rate_scale_flush.function = &iwl3945_bg_rate_scale_flush;
 
         for (i = 0; i < IWL_RATE_COUNT; i++)
-                iwl3945_clear_window(&rs_priv->win[i]);
+                iwl3945_clear_window(&rs_sta->win[i]);
 
         IWL_DEBUG_RATE("leave\n");
 
-        return rs_priv;
+        return rs_sta;
 }
 
 static void rs_free_sta(void *priv, void *priv_sta)
 {
-        struct iwl3945_rate_scale_priv *rs_priv = priv_sta;
+        struct iwl3945_rs_sta *rs_sta = priv_sta;
 
         IWL_DEBUG_RATE("enter\n");
-        del_timer_sync(&rs_priv->rate_scale_flush);
-        kfree(rs_priv);
+        del_timer_sync(&rs_sta->rate_scale_flush);
+        kfree(rs_sta);
         IWL_DEBUG_RATE("leave\n");
 }
 
@@ -464,7 +464,7 @@ static void rs_tx_status(void *priv_rate,
         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
         struct iwl3945_priv *priv = (struct iwl3945_priv *)priv_rate;
         struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
-        struct iwl3945_rate_scale_priv *rs_priv;
+        struct iwl3945_rs_sta *rs_sta;
 
         IWL_DEBUG_RATE("enter\n");
 
@@ -485,9 +485,9 @@ static void rs_tx_status(void *priv_rate,
                 return;
         }
 
-        rs_priv = (void *)sta->rate_ctrl_priv;
+        rs_sta = (void *)sta->rate_ctrl_priv;
 
-        rs_priv->tx_packets++;
+        rs_sta->tx_packets++;
 
         scale_rate_index = first_index;
         last_index = first_index;
@@ -514,8 +514,8 @@ static void rs_tx_status(void *priv_rate,
 
                 /* Update this rate accounting for as many retries
                  * as was used for it (per current_count) */
-                iwl3945_collect_tx_data(rs_priv,
-                                    &rs_priv->win[scale_rate_index],
+                iwl3945_collect_tx_data(rs_sta,
+                                    &rs_sta->win[scale_rate_index],
                                     0, current_count);
                 IWL_DEBUG_RATE("Update rate %d for %d retries.\n",
                                scale_rate_index, current_count);
@@ -533,25 +533,25 @@ static void rs_tx_status(void *priv_rate,
                        last_index,
                        (tx_resp->flags & IEEE80211_TX_STATUS_ACK) ?
                        "success" : "failure");
-        iwl3945_collect_tx_data(rs_priv,
-                            &rs_priv->win[last_index],
+        iwl3945_collect_tx_data(rs_sta,
+                            &rs_sta->win[last_index],
                             tx_resp->flags & IEEE80211_TX_STATUS_ACK, 1);
 
         /* We updated the rate scale window -- if its been more than
          * flush_time since the last run, schedule the flush
          * again */
-        spin_lock_irqsave(&rs_priv->lock, flags);
+        spin_lock_irqsave(&rs_sta->lock, flags);
 
-        if (!rs_priv->flush_pending &&
-            time_after(jiffies, rs_priv->last_partial_flush +
-                       rs_priv->flush_time)) {
+        if (!rs_sta->flush_pending &&
+            time_after(jiffies, rs_sta->last_partial_flush +
+                       rs_sta->flush_time)) {
 
-                rs_priv->flush_pending = 1;
-                mod_timer(&rs_priv->rate_scale_flush,
-                          jiffies + rs_priv->flush_time);
+                rs_sta->flush_pending = 1;
+                mod_timer(&rs_sta->rate_scale_flush,
+                          jiffies + rs_sta->flush_time);
         }
 
-        spin_unlock_irqrestore(&rs_priv->lock, flags);
+        spin_unlock_irqrestore(&rs_sta->lock, flags);
 
         sta_info_put(sta);
 
@@ -560,8 +560,8 @@ static void rs_tx_status(void *priv_rate,
         return;
 }
 
-static u16 iwl3945_get_adjacent_rate(struct iwl3945_rate_scale_priv *rs_priv,
-                                     u8 index, u16 rate_mask, int phymode)
+static u16 iwl3945_get_adjacent_rate(struct iwl3945_rs_sta *rs_sta,
+                                 u8 index, u16 rate_mask, int phymode)
 {
         u8 high = IWL_RATE_INVALID;
         u8 low = IWL_RATE_INVALID;
@@ -595,7 +595,7 @@ static u16 iwl3945_get_adjacent_rate(struct iwl3945_rate_scale_priv *rs_priv,
 
         low = index;
         while (low != IWL_RATE_INVALID) {
-                if (rs_priv->tgg)
+                if (rs_sta->tgg)
                         low = iwl3945_rates[low].prev_rs_tgg;
                 else
                         low = iwl3945_rates[low].prev_rs;
@@ -608,7 +608,7 @@ static u16 iwl3945_get_adjacent_rate(struct iwl3945_rate_scale_priv *rs_priv,
 
         high = index;
         while (high != IWL_RATE_INVALID) {
-                if (rs_priv->tgg)
+                if (rs_sta->tgg)
                         high = iwl3945_rates[high].next_rs_tgg;
                 else
                         high = iwl3945_rates[high].next_rs;
@@ -646,7 +646,7 @@ static void rs_get_rate(void *priv_rate, struct net_device *dev,
         u8 high = IWL_RATE_INVALID;
         u16 high_low;
         int index;
-        struct iwl3945_rate_scale_priv *rs_priv;
+        struct iwl3945_rs_sta *rs_sta;
         struct iwl3945_rate_scale_data *window = NULL;
         int current_tpt = IWL_INVALID_VALUE;
         int low_tpt = IWL_INVALID_VALUE;
@@ -684,10 +684,10 @@ static void rs_get_rate(void *priv_rate, struct net_device *dev,
         if (priv->phymode == (u8) MODE_IEEE80211A)
                 rate_mask = rate_mask << IWL_FIRST_OFDM_RATE;
 
-        rs_priv = (void *)sta->rate_ctrl_priv;
+        rs_sta = (void *)sta->rate_ctrl_priv;
 
         if ((priv->iw_mode == IEEE80211_IF_TYPE_IBSS) &&
-            !rs_priv->ibss_sta_added) {
+            !rs_sta->ibss_sta_added) {
                 u8 sta_id = iwl3945_hw_find_station(priv, hdr->addr1);
 
                 if (sta_id == IWL_INVALID_STATION) {
@@ -697,24 +697,24 @@ static void rs_get_rate(void *priv_rate, struct net_device *dev,
                                     hdr->addr1, 0, CMD_ASYNC);
                 }
                 if (sta_id != IWL_INVALID_STATION)
-                        rs_priv->ibss_sta_added = 1;
+                        rs_sta->ibss_sta_added = 1;
         }
 
-        spin_lock_irqsave(&rs_priv->lock, flags);
+        spin_lock_irqsave(&rs_sta->lock, flags);
 
-        if (rs_priv->start_rate != IWL_RATE_INVALID) {
-                index = rs_priv->start_rate;
-                rs_priv->start_rate = IWL_RATE_INVALID;
+        if (rs_sta->start_rate != IWL_RATE_INVALID) {
+                index = rs_sta->start_rate;
+                rs_sta->start_rate = IWL_RATE_INVALID;
         }
 
-        window = &(rs_priv->win[index]);
+        window = &(rs_sta->win[index]);
 
         fail_count = window->counter - window->success_counter;
 
         if (((fail_count <= IWL_RATE_MIN_FAILURE_TH) &&
              (window->success_counter < IWL_RATE_MIN_SUCCESS_TH))) {
                 window->average_tpt = IWL_INVALID_VALUE;
-                spin_unlock_irqrestore(&rs_priv->lock, flags);
+                spin_unlock_irqrestore(&rs_sta->lock, flags);
 
                 IWL_DEBUG_RATE("Invalid average_tpt on rate %d: "
                                "counter: %d, success_counter: %d, "
@@ -722,27 +722,27 @@ static void rs_get_rate(void *priv_rate, struct net_device *dev,
                                index,
                                window->counter,
                                window->success_counter,
-                               rs_priv->expected_tpt ? "not " : "");
+                               rs_sta->expected_tpt ? "not " : "");
                 goto out;
 
         }
 
         window->average_tpt = ((window->success_ratio *
-                                rs_priv->expected_tpt[index] + 64) / 128);
+                                rs_sta->expected_tpt[index] + 64) / 128);
         current_tpt = window->average_tpt;
 
-        high_low = iwl3945_get_adjacent_rate(rs_priv, index, rate_mask,
+        high_low = iwl3945_get_adjacent_rate(rs_sta, index, rate_mask,
                                          local->hw.conf.phymode);
         low = high_low & 0xff;
         high = (high_low >> 8) & 0xff;
 
         if (low != IWL_RATE_INVALID)
-                low_tpt = rs_priv->win[low].average_tpt;
+                low_tpt = rs_sta->win[low].average_tpt;
 
         if (high != IWL_RATE_INVALID)
-                high_tpt = rs_priv->win[high].average_tpt;
+                high_tpt = rs_sta->win[high].average_tpt;
 
-        spin_unlock_irqrestore(&rs_priv->lock, flags);
+        spin_unlock_irqrestore(&rs_sta->lock, flags);
 
         scale_action = 1;
 
@@ -840,7 +840,7 @@ int iwl3945_fill_rs_info(struct ieee80211_hw *hw, char *buf, u8 sta_id)
 {
         struct ieee80211_local *local = hw_to_local(hw);
         struct iwl3945_priv *priv = hw->priv;
-        struct iwl3945_rate_scale_priv *rs_priv;
+        struct iwl3945_rs_sta *rs_sta;
         struct sta_info *sta;
         unsigned long flags;
         int count = 0, i;
@@ -858,8 +858,8 @@ int iwl3945_fill_rs_info(struct ieee80211_hw *hw, char *buf, u8 sta_id)
                 return sprintf(buf, "station %d not found\n", sta_id);
         }
 
-        rs_priv = (void *)sta->rate_ctrl_priv;
-        spin_lock_irqsave(&rs_priv->lock, flags);
+        rs_sta = (void *)sta->rate_ctrl_priv;
+        spin_lock_irqsave(&rs_sta->lock, flags);
         i = IWL_RATE_54M_INDEX;
         while (1) {
                 u64 mask;
@@ -871,15 +871,16 @@ int iwl3945_fill_rs_info(struct ieee80211_hw *hw, char *buf, u8 sta_id)
                 mask = (1ULL << (IWL_RATE_MAX_WINDOW - 1));
                 for (j = 0; j < IWL_RATE_MAX_WINDOW; j++, mask >>= 1)
                         buf[count++] =
-                            (rs_priv->win[i].data & mask) ? '1' : '0';
+                            (rs_sta->win[i].data & mask) ? '1' : '0';
 
-                samples += rs_priv->win[i].counter;
-                good += rs_priv->win[i].success_counter;
-                success += rs_priv->win[i].success_counter * iwl3945_rates[i].ieee;
+                samples += rs_sta->win[i].counter;
+                good += rs_sta->win[i].success_counter;
+                success += rs_sta->win[i].success_counter *
+                                                iwl3945_rates[i].ieee;
 
-                if (rs_priv->win[i].stamp) {
+                if (rs_sta->win[i].stamp) {
                         int delta =
-                            jiffies_to_msecs(now - rs_priv->win[i].stamp);
+                            jiffies_to_msecs(now - rs_sta->win[i].stamp);
 
                         if (delta > max_time)
                                 max_time = delta;
@@ -893,7 +894,7 @@ int iwl3945_fill_rs_info(struct ieee80211_hw *hw, char *buf, u8 sta_id)
                         break;
                 i = j;
         }
-        spin_unlock_irqrestore(&rs_priv->lock, flags);
+        spin_unlock_irqrestore(&rs_sta->lock, flags);
         sta_info_put(sta);
 
         /* Display the average rate of all samples taken.
@@ -919,7 +920,7 @@ void iwl3945_rate_scale_init(struct ieee80211_hw *hw, s32 sta_id)
         s32 rssi = 0;
         unsigned long flags;
         struct ieee80211_local *local = hw_to_local(hw);
-        struct iwl3945_rate_scale_priv *rs_priv;
+        struct iwl3945_rs_sta *rs_sta;
         struct sta_info *sta;
 
         IWL_DEBUG_RATE("enter\n");
@@ -939,33 +940,33 @@ void iwl3945_rate_scale_init(struct ieee80211_hw *hw, s32 sta_id)
                 return;
         }
 
-        rs_priv = (void *)sta->rate_ctrl_priv;
+        rs_sta = (void *)sta->rate_ctrl_priv;
 
-        spin_lock_irqsave(&rs_priv->lock, flags);
+        spin_lock_irqsave(&rs_sta->lock, flags);
 
-        rs_priv->tgg = 0;
+        rs_sta->tgg = 0;
         switch (priv->phymode) {
         case MODE_IEEE80211G:
                 if (priv->active_rxon.flags & RXON_FLG_TGG_PROTECT_MSK) {
-                        rs_priv->tgg = 1;
-                        rs_priv->expected_tpt = iwl3945_expected_tpt_g_prot;
+                        rs_sta->tgg = 1;
+                        rs_sta->expected_tpt = iwl3945_expected_tpt_g_prot;
                 } else
-                        rs_priv->expected_tpt = iwl3945_expected_tpt_g;
+                        rs_sta->expected_tpt = iwl3945_expected_tpt_g;
                 break;
 
         case MODE_IEEE80211A:
-                rs_priv->expected_tpt = iwl3945_expected_tpt_a;
+                rs_sta->expected_tpt = iwl3945_expected_tpt_a;
                 break;
 
         default:
                 IWL_WARNING("Invalid phymode.  Defaulting to 802.11b\n");
         case MODE_IEEE80211B:
-                rs_priv->expected_tpt = iwl3945_expected_tpt_b;
+                rs_sta->expected_tpt = iwl3945_expected_tpt_b;
                 break;
         }
 
         sta_info_put(sta);
-        spin_unlock_irqrestore(&rs_priv->lock, flags);
+        spin_unlock_irqrestore(&rs_sta->lock, flags);
 
         rssi = priv->last_rx_rssi;
         if (rssi == 0)
@@ -973,11 +974,12 @@ void iwl3945_rate_scale_init(struct ieee80211_hw *hw, s32 sta_id)
 
         IWL_DEBUG(IWL_DL_INFO | IWL_DL_RATE, "Network RSSI: %d\n", rssi);
 
-        rs_priv->start_rate = iwl3945_get_rate_index_by_rssi(rssi, priv->phymode);
+        rs_sta->start_rate =
+                        iwl3945_get_rate_index_by_rssi(rssi, priv->phymode);
 
         IWL_DEBUG_RATE("leave: rssi %d assign rate index: "
-                       "%d (plcp 0x%x)\n", rssi, rs_priv->start_rate,
-                       iwl3945_rates[rs_priv->start_rate].plcp);
+                       "%d (plcp 0x%x)\n", rssi, rs_sta->start_rate,
+                       iwl3945_rates[rs_sta->start_rate].plcp);
 }
 
 void iwl3945_rate_control_register(struct ieee80211_hw *hw)