drivers/net/wireless/intel/iwlegacy/3945-rs.c

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