sys/dev/ath/if_ath_tx_ht.c

   1 /*-
   2  * Copyright (c) 2011 Adrian Chadd, Xenion Pty Ltd.
   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  *
  16  * NO WARRANTY
  17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  18  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  19  * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
  20  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
  21  * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
  22  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  23  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  24  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  25  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  26  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  27  * THE POSSIBILITY OF SUCH DAMAGES.
  28  */
  29
  30 #include <sys/cdefs.h>
  31 __FBSDID("$FreeBSD$");
  32
  33 #include "opt_inet.h"
  34 #include "opt_ath.h"
  35 #include "opt_wlan.h"
  36
  37 #include <sys/param.h>
  38 #include <sys/systm.h>
  39 #include <sys/sysctl.h>
  40 #include <sys/mbuf.h>
  41 #include <sys/malloc.h>
  42 #include <sys/lock.h>
  43 #include <sys/mutex.h>
  44 #include <sys/kernel.h>
  45 #include <sys/socket.h>
  46 #include <sys/sockio.h>
  47 #include <sys/errno.h>
  48 #include <sys/callout.h>
  49 #include <sys/bus.h>
  50 #include <sys/endian.h>
  51 #include <sys/kthread.h>
  52 #include <sys/taskqueue.h>
  53 #include <sys/priv.h>
  54
  55 #include <machine/bus.h>
  56
  57 #include <net/if.h>
  58 #include <net/if_dl.h>
  59 #include <net/if_media.h>
  60 #include <net/if_types.h>
  61 #include <net/if_arp.h>
  62 #include <net/ethernet.h>
  63 #include <net/if_llc.h>
  64
  65 #include <net80211/ieee80211_var.h>
  66 #include <net80211/ieee80211_regdomain.h>
  67 #ifdef IEEE80211_SUPPORT_SUPERG
  68 #include <net80211/ieee80211_superg.h>
  69 #endif
  70 #ifdef IEEE80211_SUPPORT_TDMA
  71 #include <net80211/ieee80211_tdma.h>
  72 #endif
  73
  74 #include <net/bpf.h>
  75
  76 #ifdef INET
  77 #include <netinet/in.h>
  78 #include <netinet/if_ether.h>
  79 #endif
  80
  81 #include <dev/ath/if_athvar.h>
  82 #include <dev/ath/ath_hal/ah_devid.h>           /* XXX for softled */
  83 #include <dev/ath/ath_hal/ah_diagcodes.h>
  84
  85 #ifdef ATH_TX99_DIAG
  86 #include <dev/ath/ath_tx99/ath_tx99.h>
  87 #endif
  88
  89 #include <dev/ath/if_ath_tx.h>          /* XXX for some support functions */
  90 #include <dev/ath/if_ath_tx_ht.h>
  91 #include <dev/ath/if_athrate.h>
  92 #include <dev/ath/if_ath_debug.h>
  93
  94 /*
  95  * XXX net80211?
  96  */
  97 #define IEEE80211_AMPDU_SUBFRAME_DEFAULT                32
  98
  99 #define ATH_AGGR_DELIM_SZ       4       /* delimiter size */
 100 #define ATH_AGGR_MINPLEN        256     /* in bytes, minimum packet length */
 101 /* number of delimiters for encryption padding */
 102 #define ATH_AGGR_ENCRYPTDELIM   10
 103
 104 /*
 105  * returns delimiter padding required given the packet length
 106  */
 107 #define ATH_AGGR_GET_NDELIM(_len)                                       \
 108             (((((_len) + ATH_AGGR_DELIM_SZ) < ATH_AGGR_MINPLEN) ?       \
 109             (ATH_AGGR_MINPLEN - (_len) - ATH_AGGR_DELIM_SZ) : 0) >> 2)
 110
 111 #define PADBYTES(_len)          ((4 - ((_len) % 4)) % 4)
 112
 113 int ath_max_4ms_framelen[4][32] = {
 114         [MCS_HT20] = {
 115                 3212,  6432,  9648,  12864,  19300,  25736,  28952,  32172,
 116                 6424,  12852, 19280, 25708,  38568,  51424,  57852,  64280,
 117                 9628,  19260, 28896, 38528,  57792,  65532,  65532,  65532,
 118                 12828, 25656, 38488, 51320,  65532,  65532,  65532,  65532,
 119         },
 120         [MCS_HT20_SGI] = {
 121                 3572,  7144,  10720,  14296,  21444,  28596,  32172,  35744,
 122                 7140,  14284, 21428,  28568,  42856,  57144,  64288,  65532,
 123                 10700, 21408, 32112,  42816,  64228,  65532,  65532,  65532,
 124                 14256, 28516, 42780,  57040,  65532,  65532,  65532,  65532,
 125         },
 126         [MCS_HT40] = {
 127                 6680,  13360,  20044,  26724,  40092,  53456,  60140,  65532,
 128                 13348, 26700,  40052,  53400,  65532,  65532,  65532,  65532,
 129                 20004, 40008,  60016,  65532,  65532,  65532,  65532,  65532,
 130                 26644, 53292,  65532,  65532,  65532,  65532,  65532,  65532,
 131         },
 132         [MCS_HT40_SGI] = {
 133                 7420,  14844,  22272,  29696,  44544,  59396,  65532,  65532,
 134                 14832, 29668,  44504,  59340,  65532,  65532,  65532,  65532,
 135                 22232, 44464,  65532,  65532,  65532,  65532,  65532,  65532,
 136                 29616, 59232,  65532,  65532,  65532,  65532,  65532,  65532,
 137         }
 138 };
 139
 140 /*
 141  * XXX should be in net80211
 142  */
 143 static int ieee80211_mpdudensity_map[] = {
 144         0,              /* IEEE80211_HTCAP_MPDUDENSITY_NA */
 145         25,             /* IEEE80211_HTCAP_MPDUDENSITY_025 */
 146         50,             /* IEEE80211_HTCAP_MPDUDENSITY_05 */
 147         100,            /* IEEE80211_HTCAP_MPDUDENSITY_1 */
 148         200,            /* IEEE80211_HTCAP_MPDUDENSITY_2 */
 149         400,            /* IEEE80211_HTCAP_MPDUDENSITY_4 */
 150         800,            /* IEEE80211_HTCAP_MPDUDENSITY_8 */
 151         1600,           /* IEEE80211_HTCAP_MPDUDENSITY_16 */
 152 };
 153
 154 /*
 155  * XXX should be in the HAL/net80211 ?
 156  */
 157 #define BITS_PER_BYTE           8
 158 #define OFDM_PLCP_BITS          22
 159 #define HT_RC_2_MCS(_rc)        ((_rc) & 0x7f)
 160 #define HT_RC_2_STREAMS(_rc)    ((((_rc) & 0x78) >> 3) + 1)
 161 #define L_STF                   8
 162 #define L_LTF                   8
 163 #define L_SIG                   4
 164 #define HT_SIG                  8
 165 #define HT_STF                  4
 166 #define HT_LTF(_ns)             (4 * (_ns))
 167 #define SYMBOL_TIME(_ns)        ((_ns) << 2)            // ns * 4 us
 168 #define SYMBOL_TIME_HALFGI(_ns) (((_ns) * 18 + 4) / 5)  // ns * 3.6 us
 169 #define NUM_SYMBOLS_PER_USEC(_usec)     (_usec >> 2)
 170 #define NUM_SYMBOLS_PER_USEC_HALFGI(_usec)      (((_usec*5)-4)/18)
 171 #define IS_HT_RATE(_rate)       ((_rate) & 0x80)
 172
 173 const uint32_t bits_per_symbol[][2] = {
 174     /* 20MHz 40MHz */
 175     {    26,   54 },     //  0: BPSK
 176     {    52,  108 },     //  1: QPSK 1/2
 177     {    78,  162 },     //  2: QPSK 3/4
 178     {   104,  216 },     //  3: 16-QAM 1/2
 179     {   156,  324 },     //  4: 16-QAM 3/4
 180     {   208,  432 },     //  5: 64-QAM 2/3
 181     {   234,  486 },     //  6: 64-QAM 3/4
 182     {   260,  540 },     //  7: 64-QAM 5/6
 183     {    52,  108 },     //  8: BPSK
 184     {   104,  216 },     //  9: QPSK 1/2
 185     {   156,  324 },     // 10: QPSK 3/4
 186     {   208,  432 },     // 11: 16-QAM 1/2
 187     {   312,  648 },     // 12: 16-QAM 3/4
 188     {   416,  864 },     // 13: 64-QAM 2/3
 189     {   468,  972 },     // 14: 64-QAM 3/4
 190     {   520, 1080 },     // 15: 64-QAM 5/6
 191     {    78,  162 },     // 16: BPSK
 192     {   156,  324 },     // 17: QPSK 1/2
 193     {   234,  486 },     // 18: QPSK 3/4
 194     {   312,  648 },     // 19: 16-QAM 1/2
 195     {   468,  972 },     // 20: 16-QAM 3/4
 196     {   624, 1296 },     // 21: 64-QAM 2/3
 197     {   702, 1458 },     // 22: 64-QAM 3/4
 198     {   780, 1620 },     // 23: 64-QAM 5/6
 199     {   104,  216 },     // 24: BPSK
 200     {   208,  432 },     // 25: QPSK 1/2
 201     {   312,  648 },     // 26: QPSK 3/4
 202     {   416,  864 },     // 27: 16-QAM 1/2
 203     {   624, 1296 },     // 28: 16-QAM 3/4
 204     {   832, 1728 },     // 29: 64-QAM 2/3
 205     {   936, 1944 },     // 30: 64-QAM 3/4
 206     {  1040, 2160 },     // 31: 64-QAM 5/6
 207 };
 208
 209 /*
 210  * Fill in the rate array information based on the current
 211  * node configuration and the choices made by the rate
 212  * selection code and ath_buf setup code.
 213  *
 214  * Later on, this may end up also being made by the
 215  * rate control code, but for now it can live here.
 216  *
 217  * This needs to be called just before the packet is
 218  * queued to the software queue or hardware queue,
 219  * so all of the needed fields in bf_state are setup.
 220  */
 221 void
 222 ath_tx_rate_fill_rcflags(struct ath_softc *sc, struct ath_buf *bf)
 223 {
 224         struct ieee80211_node *ni = bf->bf_node;
 225         struct ieee80211com *ic = ni->ni_ic;
 226         const HAL_RATE_TABLE *rt = sc->sc_currates;
 227         struct ath_rc_series *rc = bf->bf_state.bfs_rc;
 228         uint8_t rate;
 229         int i;
 230
 231         for (i = 0; i < ATH_RC_NUM; i++) {
 232                 rc[i].flags = 0;
 233                 if (rc[i].tries == 0)
 234                         continue;
 235
 236                 rate = rt->info[rc[i].rix].rateCode;
 237
 238                 /*
 239                  * Only enable short preamble for legacy rates
 240                  */
 241                 if ((! IS_HT_RATE(rate)) && bf->bf_state.bfs_shpream)
 242                         rate |= rt->info[rc[i].rix].shortPreamble;
 243
 244                 /*
 245                  * Save this, used by the TX and completion code
 246                  */
 247                 rc[i].ratecode = rate;
 248
 249                 if (bf->bf_state.bfs_txflags &
 250                     (HAL_TXDESC_RTSENA | HAL_TXDESC_CTSENA))
 251                         rc[i].flags |= ATH_RC_RTSCTS_FLAG;
 252
 253                 /* Only enable shortgi, 2040, dual-stream if HT is set */
 254                 if (IS_HT_RATE(rate)) {
 255                         rc[i].flags |= ATH_RC_HT_FLAG;
 256
 257                         if (ni->ni_chw == 40)
 258                                 rc[i].flags |= ATH_RC_CW40_FLAG;
 259
 260                         if (ni->ni_chw == 40 &&
 261                             ic->ic_htcaps & IEEE80211_HTCAP_SHORTGI40 &&
 262                             ni->ni_htcap & IEEE80211_HTCAP_SHORTGI40)
 263                                 rc[i].flags |= ATH_RC_SGI_FLAG;
 264
 265                         if (ni->ni_chw == 20 &&
 266                             ic->ic_htcaps & IEEE80211_HTCAP_SHORTGI20 &&
 267                             ni->ni_htcap & IEEE80211_HTCAP_SHORTGI20)
 268                                 rc[i].flags |= ATH_RC_SGI_FLAG;
 269
 270                         /*
 271                          * If we have STBC TX enabled and the receiver
 272                          * can receive (at least) 1 stream STBC, AND it's
 273                          * MCS 0-7, AND we have at least two chains enabled,
 274                          * enable STBC.
 275                          */
 276                         if (ic->ic_htcaps & IEEE80211_HTCAP_TXSTBC &&
 277                             ni->ni_htcap & IEEE80211_HTCAP_RXSTBC_1STREAM &&
 278                             (sc->sc_cur_txchainmask > 1) &&
 279                             HT_RC_2_STREAMS(rate) == 1) {
 280                                 rc[i].flags |= ATH_RC_STBC_FLAG;
 281                         }
 282
 283                         /*
 284                          * XXX TODO: LDPC
 285                          */
 286
 287                         /*
 288                          * Dual / Triple stream rate?
 289                          */
 290                         if (HT_RC_2_STREAMS(rate) == 2)
 291                                 rc[i].flags |= ATH_RC_DS_FLAG;
 292                         else if (HT_RC_2_STREAMS(rate) == 3)
 293                                 rc[i].flags |= ATH_RC_TS_FLAG;
 294                 }
 295
 296                 /*
 297                  * Calculate the maximum TX power cap for the current
 298                  * node.
 299                  */
 300                 rc[i].tx_power_cap = ieee80211_get_node_txpower(ni);
 301
 302                 /*
 303                  * Calculate the maximum 4ms frame length based
 304                  * on the MCS rate, SGI and channel width flags.
 305                  */
 306                 if ((rc[i].flags & ATH_RC_HT_FLAG) &&
 307                     (HT_RC_2_MCS(rate) < 32)) {
 308                         int j;
 309                         if (rc[i].flags & ATH_RC_CW40_FLAG) {
 310                                 if (rc[i].flags & ATH_RC_SGI_FLAG)
 311                                         j = MCS_HT40_SGI;
 312                                 else
 313                                         j = MCS_HT40;
 314                         } else {
 315                                 if (rc[i].flags & ATH_RC_SGI_FLAG)
 316                                         j = MCS_HT20_SGI;
 317                                 else
 318                                         j = MCS_HT20;
 319                         }
 320                         rc[i].max4msframelen =
 321                             ath_max_4ms_framelen[j][HT_RC_2_MCS(rate)];
 322                 } else
 323                         rc[i].max4msframelen = 0;
 324                 DPRINTF(sc, ATH_DEBUG_SW_TX_AGGR,
 325                     "%s: i=%d, rate=0x%x, flags=0x%x, max4ms=%d\n",
 326                     __func__, i, rate, rc[i].flags, rc[i].max4msframelen);
 327         }
 328 }
 329
 330 /*
 331  * Return the number of delimiters to be added to
 332  * meet the minimum required mpdudensity.
 333  *
 334  * Caller should make sure that the rate is HT.
 335  *
 336  * TODO: is this delimiter calculation supposed to be the
 337  * total frame length, the hdr length, the data length (including
 338  * delimiters, padding, CRC, etc) or ?
 339  *
 340  * TODO: this should ensure that the rate control information
 341  * HAS been setup for the first rate.
 342  *
 343  * TODO: ensure this is only called for MCS rates.
 344  *
 345  * TODO: enforce MCS < 31
 346  */
 347 static int
 348 ath_compute_num_delims(struct ath_softc *sc, struct ath_buf *first_bf,
 349     uint16_t pktlen)
 350 {
 351         const HAL_RATE_TABLE *rt = sc->sc_currates;
 352         struct ieee80211_node *ni = first_bf->bf_node;
 353         struct ieee80211vap *vap = ni->ni_vap;
 354         int ndelim, mindelim = 0;
 355         int mpdudensity;         /* in 1/100'th of a microsecond */
 356         uint8_t rc, rix, flags;
 357         int width, half_gi;
 358         uint32_t nsymbits, nsymbols;
 359         uint16_t minlen;
 360
 361         /*
 362          * vap->iv_ampdu_density is a value, rather than the actual
 363          * density.
 364          */
 365         if (vap->iv_ampdu_density > IEEE80211_HTCAP_MPDUDENSITY_16)
 366                 mpdudensity = 1600;             /* maximum density */
 367         else
 368                 mpdudensity = ieee80211_mpdudensity_map[vap->iv_ampdu_density];
 369
 370         /* Select standard number of delimiters based on frame length */
 371         ndelim = ATH_AGGR_GET_NDELIM(pktlen);
 372
 373         /*
 374          * If encryption is enabled, add extra delimiters to let the
 375          * crypto hardware catch up. This could be tuned per-MAC and
 376          * per-rate, but for now we'll simply assume encryption is
 377          * always enabled.
 378          *
 379          * Also note that the Atheros reference driver inserts two
 380          * delimiters by default for pre-AR9380 peers.  This will
 381          * include "that" required delimiter.
 382          */
 383         ndelim += ATH_AGGR_ENCRYPTDELIM;
 384
 385         /*
 386          * For AR9380, there's a minimum number of delimeters
 387          * required when doing RTS.
 388          *
 389          * XXX TODO: this is only needed if (a) RTS/CTS is enabled, and
 390          * XXX (b) this is the first sub-frame in the aggregate.
 391          */
 392         if (sc->sc_use_ent && (sc->sc_ent_cfg & AH_ENT_RTSCTS_DELIM_WAR)
 393             && ndelim < AH_FIRST_DESC_NDELIMS)
 394                 ndelim = AH_FIRST_DESC_NDELIMS;
 395
 396         /*
 397          * If sc_delim_min_pad is non-zero, enforce it as the minimum
 398          * pad delimiter count.
 399          */
 400         if (sc->sc_delim_min_pad != 0)
 401                 ndelim = MAX(ndelim, sc->sc_delim_min_pad);
 402
 403         DPRINTF(sc, ATH_DEBUG_SW_TX_AGGR,
 404             "%s: pktlen=%d, ndelim=%d, mpdudensity=%d\n",
 405             __func__, pktlen, ndelim, mpdudensity);
 406
 407         /*
 408          * If the MPDU density is 0, we can return here.
 409          * Otherwise, we need to convert the desired mpdudensity
 410          * into a byte length, based on the rate in the subframe.
 411          */
 412         if (mpdudensity == 0)
 413                 return ndelim;
 414
 415         /*
 416          * Convert desired mpdu density from microeconds to bytes based
 417          * on highest rate in rate series (i.e. first rate) to determine
 418          * required minimum length for subframe. Take into account
 419          * whether high rate is 20 or 40Mhz and half or full GI.
 420          */
 421         rix = first_bf->bf_state.bfs_rc[0].rix;
 422         rc = rt->info[rix].rateCode;
 423         flags = first_bf->bf_state.bfs_rc[0].flags;
 424         width = !! (flags & ATH_RC_CW40_FLAG);
 425         half_gi = !! (flags & ATH_RC_SGI_FLAG);
 426
 427         /*
 428          * mpdudensity is in 1/100th of a usec, so divide by 100
 429          */
 430         if (half_gi)
 431                 nsymbols = NUM_SYMBOLS_PER_USEC_HALFGI(mpdudensity);
 432         else
 433                 nsymbols = NUM_SYMBOLS_PER_USEC(mpdudensity);
 434         nsymbols /= 100;
 435
 436         if (nsymbols == 0)
 437                 nsymbols = 1;
 438
 439         nsymbits = bits_per_symbol[HT_RC_2_MCS(rc)][width];
 440         minlen = (nsymbols * nsymbits) / BITS_PER_BYTE;
 441
 442         /*
 443          * Min length is the minimum frame length for the
 444          * required MPDU density.
 445          */
 446         if (pktlen < minlen) {
 447                 mindelim = (minlen - pktlen) / ATH_AGGR_DELIM_SZ;
 448                 ndelim = MAX(mindelim, ndelim);
 449         }
 450
 451         DPRINTF(sc, ATH_DEBUG_SW_TX_AGGR,
 452             "%s: pktlen=%d, minlen=%d, rix=%x, rc=%x, width=%d, hgi=%d, ndelim=%d\n",
 453             __func__, pktlen, minlen, rix, rc, width, half_gi, ndelim);
 454
 455         return ndelim;
 456 }
 457
 458 /*
 459  * Fetch the aggregation limit.
 460  *
 461  * It's the lowest of the four rate series 4ms frame length.
 462  */
 463 static int
 464 ath_get_aggr_limit(struct ath_softc *sc, struct ath_buf *bf)
 465 {
 466         int amin = ATH_AGGR_MAXSIZE;
 467         int i;
 468
 469         if (sc->sc_aggr_limit > 0 && sc->sc_aggr_limit < ATH_AGGR_MAXSIZE)
 470                 amin = sc->sc_aggr_limit;
 471
 472         for (i = 0; i < ATH_RC_NUM; i++) {
 473                 if (bf->bf_state.bfs_rc[i].tries == 0)
 474                         continue;
 475                 amin = MIN(amin, bf->bf_state.bfs_rc[i].max4msframelen);
 476         }
 477
 478         DPRINTF(sc, ATH_DEBUG_SW_TX_AGGR, "%s: max frame len= %d\n",
 479             __func__, amin);
 480
 481         return amin;
 482 }
 483
 484 /*
 485  * Setup a 11n rate series structure
 486  *
 487  * This should be called for both legacy and MCS rates.
 488  *
 489  * This uses the rate series stuf from ath_tx_rate_fill_rcflags().
 490  *
 491  * It, along with ath_buf_set_rate, must be called -after- a burst
 492  * or aggregate is setup.
 493  */
 494 static void
 495 ath_rateseries_setup(struct ath_softc *sc, struct ieee80211_node *ni,
 496     struct ath_buf *bf, HAL_11N_RATE_SERIES *series)
 497 {
 498         struct ieee80211com *ic = ni->ni_ic;
 499         struct ath_hal *ah = sc->sc_ah;
 500         HAL_BOOL shortPreamble = AH_FALSE;
 501         const HAL_RATE_TABLE *rt = sc->sc_currates;
 502         int i;
 503         int pktlen;
 504         struct ath_rc_series *rc = bf->bf_state.bfs_rc;
 505
 506         if ((ic->ic_flags & IEEE80211_F_SHPREAMBLE) &&
 507             (ni->ni_capinfo & IEEE80211_CAPINFO_SHORT_PREAMBLE))
 508                 shortPreamble = AH_TRUE;
 509
 510         /*
 511          * If this is the first frame in an aggregate series,
 512          * use the aggregate length.
 513          */
 514         if (bf->bf_state.bfs_aggr)
 515                 pktlen = bf->bf_state.bfs_al;
 516         else
 517                 pktlen = bf->bf_state.bfs_pktlen;
 518
 519         /*
 520          * XXX TODO: modify this routine to use the bfs_rc[x].flags
 521          * XXX fields.
 522          */
 523         memset(series, 0, sizeof(HAL_11N_RATE_SERIES) * 4);
 524         for (i = 0; i < ATH_RC_NUM;  i++) {
 525                 /* Only set flags for actual TX attempts */
 526                 if (rc[i].tries == 0)
 527                         continue;
 528
 529                 series[i].Tries = rc[i].tries;
 530
 531                 /*
 532                  * XXX TODO: When the NIC is capable of three stream TX,
 533                  * transmit 1/2 stream rates on two streams.
 534                  *
 535                  * This reduces the power consumption of the NIC and
 536                  * keeps it within the PCIe slot power limits.
 537                  */
 538                 series[i].ChSel = sc->sc_cur_txchainmask;
 539
 540                 /*
 541                  * Setup rate and TX power cap for this series.
 542                  */
 543                 series[i].Rate = rt->info[rc[i].rix].rateCode;
 544                 series[i].RateIndex = rc[i].rix;
 545                 series[i].tx_power_cap = rc[i].tx_power_cap;
 546
 547                 /*
 548                  * Enable RTS/CTS as appropriate.
 549                  */
 550                 if (rc[i].flags & ATH_RC_RTSCTS_FLAG)
 551                         series[i].RateFlags |= HAL_RATESERIES_RTS_CTS;
 552
 553                 /*
 554                  * 11n rate? Update 11n flags.
 555                  */
 556                 if (rc[i].flags & ATH_RC_HT_FLAG) {
 557                         if (rc[i].flags & ATH_RC_CW40_FLAG)
 558                                 series[i].RateFlags |= HAL_RATESERIES_2040;
 559
 560                         if (rc[i].flags & ATH_RC_SGI_FLAG)
 561                                 series[i].RateFlags |= HAL_RATESERIES_HALFGI;
 562
 563                         if (rc[i].flags & ATH_RC_STBC_FLAG)
 564                                 series[i].RateFlags |= HAL_RATESERIES_STBC;
 565                 }
 566
 567                 /*
 568                  * PktDuration doesn't include slot, ACK, RTS, etc timing -
 569                  * it's just the packet duration
 570                  */
 571                 if (rc[i].flags & ATH_RC_HT_FLAG) {
 572                         series[i].PktDuration =
 573                             ath_computedur_ht(pktlen
 574                                 , series[i].Rate
 575                                 , HT_RC_2_STREAMS(series[i].Rate)
 576                                 , series[i].RateFlags & HAL_RATESERIES_2040
 577                                 , series[i].RateFlags & HAL_RATESERIES_HALFGI);
 578                 } else {
 579                         if (shortPreamble)
 580                                 series[i].Rate |=
 581                                     rt->info[rc[i].rix].shortPreamble;
 582                         series[i].PktDuration = ath_hal_computetxtime(ah,
 583                             rt, pktlen, rc[i].rix, shortPreamble);
 584                 }
 585         }
 586 }
 587
 588 #ifdef  ATH_DEBUG
 589 static void
 590 ath_rateseries_print(struct ath_softc *sc, HAL_11N_RATE_SERIES *series)
 591 {
 592         int i;
 593         for (i = 0; i < ATH_RC_NUM; i++) {
 594                 device_printf(sc->sc_dev ,"series %d: rate %x; tries %d; "
 595                     "pktDuration %d; chSel %d; txpowcap %d, rateFlags %x\n",
 596                     i,
 597                     series[i].Rate,
 598                     series[i].Tries,
 599                     series[i].PktDuration,
 600                     series[i].ChSel,
 601                     series[i].tx_power_cap,
 602                     series[i].RateFlags);
 603         }
 604 }
 605 #endif
 606
 607 /*
 608  * Setup the 11n rate scenario and burst duration for the given TX descriptor
 609  * list.
 610  *
 611  * This isn't useful for sending beacon frames, which has different needs
 612  * wrt what's passed into the rate scenario function.
 613  */
 614 void
 615 ath_buf_set_rate(struct ath_softc *sc, struct ieee80211_node *ni,
 616     struct ath_buf *bf)
 617 {
 618         HAL_11N_RATE_SERIES series[4];
 619         struct ath_desc *ds = bf->bf_desc;
 620         struct ath_hal *ah = sc->sc_ah;
 621         int is_pspoll = (bf->bf_state.bfs_atype == HAL_PKT_TYPE_PSPOLL);
 622         int ctsrate = bf->bf_state.bfs_ctsrate;
 623         int flags = bf->bf_state.bfs_txflags;
 624
 625         /* Setup rate scenario */
 626         memset(&series, 0, sizeof(series));
 627
 628         ath_rateseries_setup(sc, ni, bf, series);
 629
 630 #ifdef  ATH_DEBUG
 631         if (sc->sc_debug & ATH_DEBUG_XMIT)
 632                 ath_rateseries_print(sc, series);
 633 #endif
 634
 635         /* Set rate scenario */
 636         /*
 637          * Note: Don't allow hardware to override the duration on
 638          * ps-poll packets.
 639          */
 640         ath_hal_set11nratescenario(ah, ds,
 641             !is_pspoll, /* whether to override the duration or not */
 642             ctsrate,    /* rts/cts rate */
 643             series,     /* 11n rate series */
 644             4,          /* number of series */
 645             flags);
 646
 647         /* Set burst duration */
 648         /*
 649          * This is only required when doing 11n burst, not aggregation
 650          * ie, if there's a second frame in a RIFS or A-MPDU burst
 651          * w/ >1 A-MPDU frame bursting back to back.
 652          * Normal A-MPDU doesn't do bursting -between- aggregates.
 653          *
 654          * .. and it's highly likely this won't ever be implemented
 655          */
 656         //ath_hal_set11nburstduration(ah, ds, 8192);
 657 }
 658
 659 /*
 660  * Form an aggregate packet list.
 661  *
 662  * This function enforces the aggregate restrictions/requirements.
 663  *
 664  * These are:
 665  *
 666  * + The aggregate size maximum (64k for AR9160 and later, 8K for
 667  *   AR5416 when doing RTS frame protection.)
 668  * + Maximum number of sub-frames for an aggregate
 669  * + The aggregate delimiter size, giving MACs time to do whatever is
 670  *   needed before each frame
 671  * + Enforce the BAW limit
 672  *
 673  * Each descriptor queued should have the DMA setup.
 674  * The rate series, descriptor setup, linking, etc is all done
 675  * externally. This routine simply chains them together.
 676  * ath_tx_setds_11n() will take care of configuring the per-
 677  * descriptor setup, and ath_buf_set_rate() will configure the
 678  * rate control.
 679  *
 680  * The TID lock is required for the entirety of this function.
 681  *
 682  * If some code in another thread adds to the head of this
 683  * list, very strange behaviour will occur. Since retransmission is the
 684  * only reason this will occur, and this routine is designed to be called
 685  * from within the scheduler task, it won't ever clash with the completion
 686  * task.
 687  *
 688  * So if you want to call this from an upper layer context (eg, to direct-
 689  * dispatch aggregate frames to the hardware), please keep this in mind.
 690  */
 691 ATH_AGGR_STATUS
 692 ath_tx_form_aggr(struct ath_softc *sc, struct ath_node *an,
 693     struct ath_tid *tid, ath_bufhead *bf_q)
 694 {
 695         //struct ieee80211_node *ni = &an->an_node;
 696         struct ath_buf *bf, *bf_first = NULL, *bf_prev = NULL;
 697         int nframes = 0;
 698         uint16_t aggr_limit = 0, al = 0, bpad = 0, al_delta, h_baw;
 699         struct ieee80211_tx_ampdu *tap;
 700         int status = ATH_AGGR_DONE;
 701         int prev_frames = 0;    /* XXX for AR5416 burst, not done here */
 702         int prev_al = 0;        /* XXX also for AR5416 burst */
 703
 704         ATH_TX_LOCK_ASSERT(sc);
 705
 706         tap = ath_tx_get_tx_tid(an, tid->tid);
 707         if (tap == NULL) {
 708                 status = ATH_AGGR_ERROR;
 709                 goto finish;
 710         }
 711
 712         h_baw = tap->txa_wnd / 2;
 713
 714         for (;;) {
 715                 bf = ATH_TID_FIRST(tid);
 716                 if (bf_first == NULL)
 717                         bf_first = bf;
 718                 if (bf == NULL) {
 719                         status = ATH_AGGR_DONE;
 720                         break;
 721                 } else {
 722                         /*
 723                          * It's the first frame;
 724                          * set the aggregation limit based on the
 725                          * rate control decision that has been made.
 726                          */
 727                         aggr_limit = ath_get_aggr_limit(sc, bf_first);
 728                 }
 729
 730                 /* Set this early just so things don't get confused */
 731                 bf->bf_next = NULL;
 732
 733                 /*
 734                  * If the frame doesn't have a sequence number that we're
 735                  * tracking in the BAW (eg NULL QOS data frame), we can't
 736                  * aggregate it. Stop the aggregation process; the sender
 737                  * can then TX what's in the list thus far and then
 738                  * TX the frame individually.
 739                  */
 740                 if (! bf->bf_state.bfs_dobaw) {
 741                         status = ATH_AGGR_NONAGGR;
 742                         break;
 743                 }
 744
 745                 /*
 746                  * If any of the rates are non-HT, this packet
 747                  * can't be aggregated.
 748                  * XXX TODO: add a bf_state flag which gets marked
 749                  * if any active rate is non-HT.
 750                  */
 751
 752                 /*
 753                  * do not exceed aggregation limit
 754                  */
 755                 al_delta = ATH_AGGR_DELIM_SZ + bf->bf_state.bfs_pktlen;
 756                 if (nframes &&
 757                     (aggr_limit < (al + bpad + al_delta + prev_al))) {
 758                         status = ATH_AGGR_LIMITED;
 759                         break;
 760                 }
 761
 762                 /*
 763                  * If RTS/CTS is set on the first frame, enforce
 764                  * the RTS aggregate limit.
 765                  */
 766                 if (bf_first->bf_state.bfs_txflags &
 767                     (HAL_TXDESC_CTSENA | HAL_TXDESC_RTSENA)) {
 768                         if (nframes &&
 769                            (sc->sc_rts_aggr_limit <
 770                              (al + bpad + al_delta + prev_al))) {
 771                                 status = ATH_AGGR_8K_LIMITED;
 772                                 break;
 773                         }
 774                 }
 775
 776                 /*
 777                  * Do not exceed subframe limit.
 778                  */
 779                 if ((nframes + prev_frames) >= MIN((h_baw),
 780                     IEEE80211_AMPDU_SUBFRAME_DEFAULT)) {
 781                         status = ATH_AGGR_LIMITED;
 782                         break;
 783                 }
 784
 785                 /*
 786                  * If the current frame has an RTS/CTS configuration
 787                  * that differs from the first frame, override the
 788                  * subsequent frame with this config.
 789                  */
 790                 if (bf != bf_first) {
 791                         bf->bf_state.bfs_txflags &=
 792                             ~ (HAL_TXDESC_RTSENA | HAL_TXDESC_CTSENA);
 793                         bf->bf_state.bfs_txflags |=
 794                             bf_first->bf_state.bfs_txflags &
 795                             (HAL_TXDESC_RTSENA | HAL_TXDESC_CTSENA);
 796                 }
 797
 798                 /*
 799                  * If the packet has a sequence number, do not
 800                  * step outside of the block-ack window.
 801                  */
 802                 if (! BAW_WITHIN(tap->txa_start, tap->txa_wnd,
 803                     SEQNO(bf->bf_state.bfs_seqno))) {
 804                         status = ATH_AGGR_BAW_CLOSED;
 805                         break;
 806                 }
 807
 808                 /*
 809                  * this packet is part of an aggregate.
 810                  */
 811                 ATH_TID_REMOVE(tid, bf, bf_list);
 812
 813                 /* The TID lock is required for the BAW update */
 814                 ath_tx_addto_baw(sc, an, tid, bf);
 815                 bf->bf_state.bfs_addedbaw = 1;
 816
 817                 /*
 818                  * XXX enforce ACK for aggregate frames (this needs to be
 819                  * XXX handled more gracefully?
 820                  */
 821                 if (bf->bf_state.bfs_txflags & HAL_TXDESC_NOACK) {
 822                         device_printf(sc->sc_dev,
 823                             "%s: HAL_TXDESC_NOACK set for an aggregate frame?\n",
 824                             __func__);
 825                         bf->bf_state.bfs_txflags &= (~HAL_TXDESC_NOACK);
 826                 }
 827
 828                 /*
 829                  * Add the now owned buffer (which isn't
 830                  * on the software TXQ any longer) to our
 831                  * aggregate frame list.
 832                  */
 833                 TAILQ_INSERT_TAIL(bf_q, bf, bf_list);
 834                 nframes ++;
 835
 836                 /* Completion handler */
 837                 bf->bf_comp = ath_tx_aggr_comp;
 838
 839                 /*
 840                  * add padding for previous frame to aggregation length
 841                  */
 842                 al += bpad + al_delta;
 843
 844                 /*
 845                  * Calculate delimiters needed for the current frame
 846                  */
 847                 bf->bf_state.bfs_ndelim =
 848                     ath_compute_num_delims(sc, bf_first,
 849                     bf->bf_state.bfs_pktlen);
 850
 851                 /*
 852                  * Calculate the padding needed from this set of delimiters,
 853                  * used when calculating if the next frame will fit in
 854                  * the aggregate.
 855                  */
 856                 bpad = PADBYTES(al_delta) + (bf->bf_state.bfs_ndelim << 2);
 857
 858                 /*
 859                  * Chain the buffers together
 860                  */
 861                 if (bf_prev)
 862                         bf_prev->bf_next = bf;
 863                 bf_prev = bf;
 864
 865                 /*
 866                  * If we're leaking frames, just return at this point;
 867                  * we've queued a single frame and we don't want to add
 868                  * any more.
 869                  */
 870                 if (tid->an->an_leak_count) {
 871                         status = ATH_AGGR_LEAK_CLOSED;
 872                         break;
 873                 }
 874
 875 #if 0
 876                 /*
 877                  * terminate aggregation on a small packet boundary
 878                  */
 879                 if (bf->bf_state.bfs_pktlen < ATH_AGGR_MINPLEN) {
 880                         status = ATH_AGGR_SHORTPKT;
 881                         break;
 882                 }
 883 #endif
 884
 885         }
 886
 887 finish:
 888         /*
 889          * Just in case the list was empty when we tried to
 890          * dequeue a packet ..
 891          */
 892         if (bf_first) {
 893                 bf_first->bf_state.bfs_al = al;
 894                 bf_first->bf_state.bfs_nframes = nframes;
 895         }
 896         return status;
 897 }