sys/dev/ath/ath_rate/sample/sample.c

   1 /*-
   2  * Copyright (c) 2005 John Bicket
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer,
  10  *    without modification.
  11  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  12  *    similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
  13  *    redistribution must be conditioned upon including a substantially
  14  *    similar Disclaimer requirement for further binary redistribution.
  15  * 3. Neither the names of the above-listed copyright holders nor the names
  16  *    of any contributors may be used to endorse or promote products derived
  17  *    from this software without specific prior written permission.
  18  *
  19  * Alternatively, this software may be distributed under the terms of the
  20  * GNU General Public License ("GPL") version 2 as published by the Free
  21  * Software Foundation.
  22  *
  23  * NO WARRANTY
  24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  25  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  26  * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
  27  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
  28  * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
  29  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  30  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  31  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  32  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  33  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  34  * THE POSSIBILITY OF SUCH DAMAGES.
  35  *
  36  */
  37
  38 #include <sys/cdefs.h>
  39 __FBSDID("$FreeBSD$");
  40
  41 /*
  42  * John Bicket's SampleRate control algorithm.
  43  */
  44 #include "opt_inet.h"
  45 #include "opt_wlan.h"
  46
  47 #include <sys/param.h>
  48 #include <sys/systm.h>
  49 #include <sys/sysctl.h>
  50 #include <sys/module.h>
  51 #include <sys/kernel.h>
  52 #include <sys/lock.h>
  53 #include <sys/mutex.h>
  54 #include <sys/errno.h>
  55
  56 #include <machine/bus.h>
  57 #include <machine/resource.h>
  58 #include <sys/bus.h>
  59
  60 #include <sys/socket.h>
  61
  62 #include <net/if.h>
  63 #include <net/if_media.h>
  64 #include <net/if_arp.h>
  65
  66 #include <net80211/ieee80211_var.h>
  67
  68 #include <net/bpf.h>
  69
  70 #ifdef INET
  71 #include <netinet/in.h>
  72 #include <netinet/if_ether.h>
  73 #endif
  74
  75 #include <dev/ath/if_athvar.h>
  76 #include <dev/ath/ath_rate/sample/sample.h>
  77 #include <contrib/dev/ath/ah_desc.h>
  78
  79 /*
  80  * This file is an implementation of the SampleRate algorithm
  81  * in "Bit-rate Selection in Wireless Networks"
  82  * (http://www.pdos.lcs.mit.edu/papers/jbicket-ms.ps)
  83  *
  84  * SampleRate chooses the bit-rate it predicts will provide the most
  85  * throughput based on estimates of the expected per-packet
  86  * transmission time for each bit-rate.  SampleRate periodically sends
  87  * packets at bit-rates other than the current one to estimate when
  88  * another bit-rate will provide better performance. SampleRate
  89  * switches to another bit-rate when its estimated per-packet
  90  * transmission time becomes smaller than the current bit-rate's.
  91  * SampleRate reduces the number of bit-rates it must sample by
  92  * eliminating those that could not perform better than the one
  93  * currently being used.  SampleRate also stops probing at a bit-rate
  94  * if it experiences several successive losses.
  95  *
  96  * The difference between the algorithm in the thesis and the one in this
  97  * file is that the one in this file uses a ewma instead of a window.
  98  *
  99  * Also, this implementation tracks the average transmission time for
 100  * a few different packet sizes independently for each link.
 101  */
 102
 103 #define STALE_FAILURE_TIMEOUT_MS 10000
 104 #define MIN_SWITCH_MS 1000
 105
 106 static void     ath_rate_ctl_reset(struct ath_softc *, struct ieee80211_node *);
 107
 108 static __inline int
 109 size_to_bin(int size)
 110 {
 111         int x = 0;
 112         for (x = 0; x < NUM_PACKET_SIZE_BINS; x++) {
 113                 if (size <= packet_size_bins[x]) {
 114                         return x;
 115                 }
 116         }
 117         return NUM_PACKET_SIZE_BINS-1;
 118 }
 119 static __inline int
 120 bin_to_size(int index) {
 121         return packet_size_bins[index];
 122 }
 123
 124 static __inline int
 125 rate_to_ndx(struct sample_node *sn, int rate) {
 126         int x = 0;
 127         for (x = 0; x < sn->num_rates; x++) {
 128                 if (sn->rates[x].rate == rate) {
 129                         return x;
 130                 }
 131         }
 132         return -1;
 133 }
 134
 135 void
 136 ath_rate_node_init(struct ath_softc *sc, struct ath_node *an)
 137 {
 138         /* NB: assumed to be zero'd by caller */
 139 }
 140
 141 void
 142 ath_rate_node_cleanup(struct ath_softc *sc, struct ath_node *an)
 143 {
 144 }
 145
 146
 147 /*
 148  * returns the ndx with the lowest average_tx_time,
 149  * or -1 if all the average_tx_times are 0.
 150  */
 151 static __inline int best_rate_ndx(struct sample_node *sn, int size_bin,
 152                                   int require_acked_before)
 153 {
 154         int x = 0;
 155         int best_rate_ndx = 0;
 156         int best_rate_tt = 0;
 157         for (x = 0; x < sn->num_rates; x++) {
 158                 int tt = sn->stats[size_bin][x].average_tx_time;
 159                 if (tt <= 0 || (require_acked_before &&
 160                                 !sn->stats[size_bin][x].packets_acked)) {
 161                         continue;
 162                 }
 163
 164                 /* 9 megabits never works better than 12 */
 165                 if (sn->rates[x].rate == 18)
 166                         continue;
 167
 168                 /* don't use a bit-rate that has been failing */
 169                 if (sn->stats[size_bin][x].successive_failures > 3)
 170                         continue;
 171
 172                 if (!best_rate_tt || best_rate_tt > tt) {
 173                         best_rate_tt = tt;
 174                         best_rate_ndx = x;
 175                 }
 176         }
 177         return (best_rate_tt) ? best_rate_ndx : -1;
 178 }
 179
 180 /*
 181  * pick a good "random" bit-rate to sample other than the current one
 182  */
 183 static __inline int
 184 pick_sample_ndx(struct sample_node *sn, int size_bin)
 185 {
 186         int x = 0;
 187         int current_ndx = 0;
 188         unsigned current_tt = 0;
 189
 190         current_ndx = sn->current_rate[size_bin];
 191         if (current_ndx < 0) {
 192                 /* no successes yet, send at the lowest bit-rate */
 193                 return 0;
 194         }
 195
 196         current_tt = sn->stats[size_bin][current_ndx].average_tx_time;
 197
 198         for (x = 0; x < sn->num_rates; x++) {
 199                 int ndx = (sn->last_sample_ndx[size_bin]+1+x) % sn->num_rates;
 200
 201                 /* don't sample the current bit-rate */
 202                 if (ndx == current_ndx)
 203                         continue;
 204
 205                 /* this bit-rate is always worse than the current one */
 206                 if (sn->stats[size_bin][ndx].perfect_tx_time > current_tt)
 207                         continue;
 208
 209                 /* rarely sample bit-rates that fail a lot */
 210                 if (ticks - sn->stats[size_bin][ndx].last_tx < ((hz * STALE_FAILURE_TIMEOUT_MS)/1000) &&
 211                     sn->stats[size_bin][ndx].successive_failures > 3)
 212                         continue;
 213
 214                 /* don't sample more than 2 indexes higher
 215                  * for rates higher than 11 megabits
 216                  */
 217                 if (sn->rates[ndx].rate > 22 && ndx > current_ndx + 2)
 218                         continue;
 219
 220                 /* 9 megabits never works better than 12 */
 221                 if (sn->rates[ndx].rate == 18)
 222                         continue;
 223
 224                 /* if we're using 11 megabits, only sample up to 12 megabits
 225                  */
 226                 if (sn->rates[current_ndx].rate == 22 && ndx > current_ndx + 1)
 227                         continue;
 228
 229                 sn->last_sample_ndx[size_bin] = ndx;
 230                 return ndx;
 231         }
 232         return current_ndx;
 233 }
 234
 235 void
 236 ath_rate_findrate(struct ath_softc *sc, struct ath_node *an,
 237                   int shortPreamble, size_t frameLen,
 238                   u_int8_t *rix, int *try0, u_int8_t *txrate)
 239 {
 240         struct sample_node *sn = ATH_NODE_SAMPLE(an);
 241         struct sample_softc *ssc = ATH_SOFTC_SAMPLE(sc);
 242         struct ifnet *ifp = sc->sc_ifp;
 243         struct ieee80211com *ic = ifp->if_l2com;
 244         int ndx, size_bin, mrr, best_ndx, change_rates;
 245         unsigned average_tx_time;
 246
 247         mrr = sc->sc_mrretry && !(ic->ic_flags & IEEE80211_F_USEPROT);
 248         size_bin = size_to_bin(frameLen);
 249         best_ndx = best_rate_ndx(sn, size_bin, !mrr);
 250
 251         if (best_ndx >= 0) {
 252                 average_tx_time = sn->stats[size_bin][best_ndx].average_tx_time;
 253         } else {
 254                 average_tx_time = 0;
 255         }
 256
 257         if (sn->static_rate_ndx != -1) {
 258                 ndx = sn->static_rate_ndx;
 259                 *try0 = ATH_TXMAXTRY;
 260         } else {
 261                 *try0 = mrr ? 2 : ATH_TXMAXTRY;
 262
 263                 if (sn->sample_tt[size_bin] < average_tx_time * (sn->packets_since_sample[size_bin]*ssc->ath_sample_rate/100)) {
 264                         /*
 265                          * we want to limit the time measuring the performance
 266                          * of other bit-rates to ath_sample_rate% of the
 267                          * total transmission time.
 268                          */
 269                         ndx = pick_sample_ndx(sn, size_bin);
 270                         if (ndx != sn->current_rate[size_bin]) {
 271                                 sn->current_sample_ndx[size_bin] = ndx;
 272                         } else {
 273                                 sn->current_sample_ndx[size_bin] = -1;
 274                         }
 275                         sn->packets_since_sample[size_bin] = 0;
 276
 277                 } else {
 278                         change_rates = 0;
 279                         if (!sn->packets_sent[size_bin] || best_ndx == -1) {
 280                                 /* no packet has been sent successfully yet */
 281                                 for (ndx = sn->num_rates-1; ndx > 0; ndx--) {
 282                                         /*
 283                                          * pick the highest rate <= 36 Mbps
 284                                          * that hasn't failed.
 285                                          */
 286                                         if (sn->rates[ndx].rate <= 72 &&
 287                                             sn->stats[size_bin][ndx].successive_failures == 0) {
 288                                                 break;
 289                                         }
 290                                 }
 291                                 change_rates = 1;
 292                                 best_ndx = ndx;
 293                         } else if (sn->packets_sent[size_bin] < 20) {
 294                                 /* let the bit-rate switch quickly during the first few packets */
 295                                 change_rates = 1;
 296                         } else if (ticks - ((hz*MIN_SWITCH_MS)/1000) > sn->ticks_since_switch[size_bin]) {
 297                                 /* 2 seconds have gone by */
 298                                 change_rates = 1;
 299                         } else if (average_tx_time * 2 < sn->stats[size_bin][sn->current_rate[size_bin]].average_tx_time) {
 300                                 /* the current bit-rate is twice as slow as the best one */
 301                                 change_rates = 1;
 302                         }
 303
 304                         sn->packets_since_sample[size_bin]++;
 305
 306                         if (change_rates) {
 307                                 if (best_ndx != sn->current_rate[size_bin]) {
 308                                         IEEE80211_NOTE(an->an_node.ni_vap,
 309                                             IEEE80211_MSG_RATECTL,
 310                                             &an->an_node,
 311 "%s: size %d switch rate %d (%d/%d) -> %d (%d/%d) after %d packets mrr %d",
 312                                             __func__,
 313                                             packet_size_bins[size_bin],
 314                                             sn->rates[sn->current_rate[size_bin]].rate,
 315                                             sn->stats[size_bin][sn->current_rate[size_bin]].average_tx_time,
 316                                             sn->stats[size_bin][sn->current_rate[size_bin]].perfect_tx_time,
 317                                             sn->rates[best_ndx].rate,
 318                                             sn->stats[size_bin][best_ndx].average_tx_time,
 319                                             sn->stats[size_bin][best_ndx].perfect_tx_time,
 320                                             sn->packets_since_switch[size_bin],
 321                                             mrr);
 322                                 }
 323                                 sn->packets_since_switch[size_bin] = 0;
 324                                 sn->current_rate[size_bin] = best_ndx;
 325                                 sn->ticks_since_switch[size_bin] = ticks;
 326                                 /*
 327                                  * Set the visible txrate for this node.
 328                                  */
 329                                 an->an_node.ni_txrate = sn->rates[best_ndx].rate;
 330                         }
 331                         ndx = sn->current_rate[size_bin];
 332                         sn->packets_since_switch[size_bin]++;
 333                 }
 334         }
 335
 336         KASSERT(ndx >= 0 && ndx < sn->num_rates, ("ndx is %d", ndx));
 337
 338         *rix = sn->rates[ndx].rix;
 339         if (shortPreamble) {
 340                 *txrate = sn->rates[ndx].shortPreambleRateCode;
 341         } else {
 342                 *txrate = sn->rates[ndx].rateCode;
 343         }
 344         sn->packets_sent[size_bin]++;
 345 }
 346
 347 void
 348 ath_rate_setupxtxdesc(struct ath_softc *sc, struct ath_node *an,
 349                       struct ath_desc *ds, int shortPreamble, u_int8_t rix)
 350 {
 351         struct sample_node *sn = ATH_NODE_SAMPLE(an);
 352         int rateCode = -1;
 353         int frame_size = 0;
 354         int size_bin = 0;
 355         int ndx = 0;
 356
 357         size_bin = size_to_bin(frame_size);     // TODO: it's correct that frame_size alway 0 ?
 358         ndx = sn->current_rate[size_bin]; /* retry at the current bit-rate */
 359
 360         if (!sn->stats[size_bin][ndx].packets_acked) {
 361                 ndx = 0;  /* use the lowest bit-rate */
 362         }
 363
 364         if (shortPreamble) {
 365                 rateCode = sn->rates[ndx].shortPreambleRateCode;
 366         } else {
 367                 rateCode = sn->rates[ndx].rateCode;
 368         }
 369         ath_hal_setupxtxdesc(sc->sc_ah, ds
 370                              , rateCode, 3              /* series 1 */
 371                              , sn->rates[0].rateCode, 3 /* series 2 */
 372                              , 0, 0                     /* series 3 */
 373                              );
 374 }
 375
 376 static void
 377 update_stats(struct ath_softc *sc, struct ath_node *an,
 378                   int frame_size,
 379                   int ndx0, int tries0,
 380                   int ndx1, int tries1,
 381                   int ndx2, int tries2,
 382                   int ndx3, int tries3,
 383                   int short_tries, int tries, int status)
 384 {
 385         struct sample_node *sn = ATH_NODE_SAMPLE(an);
 386         struct sample_softc *ssc = ATH_SOFTC_SAMPLE(sc);
 387         int tt = 0;
 388         int tries_so_far = 0;
 389         int size_bin = 0;
 390         int size = 0;
 391         int rate = 0;
 392
 393         size_bin = size_to_bin(frame_size);
 394         size = bin_to_size(size_bin);
 395
 396         if (!(0 <= ndx0 && ndx0 < sn->num_rates)) {
 397                 printf("%s: bogus ndx0 %d, max %u, mode %u\n",
 398                     __func__, ndx0, sn->num_rates, sc->sc_curmode);
 399                 return;
 400         }
 401         rate = sn->rates[ndx0].rate;
 402
 403         tt += calc_usecs_unicast_packet(sc, size, sn->rates[ndx0].rix,
 404                                         short_tries,
 405                                         MIN(tries0, tries) - 1);
 406         tries_so_far += tries0;
 407         if (tries1 && tries0 < tries) {
 408                 if (!(0 <= ndx1 && ndx1 < sn->num_rates)) {
 409                         printf("%s: bogus ndx1 %d, max %u, mode %u\n",
 410                             __func__, ndx1, sn->num_rates, sc->sc_curmode);
 411                         return;
 412                 }
 413                 tt += calc_usecs_unicast_packet(sc, size, sn->rates[ndx1].rix,
 414                                                 short_tries,
 415                                                 MIN(tries1 + tries_so_far, tries) - tries_so_far - 1);
 416         }
 417         tries_so_far += tries1;
 418
 419         if (tries2 && tries0 + tries1 < tries) {
 420                 if (!(0 <= ndx2 && ndx2 < sn->num_rates)) {
 421                         printf("%s: bogus ndx2 %d, max %u, mode %u\n",
 422                             __func__, ndx2, sn->num_rates, sc->sc_curmode);
 423                         return;
 424                 }
 425                 tt += calc_usecs_unicast_packet(sc, size, sn->rates[ndx2].rix,
 426                                                short_tries,
 427                                                 MIN(tries2 + tries_so_far, tries) - tries_so_far - 1);
 428         }
 429
 430         tries_so_far += tries2;
 431
 432         if (tries3 && tries0 + tries1 + tries2 < tries) {
 433                 if (!(0 <= ndx3 && ndx3 < sn->num_rates)) {
 434                         printf("%s: bogus ndx3 %d, max %u, mode %u\n",
 435                             __func__, ndx3, sn->num_rates, sc->sc_curmode);
 436                         return;
 437                 }
 438                 tt += calc_usecs_unicast_packet(sc, size, sn->rates[ndx3].rix,
 439                                                 short_tries,
 440                                                 MIN(tries3 + tries_so_far, tries) - tries_so_far - 1);
 441         }
 442         if (sn->stats[size_bin][ndx0].total_packets < (100 / (100 - ssc->ath_smoothing_rate))) {
 443                 /* just average the first few packets */
 444                 int avg_tx = sn->stats[size_bin][ndx0].average_tx_time;
 445                 int packets = sn->stats[size_bin][ndx0].total_packets;
 446                 sn->stats[size_bin][ndx0].average_tx_time = (tt+(avg_tx*packets))/(packets+1);
 447         } else {
 448                 /* use a ewma */
 449                 sn->stats[size_bin][ndx0].average_tx_time =
 450                         ((sn->stats[size_bin][ndx0].average_tx_time * ssc->ath_smoothing_rate) +
 451                          (tt * (100 - ssc->ath_smoothing_rate))) / 100;
 452         }
 453
 454         if (status) {
 455                 int y;
 456                 sn->stats[size_bin][ndx0].successive_failures++;
 457                 for (y = size_bin+1; y < NUM_PACKET_SIZE_BINS; y++) {
 458                         /* also say larger packets failed since we
 459                          * assume if a small packet fails at a lower
 460                          * bit-rate then a larger one will also.
 461                          */
 462                         sn->stats[y][ndx0].successive_failures++;
 463                         sn->stats[y][ndx0].last_tx = ticks;
 464                         sn->stats[y][ndx0].tries += tries;
 465                         sn->stats[y][ndx0].total_packets++;
 466                 }
 467         } else {
 468                 sn->stats[size_bin][ndx0].packets_acked++;
 469                 sn->stats[size_bin][ndx0].successive_failures = 0;
 470         }
 471         sn->stats[size_bin][ndx0].tries += tries;
 472         sn->stats[size_bin][ndx0].last_tx = ticks;
 473         sn->stats[size_bin][ndx0].total_packets++;
 474
 475
 476         if (ndx0 == sn->current_sample_ndx[size_bin]) {
 477                 IEEE80211_NOTE(an->an_node.ni_vap, IEEE80211_MSG_RATECTL,
 478                    &an->an_node,
 479 "%s: size %d %s sample rate %d tries (%d/%d) tt %d avg_tt (%d/%d)",
 480                     __func__,
 481                     size,
 482                     status ? "FAIL" : "OK",
 483                     rate, short_tries, tries, tt,
 484                     sn->stats[size_bin][ndx0].average_tx_time,
 485                     sn->stats[size_bin][ndx0].perfect_tx_time);
 486                 sn->sample_tt[size_bin] = tt;
 487                 sn->current_sample_ndx[size_bin] = -1;
 488         }
 489 }
 490
 491 void
 492 ath_rate_tx_complete(struct ath_softc *sc, struct ath_node *an,
 493         const struct ath_buf *bf)
 494 {
 495         struct ifnet *ifp = sc->sc_ifp;
 496         struct ieee80211com *ic = ifp->if_l2com;
 497         struct sample_node *sn = ATH_NODE_SAMPLE(an);
 498         const struct ath_tx_status *ts = &bf->bf_status.ds_txstat;
 499         const struct ath_desc *ds0 = &bf->bf_desc[0];
 500         int final_rate, short_tries, long_tries, frame_size;
 501         int mrr;
 502
 503         final_rate = sc->sc_hwmap[ts->ts_rate &~ HAL_TXSTAT_ALTRATE].ieeerate;
 504         short_tries = ts->ts_shortretry;
 505         long_tries = ts->ts_longretry + 1;
 506         frame_size = ds0->ds_ctl0 & 0x0fff; /* low-order 12 bits of ds_ctl0 */
 507         if (frame_size == 0)                /* NB: should not happen */
 508                 frame_size = 1500;
 509
 510         if (sn->num_rates <= 0) {
 511                 IEEE80211_NOTE(an->an_node.ni_vap, IEEE80211_MSG_RATECTL,
 512                     &an->an_node,
 513                     "%s: size %d %s rate/try %d/%d no rates yet",
 514                     __func__,
 515                     bin_to_size(size_to_bin(frame_size)),
 516                     ts->ts_status ? "FAIL" : "OK",
 517                     short_tries, long_tries);
 518                 return;
 519         }
 520         mrr = sc->sc_mrretry && !(ic->ic_flags & IEEE80211_F_USEPROT);
 521         if (!mrr || !(ts->ts_rate & HAL_TXSTAT_ALTRATE)) {
 522                 int ndx = rate_to_ndx(sn, final_rate);
 523
 524                 /*
 525                  * Only one rate was used; optimize work.
 526                  */
 527                 IEEE80211_NOTE(an->an_node.ni_vap, IEEE80211_MSG_RATECTL,
 528                      &an->an_node, "%s: size %d %s rate/try %d/%d/%d",
 529                      __func__,
 530                      bin_to_size(size_to_bin(frame_size)),
 531                      ts->ts_status ? "FAIL" : "OK",
 532                      final_rate, short_tries, long_tries);
 533                 update_stats(sc, an, frame_size,
 534                              ndx, long_tries,
 535                              0, 0,
 536                              0, 0,
 537                              0, 0,
 538                              short_tries, long_tries, ts->ts_status);
 539         } else {
 540                 int hwrate0, rate0, tries0, ndx0;
 541                 int hwrate1, rate1, tries1, ndx1;
 542                 int hwrate2, rate2, tries2, ndx2;
 543                 int hwrate3, rate3, tries3, ndx3;
 544                 int finalTSIdx = ts->ts_finaltsi;
 545
 546                 /*
 547                  * Process intermediate rates that failed.
 548                  */
 549                 if (sc->sc_ah->ah_magic != 0x20065416) {
 550                         hwrate0 = MS(ds0->ds_ctl3, AR_XmitRate0);
 551                         hwrate1 = MS(ds0->ds_ctl3, AR_XmitRate1);
 552                         hwrate2 = MS(ds0->ds_ctl3, AR_XmitRate2);
 553                         hwrate3 = MS(ds0->ds_ctl3, AR_XmitRate3);
 554                 } else {
 555                         hwrate0 = MS(ds0->ds_ctl3, AR5416_XmitRate0);
 556                         hwrate1 = MS(ds0->ds_ctl3, AR5416_XmitRate1);
 557                         hwrate2 = MS(ds0->ds_ctl3, AR5416_XmitRate2);
 558                         hwrate3 = MS(ds0->ds_ctl3, AR5416_XmitRate3);
 559                 }
 560
 561                 rate0 = sc->sc_hwmap[hwrate0].ieeerate;
 562                 tries0 = MS(ds0->ds_ctl2, AR_XmitDataTries0);
 563                 ndx0 = rate_to_ndx(sn, rate0);
 564
 565                 rate1 = sc->sc_hwmap[hwrate1].ieeerate;
 566                 tries1 = MS(ds0->ds_ctl2, AR_XmitDataTries1);
 567                 ndx1 = rate_to_ndx(sn, rate1);
 568
 569                 rate2 = sc->sc_hwmap[hwrate2].ieeerate;
 570                 tries2 = MS(ds0->ds_ctl2, AR_XmitDataTries2);
 571                 ndx2 = rate_to_ndx(sn, rate2);
 572
 573                 rate3 = sc->sc_hwmap[hwrate3].ieeerate;
 574                 tries3 = MS(ds0->ds_ctl2, AR_XmitDataTries3);
 575                 ndx3 = rate_to_ndx(sn, rate3);
 576
 577                 IEEE80211_NOTE(an->an_node.ni_vap, IEEE80211_MSG_RATECTL,
 578                     &an->an_node,
 579 "%s: size %d finaltsidx %d tries %d %s rate/try [%d/%d %d/%d %d/%d %d/%d]",
 580                      __func__,
 581                      bin_to_size(size_to_bin(frame_size)),
 582                      finalTSIdx,
 583                      long_tries,
 584                      ts->ts_status ? "FAIL" : "OK",
 585                      rate0, tries0,
 586                      rate1, tries1,
 587                      rate2, tries2,
 588                      rate3, tries3);
 589
 590                 /*
 591                  * NB: series > 0 are not penalized for failure
 592                  * based on the try counts under the assumption
 593                  * that losses are often bursty and since we
 594                  * sample higher rates 1 try at a time doing so
 595                  * may unfairly penalize them.
 596                  */
 597                 if (tries0) {
 598                         update_stats(sc, an, frame_size,
 599                                      ndx0, tries0,
 600                                      ndx1, tries1,
 601                                      ndx2, tries2,
 602                                      ndx3, tries3,
 603                                      short_tries, long_tries,
 604                                      long_tries > tries0);
 605                         long_tries -= tries0;
 606                 }
 607
 608                 if (tries1 && finalTSIdx > 0) {
 609                         update_stats(sc, an, frame_size,
 610                                      ndx1, tries1,
 611                                      ndx2, tries2,
 612                                      ndx3, tries3,
 613                                      0, 0,
 614                                      short_tries, long_tries,
 615                                      ts->ts_status);
 616                         long_tries -= tries1;
 617                 }
 618
 619                 if (tries2 && finalTSIdx > 1) {
 620                         update_stats(sc, an, frame_size,
 621                                      ndx2, tries2,
 622                                      ndx3, tries3,
 623                                      0, 0,
 624                                      0, 0,
 625                                      short_tries, long_tries,
 626                                      ts->ts_status);
 627                         long_tries -= tries2;
 628                 }
 629
 630                 if (tries3 && finalTSIdx > 2) {
 631                         update_stats(sc, an, frame_size,
 632                                      ndx3, tries3,
 633                                      0, 0,
 634                                      0, 0,
 635                                      0, 0,
 636                                      short_tries, long_tries,
 637                                      ts->ts_status);
 638                 }
 639         }
 640 }
 641
 642 void
 643 ath_rate_newassoc(struct ath_softc *sc, struct ath_node *an, int isnew)
 644 {
 645         if (isnew)
 646                 ath_rate_ctl_reset(sc, &an->an_node);
 647 }
 648
 649 /*
 650  * Initialize the tables for a node.
 651  */
 652 static void
 653 ath_rate_ctl_reset(struct ath_softc *sc, struct ieee80211_node *ni)
 654 {
 655 #define RATE(_ix)       (ni->ni_rates.rs_rates[(_ix)] & IEEE80211_RATE_VAL)
 656         struct ath_node *an = ATH_NODE(ni);
 657         const struct ieee80211_txparam *tp = an->an_tp;
 658         struct sample_node *sn = ATH_NODE_SAMPLE(an);
 659         const HAL_RATE_TABLE *rt = sc->sc_currates;
 660         int x, y, srate;
 661
 662         KASSERT(rt != NULL, ("no rate table, mode %u", sc->sc_curmode));
 663         sn->static_rate_ndx = -1;
 664         if (tp != NULL && tp->ucastrate != IEEE80211_FIXED_RATE_NONE) {
 665                 /*
 666                  * A fixed rate is to be used; ic_fixed_rate is the
 667                  * IEEE code for this rate (sans basic bit).  Convert this
 668                  * to the index into the negotiated rate set for
 669                  * the node.
 670                  */
 671                 /* NB: the rate set is assumed sorted */
 672                 srate = ni->ni_rates.rs_nrates - 1;
 673                 for (; srate >= 0 && RATE(srate) != tp->ucastrate; srate--)
 674                         ;
 675                 /*
 676                  * The fixed rate may not be available due to races
 677                  * and mode settings.  Also orphaned nodes created in
 678                  * adhoc mode may not have any rate set so this lookup
 679                  * can fail.
 680                  */
 681                 if (srate >= 0)
 682                         sn->static_rate_ndx = srate;
 683         }
 684
 685         sn->num_rates = ni->ni_rates.rs_nrates;
 686         for (x = 0; x < ni->ni_rates.rs_nrates; x++) {
 687                 sn->rates[x].rate = ni->ni_rates.rs_rates[x] & IEEE80211_RATE_VAL;
 688                 sn->rates[x].rix = sc->sc_rixmap[sn->rates[x].rate];
 689                 if (sn->rates[x].rix == 0xff) {
 690                         IEEE80211_NOTE(ni->ni_vap, IEEE80211_MSG_RATECTL, ni,
 691                             "%s: ignore bogus rix at %d", __func__, x);
 692                         continue;
 693                 }
 694                 sn->rates[x].rateCode = rt->info[sn->rates[x].rix].rateCode;
 695                 sn->rates[x].shortPreambleRateCode =
 696                         rt->info[sn->rates[x].rix].rateCode |
 697                         rt->info[sn->rates[x].rix].shortPreamble;
 698         }
 699 #ifdef IEEE80211_DEBUG
 700         if (ieee80211_msg(ni->ni_vap, IEEE80211_MSG_RATECTL)) {
 701                 ieee80211_note(ni->ni_vap, "[%6D] %s: size 1600 rate/tt",
 702                     __func__, ni->ni_macaddr, ":");
 703                 for (x = 0; x < sn->num_rates; x++) {
 704                         if (sn->rates[x].rix == 0xff)
 705                                 continue;
 706                         printf(" %d/%d", sn->rates[x].rate,
 707                             calc_usecs_unicast_packet(sc, 1600,
 708                                 sn->rates[x].rix, 0,0));
 709                 }
 710                 printf("\n");
 711         }
 712 #endif
 713         for (y = 0; y < NUM_PACKET_SIZE_BINS; y++) {
 714                 int size = bin_to_size(y);
 715                 int ndx = 0;
 716                 sn->packets_sent[y] = 0;
 717                 sn->current_sample_ndx[y] = -1;
 718                 sn->last_sample_ndx[y] = 0;
 719
 720                 for (x = 0; x < ni->ni_rates.rs_nrates; x++) {
 721                         sn->stats[y][x].successive_failures = 0;
 722                         sn->stats[y][x].tries = 0;
 723                         sn->stats[y][x].total_packets = 0;
 724                         sn->stats[y][x].packets_acked = 0;
 725                         sn->stats[y][x].last_tx = 0;
 726
 727                         sn->stats[y][x].perfect_tx_time =
 728                                 calc_usecs_unicast_packet(sc, size,
 729                                                           sn->rates[x].rix,
 730                                                           0, 0);
 731                         sn->stats[y][x].average_tx_time = sn->stats[y][x].perfect_tx_time;
 732                 }
 733
 734                 /* set the initial rate */
 735                 for (ndx = sn->num_rates-1; ndx > 0; ndx--) {
 736                         if (sn->rates[ndx].rate <= 72) {
 737                                 break;
 738                         }
 739                 }
 740                 sn->current_rate[y] = ndx;
 741         }
 742
 743         IEEE80211_NOTE(ni->ni_vap, IEEE80211_MSG_RATECTL, ni,
 744             "%s: %d rates %d%sMbps (%dus)- %d%sMbps (%dus)", __func__,
 745             sn->num_rates,
 746             sn->rates[0].rate/2, sn->rates[0].rate % 0x1 ? ".5" : "",
 747             sn->stats[1][0].perfect_tx_time,
 748             sn->rates[sn->num_rates-1].rate/2,
 749                 sn->rates[sn->num_rates-1].rate % 0x1 ? ".5" : "",
 750             sn->stats[1][sn->num_rates-1].perfect_tx_time
 751         );
 752
 753         /* set the visible bit-rate */
 754         if (sn->static_rate_ndx != -1)
 755                 ni->ni_txrate = sn->rates[sn->static_rate_ndx].rate;
 756         else
 757                 ni->ni_txrate = sn->rates[0].rate;
 758 #undef RATE
 759 }
 760
 761 static void
 762 rate_cb(void *arg, struct ieee80211_node *ni)
 763 {
 764         struct ath_softc *sc = arg;
 765
 766         ath_rate_newassoc(sc, ATH_NODE(ni), 1);
 767 }
 768
 769 /*
 770  * Reset the rate control state for each 802.11 state transition.
 771  */
 772 void
 773 ath_rate_newstate(struct ieee80211vap *vap, enum ieee80211_state state)
 774 {
 775         struct ieee80211com *ic = vap->iv_ic;
 776         struct ath_softc *sc = ic->ic_ifp->if_softc;
 777
 778         if (state == IEEE80211_S_RUN) {
 779                 if (vap->iv_opmode != IEEE80211_M_STA) {
 780                         /*
 781                          * Sync rates for associated stations and neighbors.
 782                          */
 783                         ieee80211_iterate_nodes(&ic->ic_sta, rate_cb, sc);
 784                 }
 785                 ath_rate_newassoc(sc, ATH_NODE(vap->iv_bss), 1);
 786         }
 787 }
 788
 789 static void
 790 ath_rate_sysctlattach(struct ath_softc *sc, struct sample_softc *osc)
 791 {
 792         struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->sc_dev);
 793         struct sysctl_oid *tree = device_get_sysctl_tree(sc->sc_dev);
 794
 795         /* XXX bounds check [0..100] */
 796         SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
 797                 "smoothing_rate", CTLFLAG_RW, &osc->ath_smoothing_rate, 0,
 798                 "rate control: retry threshold to credit rate raise (%%)");
 799         /* XXX bounds check [2..100] */
 800         SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
 801                 "sample_rate", CTLFLAG_RW, &osc->ath_sample_rate,0,
 802                 "rate control: # good periods before raising rate");
 803 }
 804
 805 struct ath_ratectrl *
 806 ath_rate_attach(struct ath_softc *sc)
 807 {
 808         struct sample_softc *osc;
 809
 810         osc = malloc(sizeof(struct sample_softc), M_DEVBUF, M_NOWAIT|M_ZERO);
 811         if (osc == NULL)
 812                 return NULL;
 813         osc->arc.arc_space = sizeof(struct sample_node);
 814         osc->ath_smoothing_rate = 95;   /* ewma percentage (out of 100) */
 815         osc->ath_sample_rate = 10;      /* send a different bit-rate 1/X packets */
 816         ath_rate_sysctlattach(sc, osc);
 817         return &osc->arc;
 818 }
 819
 820 void
 821 ath_rate_detach(struct ath_ratectrl *arc)
 822 {
 823         struct sample_softc *osc = (struct sample_softc *) arc;
 824
 825         free(osc, M_DEVBUF);
 826 }
 827
 828 /*
 829  * Module glue.
 830  */
 831 static int
 832 sample_modevent(module_t mod, int type, void *unused)
 833 {
 834         switch (type) {
 835         case MOD_LOAD:
 836                 if (bootverbose)
 837                         printf("ath_rate: version 1.2 <SampleRate bit-rate selection algorithm>\n");
 838                 return 0;
 839         case MOD_UNLOAD:
 840                 return 0;
 841         }
 842         return EINVAL;
 843 }
 844
 845 static moduledata_t sample_mod = {
 846         "ath_rate",
 847         sample_modevent,
 848         0
 849 };
 850 DECLARE_MODULE(ath_rate, sample_mod, SI_SUB_DRIVERS, SI_ORDER_FIRST);
 851 MODULE_VERSION(ath_rate, 1);
 852 MODULE_DEPEND(ath_rate, ath_hal, 1, 1, 1);      /* Atheros HAL */
 853 MODULE_DEPEND(ath_rate, wlan, 1, 1, 1);