iwlegacy: s/window/win/

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

1 files changed, 54 insertions, 54 deletions

diff --git a/drivers/net/wireless/iwlegacy/iwl-3945-rs.c b/drivers/net/wireless/iwlegacy/iwl-3945-rs.c
index ebee6c350dbe..5c855e88b95e 100644
--- a/drivers/net/wireless/iwlegacy/iwl-3945-rs.c
+++ b/drivers/net/wireless/iwlegacy/iwl-3945-rs.c
@@ -131,24 +131,24 @@ static u8 il3945_get_rate_index_by_rssi(s32 rssi, enum ieee80211_band band)
         return tpt_table[index].index;
 }
 
-static void il3945_clear_window(struct il3945_rate_scale_data *window)
+static void il3945_clear_win(struct il3945_rate_scale_data *win)
 {
-        window->data = 0;
-        window->success_counter = 0;
-        window->success_ratio = -1;
-        window->counter = 0;
-        window->average_tpt = IL_INVALID_VALUE;
-        window->stamp = 0;
+        win->data = 0;
+        win->success_counter = 0;
+        win->success_ratio = -1;
+        win->counter = 0;
+        win->average_tpt = IL_INVALID_VALUE;
+        win->stamp = 0;
 }
 
 /**
- * il3945_rate_scale_flush_windows - flush out the rate scale windows
+ * il3945_rate_scale_flush_wins - flush out the rate scale wins
  *
- * Returns the number of windows that have gathered data but were
+ * Returns the number of wins that have gathered data but were
  * not flushed.  If there were any that were not flushed, then
  * reschedule the rate flushing routine.
  */
-static int il3945_rate_scale_flush_windows(struct il3945_rs_sta *rs_sta)
+static int il3945_rate_scale_flush_wins(struct il3945_rs_sta *rs_sta)
 {
         int unflushed = 0;
         int i;
@@ -170,7 +170,7 @@ static int il3945_rate_scale_flush_windows(struct il3945_rs_sta *rs_sta)
                         D_RATE("flushing %d samples of rate "
                                        "index %d\n",
                                        rs_sta->win[i].counter, i);
-                        il3945_clear_window(&rs_sta->win[i]);
+                        il3945_clear_win(&rs_sta->win[i]);
                 } else
                         unflushed++;
                 spin_unlock_irqrestore(&rs_sta->lock, flags);
@@ -193,7 +193,7 @@ static void il3945_bg_rate_scale_flush(unsigned long data)
 
         D_RATE("enter\n");
 
-        unflushed = il3945_rate_scale_flush_windows(rs_sta);
+        unflushed = il3945_rate_scale_flush_wins(rs_sta);
 
         spin_lock_irqsave(&rs_sta->lock, flags);
 
@@ -248,14 +248,14 @@ static void il3945_bg_rate_scale_flush(unsigned long data)
 }
 
 /**
- * il3945_collect_tx_data - Update the success/failure sliding window
+ * il3945_collect_tx_data - Update the success/failure sliding win
  *
- * We keep a sliding window of the last 64 packets transmitted
- * at this rate.  window->data contains the bitmask of successful
+ * We keep a sliding win of the last 64 packets transmitted
+ * at this rate.  win->data contains the bitmask of successful
  * packets.
  */
 static void il3945_collect_tx_data(struct il3945_rs_sta *rs_sta,
-                                struct il3945_rate_scale_data *window,
+                                struct il3945_rate_scale_data *win,
                                 int success, int retries, int index)
 {
         unsigned long flags;
@@ -271,34 +271,34 @@ static void il3945_collect_tx_data(struct il3945_rs_sta *rs_sta,
 
         /*
          * Keep track of only the latest 62 tx frame attempts in this rate's
-         * history window; anything older isn't really relevant any more.
-         * If we have filled up the sliding window, drop the oldest attempt;
+         * history win; anything older isn't really relevant any more.
+         * If we have filled up the sliding win, drop the oldest attempt;
          * if the oldest attempt (highest bit in bitmap) shows "success",
          * subtract "1" from the success counter (this is the main reason
          * we keep these bitmaps!).
          * */
         while (retries > 0) {
-                if (window->counter >= IL_RATE_MAX_WINDOW) {
+                if (win->counter >= IL_RATE_MAX_WINDOW) {
 
                         /* remove earliest */
-                        window->counter = IL_RATE_MAX_WINDOW - 1;
+                        win->counter = IL_RATE_MAX_WINDOW - 1;
 
-                        if (window->data & (1ULL << (IL_RATE_MAX_WINDOW - 1))) {
-                                window->data &= ~(1ULL << (IL_RATE_MAX_WINDOW - 1));
-                                window->success_counter--;
+                        if (win->data & (1ULL << (IL_RATE_MAX_WINDOW - 1))) {
+                                win->data &= ~(1ULL << (IL_RATE_MAX_WINDOW - 1));
+                                win->success_counter--;
                         }
                 }
 
                 /* Increment frames-attempted counter */
-                window->counter++;
+                win->counter++;
 
                 /* Shift bitmap by one frame (throw away oldest history),
                  * OR in "1", and increment "success" if this
                  * frame was successful. */
-                window->data <<= 1;
+                win->data <<= 1;
                 if (success > 0) {
-                        window->success_counter++;
-                        window->data |= 0x1;
+                        win->success_counter++;
+                        win->data |= 0x1;
                         success--;
                 }
 
@@ -306,24 +306,24 @@ static void il3945_collect_tx_data(struct il3945_rs_sta *rs_sta,
         }
 
         /* Calculate current success ratio, avoid divide-by-0! */
-        if (window->counter > 0)
-                window->success_ratio = 128 * (100 * window->success_counter)
-                                        / window->counter;
+        if (win->counter > 0)
+                win->success_ratio = 128 * (100 * win->success_counter)
+                                        / win->counter;
         else
-                window->success_ratio = IL_INVALID_VALUE;
+                win->success_ratio = IL_INVALID_VALUE;
 
-        fail_count = window->counter - window->success_counter;
+        fail_count = win->counter - win->success_counter;
 
         /* Calculate average throughput, if we have enough history. */
         if (fail_count >= IL_RATE_MIN_FAILURE_TH ||
-            window->success_counter >= IL_RATE_MIN_SUCCESS_TH)
-                window->average_tpt = ((window->success_ratio *
+            win->success_counter >= IL_RATE_MIN_SUCCESS_TH)
+                win->average_tpt = ((win->success_ratio *
                                 rs_sta->expected_tpt[index] + 64) / 128);
         else
-                window->average_tpt = IL_INVALID_VALUE;
+                win->average_tpt = IL_INVALID_VALUE;
 
-        /* Tag this window as having been updated */
-        window->stamp = jiffies;
+        /* Tag this win as having been updated */
+        win->stamp = jiffies;
 
         spin_unlock_irqrestore(&rs_sta->lock, flags);
 
@@ -365,7 +365,7 @@ void il3945_rs_rate_init(struct il_priv *il, struct ieee80211_sta *sta, u8 sta_i
         rs_sta->rate_scale_flush.function = il3945_bg_rate_scale_flush;
 
         for (i = 0; i < IL_RATE_COUNT_3945; i++)
-                il3945_clear_window(&rs_sta->win[i]);
+                il3945_clear_win(&rs_sta->win[i]);
 
         /* TODO: what is a good starting rate for STA? About middle? Maybe not
          * the lowest or the highest rate.. Could consider using RSSI from
@@ -484,7 +484,7 @@ static void il3945_rs_tx_status(void *il_rate, struct ieee80211_supported_band *
         last_index = first_index;
 
         /*
-         * Update the window for each rate.  We determine which rates
+         * Update the win for each rate.  We determine which rates
          * were Tx'd based on the total number of retries vs. the number
          * of retries configured for each rate -- currently set to the
          * il value 'retry_rate' vs. rate specific
@@ -517,7 +517,7 @@ static void il3945_rs_tx_status(void *il_rate, struct ieee80211_supported_band *
         }
 
 
-        /* Update the last index window with success/failure based on ACK */
+        /* Update the last index win with success/failure based on ACK */
         D_RATE("Update rate %d with %s.\n",
                        last_index,
                        (info->flags & IEEE80211_TX_STAT_ACK) ?
@@ -526,7 +526,7 @@ static void il3945_rs_tx_status(void *il_rate, struct ieee80211_supported_band *
                             &rs_sta->win[last_index],
                             info->flags & IEEE80211_TX_STAT_ACK, 1, last_index);
 
-        /* We updated the rate scale window -- if its been more than
+        /* We updated the rate scale win -- if its been more than
          * flush_time since the last run, schedule the flush
          * again */
         spin_lock_irqsave(&rs_sta->lock, flags);
@@ -636,7 +636,7 @@ static void il3945_rs_get_rate(void *il_r, struct ieee80211_sta *sta,
         u16 high_low;
         int index;
         struct il3945_rs_sta *rs_sta = il_sta;
-        struct il3945_rate_scale_data *window = NULL;
+        struct il3945_rate_scale_data *win = NULL;
         int current_tpt = IL_INVALID_VALUE;
         int low_tpt = IL_INVALID_VALUE;
         int high_tpt = IL_INVALID_VALUE;
@@ -691,29 +691,29 @@ static void il3945_rs_get_rate(void *il_r, struct ieee80211_sta *sta,
                         index = max_rate_idx;
         }
 
-        window = &(rs_sta->win[index]);
+        win = &(rs_sta->win[index]);
 
-        fail_count = window->counter - window->success_counter;
+        fail_count = win->counter - win->success_counter;
 
         if (fail_count < IL_RATE_MIN_FAILURE_TH &&
-            window->success_counter < IL_RATE_MIN_SUCCESS_TH) {
+            win->success_counter < IL_RATE_MIN_SUCCESS_TH) {
                 spin_unlock_irqrestore(&rs_sta->lock, flags);
 
                 D_RATE("Invalid average_tpt on rate %d: "
                                "counter: %d, success_counter: %d, "
                                "expected_tpt is %sNULL\n",
                                index,
-                               window->counter,
-                               window->success_counter,
+                               win->counter,
+                               win->success_counter,
                                rs_sta->expected_tpt ? "not " : "");
 
            /* Can't calculate this yet; not enough history */
-                window->average_tpt = IL_INVALID_VALUE;
+                win->average_tpt = IL_INVALID_VALUE;
                 goto out;
 
         }
 
-        current_tpt = window->average_tpt;
+        current_tpt = win->average_tpt;
 
         high_low = il3945_get_adjacent_rate(rs_sta, index, rate_mask,
                                              sband->band);
@@ -736,7 +736,7 @@ static void il3945_rs_get_rate(void *il_r, struct ieee80211_sta *sta,
         scale_action = 0;
 
         /* Low success ratio , need to drop the rate */
-        if (window->success_ratio < IL_RATE_DECREASE_TH || !current_tpt) {
+        if (win->success_ratio < IL_RATE_DECREASE_TH || !current_tpt) {
                 D_RATE("decrease rate because of low success_ratio\n");
                 scale_action = -1;
         /* No throughput measured yet for adjacent rates,
@@ -744,7 +744,7 @@ static void il3945_rs_get_rate(void *il_r, struct ieee80211_sta *sta,
         } else if (low_tpt == IL_INVALID_VALUE &&
                    high_tpt == IL_INVALID_VALUE) {
 
-                if (high != IL_RATE_INVALID && window->success_ratio >= IL_RATE_INCREASE_TH)
+                if (high != IL_RATE_INVALID && win->success_ratio >= IL_RATE_INCREASE_TH)
                         scale_action = 1;
                 else if (low != IL_RATE_INVALID)
                         scale_action = 0;
@@ -768,7 +768,7 @@ static void il3945_rs_get_rate(void *il_r, struct ieee80211_sta *sta,
                         /* High rate has better throughput, Increase
                          * rate */
                         if (high_tpt > current_tpt &&
-                                window->success_ratio >= IL_RATE_INCREASE_TH)
+                                win->success_ratio >= IL_RATE_INCREASE_TH)
                                 scale_action = 1;
                         else {
                                 D_RATE(
@@ -780,7 +780,7 @@ static void il3945_rs_get_rate(void *il_r, struct ieee80211_sta *sta,
                                 D_RATE(
                                     "decrease rate because of low tpt\n");
                                 scale_action = -1;
-                        } else if (window->success_ratio >= IL_RATE_INCREASE_TH) {
+                        } else if (win->success_ratio >= IL_RATE_INCREASE_TH) {
                                 /* Lower rate has better
                                  * throughput,decrease rate */
                                 scale_action = 1;
@@ -791,7 +791,7 @@ static void il3945_rs_get_rate(void *il_r, struct ieee80211_sta *sta,
         /* Sanity check; asked for decrease, but success rate or throughput
          * has been good at old rate.  Don't change it. */
         if (scale_action == -1 && low != IL_RATE_INVALID &&
-            (window->success_ratio > IL_RATE_HIGH_TH ||
+            (win->success_ratio > IL_RATE_HIGH_TH ||
              current_tpt > 100 * rs_sta->expected_tpt[low]))
                 scale_action = 0;