summaryrefslogtreecommitdiff
path: root/drivers
diff options
context:
space:
mode:
Diffstat (limited to 'drivers')
-rw-r--r--drivers/net/wireless/iwlwifi/iwl-4965-rs.c609
1 files changed, 308 insertions, 301 deletions
diff --git a/drivers/net/wireless/iwlwifi/iwl-4965-rs.c b/drivers/net/wireless/iwlwifi/iwl-4965-rs.c
index 5081e28..d064622 100644
--- a/drivers/net/wireless/iwlwifi/iwl-4965-rs.c
+++ b/drivers/net/wireless/iwlwifi/iwl-4965-rs.c
@@ -103,7 +103,7 @@ struct iwl4965_scale_tbl_info {
*
* Pointer to this gets passed back and forth between driver and mac80211.
*/
-struct iwl4965_rate_scale_priv {
+struct iwl4965_lq_sta {
u8 active_tbl; /* index of active table, range 0-1 */
u8 enable_counter; /* indicates HT mode */
u8 stay_in_tbl; /* 1: disallow, 0: allow search for new mode */
@@ -148,16 +148,16 @@ static void rs_rate_scale_perform(struct iwl4965_priv *priv,
struct net_device *dev,
struct ieee80211_hdr *hdr,
struct sta_info *sta);
-static void rs_fill_link_cmd(struct iwl4965_rate_scale_priv *lq_data,
+static void rs_fill_link_cmd(struct iwl4965_lq_sta *lq_sta,
struct iwl4965_rate *tx_mcs,
struct iwl4965_link_quality_cmd *tbl);
#ifdef CONFIG_MAC80211_DEBUGFS
-static void rs_dbgfs_set_mcs(struct iwl4965_rate_scale_priv *rs_priv,
+static void rs_dbgfs_set_mcs(struct iwl4965_lq_sta *lq_sta,
struct iwl4965_rate *mcs, int index);
#else
-static void rs_dbgfs_set_mcs(struct iwl4965_rate_scale_priv *rs_priv,
+static void rs_dbgfs_set_mcs(struct iwl4965_lq_sta *lq_sta,
struct iwl4965_rate *mcs, int index)
{}
#endif
@@ -516,23 +516,24 @@ static inline u8 rs_use_green(struct iwl4965_priv *priv,
* basic available rates.
*
*/
-static void rs_get_supported_rates(struct iwl4965_rate_scale_priv *lq_data,
+static void rs_get_supported_rates(struct iwl4965_lq_sta *lq_sta,
struct ieee80211_hdr *hdr,
enum iwl4965_table_type rate_type,
u16 *data_rate)
{
if (is_legacy(rate_type))
- *data_rate = lq_data->active_rate;
+ *data_rate = lq_sta->active_rate;
else {
if (is_siso(rate_type))
- *data_rate = lq_data->active_siso_rate;
+ *data_rate = lq_sta->active_siso_rate;
else
- *data_rate = lq_data->active_mimo_rate;
+ *data_rate = lq_sta->active_mimo_rate;
}
if (hdr && is_multicast_ether_addr(hdr->addr1) &&
- lq_data->active_rate_basic)
- *data_rate = lq_data->active_rate_basic;
+ lq_sta->active_rate_basic) {
+ *data_rate = lq_sta->active_rate_basic;
+ }
}
static u16 rs_get_adjacent_rate(u8 index, u16 rate_mask, int rate_type)
@@ -590,7 +591,7 @@ static u16 rs_get_adjacent_rate(u8 index, u16 rate_mask, int rate_type)
return (high << 8) | low;
}
-static void rs_get_lower_rate(struct iwl4965_rate_scale_priv *lq_data,
+static void rs_get_lower_rate(struct iwl4965_lq_sta *lq_sta,
struct iwl4965_scale_tbl_info *tbl, u8 scale_index,
u8 ht_possible, struct iwl4965_rate *mcs_rate)
{
@@ -598,7 +599,7 @@ static void rs_get_lower_rate(struct iwl4965_rate_scale_priv *lq_data,
u16 rate_mask;
u16 high_low;
u8 switch_to_legacy = 0;
- u8 is_green = lq_data->is_green;
+ u8 is_green = lq_sta->is_green;
/* check if we need to switch from HT to legacy rates.
* assumption is that mandatory rates (1Mbps or 6Mbps)
@@ -606,7 +607,7 @@ static void rs_get_lower_rate(struct iwl4965_rate_scale_priv *lq_data,
if (!is_legacy(tbl->lq_type) && (!ht_possible || !scale_index)) {
switch_to_legacy = 1;
scale_index = rs_ht_to_legacy[scale_index];
- if (lq_data->phymode == MODE_IEEE80211A)
+ if (lq_sta->phymode == MODE_IEEE80211A)
tbl->lq_type = LQ_A;
else
tbl->lq_type = LQ_G;
@@ -619,16 +620,16 @@ static void rs_get_lower_rate(struct iwl4965_rate_scale_priv *lq_data,
tbl->is_SGI = 0;
}
- rs_get_supported_rates(lq_data, NULL, tbl->lq_type, &rate_mask);
+ rs_get_supported_rates(lq_sta, NULL, tbl->lq_type, &rate_mask);
/* Mask with station rate restriction */
if (is_legacy(tbl->lq_type)) {
/* supp_rates has no CCK bits in A mode */
- if (lq_data->phymode == (u8) MODE_IEEE80211A)
+ if (lq_sta->phymode == (u8) MODE_IEEE80211A)
rate_mask = (u16)(rate_mask &
- (lq_data->supp_rates << IWL_FIRST_OFDM_RATE));
+ (lq_sta->supp_rates << IWL_FIRST_OFDM_RATE));
else
- rate_mask = (u16)(rate_mask & lq_data->supp_rates);
+ rate_mask = (u16)(rate_mask & lq_sta->supp_rates);
}
/* If we switched from HT to legacy, check current rate */
@@ -649,15 +650,14 @@ static void rs_get_lower_rate(struct iwl4965_rate_scale_priv *lq_data,
/*
* mac80211 sends us Tx status
*/
-static void rs_tx_status(void *priv_rate,
- struct net_device *dev,
+static void rs_tx_status(void *priv_rate, struct net_device *dev,
struct sk_buff *skb,
struct ieee80211_tx_status *tx_resp)
{
int status;
u8 retries;
int rs_index, index = 0;
- struct iwl4965_rate_scale_priv *lq;
+ struct iwl4965_lq_sta *lq_sta;
struct iwl4965_link_quality_cmd *table;
struct sta_info *sta;
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
@@ -691,27 +691,29 @@ static void rs_tx_status(void *priv_rate,
return;
}
- lq = (struct iwl4965_rate_scale_priv *)sta->rate_ctrl_priv;
+ lq_sta = (struct iwl4965_lq_sta *)sta->rate_ctrl_priv;
if (!priv->lq_mngr.lq_ready)
return;
- if ((priv->iw_mode == IEEE80211_IF_TYPE_IBSS) && !lq->ibss_sta_added)
+ if ((priv->iw_mode == IEEE80211_IF_TYPE_IBSS) &&
+ !lq_sta->ibss_sta_added)
return;
- table = &lq->lq;
- active_index = lq->active_tbl;
+ table = &lq_sta->lq;
+ active_index = lq_sta->active_tbl;
/* Get mac80211 antenna info */
- lq->antenna = (lq->valid_antenna & local->hw.conf.antenna_sel_tx);
- if (!lq->antenna)
- lq->antenna = lq->valid_antenna;
+ lq_sta->antenna =
+ (lq_sta->valid_antenna & local->hw.conf.antenna_sel_tx);
+ if (!lq_sta->antenna)
+ lq_sta->antenna = lq_sta->valid_antenna;
/* Ignore mac80211 antenna info for now */
- lq->antenna = lq->valid_antenna;
+ lq_sta->antenna = lq_sta->valid_antenna;
- curr_tbl = &(lq->lq_info[active_index]);
- search_tbl = &(lq->lq_info[(1 - active_index)]);
+ curr_tbl = &(lq_sta->lq_info[active_index]);
+ search_tbl = &(lq_sta->lq_info[(1 - active_index)]);
window = (struct iwl4965_rate_scale_data *)
&(curr_tbl->win[0]);
search_win = (struct iwl4965_rate_scale_data *)
@@ -780,8 +782,8 @@ static void rs_tx_status(void *priv_rate,
/* If not searching for a new mode, increment failed counter
* ... this helps determine when to start searching again */
- if (lq->stay_in_tbl)
- lq->total_failed++;
+ if (lq_sta->stay_in_tbl)
+ lq_sta->total_failed++;
--retries;
index++;
@@ -833,11 +835,11 @@ static void rs_tx_status(void *priv_rate,
/* If not searching for new mode, increment success/failed counter
* ... these help determine when to start searching again */
- if (lq->stay_in_tbl) {
+ if (lq_sta->stay_in_tbl) {
if (status)
- lq->total_success++;
+ lq_sta->total_success++;
else
- lq->total_failed++;
+ lq_sta->total_failed++;
}
/* See if there's a better rate or modulation mode to try. */
@@ -879,28 +881,28 @@ static u8 rs_is_other_ant_connected(u8 valid_antenna,
* searching for a new mode.
*/
static void rs_set_stay_in_table(u8 is_legacy,
- struct iwl4965_rate_scale_priv *lq_data)
+ struct iwl4965_lq_sta *lq_sta)
{
IWL_DEBUG_HT("we are staying in the same table\n");
- lq_data->stay_in_tbl = 1; /* only place this gets set */
+ lq_sta->stay_in_tbl = 1; /* only place this gets set */
if (is_legacy) {
- lq_data->table_count_limit = IWL_LEGACY_TABLE_COUNT;
- lq_data->max_failure_limit = IWL_LEGACY_FAILURE_LIMIT;
- lq_data->max_success_limit = IWL_LEGACY_SUCCESS_LIMIT;
+ lq_sta->table_count_limit = IWL_LEGACY_TABLE_COUNT;
+ lq_sta->max_failure_limit = IWL_LEGACY_FAILURE_LIMIT;
+ lq_sta->max_success_limit = IWL_LEGACY_SUCCESS_LIMIT;
} else {
- lq_data->table_count_limit = IWL_NONE_LEGACY_TABLE_COUNT;
- lq_data->max_failure_limit = IWL_NONE_LEGACY_FAILURE_LIMIT;
- lq_data->max_success_limit = IWL_NONE_LEGACY_SUCCESS_LIMIT;
+ lq_sta->table_count_limit = IWL_NONE_LEGACY_TABLE_COUNT;
+ lq_sta->max_failure_limit = IWL_NONE_LEGACY_FAILURE_LIMIT;
+ lq_sta->max_success_limit = IWL_NONE_LEGACY_SUCCESS_LIMIT;
}
- lq_data->table_count = 0;
- lq_data->total_failed = 0;
- lq_data->total_success = 0;
+ lq_sta->table_count = 0;
+ lq_sta->total_failed = 0;
+ lq_sta->total_success = 0;
}
/*
* Find correct throughput table for given mode of modulation
*/
-static void rs_get_expected_tpt_table(struct iwl4965_rate_scale_priv *lq_data,
+static void rs_get_expected_tpt_table(struct iwl4965_lq_sta *lq_sta,
struct iwl4965_scale_tbl_info *tbl)
{
if (is_legacy(tbl->lq_type)) {
@@ -909,7 +911,7 @@ static void rs_get_expected_tpt_table(struct iwl4965_rate_scale_priv *lq_data,
else
tbl->expected_tpt = expected_tpt_A;
} else if (is_siso(tbl->lq_type)) {
- if (tbl->is_fat && !lq_data->is_dup)
+ if (tbl->is_fat && !lq_sta->is_dup)
if (tbl->is_SGI)
tbl->expected_tpt = expected_tpt_siso40MHzSGI;
else
@@ -920,7 +922,7 @@ static void rs_get_expected_tpt_table(struct iwl4965_rate_scale_priv *lq_data,
tbl->expected_tpt = expected_tpt_siso20MHz;
} else if (is_mimo(tbl->lq_type)) {
- if (tbl->is_fat && !lq_data->is_dup)
+ if (tbl->is_fat && !lq_sta->is_dup)
if (tbl->is_SGI)
tbl->expected_tpt = expected_tpt_mimo40MHzSGI;
else
@@ -947,13 +949,13 @@ static void rs_get_expected_tpt_table(struct iwl4965_rate_scale_priv *lq_data,
* bit rate will typically need to increase, but not if performance was bad.
*/
static s32 rs_get_best_rate(struct iwl4965_priv *priv,
- struct iwl4965_rate_scale_priv *lq_data,
+ struct iwl4965_lq_sta *lq_sta,
struct iwl4965_scale_tbl_info *tbl, /* "search" */
u16 rate_mask, s8 index, s8 rate)
{
/* "active" values */
struct iwl4965_scale_tbl_info *active_tbl =
- &(lq_data->lq_info[lq_data->active_tbl]);
+ &(lq_sta->lq_info[lq_sta->active_tbl]);
s32 active_sr = active_tbl->win[index].success_ratio;
s32 active_tpt = active_tbl->expected_tpt[index];
@@ -986,7 +988,7 @@ static s32 rs_get_best_rate(struct iwl4965_priv *priv,
* conditions) at candidate rate is above expected
* "active" throughput (under perfect conditions).
*/
- if ((((100 * tpt_tbl[rate]) > lq_data->last_tpt) &&
+ if ((((100 * tpt_tbl[rate]) > lq_sta->last_tpt) &&
((active_sr > IWL_RATE_DECREASE_TH) &&
(active_sr <= IWL_RATE_HIGH_TH) &&
(tpt_tbl[rate] <= active_tpt))) ||
@@ -1045,7 +1047,7 @@ static inline u8 rs_is_both_ant_supp(u8 valid_antenna)
* Set up search table for MIMO
*/
static int rs_switch_to_mimo(struct iwl4965_priv *priv,
- struct iwl4965_rate_scale_priv *lq_data,
+ struct iwl4965_lq_sta *lq_sta,
struct ieee80211_conf *conf,
struct sta_info *sta,
struct iwl4965_scale_tbl_info *tbl, int index)
@@ -1053,7 +1055,7 @@ static int rs_switch_to_mimo(struct iwl4965_priv *priv,
#ifdef CONFIG_IWL4965_HT
u16 rate_mask;
s32 rate;
- s8 is_green = lq_data->is_green;
+ s8 is_green = lq_sta->is_green;
if (!(conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE) ||
!sta->ht_info.ht_supported)
@@ -1061,17 +1063,17 @@ static int rs_switch_to_mimo(struct iwl4965_priv *priv,
IWL_DEBUG_HT("LQ: try to switch to MIMO\n");
tbl->lq_type = LQ_MIMO;
- rs_get_supported_rates(lq_data, NULL, tbl->lq_type,
+ rs_get_supported_rates(lq_sta, NULL, tbl->lq_type,
&rate_mask);
if (priv->current_ht_config.tx_mimo_ps_mode == IWL_MIMO_PS_STATIC)
return -1;
/* Need both Tx chains/antennas to support MIMO */
- if (!rs_is_both_ant_supp(lq_data->antenna))
+ if (!rs_is_both_ant_supp(lq_sta->antenna))
return -1;
- tbl->is_dup = lq_data->is_dup;
+ tbl->is_dup = lq_sta->is_dup;
tbl->action = 0;
if (priv->current_ht_config.supported_chan_width
== IWL_CHANNEL_WIDTH_40MHZ)
@@ -1089,9 +1091,9 @@ static int rs_switch_to_mimo(struct iwl4965_priv *priv,
else
tbl->is_SGI = 0;
- rs_get_expected_tpt_table(lq_data, tbl);
+ rs_get_expected_tpt_table(lq_sta, tbl);
- rate = rs_get_best_rate(priv, lq_data, tbl, rate_mask, index, index);
+ rate = rs_get_best_rate(priv, lq_sta, tbl, rate_mask, index, index);
IWL_DEBUG_HT("LQ: MIMO best rate %d mask %X\n", rate, rate_mask);
if ((rate == IWL_RATE_INVALID) || !((1 << rate) & rate_mask))
@@ -1110,14 +1112,14 @@ static int rs_switch_to_mimo(struct iwl4965_priv *priv,
* Set up search table for SISO
*/
static int rs_switch_to_siso(struct iwl4965_priv *priv,
- struct iwl4965_rate_scale_priv *lq_data,
+ struct iwl4965_lq_sta *lq_sta,
struct ieee80211_conf *conf,
struct sta_info *sta,
struct iwl4965_scale_tbl_info *tbl, int index)
{
#ifdef CONFIG_IWL4965_HT
u16 rate_mask;
- u8 is_green = lq_data->is_green;
+ u8 is_green = lq_sta->is_green;
s32 rate;
IWL_DEBUG_HT("LQ: try to switch to SISO\n");
@@ -1125,10 +1127,10 @@ static int rs_switch_to_siso(struct iwl4965_priv *priv,
!sta->ht_info.ht_supported)
return -1;
- tbl->is_dup = lq_data->is_dup;
+ tbl->is_dup = lq_sta->is_dup;
tbl->lq_type = LQ_SISO;
tbl->action = 0;
- rs_get_supported_rates(lq_data, NULL, tbl->lq_type,
+ rs_get_supported_rates(lq_sta, NULL, tbl->lq_type,
&rate_mask);
if (priv->current_ht_config.supported_chan_width
@@ -1150,8 +1152,8 @@ static int rs_switch_to_siso(struct iwl4965_priv *priv,
if (is_green)
tbl->is_SGI = 0;
- rs_get_expected_tpt_table(lq_data, tbl);
- rate = rs_get_best_rate(priv, lq_data, tbl, rate_mask, index, index);
+ rs_get_expected_tpt_table(lq_sta, tbl);
+ rate = rs_get_best_rate(priv, lq_sta, tbl, rate_mask, index, index);
IWL_DEBUG_HT("LQ: get best rate %d mask %X\n", rate, rate_mask);
if ((rate == IWL_RATE_INVALID) || !((1 << rate) & rate_mask)) {
@@ -1173,16 +1175,16 @@ static int rs_switch_to_siso(struct iwl4965_priv *priv,
* Try to switch to new modulation mode from legacy
*/
static int rs_move_legacy_other(struct iwl4965_priv *priv,
- struct iwl4965_rate_scale_priv *lq_data,
+ struct iwl4965_lq_sta *lq_sta,
struct ieee80211_conf *conf,
struct sta_info *sta,
int index)
{
int ret = 0;
struct iwl4965_scale_tbl_info *tbl =
- &(lq_data->lq_info[lq_data->active_tbl]);
+ &(lq_sta->lq_info[lq_sta->active_tbl]);
struct iwl4965_scale_tbl_info *search_tbl =
- &(lq_data->lq_info[(1 - lq_data->active_tbl)]);
+ &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
struct iwl4965_rate_scale_data *window = &(tbl->win[index]);
u32 sz = (sizeof(struct iwl4965_scale_tbl_info) -
(sizeof(struct iwl4965_rate_scale_data) * IWL_RATE_COUNT));
@@ -1194,14 +1196,14 @@ static int rs_move_legacy_other(struct iwl4965_priv *priv,
IWL_DEBUG_HT("LQ Legacy switch Antenna\n");
search_tbl->lq_type = LQ_NONE;
- lq_data->action_counter++;
+ lq_sta->action_counter++;
/* Don't change antenna if success has been great */
if (window->success_ratio >= IWL_RS_GOOD_RATIO)
break;
/* Don't change antenna if other one is not connected */
- if (!rs_is_other_ant_connected(lq_data->antenna,
+ if (!rs_is_other_ant_connected(lq_sta->antenna,
tbl->antenna_type))
break;
@@ -1210,8 +1212,8 @@ static int rs_move_legacy_other(struct iwl4965_priv *priv,
rs_toggle_antenna(&(search_tbl->current_rate),
search_tbl);
- rs_get_expected_tpt_table(lq_data, search_tbl);
- lq_data->search_better_tbl = 1;
+ rs_get_expected_tpt_table(lq_sta, search_tbl);
+ lq_sta->search_better_tbl = 1;
goto out;
case IWL_LEGACY_SWITCH_SISO:
@@ -1222,11 +1224,11 @@ static int rs_move_legacy_other(struct iwl4965_priv *priv,
search_tbl->lq_type = LQ_SISO;
search_tbl->is_SGI = 0;
search_tbl->is_fat = 0;
- ret = rs_switch_to_siso(priv, lq_data, conf, sta,
+ ret = rs_switch_to_siso(priv, lq_sta, conf, sta,
search_tbl, index);
if (!ret) {
- lq_data->search_better_tbl = 1;
- lq_data->action_counter = 0;
+ lq_sta->search_better_tbl = 1;
+ lq_sta->action_counter = 0;
goto out;
}
@@ -1240,11 +1242,11 @@ static int rs_move_legacy_other(struct iwl4965_priv *priv,
search_tbl->is_SGI = 0;
search_tbl->is_fat = 0;
search_tbl->antenna_type = ANT_BOTH;
- ret = rs_switch_to_mimo(priv, lq_data, conf, sta,
+ ret = rs_switch_to_mimo(priv, lq_sta, conf, sta,
search_tbl, index);
if (!ret) {
- lq_data->search_better_tbl = 1;
- lq_data->action_counter = 0;
+ lq_sta->search_better_tbl = 1;
+ lq_sta->action_counter = 0;
goto out;
}
break;
@@ -1271,31 +1273,31 @@ static int rs_move_legacy_other(struct iwl4965_priv *priv,
* Try to switch to new modulation mode from SISO
*/
static int rs_move_siso_to_other(struct iwl4965_priv *priv,
- struct iwl4965_rate_scale_priv *lq_data,
+ struct iwl4965_lq_sta *lq_sta,
struct ieee80211_conf *conf,
struct sta_info *sta,
int index)
{
int ret;
- u8 is_green = lq_data->is_green;
+ u8 is_green = lq_sta->is_green;
struct iwl4965_scale_tbl_info *tbl =
- &(lq_data->lq_info[lq_data->active_tbl]);
+ &(lq_sta->lq_info[lq_sta->active_tbl]);
struct iwl4965_scale_tbl_info *search_tbl =
- &(lq_data->lq_info[(1 - lq_data->active_tbl)]);
+ &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
struct iwl4965_rate_scale_data *window = &(tbl->win[index]);
u32 sz = (sizeof(struct iwl4965_scale_tbl_info) -
(sizeof(struct iwl4965_rate_scale_data) * IWL_RATE_COUNT));
u8 start_action = tbl->action;
for (;;) {
- lq_data->action_counter++;
+ lq_sta->action_counter++;
switch (tbl->action) {
case IWL_SISO_SWITCH_ANTENNA:
IWL_DEBUG_HT("LQ: SISO SWITCH ANTENNA SISO\n");
search_tbl->lq_type = LQ_NONE;
if (window->success_ratio >= IWL_RS_GOOD_RATIO)
break;
- if (!rs_is_other_ant_connected(lq_data->antenna,
+ if (!rs_is_other_ant_connected(lq_sta->antenna,
tbl->antenna_type))
break;
@@ -1303,7 +1305,7 @@ static int rs_move_siso_to_other(struct iwl4965_priv *priv,
search_tbl->action = IWL_SISO_SWITCH_MIMO;
rs_toggle_antenna(&(search_tbl->current_rate),
search_tbl);
- lq_data->search_better_tbl = 1;
+ lq_sta->search_better_tbl = 1;
goto out;
@@ -1314,10 +1316,10 @@ static int rs_move_siso_to_other(struct iwl4965_priv *priv,
search_tbl->is_SGI = 0;
search_tbl->is_fat = 0;
search_tbl->antenna_type = ANT_BOTH;
- ret = rs_switch_to_mimo(priv, lq_data, conf, sta,
+ ret = rs_switch_to_mimo(priv, lq_sta, conf, sta,
search_tbl, index);
if (!ret) {
- lq_data->search_better_tbl = 1;
+ lq_sta->search_better_tbl = 1;
goto out;
}
break;
@@ -1331,17 +1333,17 @@ static int rs_move_siso_to_other(struct iwl4965_priv *priv,
search_tbl->is_SGI = 1;
else
break;
- lq_data->search_better_tbl = 1;
+ lq_sta->search_better_tbl = 1;
if ((tbl->lq_type == LQ_SISO) &&
(tbl->is_SGI)) {
- s32 tpt = lq_data->last_tpt / 100;
+ s32 tpt = lq_sta->last_tpt / 100;
if (((!tbl->is_fat) &&
(tpt >= expected_tpt_siso20MHz[index])) ||
((tbl->is_fat) &&
(tpt >= expected_tpt_siso40MHz[index])))
- lq_data->search_better_tbl = 0;
+ lq_sta->search_better_tbl = 0;
}
- rs_get_expected_tpt_table(lq_data, search_tbl);
+ rs_get_expected_tpt_table(lq_sta, search_tbl);
rs_mcs_from_tbl(&search_tbl->current_rate,
search_tbl, index, is_green);
goto out;
@@ -1366,23 +1368,23 @@ static int rs_move_siso_to_other(struct iwl4965_priv *priv,
* Try to switch to new modulation mode from MIMO
*/
static int rs_move_mimo_to_other(struct iwl4965_priv *priv,
- struct iwl4965_rate_scale_priv *lq_data,
+ struct iwl4965_lq_sta *lq_sta,
struct ieee80211_conf *conf,
struct sta_info *sta,
int index)
{
int ret;
- s8 is_green = lq_data->is_green;
+ s8 is_green = lq_sta->is_green;
struct iwl4965_scale_tbl_info *tbl =
- &(lq_data->lq_info[lq_data->active_tbl]);
+ &(lq_sta->lq_info[lq_sta->active_tbl]);
struct iwl4965_scale_tbl_info *search_tbl =
- &(lq_data->lq_info[(1 - lq_data->active_tbl)]);
+ &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
u32 sz = (sizeof(struct iwl4965_scale_tbl_info) -
(sizeof(struct iwl4965_rate_scale_data) * IWL_RATE_COUNT));
u8 start_action = tbl->action;
for (;;) {
- lq_data->action_counter++;
+ lq_sta->action_counter++;
switch (tbl->action) {
case IWL_MIMO_SWITCH_ANTENNA_A:
case IWL_MIMO_SWITCH_ANTENNA_B:
@@ -1398,10 +1400,10 @@ static int rs_move_mimo_to_other(struct iwl4965_priv *priv,
else
search_tbl->antenna_type = ANT_AUX;
- ret = rs_switch_to_siso(priv, lq_data, conf, sta,
+ ret = rs_switch_to_siso(priv, lq_sta, conf, sta,
search_tbl, index);
if (!ret) {
- lq_data->search_better_tbl = 1;
+ lq_sta->search_better_tbl = 1;
goto out;
}
break;
@@ -1418,7 +1420,7 @@ static int rs_move_mimo_to_other(struct iwl4965_priv *priv,
search_tbl->is_SGI = 0;
else
search_tbl->is_SGI = 1;
- lq_data->search_better_tbl = 1;
+ lq_sta->search_better_tbl = 1;
/*
* If active table already uses the fastest possible
@@ -1428,14 +1430,14 @@ static int rs_move_mimo_to_other(struct iwl4965_priv *priv,
*/
if ((tbl->lq_type == LQ_MIMO) &&
(tbl->is_SGI)) {
- s32 tpt = lq_data->last_tpt / 100;
+ s32 tpt = lq_sta->last_tpt / 100;
if (((!tbl->is_fat) &&
(tpt >= expected_tpt_mimo20MHz[index])) ||
((tbl->is_fat) &&
(tpt >= expected_tpt_mimo40MHz[index])))
- lq_data->search_better_tbl = 0;
+ lq_sta->search_better_tbl = 0;
}
- rs_get_expected_tpt_table(lq_data, search_tbl);
+ rs_get_expected_tpt_table(lq_sta, search_tbl);
rs_mcs_from_tbl(&search_tbl->current_rate,
search_tbl, index, is_green);
goto out;
@@ -1465,25 +1467,25 @@ static int rs_move_mimo_to_other(struct iwl4965_priv *priv,
* 2) # times calling this function
* 3) elapsed time in this mode (not used, for now)
*/
-static void rs_stay_in_table(struct iwl4965_rate_scale_priv *lq_data)
+static void rs_stay_in_table(struct iwl4965_lq_sta *lq_sta)
{
struct iwl4965_scale_tbl_info *tbl;
int i;
int active_tbl;
int flush_interval_passed = 0;
- active_tbl = lq_data->active_tbl;
+ active_tbl = lq_sta->active_tbl;
- tbl = &(lq_data->lq_info[active_tbl]);
+ tbl = &(lq_sta->lq_info[active_tbl]);
/* If we've been disallowing search, see if we should now allow it */
- if (lq_data->stay_in_tbl) {
+ if (lq_sta->stay_in_tbl) {
/* Elapsed time using current modulation mode */
- if (lq_data->flush_timer)
+ if (lq_sta->flush_timer)
flush_interval_passed =
time_after(jiffies,
- (unsigned long)(lq_data->flush_timer +
+ (unsigned long)(lq_sta->flush_timer +
IWL_RATE_SCALE_FLUSH_INTVL));
/* For now, disable the elapsed time criterion */
@@ -1497,20 +1499,20 @@ static void rs_stay_in_table(struct iwl4965_rate_scale_priv *lq_data)
* allow a new search. Also (below) reset all bitmaps and
* stats in active history.
*/
- if ((lq_data->total_failed > lq_data->max_failure_limit) ||
- (lq_data->total_success > lq_data->max_success_limit) ||
- ((!lq_data->search_better_tbl) && (lq_data->flush_timer)
+ if ((lq_sta->total_failed > lq_sta->max_failure_limit) ||
+ (lq_sta->total_success > lq_sta->max_success_limit) ||
+ ((!lq_sta->search_better_tbl) && (lq_sta->flush_timer)
&& (flush_interval_passed))) {
IWL_DEBUG_HT("LQ: stay is expired %d %d %d\n:",
- lq_data->total_failed,
- lq_data->total_success,
+ lq_sta->total_failed,
+ lq_sta->total_success,
flush_interval_passed);
/* Allow search for new mode */
- lq_data->stay_in_tbl = 0; /* only place reset */
- lq_data->total_failed = 0;
- lq_data->total_success = 0;
- lq_data->flush_timer = 0;
+ lq_sta->stay_in_tbl = 0; /* only place reset */
+ lq_sta->total_failed = 0;
+ lq_sta->total_success = 0;
+ lq_sta->flush_timer = 0;
/*
* Else if we've used this modulation mode enough repetitions
@@ -1519,10 +1521,10 @@ static void rs_stay_in_table(struct iwl4965_rate_scale_priv *lq_data)
* active table.
*/
} else {
- lq_data->table_count++;
- if (lq_data->table_count >=
- lq_data->table_count_limit) {
- lq_data->table_count = 0;
+ lq_sta->table_count++;
+ if (lq_sta->table_count >=
+ lq_sta->table_count_limit) {
+ lq_sta->table_count = 0;
IWL_DEBUG_HT("LQ: stay in table clear win\n");
for (i = 0; i < IWL_RATE_COUNT; i++)
@@ -1534,7 +1536,7 @@ static void rs_stay_in_table(struct iwl4965_rate_scale_priv *lq_data)
/* If transitioning to allow "search", reset all history
* bitmaps and stats in active table (this will become the new
* "search" table). */
- if (!lq_data->stay_in_tbl) {
+ if (!lq_sta->stay_in_tbl) {
for (i = 0; i < IWL_RATE_COUNT; i++)
rs_rate_scale_clear_window(&(tbl->win[i]));
}
@@ -1564,7 +1566,7 @@ static void rs_rate_scale_perform(struct iwl4965_priv *priv,
s8 scale_action = 0;
u16 fc, rate_mask;
u8 update_lq = 0;
- struct iwl4965_rate_scale_priv *lq_data;
+ struct iwl4965_lq_sta *lq_sta;
struct iwl4965_scale_tbl_info *tbl, *tbl1;
u16 rate_scale_index_msk = 0;
struct iwl4965_rate mcs_rate;
@@ -1590,20 +1592,20 @@ static void rs_rate_scale_perform(struct iwl4965_priv *priv,
IWL_DEBUG_RATE("still rate scaling not ready\n");
return;
}
- lq_data = (struct iwl4965_rate_scale_priv *)sta->rate_ctrl_priv;
+ lq_sta = (struct iwl4965_lq_sta *)sta->rate_ctrl_priv;
/*
* Select rate-scale / modulation-mode table to work with in
* the rest of this function: "search" if searching for better
* modulation mode, or "active" if doing rate scaling within a mode.
*/
- if (!lq_data->search_better_tbl)
- active_tbl = lq_data->active_tbl;
+ if (!lq_sta->search_better_tbl)
+ active_tbl = lq_sta->active_tbl;
else
- active_tbl = 1 - lq_data->active_tbl;
+ active_tbl = 1 - lq_sta->active_tbl;
- tbl = &(lq_data->lq_info[active_tbl]);
- is_green = lq_data->is_green;
+ tbl = &(lq_sta->lq_info[active_tbl]);
+ is_green = lq_sta->is_green;
/* current tx rate */
index = sta->last_txrate;
@@ -1612,20 +1614,20 @@ static void rs_rate_scale_perform(struct iwl4965_priv *priv,
tbl->lq_type);
/* rates available for this association, and for modulation mode */
- rs_get_supported_rates(lq_data, hdr, tbl->lq_type,
+ rs_get_supported_rates(lq_sta, hdr, tbl->lq_type,
&rate_mask);
IWL_DEBUG_RATE("mask 0x%04X \n", rate_mask);
/* mask with station rate restriction */
if (is_legacy(tbl->lq_type)) {
- if (lq_data->phymode == (u8) MODE_IEEE80211A)
+ if (lq_sta->phymode == (u8) MODE_IEEE80211A)
/* supp_rates has no CCK bits in A mode */
rate_scale_index_msk = (u16) (rate_mask &
- (lq_data->supp_rates << IWL_FIRST_OFDM_RATE));
+ (lq_sta->supp_rates << IWL_FIRST_OFDM_RATE));
else
rate_scale_index_msk = (u16) (rate_mask &
- lq_data->supp_rates);
+ lq_sta->supp_rates);
} else
rate_scale_index_msk = rate_mask;
@@ -1653,7 +1655,7 @@ static void rs_rate_scale_perform(struct iwl4965_priv *priv,
/* Get expected throughput table and history window for current rate */
if (!tbl->expected_tpt)
- rs_get_expected_tpt_table(lq_data, tbl);
+ rs_get_expected_tpt_table(lq_sta, tbl);
window = &(tbl->win[index]);
@@ -1677,13 +1679,13 @@ static void rs_rate_scale_perform(struct iwl4965_priv *priv,
/* Should we stay with this modulation mode,
* or search for a new one? */
- rs_stay_in_table(lq_data);
+ rs_stay_in_table(lq_sta);
/* Set up new rate table in uCode, if needed */
if (update_lq) {
rs_mcs_from_tbl(&mcs_rate, tbl, index, is_green);
- rs_fill_link_cmd(lq_data, &mcs_rate, &lq_data->lq);
- rs_send_lq_cmd(priv, &lq_data->lq, CMD_ASYNC);
+ rs_fill_link_cmd(lq_sta, &mcs_rate, &lq_sta->lq);
+ rs_send_lq_cmd(priv, &lq_sta->lq, CMD_ASYNC);
}
goto out;
@@ -1694,25 +1696,25 @@ static void rs_rate_scale_perform(struct iwl4965_priv *priv,
tbl->expected_tpt[index] + 64) / 128);
/* If we are searching for better modulation mode, check success. */
- if (lq_data->search_better_tbl) {
+ if (lq_sta->search_better_tbl) {
int success_limit = IWL_RATE_SCALE_SWITCH;
/* If good success, continue using the "search" mode;
* no need to send new link quality command, since we're
* continuing to use the setup that we've been trying. */
if ((window->success_ratio > success_limit) ||
- (window->average_tpt > lq_data->last_tpt)) {
+ (window->average_tpt > lq_sta->last_tpt)) {
if (!is_legacy(tbl->lq_type)) {
IWL_DEBUG_HT("LQ: we are switching to HT"
" rate suc %d current tpt %d"
" old tpt %d\n",
window->success_ratio,
window->average_tpt,
- lq_data->last_tpt);
- lq_data->enable_counter = 1;
+ lq_sta->last_tpt);
+ lq_sta->enable_counter = 1;
}
/* Swap tables; "search" becomes "active" */
- lq_data->active_tbl = active_tbl;
+ lq_sta->active_tbl = active_tbl;
current_tpt = window->average_tpt;
/* Else poor success; go back to mode in "active" table */
@@ -1721,13 +1723,13 @@ static void rs_rate_scale_perform(struct iwl4965_priv *priv,
tbl->lq_type = LQ_NONE;
/* Revert to "active" table */
- active_tbl = lq_data->active_tbl;
- tbl = &(lq_data->lq_info[active_tbl]);
+ active_tbl = lq_sta->active_tbl;
+ tbl = &(lq_sta->lq_info[active_tbl]);
/* Revert to "active" rate and throughput info */
index = iwl4965_rate_index_from_plcp(
tbl->current_rate.rate_n_flags);
- current_tpt = lq_data->last_tpt;
+ current_tpt = lq_sta->last_tpt;
/* Need to set up a new rate table in uCode */
update_lq = 1;
@@ -1736,7 +1738,7 @@ static void rs_rate_scale_perform(struct iwl4965_priv *priv,
/* Either way, we've made a decision; modulation mode
* search is done, allow rate adjustment next time. */
- lq_data->search_better_tbl = 0;
+ lq_sta->search_better_tbl = 0;
done_search = 1; /* Don't switch modes below! */
goto lq_update;
}
@@ -1847,12 +1849,12 @@ static void rs_rate_scale_perform(struct iwl4965_priv *priv,
/* Replace uCode's rate table for the destination station. */
if (update_lq) {
rs_mcs_from_tbl(&mcs_rate, tbl, index, is_green);
- rs_fill_link_cmd(lq_data, &mcs_rate, &lq_data->lq);
- rs_send_lq_cmd(priv, &lq_data->lq, CMD_ASYNC);
+ rs_fill_link_cmd(lq_sta, &mcs_rate, &lq_sta->lq);
+ rs_send_lq_cmd(priv, &lq_sta->lq, CMD_ASYNC);
}
/* Should we stay with this modulation mode, or search for a new one? */
- rs_stay_in_table(lq_data);
+ rs_stay_in_table(lq_sta);
/*
* Search for new modulation mode if we're:
@@ -1860,23 +1862,23 @@ static void rs_rate_scale_perform(struct iwl4965_priv *priv,
* 2) Not just finishing up a search
* 3) Allowing a new search
*/
- if (!update_lq && !done_search && !lq_data->stay_in_tbl) {
+ if (!update_lq && !done_search && !lq_sta->stay_in_tbl) {
/* Save current throughput to compare with "search" throughput*/
- lq_data->last_tpt = current_tpt;
+ lq_sta->last_tpt = current_tpt;
/* Select a new "search" modulation mode to try.
* If one is found, set up the new "search" table. */
if (is_legacy(tbl->lq_type))
- rs_move_legacy_other(priv, lq_data, conf, sta, index);
+ rs_move_legacy_other(priv, lq_sta, conf, sta, index);
else if (is_siso(tbl->lq_type))
- rs_move_siso_to_other(priv, lq_data, conf, sta, index);
+ rs_move_siso_to_other(priv, lq_sta, conf, sta, index);
else
- rs_move_mimo_to_other(priv, lq_data, conf, sta, index);
+ rs_move_mimo_to_other(priv, lq_sta, conf, sta, index);
/* If new "search" mode was selected, set up in uCode table */
- if (lq_data->search_better_tbl) {
+ if (lq_sta->search_better_tbl) {
/* Access the "search" table, clear its history. */
- tbl = &(lq_data->lq_info[(1 - lq_data->active_tbl)]);
+ tbl = &(lq_sta->lq_info[(1 - lq_sta->active_tbl)]);
for (i = 0; i < IWL_RATE_COUNT; i++)
rs_rate_scale_clear_window(&(tbl->win[i]));
@@ -1886,9 +1888,9 @@ static void rs_rate_scale_perform(struct iwl4965_priv *priv,
IWL_DEBUG_HT("Switch current mcs: %X index: %d\n",
tbl->current_rate.rate_n_flags, index);
- rs_fill_link_cmd(lq_data, &tbl->current_rate,
- &lq_data->lq);
- rs_send_lq_cmd(priv, &lq_data->lq, CMD_ASYNC);
+ rs_fill_link_cmd(lq_sta, &tbl->current_rate,
+ &lq_sta->lq);
+ rs_send_lq_cmd(priv, &lq_sta->lq, CMD_ASYNC);
}
/* If the "active" (non-search) mode was legacy,
@@ -1896,33 +1898,33 @@ static void rs_rate_scale_perform(struct iwl4965_priv *priv,
* but we haven't been able to try HT modes (not available),
* stay with best antenna legacy modulation for a while
* before next round of mode comparisons. */
- tbl1 = &(lq_data->lq_info[lq_data->active_tbl]);
+ tbl1 = &(lq_sta->lq_info[lq_sta->active_tbl]);
if (is_legacy(tbl1->lq_type) &&
#ifdef CONFIG_IWL4965_HT
(!(conf->flags & IEEE80211_CONF_SUPPORT_HT_MODE)) &&
#endif
- (lq_data->action_counter >= 1)) {
- lq_data->action_counter = 0;
+ (lq_sta->action_counter >= 1)) {
+ lq_sta->action_counter = 0;
IWL_DEBUG_HT("LQ: STAY in legacy table\n");
- rs_set_stay_in_table(1, lq_data);
+ rs_set_stay_in_table(1, lq_sta);
}
/* If we're in an HT mode, and all 3 mode switch actions
* have been tried and compared, stay in this best modulation
* mode for a while before next round of mode comparisons. */
- if (lq_data->enable_counter &&
- (lq_data->action_counter >= IWL_ACTION_LIMIT)) {
+ if (lq_sta->enable_counter &&
+ (lq_sta->action_counter >= IWL_ACTION_LIMIT)) {
#ifdef CONFIG_IWL4965_HT_AGG
/* If appropriate, set up aggregation! */
- if ((lq_data->last_tpt > TID_AGG_TPT_THREHOLD) &&
+ if ((lq_sta->last_tpt > TID_AGG_TPT_THREHOLD) &&
(priv->lq_mngr.agg_ctrl.auto_agg)) {
priv->lq_mngr.agg_ctrl.tid_retry =
TID_ALL_SPECIFIED;
schedule_work(&priv->agg_work);
}
#endif /*CONFIG_IWL4965_HT_AGG */
- lq_data->action_counter = 0;
- rs_set_stay_in_table(0, lq_data);
+ lq_sta->action_counter = 0;
+ rs_set_stay_in_table(0, lq_sta);
}
/*
@@ -1933,8 +1935,8 @@ static void rs_rate_scale_perform(struct iwl4965_priv *priv,
* 3) flush timer is empty
*/
} else {
- if ((!update_lq) && (!done_search) && (!lq_data->flush_timer))
- lq_data->flush_timer = jiffies;
+ if ((!update_lq) && (!done_search) && (!lq_sta->flush_timer))
+ lq_sta->flush_timer = jiffies;
}
out:
@@ -1945,7 +1947,7 @@ out:
/* sta->txrate is an index to A mode rates which start
* at IWL_FIRST_OFDM_RATE
*/
- if (lq_data->phymode == (u8) MODE_IEEE80211A)
+ if (lq_sta->phymode == (u8) MODE_IEEE80211A)
sta->txrate = i - IWL_FIRST_OFDM_RATE;
else
sta->txrate = i;
@@ -1959,7 +1961,7 @@ static void rs_initialize_lq(struct iwl4965_priv *priv,
struct sta_info *sta)
{
int i;
- struct iwl4965_rate_scale_priv *lq;
+ struct iwl4965_lq_sta *lq_sta;
struct iwl4965_scale_tbl_info *tbl;
u8 active_tbl = 0;
int rate_idx;
@@ -1969,19 +1971,19 @@ static void rs_initialize_lq(struct iwl4965_priv *priv,
if (!sta || !sta->rate_ctrl_priv)
goto out;
- lq = (struct iwl4965_rate_scale_priv *)sta->rate_ctrl_priv;
+ lq_sta = (struct iwl4965_lq_sta *)sta->rate_ctrl_priv;
i = sta->last_txrate;
- if ((lq->lq.sta_id == 0xff) &&
+ if ((lq_sta->lq.sta_id == 0xff) &&
(priv->iw_mode == IEEE80211_IF_TYPE_IBSS))
goto out;
- if (!lq->search_better_tbl)
- active_tbl = lq->active_tbl;
+ if (!lq_sta->search_better_tbl)
+ active_tbl = lq_sta->active_tbl;
else
- active_tbl = 1 - lq->active_tbl;
+ active_tbl = 1 - lq_sta->active_tbl;
- tbl = &(lq->lq_info[active_tbl]);
+ tbl = &(lq_sta->lq_info[active_tbl]);
if ((i < 0) || (i >= IWL_RATE_COUNT))
i = 0;
@@ -2000,9 +2002,9 @@ static void rs_initialize_lq(struct iwl4965_priv *priv,
rs_mcs_from_tbl(&mcs_rate, tbl, rate_idx, use_green);
tbl->current_rate.rate_n_flags = mcs_rate.rate_n_flags;
- rs_get_expected_tpt_table(lq, tbl);
- rs_fill_link_cmd(lq, &mcs_rate, &lq->lq);
- rs_send_lq_cmd(priv, &lq->lq, CMD_ASYNC);
+ rs_get_expected_tpt_table(lq_sta, tbl);
+ rs_fill_link_cmd(lq_sta, &mcs_rate, &lq_sta->lq);
+ rs_send_lq_cmd(priv, &lq_sta->lq, CMD_ASYNC);
out:
return;
}
@@ -2019,7 +2021,7 @@ static void rs_get_rate(void *priv_rate, struct net_device *dev,
struct sta_info *sta;
u16 fc;
struct iwl4965_priv *priv = (struct iwl4965_priv *)priv_rate;
- struct iwl4965_rate_scale_priv *lq;
+ struct iwl4965_lq_sta *lq_sta;
IWL_DEBUG_RATE_LIMIT("rate scale calculate new rate for skb\n");
@@ -2036,10 +2038,11 @@ static void rs_get_rate(void *priv_rate, struct net_device *dev,
return;
}
- lq = (struct iwl4965_rate_scale_priv *)sta->rate_ctrl_priv;
+ lq_sta = (struct iwl4965_lq_sta *)sta->rate_ctrl_priv;
i = sta->last_txrate;
- if ((priv->iw_mode == IEEE80211_IF_TYPE_IBSS) && !lq->ibss_sta_added) {
+ if ((priv->iw_mode == IEEE80211_IF_TYPE_IBSS) &&
+ !lq_sta->ibss_sta_added) {
u8 sta_id = iwl4965_hw_find_station(priv, hdr->addr1);
DECLARE_MAC_BUF(mac);
@@ -2050,12 +2053,12 @@ static void rs_get_rate(void *priv_rate, struct net_device *dev,
0, CMD_ASYNC, NULL);
}
if ((sta_id != IWL_INVALID_STATION)) {
- lq->lq.sta_id = sta_id;
- lq->lq.rs_table[0].rate_n_flags = 0;
- lq->ibss_sta_added = 1;
+ lq_sta->lq.sta_id = sta_id;
+ lq_sta->lq.rs_table[0].rate_n_flags = 0;
+ lq_sta->ibss_sta_added = 1;
rs_initialize_lq(priv, conf, sta);
}
- if (!lq->ibss_sta_added)
+ if (!lq_sta->ibss_sta_added)
goto done;
}
@@ -2071,23 +2074,23 @@ static void rs_get_rate(void *priv_rate, struct net_device *dev,
static void *rs_alloc_sta(void *priv, gfp_t gfp)
{
- struct iwl4965_rate_scale_priv *crl;
+ struct iwl4965_lq_sta *lq_sta;
int i, j;
IWL_DEBUG_RATE("create station rate scale window\n");
- crl = kzalloc(sizeof(struct iwl4965_rate_scale_priv), gfp);
+ lq_sta = kzalloc(sizeof(struct iwl4965_lq_sta), gfp);
- if (crl == NULL)
+ if (lq_sta == NULL)
return NULL;
- crl->lq.sta_id = 0xff;
+ lq_sta->lq.sta_id = 0xff;
for (j = 0; j < LQ_SIZE; j++)
for (i = 0; i < IWL_RATE_COUNT; i++)
- rs_rate_scale_clear_window(&(crl->lq_info[j].win[i]));
+ rs_rate_scale_clear_window(&(lq_sta->lq_info[j].win[i]));
- return crl;
+ return lq_sta;
}
static void rs_rate_init(void *priv_rate, void *priv_sta,
@@ -2098,14 +2101,14 @@ static void rs_rate_init(void *priv_rate, void *priv_sta,
struct ieee80211_conf *conf = &local->hw.conf;
struct ieee80211_hw_mode *mode = local->oper_hw_mode;
struct iwl4965_priv *priv = (struct iwl4965_priv *)priv_rate;
- struct iwl4965_rate_scale_priv *crl = priv_sta;
+ struct iwl4965_lq_sta *lq_sta = priv_sta;
- crl->flush_timer = 0;
- crl->supp_rates = sta->supp_rates;
+ lq_sta->flush_timer = 0;
+ lq_sta->supp_rates = sta->supp_rates;
sta->txrate = 3;
for (j = 0; j < LQ_SIZE; j++)
for (i = 0; i < IWL_RATE_COUNT; i++)
- rs_rate_scale_clear_window(&(crl->lq_info[j].win[i]));
+ rs_rate_scale_clear_window(&(lq_sta->lq_info[j].win[i]));
IWL_DEBUG_RATE("rate scale global init\n");
/* TODO: what is a good starting rate for STA? About middle? Maybe not
@@ -2113,7 +2116,7 @@ static void rs_rate_init(void *priv_rate, void *priv_sta,
* previous packets? Need to have IEEE 802.1X auth succeed immediately
* after assoc.. */
- crl->ibss_sta_added = 0;
+ lq_sta->ibss_sta_added = 0;
if (priv->iw_mode == IEEE80211_IF_TYPE_AP) {
u8 sta_id = iwl4965_hw_find_station(priv, sta->addr);
DECLARE_MAC_BUF(mac);
@@ -2129,8 +2132,8 @@ static void rs_rate_init(void *priv_rate, void *priv_sta,
0, CMD_ASYNC, NULL);
}
if ((sta_id != IWL_INVALID_STATION)) {
- crl->lq.sta_id = sta_id;
- crl->lq.rs_table[0].rate_n_flags = 0;
+ lq_sta->lq.sta_id = sta_id;
+ lq_sta->lq.rs_table[0].rate_n_flags = 0;
}
/* FIXME: this is w/a remove it later */
priv->assoc_station_added = 1;
@@ -2147,36 +2150,39 @@ static void rs_rate_init(void *priv_rate, void *priv_sta,
if (local->hw.conf.phymode == MODE_IEEE80211A)
sta->last_txrate += IWL_FIRST_OFDM_RATE;
- crl->is_dup = 0;
- crl->valid_antenna = priv->valid_antenna;
- crl->antenna = priv->antenna;
- crl->is_green = rs_use_green(priv, conf);
- crl->active_rate = priv->active_rate;
- crl->active_rate &= ~(0x1000);
- crl->active_rate_basic = priv->active_rate_basic;
- crl->phymode = priv->phymode;
+ lq_sta->is_dup = 0;
+ lq_sta->valid_antenna = priv->valid_antenna;
+ lq_sta->antenna = priv->antenna;
+ lq_sta->is_green = rs_use_green(priv, conf);
+ lq_sta->active_rate = priv->active_rate;
+ lq_sta->active_rate &= ~(0x1000);
+ lq_sta->active_rate_basic = priv->active_rate_basic;
+ lq_sta->phymode = priv->phymode;
#ifdef CONFIG_IWL4965_HT
/*
* active_siso_rate mask includes 9 MBits (bit 5), and CCK (bits 0-3),
* supp_rates[] does not; shift to convert format, force 9 MBits off.
*/
- crl->active_siso_rate = (priv->current_ht_config.supp_mcs_set[0] << 1);
- crl->active_siso_rate |=
+ lq_sta->active_siso_rate = (priv->current_ht_config.supp_mcs_set[0] << 1);
+ lq_sta->active_siso_rate |=
(priv->current_ht_config.supp_mcs_set[0] & 0x1);
- crl->active_siso_rate &= ~((u16)0x2);
- crl->active_siso_rate = crl->active_siso_rate << IWL_FIRST_OFDM_RATE;
+ lq_sta->active_siso_rate &= ~((u16)0x2);
+ lq_sta->active_siso_rate =
+ lq_sta->active_siso_rate << IWL_FIRST_OFDM_RATE;
/* Same here */
- crl->active_mimo_rate = (priv->current_ht_config.supp_mcs_set[1] << 1);
- crl->active_mimo_rate |=
+ lq_sta->active_mimo_rate = (priv->current_ht_config.supp_mcs_set[1] << 1);
+ lq_sta->active_mimo_rate |=
(priv->current_ht_config.supp_mcs_set[1] & 0x1);
- crl->active_mimo_rate &= ~((u16)0x2);
- crl->active_mimo_rate = crl->active_mimo_rate << IWL_FIRST_OFDM_RATE;
- IWL_DEBUG_HT("MIMO RATE 0x%X SISO MASK 0x%X\n", crl->active_siso_rate,
- crl->active_mimo_rate);
+ lq_sta->active_mimo_rate &= ~((u16)0x2);
+ lq_sta->active_mimo_rate =
+ lq_sta->active_mimo_rate << IWL_FIRST_OFDM_RATE;
+ IWL_DEBUG_HT("SISO RATE 0x%X MIMO RATE 0x%X\n",
+ lq_sta->active_siso_rate,
+ lq_sta->active_mimo_rate);
#endif /*CONFIG_IWL4965_HT*/
#ifdef CONFIG_MAC80211_DEBUGFS
- crl->drv = priv;
+ lq_sta->drv = priv;
#endif
if (priv->assoc_station_added)
@@ -2185,7 +2191,7 @@ static void rs_rate_init(void *priv_rate, void *priv_sta,
rs_initialize_lq(priv, conf, sta);
}
-static void rs_fill_link_cmd(struct iwl4965_rate_scale_priv *lq_data,
+static void rs_fill_link_cmd(struct iwl4965_lq_sta *lq_sta,
struct iwl4965_rate *tx_mcs,
struct iwl4965_link_quality_cmd *lq_cmd)
{
@@ -2198,10 +2204,10 @@ static void rs_fill_link_cmd(struct iwl4965_rate_scale_priv *lq_data,
struct iwl4965_scale_tbl_info tbl_type = { 0 };
/* Override starting rate (index 0) if needed for debug purposes */
- rs_dbgfs_set_mcs(lq_data, tx_mcs, index);
+ rs_dbgfs_set_mcs(lq_sta, tx_mcs, index);
/* Interpret rate_n_flags */
- rs_get_tbl_info_from_mcs(tx_mcs, lq_data->phymode,
+ rs_get_tbl_info_from_mcs(tx_mcs, lq_sta->phymode,
&tbl_type, &rate_idx);
/* How many times should we repeat the initial rate? */
@@ -2246,7 +2252,7 @@ static void rs_fill_link_cmd(struct iwl4965_rate_scale_priv *lq_data,
}
/* Override next rate if needed for debug purposes */
- rs_dbgfs_set_mcs(lq_data, &new_rate, index);
+ rs_dbgfs_set_mcs(lq_sta, &new_rate, index);
/* Fill next table entry */
lq_cmd->rs_table[index].rate_n_flags =
@@ -2255,7 +2261,7 @@ static void rs_fill_link_cmd(struct iwl4965_rate_scale_priv *lq_data,
index++;
}
- rs_get_tbl_info_from_mcs(&new_rate, lq_data->phymode, &tbl_type,
+ rs_get_tbl_info_from_mcs(&new_rate, lq_sta->phymode, &tbl_type,
&rate_idx);
/* Indicate to uCode which entries might be MIMO.
@@ -2265,7 +2271,7 @@ static void rs_fill_link_cmd(struct iwl4965_rate_scale_priv *lq_data,
lq_cmd->general_params.mimo_delimiter = index;
/* Get next rate */
- rs_get_lower_rate(lq_data, &tbl_type, rate_idx,
+ rs_get_lower_rate(lq_sta, &tbl_type, rate_idx,
use_ht_possible, &new_rate);
/* How many times should we repeat the next rate? */
@@ -2285,7 +2291,7 @@ static void rs_fill_link_cmd(struct iwl4965_rate_scale_priv *lq_data,
use_ht_possible = 0;
/* Override next rate if needed for debug purposes */
- rs_dbgfs_set_mcs(lq_data, &new_rate, index);
+ rs_dbgfs_set_mcs(lq_sta, &new_rate, index);
/* Fill next table entry */
lq_cmd->rs_table[index].rate_n_flags =
@@ -2329,10 +2335,10 @@ static void rs_clear(void *priv_rate)
static void rs_free_sta(void *priv, void *priv_sta)
{
- struct iwl4965_rate_scale_priv *rs_priv = priv_sta;
+ struct iwl4965_lq_sta *lq_sta = priv_sta;
IWL_DEBUG_RATE("enter\n");
- kfree(rs_priv);
+ kfree(lq_sta);
IWL_DEBUG_RATE("leave\n");
}
@@ -2343,19 +2349,19 @@ static int open_file_generic(struct inode *inode, struct file *file)
file->private_data = inode->i_private;
return 0;
}
-static void rs_dbgfs_set_mcs(struct iwl4965_rate_scale_priv *rs_priv,
+static void rs_dbgfs_set_mcs(struct iwl4965_lq_sta *lq_sta,
struct iwl4965_rate *mcs, int index)
{
u32 base_rate;
- if (rs_priv->phymode == (u8) MODE_IEEE80211A)
+ if (lq_sta->phymode == (u8) MODE_IEEE80211A)
base_rate = 0x800D;
else
base_rate = 0x820A;
- if (rs_priv->dbg_fixed.rate_n_flags) {
+ if (lq_sta->dbg_fixed.rate_n_flags) {
if (index < 12)
- mcs->rate_n_flags = rs_priv->dbg_fixed.rate_n_flags;
+ mcs->rate_n_flags = lq_sta->dbg_fixed.rate_n_flags;
else
mcs->rate_n_flags = base_rate;
IWL_DEBUG_RATE("Fixed rate ON\n");
@@ -2368,7 +2374,7 @@ static void rs_dbgfs_set_mcs(struct iwl4965_rate_scale_priv *rs_priv,
static ssize_t rs_sta_dbgfs_scale_table_write(struct file *file,
const char __user *user_buf, size_t count, loff_t *ppos)
{
- struct iwl4965_rate_scale_priv *rs_priv = file->private_data;
+ struct iwl4965_lq_sta *lq_sta = file->private_data;
char buf[64];
int buf_size;
u32 parsed_rate;
@@ -2379,20 +2385,20 @@ static ssize_t rs_sta_dbgfs_scale_table_write(struct file *file,
return -EFAULT;
if (sscanf(buf, "%x", &parsed_rate) == 1)
- rs_priv->dbg_fixed.rate_n_flags = parsed_rate;
+ lq_sta->dbg_fixed.rate_n_flags = parsed_rate;
else
- rs_priv->dbg_fixed.rate_n_flags = 0;
+ lq_sta->dbg_fixed.rate_n_flags = 0;
- rs_priv->active_rate = 0x0FFF; /* 1 - 54 MBits, includes CCK */
- rs_priv->active_siso_rate = 0x1FD0; /* 6 - 60 MBits, no 9, no CCK */
- rs_priv->active_mimo_rate = 0x1FD0; /* 6 - 60 MBits, no 9, no CCK */
+ lq_sta->active_rate = 0x0FFF; /* 1 - 54 MBits, includes CCK */
+ lq_sta->active_siso_rate = 0x1FD0; /* 6 - 60 MBits, no 9, no CCK */
+ lq_sta->active_mimo_rate = 0x1FD0; /* 6 - 60 MBits, no 9, no CCK */
IWL_DEBUG_RATE("sta_id %d rate 0x%X\n",
- rs_priv->lq.sta_id, rs_priv->dbg_fixed.rate_n_flags);
+ lq_sta->lq.sta_id, lq_sta->dbg_fixed.rate_n_flags);
- if (rs_priv->dbg_fixed.rate_n_flags) {
- rs_fill_link_cmd(rs_priv, &rs_priv->dbg_fixed, &rs_priv->lq);
- rs_send_lq_cmd(rs_priv->drv, &rs_priv->lq, CMD_ASYNC);
+ if (lq_sta->dbg_fixed.rate_n_flags) {
+ rs_fill_link_cmd(lq_sta, &lq_sta->dbg_fixed, &lq_sta->lq);
+ rs_send_lq_cmd(lq_sta->drv, &lq_sta->lq, CMD_ASYNC);
}
return count;
@@ -2405,38 +2411,38 @@ static ssize_t rs_sta_dbgfs_scale_table_read(struct file *file,
int desc = 0;
int i = 0;
- struct iwl4965_rate_scale_priv *rs_priv = file->private_data;
+ struct iwl4965_lq_sta *lq_sta = file->private_data;
- desc += sprintf(buff+desc, "sta_id %d\n", rs_priv->lq.sta_id);
+ desc += sprintf(buff+desc, "sta_id %d\n", lq_sta->lq.sta_id);
desc += sprintf(buff+desc, "failed=%d success=%d rate=0%X\n",
- rs_priv->total_failed, rs_priv->total_success,
- rs_priv->active_rate);
+ lq_sta->total_failed, lq_sta->total_success,
+ lq_sta->active_rate);
desc += sprintf(buff+desc, "fixed rate 0x%X\n",
- rs_priv->dbg_fixed.rate_n_flags);
+ lq_sta->dbg_fixed.rate_n_flags);
desc += sprintf(buff+desc, "general:"
"flags=0x%X mimo-d=%d s-ant0x%x d-ant=0x%x\n",
- rs_priv->lq.general_params.flags,
- rs_priv->lq.general_params.mimo_delimiter,
- rs_priv->lq.general_params.single_stream_ant_msk,
- rs_priv->lq.general_params.dual_stream_ant_msk);
+ lq_sta->lq.general_params.flags,
+ lq_sta->lq.general_params.mimo_delimiter,
+ lq_sta->lq.general_params.single_stream_ant_msk,
+ lq_sta->lq.general_params.dual_stream_ant_msk);
desc += sprintf(buff+desc, "agg:"
"time_limit=%d dist_start_th=%d frame_cnt_limit=%d\n",
- le16_to_cpu(rs_priv->lq.agg_params.agg_time_limit),
- rs_priv->lq.agg_params.agg_dis_start_th,
- rs_priv->lq.agg_params.agg_frame_cnt_limit);
+ le16_to_cpu(lq_sta->lq.agg_params.agg_time_limit),
+ lq_sta->lq.agg_params.agg_dis_start_th,
+ lq_sta->lq.agg_params.agg_frame_cnt_limit);
desc += sprintf(buff+desc,
"Start idx [0]=0x%x [1]=0x%x [2]=0x%x [3]=0x%x\n",
- rs_priv->lq.general_params.start_rate_index[0],
- rs_priv->lq.general_params.start_rate_index[1],
- rs_priv->lq.general_params.start_rate_index[2],
- rs_priv->lq.general_params.start_rate_index[3]);
+ lq_sta->lq.general_params.start_rate_index[0],
+ lq_sta->lq.general_params.start_rate_index[1],
+ lq_sta->lq.general_params.start_rate_index[2],
+ lq_sta->lq.general_params.start_rate_index[3]);
for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++)
desc += sprintf(buff+desc, " rate[%d] 0x%X\n",
- i, le32_to_cpu(rs_priv->lq.rs_table[i].rate_n_flags));
+ i, le32_to_cpu(lq_sta->lq.rs_table[i].rate_n_flags));
return simple_read_from_buffer(user_buf, count, ppos, buff, desc);
}
@@ -2453,22 +2459,22 @@ static ssize_t rs_sta_dbgfs_stats_table_read(struct file *file,
int desc = 0;
int i, j;
- struct iwl4965_rate_scale_priv *rs_priv = file->private_data;
+ struct iwl4965_lq_sta *lq_sta = file->private_data;
for (i = 0; i < LQ_SIZE; i++) {
desc += sprintf(buff+desc, "%s type=%d SGI=%d FAT=%d DUP=%d\n"
"rate=0x%X\n",
- rs_priv->active_tbl == i?"*":"x",
- rs_priv->lq_info[i].lq_type,
- rs_priv->lq_info[i].is_SGI,
- rs_priv->lq_info[i].is_fat,
- rs_priv->lq_info[i].is_dup,
- rs_priv->lq_info[i].current_rate.rate_n_flags);
+ lq_sta->active_tbl == i?"*":"x",
+ lq_sta->lq_info[i].lq_type,
+ lq_sta->lq_info[i].is_SGI,
+ lq_sta->lq_info[i].is_fat,
+ lq_sta->lq_info[i].is_dup,
+ lq_sta->lq_info[i].current_rate.rate_n_flags);
for (j = 0; j < IWL_RATE_COUNT; j++) {
desc += sprintf(buff+desc,
- "counter=%d success=%d %%=%d\n",
- rs_priv->lq_info[i].win[j].counter,
- rs_priv->lq_info[i].win[j].success_counter,
- rs_priv->lq_info[i].win[j].success_ratio);
+ "counter=%d success=%d %%=%d\n",
+ lq_sta->lq_info[i].win[j].counter,
+ lq_sta->lq_info[i].win[j].success_counter,
+ lq_sta->lq_info[i].win[j].success_ratio);
}
}
return simple_read_from_buffer(user_buf, count, ppos, buff, desc);
@@ -2482,20 +2488,20 @@ static const struct file_operations rs_sta_dbgfs_stats_table_ops = {
static void rs_add_debugfs(void *priv, void *priv_sta,
struct dentry *dir)
{
- struct iwl4965_rate_scale_priv *rs_priv = priv_sta;
- rs_priv->rs_sta_dbgfs_scale_table_file =
+ struct iwl4965_lq_sta *lq_sta = priv_sta;
+ lq_sta->rs_sta_dbgfs_scale_table_file =
debugfs_create_file("rate_scale_table", 0600, dir,
- rs_priv, &rs_sta_dbgfs_scale_table_ops);
- rs_priv->rs_sta_dbgfs_stats_table_file =
+ lq_sta, &rs_sta_dbgfs_scale_table_ops);
+ lq_sta->rs_sta_dbgfs_stats_table_file =
debugfs_create_file("rate_stats_table", 0600, dir,
- rs_priv, &rs_sta_dbgfs_stats_table_ops);
+ lq_sta, &rs_sta_dbgfs_stats_table_ops);
}
static void rs_remove_debugfs(void *priv, void *priv_sta)
{
- struct iwl4965_rate_scale_priv *rs_priv = priv_sta;
- debugfs_remove(rs_priv->rs_sta_dbgfs_scale_table_file);
- debugfs_remove(rs_priv->rs_sta_dbgfs_stats_table_file);
+ struct iwl4965_lq_sta *lq_sta = priv_sta;
+ debugfs_remove(lq_sta->rs_sta_dbgfs_scale_table_file);
+ debugfs_remove(lq_sta->rs_sta_dbgfs_stats_table_file);
}
#endif
@@ -2520,9 +2526,9 @@ int iwl4965_fill_rs_info(struct ieee80211_hw *hw, char *buf, u8 sta_id)
{
struct ieee80211_local *local = hw_to_local(hw);
struct iwl4965_priv *priv = hw->priv;
- struct iwl4965_rate_scale_priv *rs_priv;
+ struct iwl4965_lq_sta *lq_sta;
struct sta_info *sta;
- int count = 0, i;
+ int cnt = 0, i;
u32 samples = 0, success = 0, good = 0;
unsigned long now = jiffies;
u32 max_time = 0;
@@ -2538,10 +2544,10 @@ int iwl4965_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;
+ lq_sta = (void *)sta->rate_ctrl_priv;
- lq_type = rs_priv->lq_info[rs_priv->active_tbl].lq_type;
- antenna = rs_priv->lq_info[rs_priv->active_tbl].antenna_type;
+ lq_type = lq_sta->lq_info[lq_sta->active_tbl].lq_type;
+ antenna = lq_sta->lq_info[lq_sta->active_tbl].antenna_type;
if (is_legacy(lq_type))
i = IWL_RATE_54M_INDEX;
@@ -2550,33 +2556,33 @@ int iwl4965_fill_rs_info(struct ieee80211_hw *hw, char *buf, u8 sta_id)
while (1) {
u64 mask;
int j;
- int active = rs_priv->active_tbl;
+ int active = lq_sta->active_tbl;
- count +=
- sprintf(&buf[count], " %2dMbs: ", iwl4965_rates[i].ieee / 2);
+ cnt +=
+ sprintf(&buf[cnt], " %2dMbs: ", iwl4965_rates[i].ieee / 2);
mask = (1ULL << (IWL_RATE_MAX_WINDOW - 1));
for (j = 0; j < IWL_RATE_MAX_WINDOW; j++, mask >>= 1)
- buf[count++] =
- (rs_priv->lq_info[active].win[i].data & mask)
+ buf[cnt++] =
+ (lq_sta->lq_info[active].win[i].data & mask)
? '1' : '0';
- samples += rs_priv->lq_info[active].win[i].counter;
- good += rs_priv->lq_info[active].win[i].success_counter;
- success += rs_priv->lq_info[active].win[i].success_counter *
+ samples += lq_sta->lq_info[active].win[i].counter;
+ good += lq_sta->lq_info[active].win[i].success_counter;
+ success += lq_sta->lq_info[active].win[i].success_counter *
iwl4965_rates[i].ieee;
- if (rs_priv->lq_info[active].win[i].stamp) {
+ if (lq_sta->lq_info[active].win[i].stamp) {
int delta =
jiffies_to_msecs(now -
- rs_priv->lq_info[active].win[i].stamp);
+ lq_sta->lq_info[active].win[i].stamp);
if (delta > max_time)
max_time = delta;
- count += sprintf(&buf[count], "%5dms\n", delta);
+ cnt += sprintf(&buf[cnt], "%5dms\n", delta);
} else
- buf[count++] = '\n';
+ buf[cnt++] = '\n';
j = iwl4965_get_prev_ieee_rate(i);
if (j == i)
@@ -2589,19 +2595,20 @@ int iwl4965_fill_rs_info(struct ieee80211_hw *hw, char *buf, u8 sta_id)
* NOTE: We multiply # of samples by 2 since the IEEE measurement
* added from iwl4965_rates is actually 2X the rate */
if (samples)
- count += sprintf(&buf[count],
+ cnt += sprintf(&buf[cnt],
"\nAverage rate is %3d.%02dMbs over last %4dms\n"
"%3d%% success (%d good packets over %d tries)\n",
success / (2 * samples), (success * 5 / samples) % 10,
max_time, good * 100 / samples, good, samples);
else
- count += sprintf(&buf[count], "\nAverage rate: 0Mbs\n");
- count += sprintf(&buf[count], "\nrate scale type %d antenna %d "
+ cnt += sprintf(&buf[cnt], "\nAverage rate: 0Mbs\n");
+
+ cnt += sprintf(&buf[cnt], "\nrate scale type %d antenna %d "
"active_search %d rate index %d\n", lq_type, antenna,
- rs_priv->search_better_tbl, sta->last_txrate);
+ lq_sta->search_better_tbl, sta->last_txrate);
sta_info_put(sta);
- return count;
+ return cnt;
}
void iwl4965_rate_scale_init(struct ieee80211_hw *hw, s32 sta_id)
generated by cgit v0.10.2 at 2024-11-12 02:26:11 (GMT)