From fa254a68076bf7ae21747fe2cdb15db306938d78 Mon Sep 17 00:00:00 2001 From: Tomas Winkler Date: Sun, 27 Jan 2008 20:41:38 -0800 Subject: 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 Signed-off-by: Zhu Yi Signed-off-by: John W. Linville Signed-off-by: David S. Miller --- drivers/net/wireless/iwlwifi/iwl-3945-rs.c | 206 +++++++++++++++-------------- 1 file changed, 104 insertions(+), 102 deletions(-) (limited to 'drivers/net') 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) -- cgit v1.2.2