1/****************************************************************************** 2 * 3 * Copyright(c) 2005 - 2010 Intel Corporation. All rights reserved. 4 * 5 * This program is free software; you can redistribute it and/or modify it 6 * under the terms of version 2 of the GNU General Public License as 7 * published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 12 * more details. 13 * 14 * You should have received a copy of the GNU General Public License along with 15 * this program; if not, write to the Free Software Foundation, Inc., 16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA 17 * 18 * The full GNU General Public License is included in this distribution in the 19 * file called LICENSE. 20 * 21 * Contact Information: 22 * Intel Linux Wireless <ilw@linux.intel.com> 23 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 24 * 25 *****************************************************************************/ 26 27#include <linux/kernel.h> 28#include <linux/init.h> 29#include <linux/skbuff.h> 30#include <linux/slab.h> 31#include <linux/wireless.h> 32#include <net/mac80211.h> 33 34#include <linux/netdevice.h> 35#include <linux/etherdevice.h> 36#include <linux/delay.h> 37 38#include <linux/workqueue.h> 39 40#include "iwl-commands.h" 41#include "iwl-3945.h" 42#include "iwl-sta.h" 43 44#define RS_NAME "iwl-3945-rs" 45 46static s32 iwl3945_expected_tpt_g[IWL_RATE_COUNT_3945] = { 47 7, 13, 35, 58, 0, 0, 76, 104, 130, 168, 191, 202 48}; 49 50static s32 iwl3945_expected_tpt_g_prot[IWL_RATE_COUNT_3945] = { 51 7, 13, 35, 58, 0, 0, 0, 80, 93, 113, 123, 125 52}; 53 54static s32 iwl3945_expected_tpt_a[IWL_RATE_COUNT_3945] = { 55 0, 0, 0, 0, 40, 57, 72, 98, 121, 154, 177, 186 56}; 57 58static s32 iwl3945_expected_tpt_b[IWL_RATE_COUNT_3945] = { 59 7, 13, 35, 58, 0, 0, 0, 0, 0, 0, 0, 0 60}; 61 62struct iwl3945_tpt_entry { 63 s8 min_rssi; 64 u8 index; 65}; 66 67static struct iwl3945_tpt_entry iwl3945_tpt_table_a[] = { 68 {-60, IWL_RATE_54M_INDEX}, 69 {-64, IWL_RATE_48M_INDEX}, 70 {-72, IWL_RATE_36M_INDEX}, 71 {-80, IWL_RATE_24M_INDEX}, 72 {-84, IWL_RATE_18M_INDEX}, 73 {-85, IWL_RATE_12M_INDEX}, 74 {-87, IWL_RATE_9M_INDEX}, 75 {-89, IWL_RATE_6M_INDEX} 76}; 77 78static struct iwl3945_tpt_entry iwl3945_tpt_table_g[] = { 79 {-60, IWL_RATE_54M_INDEX}, 80 {-64, IWL_RATE_48M_INDEX}, 81 {-68, IWL_RATE_36M_INDEX}, 82 {-80, IWL_RATE_24M_INDEX}, 83 {-84, IWL_RATE_18M_INDEX}, 84 {-85, IWL_RATE_12M_INDEX}, 85 {-86, IWL_RATE_11M_INDEX}, 86 {-88, IWL_RATE_5M_INDEX}, 87 {-90, IWL_RATE_2M_INDEX}, 88 {-92, IWL_RATE_1M_INDEX} 89}; 90 91#define IWL_RATE_MAX_WINDOW 62 92#define IWL_RATE_FLUSH (3*HZ) 93#define IWL_RATE_WIN_FLUSH (HZ/2) 94#define IWL39_RATE_HIGH_TH 11520 95#define IWL_SUCCESS_UP_TH 8960 96#define IWL_SUCCESS_DOWN_TH 10880 97#define IWL_RATE_MIN_FAILURE_TH 6 98#define IWL_RATE_MIN_SUCCESS_TH 8 99#define IWL_RATE_DECREASE_TH 1920 100#define IWL_RATE_RETRY_TH 15 101 102static u8 iwl3945_get_rate_index_by_rssi(s32 rssi, enum ieee80211_band band) 103{ 104 u32 index = 0; 105 u32 table_size = 0; 106 struct iwl3945_tpt_entry *tpt_table = NULL; 107 108 if ((rssi < IWL_MIN_RSSI_VAL) || (rssi > IWL_MAX_RSSI_VAL)) 109 rssi = IWL_MIN_RSSI_VAL; 110 111 switch (band) { 112 case IEEE80211_BAND_2GHZ: 113 tpt_table = iwl3945_tpt_table_g; 114 table_size = ARRAY_SIZE(iwl3945_tpt_table_g); 115 break; 116 117 case IEEE80211_BAND_5GHZ: 118 tpt_table = iwl3945_tpt_table_a; 119 table_size = ARRAY_SIZE(iwl3945_tpt_table_a); 120 break; 121 122 default: 123 BUG(); 124 break; 125 } 126 127 while ((index < table_size) && (rssi < tpt_table[index].min_rssi)) 128 index++; 129 130 index = min(index, (table_size - 1)); 131 132 return tpt_table[index].index; 133} 134 135static void iwl3945_clear_window(struct iwl3945_rate_scale_data *window) 136{ 137 window->data = 0; 138 window->success_counter = 0; 139 window->success_ratio = -1; 140 window->counter = 0; 141 window->average_tpt = IWL_INVALID_VALUE; 142 window->stamp = 0; 143} 144 145/** 146 * iwl3945_rate_scale_flush_windows - flush out the rate scale windows 147 * 148 * Returns the number of windows that have gathered data but were 149 * not flushed. If there were any that were not flushed, then 150 * reschedule the rate flushing routine. 151 */ 152static int iwl3945_rate_scale_flush_windows(struct iwl3945_rs_sta *rs_sta) 153{ 154 int unflushed = 0; 155 int i; 156 unsigned long flags; 157 struct iwl_priv *priv __maybe_unused = rs_sta->priv; 158 159 /* 160 * For each rate, if we have collected data on that rate 161 * and it has been more than IWL_RATE_WIN_FLUSH 162 * since we flushed, clear out the gathered statistics 163 */ 164 for (i = 0; i < IWL_RATE_COUNT_3945; i++) { 165 if (!rs_sta->win[i].counter) 166 continue; 167 168 spin_lock_irqsave(&rs_sta->lock, flags); 169 if (time_after(jiffies, rs_sta->win[i].stamp + 170 IWL_RATE_WIN_FLUSH)) { 171 IWL_DEBUG_RATE(priv, "flushing %d samples of rate " 172 "index %d\n", 173 rs_sta->win[i].counter, i); 174 iwl3945_clear_window(&rs_sta->win[i]); 175 } else 176 unflushed++; 177 spin_unlock_irqrestore(&rs_sta->lock, flags); 178 } 179 180 return unflushed; 181} 182 183#define IWL_RATE_FLUSH_MAX 5000 /* msec */ 184#define IWL_RATE_FLUSH_MIN 50 /* msec */ 185#define IWL_AVERAGE_PACKETS 1500 186 187static void iwl3945_bg_rate_scale_flush(unsigned long data) 188{ 189 struct iwl3945_rs_sta *rs_sta = (void *)data; 190 struct iwl_priv *priv __maybe_unused = rs_sta->priv; 191 int unflushed = 0; 192 unsigned long flags; 193 u32 packet_count, duration, pps; 194 195 IWL_DEBUG_RATE(priv, "enter\n"); 196 197 unflushed = iwl3945_rate_scale_flush_windows(rs_sta); 198 199 spin_lock_irqsave(&rs_sta->lock, flags); 200 201 /* Number of packets Rx'd since last time this timer ran */ 202 packet_count = (rs_sta->tx_packets - rs_sta->last_tx_packets) + 1; 203 204 rs_sta->last_tx_packets = rs_sta->tx_packets + 1; 205 206 if (unflushed) { 207 duration = 208 jiffies_to_msecs(jiffies - rs_sta->last_partial_flush); 209 210 IWL_DEBUG_RATE(priv, "Tx'd %d packets in %dms\n", 211 packet_count, duration); 212 213 /* Determine packets per second */ 214 if (duration) 215 pps = (packet_count * 1000) / duration; 216 else 217 pps = 0; 218 219 if (pps) { 220 duration = (IWL_AVERAGE_PACKETS * 1000) / pps; 221 if (duration < IWL_RATE_FLUSH_MIN) 222 duration = IWL_RATE_FLUSH_MIN; 223 else if (duration > IWL_RATE_FLUSH_MAX) 224 duration = IWL_RATE_FLUSH_MAX; 225 } else 226 duration = IWL_RATE_FLUSH_MAX; 227 228 rs_sta->flush_time = msecs_to_jiffies(duration); 229 230 IWL_DEBUG_RATE(priv, "new flush period: %d msec ave %d\n", 231 duration, packet_count); 232 233 mod_timer(&rs_sta->rate_scale_flush, jiffies + 234 rs_sta->flush_time); 235 236 rs_sta->last_partial_flush = jiffies; 237 } else { 238 rs_sta->flush_time = IWL_RATE_FLUSH; 239 rs_sta->flush_pending = 0; 240 } 241 /* If there weren't any unflushed entries, we don't schedule the timer 242 * to run again */ 243 244 rs_sta->last_flush = jiffies; 245 246 spin_unlock_irqrestore(&rs_sta->lock, flags); 247 248 IWL_DEBUG_RATE(priv, "leave\n"); 249} 250 251/** 252 * iwl3945_collect_tx_data - Update the success/failure sliding window 253 * 254 * We keep a sliding window of the last 64 packets transmitted 255 * at this rate. window->data contains the bitmask of successful 256 * packets. 257 */ 258static void iwl3945_collect_tx_data(struct iwl3945_rs_sta *rs_sta, 259 struct iwl3945_rate_scale_data *window, 260 int success, int retries, int index) 261{ 262 unsigned long flags; 263 s32 fail_count; 264 struct iwl_priv *priv __maybe_unused = rs_sta->priv; 265 266 if (!retries) { 267 IWL_DEBUG_RATE(priv, "leave: retries == 0 -- should be at least 1\n"); 268 return; 269 } 270 271 spin_lock_irqsave(&rs_sta->lock, flags); 272 273 /* 274 * Keep track of only the latest 62 tx frame attempts in this rate's 275 * history window; anything older isn't really relevant any more. 276 * If we have filled up the sliding window, drop the oldest attempt; 277 * if the oldest attempt (highest bit in bitmap) shows "success", 278 * subtract "1" from the success counter (this is the main reason 279 * we keep these bitmaps!). 280 * */ 281 while (retries > 0) { 282 if (window->counter >= IWL_RATE_MAX_WINDOW) { 283 284 /* remove earliest */ 285 window->counter = IWL_RATE_MAX_WINDOW - 1; 286 287 if (window->data & (1ULL << (IWL_RATE_MAX_WINDOW - 1))) { 288 window->data &= ~(1ULL << (IWL_RATE_MAX_WINDOW - 1)); 289 window->success_counter--; 290 } 291 } 292 293 /* Increment frames-attempted counter */ 294 window->counter++; 295 296 /* Shift bitmap by one frame (throw away oldest history), 297 * OR in "1", and increment "success" if this 298 * frame was successful. */ 299 window->data <<= 1; 300 if (success > 0) { 301 window->success_counter++; 302 window->data |= 0x1; 303 success--; 304 } 305 306 retries--; 307 } 308 309 /* Calculate current success ratio, avoid divide-by-0! */ 310 if (window->counter > 0) 311 window->success_ratio = 128 * (100 * window->success_counter) 312 / window->counter; 313 else 314 window->success_ratio = IWL_INVALID_VALUE; 315 316 fail_count = window->counter - window->success_counter; 317 318 /* Calculate average throughput, if we have enough history. */ 319 if ((fail_count >= IWL_RATE_MIN_FAILURE_TH) || 320 (window->success_counter >= IWL_RATE_MIN_SUCCESS_TH)) 321 window->average_tpt = ((window->success_ratio * 322 rs_sta->expected_tpt[index] + 64) / 128); 323 else 324 window->average_tpt = IWL_INVALID_VALUE; 325 326 /* Tag this window as having been updated */ 327 window->stamp = jiffies; 328 329 spin_unlock_irqrestore(&rs_sta->lock, flags); 330 331} 332 333/* 334 * Called after adding a new station to initialize rate scaling 335 */ 336void iwl3945_rs_rate_init(struct iwl_priv *priv, struct ieee80211_sta *sta, u8 sta_id) 337{ 338 struct ieee80211_hw *hw = priv->hw; 339 struct ieee80211_conf *conf = &priv->hw->conf; 340 struct iwl3945_sta_priv *psta; 341 struct iwl3945_rs_sta *rs_sta; 342 struct ieee80211_supported_band *sband; 343 int i; 344 345 IWL_DEBUG_INFO(priv, "enter\n"); 346 if (sta_id == priv->hw_params.bcast_sta_id) 347 goto out; 348 349 psta = (struct iwl3945_sta_priv *) sta->drv_priv; 350 rs_sta = &psta->rs_sta; 351 sband = hw->wiphy->bands[conf->channel->band]; 352 353 rs_sta->priv = priv; 354 355 rs_sta->start_rate = IWL_RATE_INVALID; 356 357 /* default to just 802.11b */ 358 rs_sta->expected_tpt = iwl3945_expected_tpt_b; 359 360 rs_sta->last_partial_flush = jiffies; 361 rs_sta->last_flush = jiffies; 362 rs_sta->flush_time = IWL_RATE_FLUSH; 363 rs_sta->last_tx_packets = 0; 364 365 rs_sta->rate_scale_flush.data = (unsigned long)rs_sta; 366 rs_sta->rate_scale_flush.function = iwl3945_bg_rate_scale_flush; 367 368 for (i = 0; i < IWL_RATE_COUNT_3945; i++) 369 iwl3945_clear_window(&rs_sta->win[i]); 370 371 /* TODO: what is a good starting rate for STA? About middle? Maybe not 372 * the lowest or the highest rate.. Could consider using RSSI from 373 * previous packets? Need to have IEEE 802.1X auth succeed immediately 374 * after assoc.. */ 375 376 for (i = sband->n_bitrates - 1; i >= 0; i--) { 377 if (sta->supp_rates[sband->band] & (1 << i)) { 378 rs_sta->last_txrate_idx = i; 379 break; 380 } 381 } 382 383 priv->_3945.sta_supp_rates = sta->supp_rates[sband->band]; 384 /* For 5 GHz band it start at IWL_FIRST_OFDM_RATE */ 385 if (sband->band == IEEE80211_BAND_5GHZ) { 386 rs_sta->last_txrate_idx += IWL_FIRST_OFDM_RATE; 387 priv->_3945.sta_supp_rates = priv->_3945.sta_supp_rates << 388 IWL_FIRST_OFDM_RATE; 389 } 390 391out: 392 priv->stations[sta_id].used &= ~IWL_STA_UCODE_INPROGRESS; 393 394 IWL_DEBUG_INFO(priv, "leave\n"); 395} 396 397static void *rs_alloc(struct ieee80211_hw *hw, struct dentry *debugfsdir) 398{ 399 return hw->priv; 400} 401 402/* rate scale requires free function to be implemented */ 403static void rs_free(void *priv) 404{ 405 return; 406} 407 408static void *rs_alloc_sta(void *iwl_priv, struct ieee80211_sta *sta, gfp_t gfp) 409{ 410 struct iwl3945_rs_sta *rs_sta; 411 struct iwl3945_sta_priv *psta = (void *) sta->drv_priv; 412 struct iwl_priv *priv __maybe_unused = iwl_priv; 413 414 IWL_DEBUG_RATE(priv, "enter\n"); 415 416 rs_sta = &psta->rs_sta; 417 418 spin_lock_init(&rs_sta->lock); 419 init_timer(&rs_sta->rate_scale_flush); 420 421 IWL_DEBUG_RATE(priv, "leave\n"); 422 423 return rs_sta; 424} 425 426static void rs_free_sta(void *iwl_priv, struct ieee80211_sta *sta, 427 void *priv_sta) 428{ 429 struct iwl3945_rs_sta *rs_sta = priv_sta; 430 431 /* 432 * Be careful not to use any members of iwl3945_rs_sta (like trying 433 * to use iwl_priv to print out debugging) since it may not be fully 434 * initialized at this point. 435 */ 436 del_timer_sync(&rs_sta->rate_scale_flush); 437} 438 439 440/** 441 * rs_tx_status - Update rate control values based on Tx results 442 * 443 * NOTE: Uses iwl_priv->retry_rate for the # of retries attempted by 444 * the hardware for each rate. 445 */ 446static void rs_tx_status(void *priv_rate, struct ieee80211_supported_band *sband, 447 struct ieee80211_sta *sta, void *priv_sta, 448 struct sk_buff *skb) 449{ 450 s8 retries = 0, current_count; 451 int scale_rate_index, first_index, last_index; 452 unsigned long flags; 453 struct iwl_priv *priv = (struct iwl_priv *)priv_rate; 454 struct iwl3945_rs_sta *rs_sta = priv_sta; 455 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 456 457 IWL_DEBUG_RATE(priv, "enter\n"); 458 459 retries = info->status.rates[0].count; 460 /* Sanity Check for retries */ 461 if (retries > IWL_RATE_RETRY_TH) 462 retries = IWL_RATE_RETRY_TH; 463 464 first_index = sband->bitrates[info->status.rates[0].idx].hw_value; 465 if ((first_index < 0) || (first_index >= IWL_RATE_COUNT_3945)) { 466 IWL_DEBUG_RATE(priv, "leave: Rate out of bounds: %d\n", first_index); 467 return; 468 } 469 470 if (!priv_sta) { 471 IWL_DEBUG_RATE(priv, "leave: No STA priv data to update!\n"); 472 return; 473 } 474 475 /* Treat uninitialized rate scaling data same as non-existing. */ 476 if (!rs_sta->priv) { 477 IWL_DEBUG_RATE(priv, "leave: STA priv data uninitialized!\n"); 478 return; 479 } 480 481 482 rs_sta->tx_packets++; 483 484 scale_rate_index = first_index; 485 last_index = first_index; 486 487 /* 488 * Update the window for each rate. We determine which rates 489 * were Tx'd based on the total number of retries vs. the number 490 * of retries configured for each rate -- currently set to the 491 * priv value 'retry_rate' vs. rate specific 492 * 493 * On exit from this while loop last_index indicates the rate 494 * at which the frame was finally transmitted (or failed if no 495 * ACK) 496 */ 497 while (retries > 1) { 498 if ((retries - 1) < priv->retry_rate) { 499 current_count = (retries - 1); 500 last_index = scale_rate_index; 501 } else { 502 current_count = priv->retry_rate; 503 last_index = iwl3945_rs_next_rate(priv, 504 scale_rate_index); 505 } 506 507 /* Update this rate accounting for as many retries 508 * as was used for it (per current_count) */ 509 iwl3945_collect_tx_data(rs_sta, 510 &rs_sta->win[scale_rate_index], 511 0, current_count, scale_rate_index); 512 IWL_DEBUG_RATE(priv, "Update rate %d for %d retries.\n", 513 scale_rate_index, current_count); 514 515 retries -= current_count; 516 517 scale_rate_index = last_index; 518 } 519 520 521 /* Update the last index window with success/failure based on ACK */ 522 IWL_DEBUG_RATE(priv, "Update rate %d with %s.\n", 523 last_index, 524 (info->flags & IEEE80211_TX_STAT_ACK) ? 525 "success" : "failure"); 526 iwl3945_collect_tx_data(rs_sta, 527 &rs_sta->win[last_index], 528 info->flags & IEEE80211_TX_STAT_ACK, 1, last_index); 529 530 /* We updated the rate scale window -- if its been more than 531 * flush_time since the last run, schedule the flush 532 * again */ 533 spin_lock_irqsave(&rs_sta->lock, flags); 534 535 if (!rs_sta->flush_pending && 536 time_after(jiffies, rs_sta->last_flush + 537 rs_sta->flush_time)) { 538 539 rs_sta->last_partial_flush = jiffies; 540 rs_sta->flush_pending = 1; 541 mod_timer(&rs_sta->rate_scale_flush, 542 jiffies + rs_sta->flush_time); 543 } 544 545 spin_unlock_irqrestore(&rs_sta->lock, flags); 546 547 IWL_DEBUG_RATE(priv, "leave\n"); 548} 549 550static u16 iwl3945_get_adjacent_rate(struct iwl3945_rs_sta *rs_sta, 551 u8 index, u16 rate_mask, enum ieee80211_band band) 552{ 553 u8 high = IWL_RATE_INVALID; 554 u8 low = IWL_RATE_INVALID; 555 struct iwl_priv *priv __maybe_unused = rs_sta->priv; 556 557 /* 802.11A walks to the next literal adjacent rate in 558 * the rate table */ 559 if (unlikely(band == IEEE80211_BAND_5GHZ)) { 560 int i; 561 u32 mask; 562 563 /* Find the previous rate that is in the rate mask */ 564 i = index - 1; 565 for (mask = (1 << i); i >= 0; i--, mask >>= 1) { 566 if (rate_mask & mask) { 567 low = i; 568 break; 569 } 570 } 571 572 /* Find the next rate that is in the rate mask */ 573 i = index + 1; 574 for (mask = (1 << i); i < IWL_RATE_COUNT_3945; 575 i++, mask <<= 1) { 576 if (rate_mask & mask) { 577 high = i; 578 break; 579 } 580 } 581 582 return (high << 8) | low; 583 } 584 585 low = index; 586 while (low != IWL_RATE_INVALID) { 587 if (rs_sta->tgg) 588 low = iwl3945_rates[low].prev_rs_tgg; 589 else 590 low = iwl3945_rates[low].prev_rs; 591 if (low == IWL_RATE_INVALID) 592 break; 593 if (rate_mask & (1 << low)) 594 break; 595 IWL_DEBUG_RATE(priv, "Skipping masked lower rate: %d\n", low); 596 } 597 598 high = index; 599 while (high != IWL_RATE_INVALID) { 600 if (rs_sta->tgg) 601 high = iwl3945_rates[high].next_rs_tgg; 602 else 603 high = iwl3945_rates[high].next_rs; 604 if (high == IWL_RATE_INVALID) 605 break; 606 if (rate_mask & (1 << high)) 607 break; 608 IWL_DEBUG_RATE(priv, "Skipping masked higher rate: %d\n", high); 609 } 610 611 return (high << 8) | low; 612} 613 614/** 615 * rs_get_rate - find the rate for the requested packet 616 * 617 * Returns the ieee80211_rate structure allocated by the driver. 618 * 619 * The rate control algorithm has no internal mapping between hw_mode's 620 * rate ordering and the rate ordering used by the rate control algorithm. 621 * 622 * The rate control algorithm uses a single table of rates that goes across 623 * the entire A/B/G spectrum vs. being limited to just one particular 624 * hw_mode. 625 * 626 * As such, we can't convert the index obtained below into the hw_mode's 627 * rate table and must reference the driver allocated rate table 628 * 629 */ 630static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta, 631 void *priv_sta, struct ieee80211_tx_rate_control *txrc) 632{ 633 struct ieee80211_supported_band *sband = txrc->sband; 634 struct sk_buff *skb = txrc->skb; 635 u8 low = IWL_RATE_INVALID; 636 u8 high = IWL_RATE_INVALID; 637 u16 high_low; 638 int index; 639 struct iwl3945_rs_sta *rs_sta = priv_sta; 640 struct iwl3945_rate_scale_data *window = NULL; 641 int current_tpt = IWL_INVALID_VALUE; 642 int low_tpt = IWL_INVALID_VALUE; 643 int high_tpt = IWL_INVALID_VALUE; 644 u32 fail_count; 645 s8 scale_action = 0; 646 unsigned long flags; 647 u16 rate_mask = sta ? sta->supp_rates[sband->band] : 0; 648 s8 max_rate_idx = -1; 649 struct iwl_priv *priv __maybe_unused = (struct iwl_priv *)priv_r; 650 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 651 652 IWL_DEBUG_RATE(priv, "enter\n"); 653 654 /* Treat uninitialized rate scaling data same as non-existing. */ 655 if (rs_sta && !rs_sta->priv) { 656 IWL_DEBUG_RATE(priv, "Rate scaling information not initialized yet.\n"); 657 priv_sta = NULL; 658 } 659 660 if (rate_control_send_low(sta, priv_sta, txrc)) 661 return; 662 663 rate_mask = sta->supp_rates[sband->band]; 664 665 /* get user max rate if set */ 666 max_rate_idx = txrc->max_rate_idx; 667 if ((sband->band == IEEE80211_BAND_5GHZ) && (max_rate_idx != -1)) 668 max_rate_idx += IWL_FIRST_OFDM_RATE; 669 if ((max_rate_idx < 0) || (max_rate_idx >= IWL_RATE_COUNT)) 670 max_rate_idx = -1; 671 672 index = min(rs_sta->last_txrate_idx & 0xffff, IWL_RATE_COUNT_3945 - 1); 673 674 if (sband->band == IEEE80211_BAND_5GHZ) 675 rate_mask = rate_mask << IWL_FIRST_OFDM_RATE; 676 677 spin_lock_irqsave(&rs_sta->lock, flags); 678 679 /* for recent assoc, choose best rate regarding 680 * to rssi value 681 */ 682 if (rs_sta->start_rate != IWL_RATE_INVALID) { 683 if (rs_sta->start_rate < index && 684 (rate_mask & (1 << rs_sta->start_rate))) 685 index = rs_sta->start_rate; 686 rs_sta->start_rate = IWL_RATE_INVALID; 687 } 688 689 /* force user max rate if set by user */ 690 if ((max_rate_idx != -1) && (max_rate_idx < index)) { 691 if (rate_mask & (1 << max_rate_idx)) 692 index = max_rate_idx; 693 } 694 695 window = &(rs_sta->win[index]); 696 697 fail_count = window->counter - window->success_counter; 698 699 if (((fail_count < IWL_RATE_MIN_FAILURE_TH) && 700 (window->success_counter < IWL_RATE_MIN_SUCCESS_TH))) { 701 spin_unlock_irqrestore(&rs_sta->lock, flags); 702 703 IWL_DEBUG_RATE(priv, "Invalid average_tpt on rate %d: " 704 "counter: %d, success_counter: %d, " 705 "expected_tpt is %sNULL\n", 706 index, 707 window->counter, 708 window->success_counter, 709 rs_sta->expected_tpt ? "not " : ""); 710 711 /* Can't calculate this yet; not enough history */ 712 window->average_tpt = IWL_INVALID_VALUE; 713 goto out; 714 715 } 716 717 current_tpt = window->average_tpt; 718 719 high_low = iwl3945_get_adjacent_rate(rs_sta, index, rate_mask, 720 sband->band); 721 low = high_low & 0xff; 722 high = (high_low >> 8) & 0xff; 723 724 /* If user set max rate, dont allow higher than user constrain */ 725 if ((max_rate_idx != -1) && (max_rate_idx < high)) 726 high = IWL_RATE_INVALID; 727 728 /* Collect Measured throughputs of adjacent rates */ 729 if (low != IWL_RATE_INVALID) 730 low_tpt = rs_sta->win[low].average_tpt; 731 732 if (high != IWL_RATE_INVALID) 733 high_tpt = rs_sta->win[high].average_tpt; 734 735 spin_unlock_irqrestore(&rs_sta->lock, flags); 736 737 scale_action = 0; 738 739 /* Low success ratio , need to drop the rate */ 740 if ((window->success_ratio < IWL_RATE_DECREASE_TH) || !current_tpt) { 741 IWL_DEBUG_RATE(priv, "decrease rate because of low success_ratio\n"); 742 scale_action = -1; 743 /* No throughput measured yet for adjacent rates, 744 * try increase */ 745 } else if ((low_tpt == IWL_INVALID_VALUE) && 746 (high_tpt == IWL_INVALID_VALUE)) { 747 748 if (high != IWL_RATE_INVALID && window->success_ratio >= IWL_RATE_INCREASE_TH) 749 scale_action = 1; 750 else if (low != IWL_RATE_INVALID) 751 scale_action = 0; 752 753 /* Both adjacent throughputs are measured, but neither one has 754 * better throughput; we're using the best rate, don't change 755 * it! */ 756 } else if ((low_tpt != IWL_INVALID_VALUE) && 757 (high_tpt != IWL_INVALID_VALUE) && 758 (low_tpt < current_tpt) && (high_tpt < current_tpt)) { 759 760 IWL_DEBUG_RATE(priv, "No action -- low [%d] & high [%d] < " 761 "current_tpt [%d]\n", 762 low_tpt, high_tpt, current_tpt); 763 scale_action = 0; 764 765 /* At least one of the rates has better throughput */ 766 } else { 767 if (high_tpt != IWL_INVALID_VALUE) { 768 769 /* High rate has better throughput, Increase 770 * rate */ 771 if (high_tpt > current_tpt && 772 window->success_ratio >= IWL_RATE_INCREASE_TH) 773 scale_action = 1; 774 else { 775 IWL_DEBUG_RATE(priv, 776 "decrease rate because of high tpt\n"); 777 scale_action = 0; 778 } 779 } else if (low_tpt != IWL_INVALID_VALUE) { 780 if (low_tpt > current_tpt) { 781 IWL_DEBUG_RATE(priv, 782 "decrease rate because of low tpt\n"); 783 scale_action = -1; 784 } else if (window->success_ratio >= IWL_RATE_INCREASE_TH) { 785 /* Lower rate has better 786 * throughput,decrease rate */ 787 scale_action = 1; 788 } 789 } 790 } 791 792 /* Sanity check; asked for decrease, but success rate or throughput 793 * has been good at old rate. Don't change it. */ 794 if ((scale_action == -1) && (low != IWL_RATE_INVALID) && 795 ((window->success_ratio > IWL_RATE_HIGH_TH) || 796 (current_tpt > (100 * rs_sta->expected_tpt[low])))) 797 scale_action = 0; 798 799 switch (scale_action) { 800 case -1: 801 802 /* Decrese rate */ 803 if (low != IWL_RATE_INVALID) 804 index = low; 805 break; 806 807 case 1: 808 /* Increase rate */ 809 if (high != IWL_RATE_INVALID) 810 index = high; 811 812 break; 813 814 case 0: 815 default: 816 /* No change */ 817 break; 818 } 819 820 IWL_DEBUG_RATE(priv, "Selected %d (action %d) - low %d high %d\n", 821 index, scale_action, low, high); 822 823 out: 824 825 rs_sta->last_txrate_idx = index; 826 if (sband->band == IEEE80211_BAND_5GHZ) 827 info->control.rates[0].idx = rs_sta->last_txrate_idx - 828 IWL_FIRST_OFDM_RATE; 829 else 830 info->control.rates[0].idx = rs_sta->last_txrate_idx; 831 832 IWL_DEBUG_RATE(priv, "leave: %d\n", index); 833} 834 835#ifdef CONFIG_MAC80211_DEBUGFS 836static int iwl3945_open_file_generic(struct inode *inode, struct file *file) 837{ 838 file->private_data = inode->i_private; 839 return 0; 840} 841 842static ssize_t iwl3945_sta_dbgfs_stats_table_read(struct file *file, 843 char __user *user_buf, 844 size_t count, loff_t *ppos) 845{ 846 char *buff; 847 int desc = 0; 848 int j; 849 ssize_t ret; 850 struct iwl3945_rs_sta *lq_sta = file->private_data; 851 852 buff = kmalloc(1024, GFP_KERNEL); 853 if (!buff) 854 return -ENOMEM; 855 856 desc += sprintf(buff + desc, "tx packets=%d last rate index=%d\n" 857 "rate=0x%X flush time %d\n", 858 lq_sta->tx_packets, 859 lq_sta->last_txrate_idx, 860 lq_sta->start_rate, jiffies_to_msecs(lq_sta->flush_time)); 861 for (j = 0; j < IWL_RATE_COUNT_3945; j++) { 862 desc += sprintf(buff+desc, 863 "counter=%d success=%d %%=%d\n", 864 lq_sta->win[j].counter, 865 lq_sta->win[j].success_counter, 866 lq_sta->win[j].success_ratio); 867 } 868 ret = simple_read_from_buffer(user_buf, count, ppos, buff, desc); 869 kfree(buff); 870 return ret; 871} 872 873static const struct file_operations rs_sta_dbgfs_stats_table_ops = { 874 .read = iwl3945_sta_dbgfs_stats_table_read, 875 .open = iwl3945_open_file_generic, 876}; 877 878static void iwl3945_add_debugfs(void *priv, void *priv_sta, 879 struct dentry *dir) 880{ 881 struct iwl3945_rs_sta *lq_sta = priv_sta; 882 883 lq_sta->rs_sta_dbgfs_stats_table_file = 884 debugfs_create_file("rate_stats_table", 0600, dir, 885 lq_sta, &rs_sta_dbgfs_stats_table_ops); 886 887} 888 889static void iwl3945_remove_debugfs(void *priv, void *priv_sta) 890{ 891 struct iwl3945_rs_sta *lq_sta = priv_sta; 892 debugfs_remove(lq_sta->rs_sta_dbgfs_stats_table_file); 893} 894#endif 895 896/* 897 * Initialization of rate scaling information is done by driver after 898 * the station is added. Since mac80211 calls this function before a 899 * station is added we ignore it. 900 */ 901static void rs_rate_init_stub(void *priv_r, struct ieee80211_supported_band *sband, 902 struct ieee80211_sta *sta, void *priv_sta) 903{ 904} 905 906static struct rate_control_ops rs_ops = { 907 .module = NULL, 908 .name = RS_NAME, 909 .tx_status = rs_tx_status, 910 .get_rate = rs_get_rate, 911 .rate_init = rs_rate_init_stub, 912 .alloc = rs_alloc, 913 .free = rs_free, 914 .alloc_sta = rs_alloc_sta, 915 .free_sta = rs_free_sta, 916#ifdef CONFIG_MAC80211_DEBUGFS 917 .add_sta_debugfs = iwl3945_add_debugfs, 918 .remove_sta_debugfs = iwl3945_remove_debugfs, 919#endif 920 921}; 922void iwl3945_rate_scale_init(struct ieee80211_hw *hw, s32 sta_id) 923{ 924 struct iwl_priv *priv = hw->priv; 925 s32 rssi = 0; 926 unsigned long flags; 927 struct iwl3945_rs_sta *rs_sta; 928 struct ieee80211_sta *sta; 929 struct iwl3945_sta_priv *psta; 930 931 IWL_DEBUG_RATE(priv, "enter\n"); 932 933 rcu_read_lock(); 934 935 sta = ieee80211_find_sta(priv->vif, 936 priv->stations[sta_id].sta.sta.addr); 937 if (!sta) { 938 IWL_DEBUG_RATE(priv, "Unable to find station to initialize rate scaling.\n"); 939 rcu_read_unlock(); 940 return; 941 } 942 943 psta = (void *) sta->drv_priv; 944 rs_sta = &psta->rs_sta; 945 946 spin_lock_irqsave(&rs_sta->lock, flags); 947 948 rs_sta->tgg = 0; 949 switch (priv->band) { 950 case IEEE80211_BAND_2GHZ: 951 /* TODO: this always does G, not a regression */ 952 if (priv->active_rxon.flags & RXON_FLG_TGG_PROTECT_MSK) { 953 rs_sta->tgg = 1; 954 rs_sta->expected_tpt = iwl3945_expected_tpt_g_prot; 955 } else 956 rs_sta->expected_tpt = iwl3945_expected_tpt_g; 957 break; 958 959 case IEEE80211_BAND_5GHZ: 960 rs_sta->expected_tpt = iwl3945_expected_tpt_a; 961 break; 962 case IEEE80211_NUM_BANDS: 963 BUG(); 964 break; 965 } 966 967 spin_unlock_irqrestore(&rs_sta->lock, flags); 968 969 rssi = priv->_3945.last_rx_rssi; 970 if (rssi == 0) 971 rssi = IWL_MIN_RSSI_VAL; 972 973 IWL_DEBUG_RATE(priv, "Network RSSI: %d\n", rssi); 974 975 rs_sta->start_rate = iwl3945_get_rate_index_by_rssi(rssi, priv->band); 976 977 IWL_DEBUG_RATE(priv, "leave: rssi %d assign rate index: " 978 "%d (plcp 0x%x)\n", rssi, rs_sta->start_rate, 979 iwl3945_rates[rs_sta->start_rate].plcp); 980 rcu_read_unlock(); 981} 982 983int iwl3945_rate_control_register(void) 984{ 985 return ieee80211_rate_control_register(&rs_ops); 986} 987 988void iwl3945_rate_control_unregister(void) 989{ 990 ieee80211_rate_control_unregister(&rs_ops); 991} 992