948 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/******************************************************************************3 *4 * Copyright(c) 2005 - 2011 Intel Corporation. All rights reserved.5 *6 * Contact Information:7 * Intel Linux Wireless <ilw@linux.intel.com>8 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-64979 *10 *****************************************************************************/11 12#include <linux/kernel.h>13#include <linux/skbuff.h>14#include <linux/slab.h>15#include <net/mac80211.h>16 17#include <linux/netdevice.h>18#include <linux/etherdevice.h>19#include <linux/delay.h>20 21#include <linux/workqueue.h>22 23#include "commands.h"24#include "3945.h"25 26#define RS_NAME "iwl-3945-rs"27 28static s32 il3945_expected_tpt_g[RATE_COUNT_3945] = {29 7, 13, 35, 58, 0, 0, 76, 104, 130, 168, 191, 20230};31 32static s32 il3945_expected_tpt_g_prot[RATE_COUNT_3945] = {33 7, 13, 35, 58, 0, 0, 0, 80, 93, 113, 123, 12534};35 36static s32 il3945_expected_tpt_a[RATE_COUNT_3945] = {37 0, 0, 0, 0, 40, 57, 72, 98, 121, 154, 177, 18638};39 40static s32 il3945_expected_tpt_b[RATE_COUNT_3945] = {41 7, 13, 35, 58, 0, 0, 0, 0, 0, 0, 0, 042};43 44struct il3945_tpt_entry {45 s8 min_rssi;46 u8 idx;47};48 49static struct il3945_tpt_entry il3945_tpt_table_a[] = {50 {-60, RATE_54M_IDX},51 {-64, RATE_48M_IDX},52 {-72, RATE_36M_IDX},53 {-80, RATE_24M_IDX},54 {-84, RATE_18M_IDX},55 {-85, RATE_12M_IDX},56 {-87, RATE_9M_IDX},57 {-89, RATE_6M_IDX}58};59 60static struct il3945_tpt_entry il3945_tpt_table_g[] = {61 {-60, RATE_54M_IDX},62 {-64, RATE_48M_IDX},63 {-68, RATE_36M_IDX},64 {-80, RATE_24M_IDX},65 {-84, RATE_18M_IDX},66 {-85, RATE_12M_IDX},67 {-86, RATE_11M_IDX},68 {-88, RATE_5M_IDX},69 {-90, RATE_2M_IDX},70 {-92, RATE_1M_IDX}71};72 73#define RATE_MAX_WINDOW 6274#define RATE_FLUSH (3*HZ)75#define RATE_WIN_FLUSH (HZ/2)76#define IL39_RATE_HIGH_TH 1152077#define IL_SUCCESS_UP_TH 896078#define IL_SUCCESS_DOWN_TH 1088079#define RATE_MIN_FAILURE_TH 680#define RATE_MIN_SUCCESS_TH 881#define RATE_DECREASE_TH 192082#define RATE_RETRY_TH 1583 84static u885il3945_get_rate_idx_by_rssi(s32 rssi, enum nl80211_band band)86{87 u32 idx = 0;88 u32 table_size = 0;89 struct il3945_tpt_entry *tpt_table = NULL;90 91 if (rssi < IL_MIN_RSSI_VAL || rssi > IL_MAX_RSSI_VAL)92 rssi = IL_MIN_RSSI_VAL;93 94 switch (band) {95 case NL80211_BAND_2GHZ:96 tpt_table = il3945_tpt_table_g;97 table_size = ARRAY_SIZE(il3945_tpt_table_g);98 break;99 case NL80211_BAND_5GHZ:100 tpt_table = il3945_tpt_table_a;101 table_size = ARRAY_SIZE(il3945_tpt_table_a);102 break;103 default:104 BUG();105 break;106 }107 108 while (idx < table_size && rssi < tpt_table[idx].min_rssi)109 idx++;110 111 idx = min(idx, table_size - 1);112 113 return tpt_table[idx].idx;114}115 116static void117il3945_clear_win(struct il3945_rate_scale_data *win)118{119 win->data = 0;120 win->success_counter = 0;121 win->success_ratio = -1;122 win->counter = 0;123 win->average_tpt = IL_INVALID_VALUE;124 win->stamp = 0;125}126 127/*128 * il3945_rate_scale_flush_wins - flush out the rate scale wins129 *130 * Returns the number of wins that have gathered data but were131 * not flushed. If there were any that were not flushed, then132 * reschedule the rate flushing routine.133 */134static int135il3945_rate_scale_flush_wins(struct il3945_rs_sta *rs_sta)136{137 int unflushed = 0;138 int i;139 unsigned long flags;140 struct il_priv *il __maybe_unused = rs_sta->il;141 142 /*143 * For each rate, if we have collected data on that rate144 * and it has been more than RATE_WIN_FLUSH145 * since we flushed, clear out the gathered stats146 */147 for (i = 0; i < RATE_COUNT_3945; i++) {148 if (!rs_sta->win[i].counter)149 continue;150 151 spin_lock_irqsave(&rs_sta->lock, flags);152 if (time_after(jiffies, rs_sta->win[i].stamp + RATE_WIN_FLUSH)) {153 D_RATE("flushing %d samples of rate " "idx %d\n",154 rs_sta->win[i].counter, i);155 il3945_clear_win(&rs_sta->win[i]);156 } else157 unflushed++;158 spin_unlock_irqrestore(&rs_sta->lock, flags);159 }160 161 return unflushed;162}163 164#define RATE_FLUSH_MAX 5000 /* msec */165#define RATE_FLUSH_MIN 50 /* msec */166#define IL_AVERAGE_PACKETS 1500167 168static void169il3945_bg_rate_scale_flush(struct timer_list *t)170{171 struct il3945_rs_sta *rs_sta = from_timer(rs_sta, t, rate_scale_flush);172 struct il_priv *il __maybe_unused = rs_sta->il;173 int unflushed = 0;174 unsigned long flags;175 u32 packet_count, duration, pps;176 177 D_RATE("enter\n");178 179 unflushed = il3945_rate_scale_flush_wins(rs_sta);180 181 spin_lock_irqsave(&rs_sta->lock, flags);182 183 /* Number of packets Rx'd since last time this timer ran */184 packet_count = (rs_sta->tx_packets - rs_sta->last_tx_packets) + 1;185 186 rs_sta->last_tx_packets = rs_sta->tx_packets + 1;187 188 if (unflushed) {189 duration =190 jiffies_to_msecs(jiffies - rs_sta->last_partial_flush);191 192 D_RATE("Tx'd %d packets in %dms\n", packet_count, duration);193 194 /* Determine packets per second */195 if (duration)196 pps = (packet_count * 1000) / duration;197 else198 pps = 0;199 200 if (pps) {201 duration = (IL_AVERAGE_PACKETS * 1000) / pps;202 if (duration < RATE_FLUSH_MIN)203 duration = RATE_FLUSH_MIN;204 else if (duration > RATE_FLUSH_MAX)205 duration = RATE_FLUSH_MAX;206 } else207 duration = RATE_FLUSH_MAX;208 209 rs_sta->flush_time = msecs_to_jiffies(duration);210 211 D_RATE("new flush period: %d msec ave %d\n", duration,212 packet_count);213 214 mod_timer(&rs_sta->rate_scale_flush,215 jiffies + rs_sta->flush_time);216 217 rs_sta->last_partial_flush = jiffies;218 } else {219 rs_sta->flush_time = RATE_FLUSH;220 rs_sta->flush_pending = 0;221 }222 /* If there weren't any unflushed entries, we don't schedule the timer223 * to run again */224 225 rs_sta->last_flush = jiffies;226 227 spin_unlock_irqrestore(&rs_sta->lock, flags);228 229 D_RATE("leave\n");230}231 232/*233 * il3945_collect_tx_data - Update the success/failure sliding win234 *235 * We keep a sliding win of the last 64 packets transmitted236 * at this rate. win->data contains the bitmask of successful237 * packets.238 */239static void240il3945_collect_tx_data(struct il3945_rs_sta *rs_sta,241 struct il3945_rate_scale_data *win, int success,242 int retries, int idx)243{244 unsigned long flags;245 s32 fail_count;246 struct il_priv *il __maybe_unused = rs_sta->il;247 248 if (!retries) {249 D_RATE("leave: retries == 0 -- should be at least 1\n");250 return;251 }252 253 spin_lock_irqsave(&rs_sta->lock, flags);254 255 /*256 * Keep track of only the latest 62 tx frame attempts in this rate's257 * history win; anything older isn't really relevant any more.258 * If we have filled up the sliding win, drop the oldest attempt;259 * if the oldest attempt (highest bit in bitmap) shows "success",260 * subtract "1" from the success counter (this is the main reason261 * we keep these bitmaps!).262 * */263 while (retries > 0) {264 if (win->counter >= RATE_MAX_WINDOW) {265 266 /* remove earliest */267 win->counter = RATE_MAX_WINDOW - 1;268 269 if (win->data & (1ULL << (RATE_MAX_WINDOW - 1))) {270 win->data &= ~(1ULL << (RATE_MAX_WINDOW - 1));271 win->success_counter--;272 }273 }274 275 /* Increment frames-attempted counter */276 win->counter++;277 278 /* Shift bitmap by one frame (throw away oldest history),279 * OR in "1", and increment "success" if this280 * frame was successful. */281 win->data <<= 1;282 if (success > 0) {283 win->success_counter++;284 win->data |= 0x1;285 success--;286 }287 288 retries--;289 }290 291 /* Calculate current success ratio, avoid divide-by-0! */292 if (win->counter > 0)293 win->success_ratio =294 128 * (100 * win->success_counter) / win->counter;295 else296 win->success_ratio = IL_INVALID_VALUE;297 298 fail_count = win->counter - win->success_counter;299 300 /* Calculate average throughput, if we have enough history. */301 if (fail_count >= RATE_MIN_FAILURE_TH ||302 win->success_counter >= RATE_MIN_SUCCESS_TH)303 win->average_tpt =304 ((win->success_ratio * rs_sta->expected_tpt[idx] +305 64) / 128);306 else307 win->average_tpt = IL_INVALID_VALUE;308 309 /* Tag this win as having been updated */310 win->stamp = jiffies;311 312 spin_unlock_irqrestore(&rs_sta->lock, flags);313}314 315/*316 * Called after adding a new station to initialize rate scaling317 */318void319il3945_rs_rate_init(struct il_priv *il, struct ieee80211_sta *sta, u8 sta_id)320{321 struct ieee80211_hw *hw = il->hw;322 struct ieee80211_conf *conf = &il->hw->conf;323 struct il3945_sta_priv *psta;324 struct il3945_rs_sta *rs_sta;325 struct ieee80211_supported_band *sband;326 int i;327 328 D_INFO("enter\n");329 if (sta_id == il->hw_params.bcast_id)330 goto out;331 332 psta = (struct il3945_sta_priv *)sta->drv_priv;333 rs_sta = &psta->rs_sta;334 sband = hw->wiphy->bands[conf->chandef.chan->band];335 336 rs_sta->il = il;337 338 rs_sta->start_rate = RATE_INVALID;339 340 /* default to just 802.11b */341 rs_sta->expected_tpt = il3945_expected_tpt_b;342 343 rs_sta->last_partial_flush = jiffies;344 rs_sta->last_flush = jiffies;345 rs_sta->flush_time = RATE_FLUSH;346 rs_sta->last_tx_packets = 0;347 348 for (i = 0; i < RATE_COUNT_3945; i++)349 il3945_clear_win(&rs_sta->win[i]);350 351 /* TODO: what is a good starting rate for STA? About middle? Maybe not352 * the lowest or the highest rate.. Could consider using RSSI from353 * previous packets? Need to have IEEE 802.1X auth succeed immediately354 * after assoc.. */355 356 for (i = sband->n_bitrates - 1; i >= 0; i--) {357 if (sta->deflink.supp_rates[sband->band] & (1 << i)) {358 rs_sta->last_txrate_idx = i;359 break;360 }361 }362 363 il->_3945.sta_supp_rates = sta->deflink.supp_rates[sband->band];364 /* For 5 GHz band it start at IL_FIRST_OFDM_RATE */365 if (sband->band == NL80211_BAND_5GHZ) {366 rs_sta->last_txrate_idx += IL_FIRST_OFDM_RATE;367 il->_3945.sta_supp_rates <<= IL_FIRST_OFDM_RATE;368 }369 370out:371 il->stations[sta_id].used &= ~IL_STA_UCODE_INPROGRESS;372 373 D_INFO("leave\n");374}375 376static void *377il3945_rs_alloc(struct ieee80211_hw *hw)378{379 return hw->priv;380}381 382/* rate scale requires free function to be implemented */383static void384il3945_rs_free(void *il)385{386}387 388static void *389il3945_rs_alloc_sta(void *il_priv, struct ieee80211_sta *sta, gfp_t gfp)390{391 struct il3945_rs_sta *rs_sta;392 struct il3945_sta_priv *psta = (void *)sta->drv_priv;393 struct il_priv *il __maybe_unused = il_priv;394 395 D_RATE("enter\n");396 397 rs_sta = &psta->rs_sta;398 399 spin_lock_init(&rs_sta->lock);400 timer_setup(&rs_sta->rate_scale_flush, il3945_bg_rate_scale_flush, 0);401 D_RATE("leave\n");402 403 return rs_sta;404}405 406static void407il3945_rs_free_sta(void *il_priv, struct ieee80211_sta *sta, void *il_sta)408{409 struct il3945_rs_sta *rs_sta = il_sta;410 411 /*412 * Be careful not to use any members of il3945_rs_sta (like trying413 * to use il_priv to print out debugging) since it may not be fully414 * initialized at this point.415 */416 del_timer_sync(&rs_sta->rate_scale_flush);417}418 419/*420 * il3945_rs_tx_status - Update rate control values based on Tx results421 *422 * NOTE: Uses il_priv->retry_rate for the # of retries attempted by423 * the hardware for each rate.424 */425static void426il3945_rs_tx_status(void *il_rate, struct ieee80211_supported_band *sband,427 struct ieee80211_sta *sta, void *il_sta,428 struct sk_buff *skb)429{430 s8 retries = 0, current_count;431 int scale_rate_idx, first_idx, last_idx;432 unsigned long flags;433 struct il_priv *il = (struct il_priv *)il_rate;434 struct il3945_rs_sta *rs_sta = il_sta;435 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);436 437 D_RATE("enter\n");438 439 retries = info->status.rates[0].count;440 /* Sanity Check for retries */441 if (retries > RATE_RETRY_TH)442 retries = RATE_RETRY_TH;443 444 first_idx = sband->bitrates[info->status.rates[0].idx].hw_value;445 if (first_idx < 0 || first_idx >= RATE_COUNT_3945) {446 D_RATE("leave: Rate out of bounds: %d\n", first_idx);447 return;448 }449 450 if (!il_sta) {451 D_RATE("leave: No STA il data to update!\n");452 return;453 }454 455 /* Treat uninitialized rate scaling data same as non-existing. */456 if (!rs_sta->il) {457 D_RATE("leave: STA il data uninitialized!\n");458 return;459 }460 461 rs_sta->tx_packets++;462 463 scale_rate_idx = first_idx;464 last_idx = first_idx;465 466 /*467 * Update the win for each rate. We determine which rates468 * were Tx'd based on the total number of retries vs. the number469 * of retries configured for each rate -- currently set to the470 * il value 'retry_rate' vs. rate specific471 *472 * On exit from this while loop last_idx indicates the rate473 * at which the frame was finally transmitted (or failed if no474 * ACK)475 */476 while (retries > 1) {477 if ((retries - 1) < il->retry_rate) {478 current_count = (retries - 1);479 last_idx = scale_rate_idx;480 } else {481 current_count = il->retry_rate;482 last_idx = il3945_rs_next_rate(il, scale_rate_idx);483 }484 485 /* Update this rate accounting for as many retries486 * as was used for it (per current_count) */487 il3945_collect_tx_data(rs_sta, &rs_sta->win[scale_rate_idx], 0,488 current_count, scale_rate_idx);489 D_RATE("Update rate %d for %d retries.\n", scale_rate_idx,490 current_count);491 492 retries -= current_count;493 494 scale_rate_idx = last_idx;495 }496 497 /* Update the last idx win with success/failure based on ACK */498 D_RATE("Update rate %d with %s.\n", last_idx,499 (info->flags & IEEE80211_TX_STAT_ACK) ? "success" : "failure");500 il3945_collect_tx_data(rs_sta, &rs_sta->win[last_idx],501 info->flags & IEEE80211_TX_STAT_ACK, 1,502 last_idx);503 504 /* We updated the rate scale win -- if its been more than505 * flush_time since the last run, schedule the flush506 * again */507 spin_lock_irqsave(&rs_sta->lock, flags);508 509 if (!rs_sta->flush_pending &&510 time_after(jiffies, rs_sta->last_flush + rs_sta->flush_time)) {511 512 rs_sta->last_partial_flush = jiffies;513 rs_sta->flush_pending = 1;514 mod_timer(&rs_sta->rate_scale_flush,515 jiffies + rs_sta->flush_time);516 }517 518 spin_unlock_irqrestore(&rs_sta->lock, flags);519 520 D_RATE("leave\n");521}522 523static u16524il3945_get_adjacent_rate(struct il3945_rs_sta *rs_sta, u8 idx, u16 rate_mask,525 enum nl80211_band band)526{527 u8 high = RATE_INVALID;528 u8 low = RATE_INVALID;529 struct il_priv *il __maybe_unused = rs_sta->il;530 531 /* 802.11A walks to the next literal adjacent rate in532 * the rate table */533 if (unlikely(band == NL80211_BAND_5GHZ)) {534 int i;535 u32 mask;536 537 /* Find the previous rate that is in the rate mask */538 i = idx - 1;539 for (mask = (1 << i); i >= 0; i--, mask >>= 1) {540 if (rate_mask & mask) {541 low = i;542 break;543 }544 }545 546 /* Find the next rate that is in the rate mask */547 i = idx + 1;548 for (mask = (1 << i); i < RATE_COUNT_3945; i++, mask <<= 1) {549 if (rate_mask & mask) {550 high = i;551 break;552 }553 }554 555 return (high << 8) | low;556 }557 558 low = idx;559 while (low != RATE_INVALID) {560 if (rs_sta->tgg)561 low = il3945_rates[low].prev_rs_tgg;562 else563 low = il3945_rates[low].prev_rs;564 if (low == RATE_INVALID)565 break;566 if (rate_mask & (1 << low))567 break;568 D_RATE("Skipping masked lower rate: %d\n", low);569 }570 571 high = idx;572 while (high != RATE_INVALID) {573 if (rs_sta->tgg)574 high = il3945_rates[high].next_rs_tgg;575 else576 high = il3945_rates[high].next_rs;577 if (high == RATE_INVALID)578 break;579 if (rate_mask & (1 << high))580 break;581 D_RATE("Skipping masked higher rate: %d\n", high);582 }583 584 return (high << 8) | low;585}586 587/*588 * il3945_rs_get_rate - find the rate for the requested packet589 *590 * Returns the ieee80211_rate structure allocated by the driver.591 *592 * The rate control algorithm has no internal mapping between hw_mode's593 * rate ordering and the rate ordering used by the rate control algorithm.594 *595 * The rate control algorithm uses a single table of rates that goes across596 * the entire A/B/G spectrum vs. being limited to just one particular597 * hw_mode.598 *599 * As such, we can't convert the idx obtained below into the hw_mode's600 * rate table and must reference the driver allocated rate table601 *602 */603static void604il3945_rs_get_rate(void *il_r, struct ieee80211_sta *sta, void *il_sta,605 struct ieee80211_tx_rate_control *txrc)606{607 struct ieee80211_supported_band *sband = txrc->sband;608 struct sk_buff *skb = txrc->skb;609 u8 low = RATE_INVALID;610 u8 high = RATE_INVALID;611 u16 high_low;612 int idx;613 struct il3945_rs_sta *rs_sta = il_sta;614 struct il3945_rate_scale_data *win = NULL;615 int current_tpt = IL_INVALID_VALUE;616 int low_tpt = IL_INVALID_VALUE;617 int high_tpt = IL_INVALID_VALUE;618 u32 fail_count;619 s8 scale_action = 0;620 unsigned long flags;621 u16 rate_mask;622 s8 max_rate_idx = -1;623 struct il_priv *il __maybe_unused = (struct il_priv *)il_r;624 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);625 626 D_RATE("enter\n");627 628 /* Treat uninitialized rate scaling data same as non-existing. */629 if (rs_sta && !rs_sta->il) {630 D_RATE("Rate scaling information not initialized yet.\n");631 il_sta = NULL;632 }633 634 rate_mask = sta->deflink.supp_rates[sband->band];635 636 /* get user max rate if set */637 max_rate_idx = fls(txrc->rate_idx_mask) - 1;638 if (sband->band == NL80211_BAND_5GHZ && max_rate_idx != -1)639 max_rate_idx += IL_FIRST_OFDM_RATE;640 if (max_rate_idx < 0 || max_rate_idx >= RATE_COUNT)641 max_rate_idx = -1;642 643 idx = min(rs_sta->last_txrate_idx & 0xffff, RATE_COUNT_3945 - 1);644 645 if (sband->band == NL80211_BAND_5GHZ)646 rate_mask = rate_mask << IL_FIRST_OFDM_RATE;647 648 spin_lock_irqsave(&rs_sta->lock, flags);649 650 /* for recent assoc, choose best rate regarding651 * to rssi value652 */653 if (rs_sta->start_rate != RATE_INVALID) {654 if (rs_sta->start_rate < idx &&655 (rate_mask & (1 << rs_sta->start_rate)))656 idx = rs_sta->start_rate;657 rs_sta->start_rate = RATE_INVALID;658 }659 660 /* force user max rate if set by user */661 if (max_rate_idx != -1 && max_rate_idx < idx) {662 if (rate_mask & (1 << max_rate_idx))663 idx = max_rate_idx;664 }665 666 win = &(rs_sta->win[idx]);667 668 fail_count = win->counter - win->success_counter;669 670 if (fail_count < RATE_MIN_FAILURE_TH &&671 win->success_counter < RATE_MIN_SUCCESS_TH) {672 spin_unlock_irqrestore(&rs_sta->lock, flags);673 674 D_RATE("Invalid average_tpt on rate %d: "675 "counter: %d, success_counter: %d, "676 "expected_tpt is %sNULL\n", idx, win->counter,677 win->success_counter,678 rs_sta->expected_tpt ? "not " : "");679 680 /* Can't calculate this yet; not enough history */681 win->average_tpt = IL_INVALID_VALUE;682 goto out;683 684 }685 686 current_tpt = win->average_tpt;687 688 high_low =689 il3945_get_adjacent_rate(rs_sta, idx, rate_mask, sband->band);690 low = high_low & 0xff;691 high = (high_low >> 8) & 0xff;692 693 /* If user set max rate, dont allow higher than user constrain */694 if (max_rate_idx != -1 && max_rate_idx < high)695 high = RATE_INVALID;696 697 /* Collect Measured throughputs of adjacent rates */698 if (low != RATE_INVALID)699 low_tpt = rs_sta->win[low].average_tpt;700 701 if (high != RATE_INVALID)702 high_tpt = rs_sta->win[high].average_tpt;703 704 spin_unlock_irqrestore(&rs_sta->lock, flags);705 706 scale_action = 0;707 708 /* Low success ratio , need to drop the rate */709 if (win->success_ratio < RATE_DECREASE_TH || !current_tpt) {710 D_RATE("decrease rate because of low success_ratio\n");711 scale_action = -1;712 /* No throughput measured yet for adjacent rates,713 * try increase */714 } else if (low_tpt == IL_INVALID_VALUE && high_tpt == IL_INVALID_VALUE) {715 716 if (high != RATE_INVALID &&717 win->success_ratio >= RATE_INCREASE_TH)718 scale_action = 1;719 else if (low != RATE_INVALID)720 scale_action = 0;721 722 /* Both adjacent throughputs are measured, but neither one has723 * better throughput; we're using the best rate, don't change724 * it! */725 } else if (low_tpt != IL_INVALID_VALUE && high_tpt != IL_INVALID_VALUE726 && low_tpt < current_tpt && high_tpt < current_tpt) {727 728 D_RATE("No action -- low [%d] & high [%d] < "729 "current_tpt [%d]\n", low_tpt, high_tpt, current_tpt);730 scale_action = 0;731 732 /* At least one of the rates has better throughput */733 } else {734 if (high_tpt != IL_INVALID_VALUE) {735 736 /* High rate has better throughput, Increase737 * rate */738 if (high_tpt > current_tpt &&739 win->success_ratio >= RATE_INCREASE_TH)740 scale_action = 1;741 else {742 D_RATE("decrease rate because of high tpt\n");743 scale_action = 0;744 }745 } else if (low_tpt != IL_INVALID_VALUE) {746 if (low_tpt > current_tpt) {747 D_RATE("decrease rate because of low tpt\n");748 scale_action = -1;749 } else if (win->success_ratio >= RATE_INCREASE_TH) {750 /* Lower rate has better751 * throughput,decrease rate */752 scale_action = 1;753 }754 }755 }756 757 /* Sanity check; asked for decrease, but success rate or throughput758 * has been good at old rate. Don't change it. */759 if (scale_action == -1 && low != RATE_INVALID &&760 (win->success_ratio > RATE_HIGH_TH ||761 current_tpt > 100 * rs_sta->expected_tpt[low]))762 scale_action = 0;763 764 switch (scale_action) {765 case -1:766 /* Decrease rate */767 if (low != RATE_INVALID)768 idx = low;769 break;770 case 1:771 /* Increase rate */772 if (high != RATE_INVALID)773 idx = high;774 775 break;776 case 0:777 default:778 /* No change */779 break;780 }781 782 D_RATE("Selected %d (action %d) - low %d high %d\n", idx, scale_action,783 low, high);784 785out:786 787 if (sband->band == NL80211_BAND_5GHZ) {788 if (WARN_ON_ONCE(idx < IL_FIRST_OFDM_RATE))789 idx = IL_FIRST_OFDM_RATE;790 rs_sta->last_txrate_idx = idx;791 info->control.rates[0].idx = idx - IL_FIRST_OFDM_RATE;792 } else {793 rs_sta->last_txrate_idx = idx;794 info->control.rates[0].idx = rs_sta->last_txrate_idx;795 }796 info->control.rates[0].count = 1;797 798 D_RATE("leave: %d\n", idx);799}800 801#ifdef CONFIG_MAC80211_DEBUGFS802 803static ssize_t804il3945_sta_dbgfs_stats_table_read(struct file *file, char __user *user_buf,805 size_t count, loff_t *ppos)806{807 char *buff;808 int desc = 0;809 int j;810 ssize_t ret;811 struct il3945_rs_sta *lq_sta = file->private_data;812 813 buff = kmalloc(1024, GFP_KERNEL);814 if (!buff)815 return -ENOMEM;816 817 desc +=818 sprintf(buff + desc,819 "tx packets=%d last rate idx=%d\n"820 "rate=0x%X flush time %d\n", lq_sta->tx_packets,821 lq_sta->last_txrate_idx, lq_sta->start_rate,822 jiffies_to_msecs(lq_sta->flush_time));823 for (j = 0; j < RATE_COUNT_3945; j++) {824 desc +=825 sprintf(buff + desc, "counter=%d success=%d %%=%d\n",826 lq_sta->win[j].counter,827 lq_sta->win[j].success_counter,828 lq_sta->win[j].success_ratio);829 }830 ret = simple_read_from_buffer(user_buf, count, ppos, buff, desc);831 kfree(buff);832 return ret;833}834 835static const struct file_operations rs_sta_dbgfs_stats_table_ops = {836 .read = il3945_sta_dbgfs_stats_table_read,837 .open = simple_open,838 .llseek = default_llseek,839};840 841static void842il3945_add_debugfs(void *il, void *il_sta, struct dentry *dir)843{844 struct il3945_rs_sta *lq_sta = il_sta;845 846 debugfs_create_file("rate_stats_table", 0600, dir, lq_sta,847 &rs_sta_dbgfs_stats_table_ops);848}849#endif850 851/*852 * Initialization of rate scaling information is done by driver after853 * the station is added. Since mac80211 calls this function before a854 * station is added we ignore it.855 */856static void857il3945_rs_rate_init_stub(void *il_r, struct ieee80211_supported_band *sband,858 struct cfg80211_chan_def *chandef,859 struct ieee80211_sta *sta, void *il_sta)860{861}862 863static const struct rate_control_ops rs_ops = {864 .name = RS_NAME,865 .tx_status = il3945_rs_tx_status,866 .get_rate = il3945_rs_get_rate,867 .rate_init = il3945_rs_rate_init_stub,868 .alloc = il3945_rs_alloc,869 .free = il3945_rs_free,870 .alloc_sta = il3945_rs_alloc_sta,871 .free_sta = il3945_rs_free_sta,872#ifdef CONFIG_MAC80211_DEBUGFS873 .add_sta_debugfs = il3945_add_debugfs,874#endif875 876};877 878void879il3945_rate_scale_init(struct ieee80211_hw *hw, s32 sta_id)880{881 struct il_priv *il = hw->priv;882 s32 rssi = 0;883 unsigned long flags;884 struct il3945_rs_sta *rs_sta;885 struct ieee80211_sta *sta;886 struct il3945_sta_priv *psta;887 888 D_RATE("enter\n");889 890 rcu_read_lock();891 892 sta = ieee80211_find_sta(il->vif, il->stations[sta_id].sta.sta.addr);893 if (!sta) {894 D_RATE("Unable to find station to initialize rate scaling.\n");895 rcu_read_unlock();896 return;897 }898 899 psta = (void *)sta->drv_priv;900 rs_sta = &psta->rs_sta;901 902 spin_lock_irqsave(&rs_sta->lock, flags);903 904 rs_sta->tgg = 0;905 switch (il->band) {906 case NL80211_BAND_2GHZ:907 /* TODO: this always does G, not a regression */908 if (il->active.flags & RXON_FLG_TGG_PROTECT_MSK) {909 rs_sta->tgg = 1;910 rs_sta->expected_tpt = il3945_expected_tpt_g_prot;911 } else912 rs_sta->expected_tpt = il3945_expected_tpt_g;913 break;914 case NL80211_BAND_5GHZ:915 rs_sta->expected_tpt = il3945_expected_tpt_a;916 break;917 default:918 BUG();919 break;920 }921 922 spin_unlock_irqrestore(&rs_sta->lock, flags);923 924 rssi = il->_3945.last_rx_rssi;925 if (rssi == 0)926 rssi = IL_MIN_RSSI_VAL;927 928 D_RATE("Network RSSI: %d\n", rssi);929 930 rs_sta->start_rate = il3945_get_rate_idx_by_rssi(rssi, il->band);931 932 D_RATE("leave: rssi %d assign rate idx: " "%d (plcp 0x%x)\n", rssi,933 rs_sta->start_rate, il3945_rates[rs_sta->start_rate].plcp);934 rcu_read_unlock();935}936 937int938il3945_rate_control_register(void)939{940 return ieee80211_rate_control_register(&rs_ops);941}942 943void944il3945_rate_control_unregister(void)945{946 ieee80211_rate_control_unregister(&rs_ops);947}948