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         int do_ldpc;
 231         int do_stbc;
 232
 233         /*
 234          * We only do LDPC if the rate is 11n, both we and the
 235          * receiver support LDPC and it's enabled.
 236          *
 237          * It's a global flag, not a per-try flag, so we clear
 238          * it if any of the rate entries aren't 11n.
 239          */
 240         do_ldpc = 0;
 241         if ((ni->ni_vap->iv_htcaps & IEEE80211_HTCAP_LDPC) &&
 242             (ni->ni_htcap & IEEE80211_HTCAP_LDPC))
 243                 do_ldpc = 1;
 244         do_stbc = 0;
 245
 246         for (i = 0; i < ATH_RC_NUM; i++) {
 247                 rc[i].flags = 0;
 248                 if (rc[i].tries == 0)
 249                         continue;
 250
 251                 rate = rt->info[rc[i].rix].rateCode;
 252
 253                 /*
 254                  * Only enable short preamble for legacy rates
 255                  */
 256                 if ((! IS_HT_RATE(rate)) && bf->bf_state.bfs_shpream)
 257                         rate |= rt->info[rc[i].rix].shortPreamble;
 258
 259                 /*
 260                  * Save this, used by the TX and completion code
 261                  */
 262                 rc[i].ratecode = rate;
 263
 264                 if (bf->bf_state.bfs_txflags &
 265                     (HAL_TXDESC_RTSENA | HAL_TXDESC_CTSENA))
 266                         rc[i].flags |= ATH_RC_RTSCTS_FLAG;
 267
 268                 /*
 269                  * If we can't do LDPC, don't.
 270                  */
 271                 if (! IS_HT_RATE(rate))
 272                         do_ldpc = 0;
 273
 274                 /* Only enable shortgi, 2040, dual-stream if HT is set */
 275                 if (IS_HT_RATE(rate)) {
 276                         rc[i].flags |= ATH_RC_HT_FLAG;
 277
 278                         if (ni->ni_chw == 40)
 279                                 rc[i].flags |= ATH_RC_CW40_FLAG;
 280
 281                         if (ni->ni_chw == 40 &&
 282                             ic->ic_htcaps & IEEE80211_HTCAP_SHORTGI40 &&
 283                             ni->ni_htcap & IEEE80211_HTCAP_SHORTGI40)
 284                                 rc[i].flags |= ATH_RC_SGI_FLAG;
 285
 286                         if (ni->ni_chw == 20 &&
 287                             ic->ic_htcaps & IEEE80211_HTCAP_SHORTGI20 &&
 288                             ni->ni_htcap & IEEE80211_HTCAP_SHORTGI20)
 289                                 rc[i].flags |= ATH_RC_SGI_FLAG;
 290
 291                         /*
 292                          * If we have STBC TX enabled and the receiver
 293                          * can receive (at least) 1 stream STBC, AND it's
 294                          * MCS 0-7, AND we have at least two chains enabled,
 295                          * enable STBC.
 296                          *
 297                          * XXX TODO: .. and the rate is an 11n rate?
 298                          */
 299                         if (ic->ic_htcaps & IEEE80211_HTCAP_TXSTBC &&
 300                             ni->ni_vap->iv_flags_ht & IEEE80211_FHT_STBC_TX &&
 301                             ni->ni_htcap & IEEE80211_HTCAP_RXSTBC_1STREAM &&
 302                             (sc->sc_cur_txchainmask > 1) &&
 303                             HT_RC_2_STREAMS(rate) == 1) {
 304                                 rc[i].flags |= ATH_RC_STBC_FLAG;
 305                                 do_stbc = 1;
 306                         }
 307
 308                         /*
 309                          * Dual / Triple stream rate?
 310                          */
 311                         if (HT_RC_2_STREAMS(rate) == 2)
 312                                 rc[i].flags |= ATH_RC_DS_FLAG;
 313                         else if (HT_RC_2_STREAMS(rate) == 3)
 314                                 rc[i].flags |= ATH_RC_TS_FLAG;
 315                 }
 316
 317                 /*
 318                  * Calculate the maximum TX power cap for the current
 319                  * node.
 320                  */
 321                 rc[i].tx_power_cap = ieee80211_get_node_txpower(ni);
 322
 323                 /*
 324                  * Calculate the maximum 4ms frame length based
 325                  * on the MCS rate, SGI and channel width flags.
 326                  */
 327                 if ((rc[i].flags & ATH_RC_HT_FLAG) &&
 328                     (HT_RC_2_MCS(rate) < 32)) {
 329                         int j;
 330                         if (rc[i].flags & ATH_RC_CW40_FLAG) {
 331                                 if (rc[i].flags & ATH_RC_SGI_FLAG)
 332                                         j = MCS_HT40_SGI;
 333                                 else
 334                                         j = MCS_HT40;
 335                         } else {
 336                                 if (rc[i].flags & ATH_RC_SGI_FLAG)
 337                                         j = MCS_HT20_SGI;
 338                                 else
 339                                         j = MCS_HT20;
 340                         }
 341                         rc[i].max4msframelen =
 342                             ath_max_4ms_framelen[j][HT_RC_2_MCS(rate)];
 343                 } else
 344                         rc[i].max4msframelen = 0;
 345                 DPRINTF(sc, ATH_DEBUG_SW_TX_AGGR,
 346                     "%s: i=%d, rate=0x%x, flags=0x%x, max4ms=%d\n",
 347                     __func__, i, rate, rc[i].flags, rc[i].max4msframelen);
 348         }
 349
 350         /*
 351          * LDPC is a global flag, so ...
 352          */
 353         if (do_ldpc) {
 354                 bf->bf_state.bfs_txflags |= HAL_TXDESC_LDPC;
 355                 sc->sc_stats.ast_tx_ldpc++;
 356         }
 357
 358         if (do_stbc) {
 359                 sc->sc_stats.ast_tx_stbc++;
 360         }
 361 }
 362
 363 /*
 364  * Return the number of delimiters to be added to
 365  * meet the minimum required mpdudensity.
 366  *
 367  * Caller should make sure that the rate is HT.
 368  *
 369  * TODO: is this delimiter calculation supposed to be the
 370  * total frame length, the hdr length, the data length (including
 371  * delimiters, padding, CRC, etc) or ?
 372  *
 373  * TODO: this should ensure that the rate control information
 374  * HAS been setup for the first rate.
 375  *
 376  * TODO: ensure this is only called for MCS rates.
 377  *
 378  * TODO: enforce MCS < 31
 379  */
 380 static int
 381 ath_compute_num_delims(struct ath_softc *sc, struct ath_buf *first_bf,
 382     uint16_t pktlen)
 383 {
 384         const HAL_RATE_TABLE *rt = sc->sc_currates;
 385         struct ieee80211_node *ni = first_bf->bf_node;
 386         struct ieee80211vap *vap = ni->ni_vap;
 387         int ndelim, mindelim = 0;
 388         int mpdudensity;         /* in 1/100'th of a microsecond */
 389         uint8_t rc, rix, flags;
 390         int width, half_gi;
 391         uint32_t nsymbits, nsymbols;
 392         uint16_t minlen;
 393
 394         /*
 395          * vap->iv_ampdu_density is a value, rather than the actual
 396          * density.
 397          */
 398         if (vap->iv_ampdu_density > IEEE80211_HTCAP_MPDUDENSITY_16)
 399                 mpdudensity = 1600;             /* maximum density */
 400         else
 401                 mpdudensity = ieee80211_mpdudensity_map[vap->iv_ampdu_density];
 402
 403         /* Select standard number of delimiters based on frame length */
 404         ndelim = ATH_AGGR_GET_NDELIM(pktlen);
 405
 406         /*
 407          * If encryption is enabled, add extra delimiters to let the
 408          * crypto hardware catch up. This could be tuned per-MAC and
 409          * per-rate, but for now we'll simply assume encryption is
 410          * always enabled.
 411          *
 412          * Also note that the Atheros reference driver inserts two
 413          * delimiters by default for pre-AR9380 peers.  This will
 414          * include "that" required delimiter.
 415          */
 416         ndelim += ATH_AGGR_ENCRYPTDELIM;
 417
 418         /*
 419          * For AR9380, there's a minimum number of delimeters
 420          * required when doing RTS.
 421          *
 422          * XXX TODO: this is only needed if (a) RTS/CTS is enabled, and
 423          * XXX (b) this is the first sub-frame in the aggregate.
 424          */
 425         if (sc->sc_use_ent && (sc->sc_ent_cfg & AH_ENT_RTSCTS_DELIM_WAR)
 426             && ndelim < AH_FIRST_DESC_NDELIMS)
 427                 ndelim = AH_FIRST_DESC_NDELIMS;
 428
 429         /*
 430          * If sc_delim_min_pad is non-zero, enforce it as the minimum
 431          * pad delimiter count.
 432          */
 433         if (sc->sc_delim_min_pad != 0)
 434                 ndelim = MAX(ndelim, sc->sc_delim_min_pad);
 435
 436         DPRINTF(sc, ATH_DEBUG_SW_TX_AGGR,
 437             "%s: pktlen=%d, ndelim=%d, mpdudensity=%d\n",
 438             __func__, pktlen, ndelim, mpdudensity);
 439
 440         /*
 441          * If the MPDU density is 0, we can return here.
 442          * Otherwise, we need to convert the desired mpdudensity
 443          * into a byte length, based on the rate in the subframe.
 444          */
 445         if (mpdudensity == 0)
 446                 return ndelim;
 447
 448         /*
 449          * Convert desired mpdu density from microeconds to bytes based
 450          * on highest rate in rate series (i.e. first rate) to determine
 451          * required minimum length for subframe. Take into account
 452          * whether high rate is 20 or 40Mhz and half or full GI.
 453          */
 454         rix = first_bf->bf_state.bfs_rc[0].rix;
 455         rc = rt->info[rix].rateCode;
 456         flags = first_bf->bf_state.bfs_rc[0].flags;
 457         width = !! (flags & ATH_RC_CW40_FLAG);
 458         half_gi = !! (flags & ATH_RC_SGI_FLAG);
 459
 460         /*
 461          * mpdudensity is in 1/100th of a usec, so divide by 100
 462          */
 463         if (half_gi)
 464                 nsymbols = NUM_SYMBOLS_PER_USEC_HALFGI(mpdudensity);
 465         else
 466                 nsymbols = NUM_SYMBOLS_PER_USEC(mpdudensity);
 467         nsymbols /= 100;
 468
 469         if (nsymbols == 0)
 470                 nsymbols = 1;
 471
 472         nsymbits = bits_per_symbol[HT_RC_2_MCS(rc)][width];
 473         minlen = (nsymbols * nsymbits) / BITS_PER_BYTE;
 474
 475         /*
 476          * Min length is the minimum frame length for the
 477          * required MPDU density.
 478          */
 479         if (pktlen < minlen) {
 480                 mindelim = (minlen - pktlen) / ATH_AGGR_DELIM_SZ;
 481                 ndelim = MAX(mindelim, ndelim);
 482         }
 483
 484         DPRINTF(sc, ATH_DEBUG_SW_TX_AGGR,
 485             "%s: pktlen=%d, minlen=%d, rix=%x, rc=%x, width=%d, hgi=%d, ndelim=%d\n",
 486             __func__, pktlen, minlen, rix, rc, width, half_gi, ndelim);
 487
 488         return ndelim;
 489 }
 490
 491 /*
 492  * Fetch the aggregation limit.
 493  *
 494  * It's the lowest of the four rate series 4ms frame length.
 495  */
 496 static int
 497 ath_get_aggr_limit(struct ath_softc *sc, struct ath_buf *bf)
 498 {
 499         int amin = ATH_AGGR_MAXSIZE;
 500         int i;
 501
 502         if (sc->sc_aggr_limit > 0 && sc->sc_aggr_limit < ATH_AGGR_MAXSIZE)
 503                 amin = sc->sc_aggr_limit;
 504
 505         for (i = 0; i < ATH_RC_NUM; i++) {
 506                 if (bf->bf_state.bfs_rc[i].tries == 0)
 507                         continue;
 508                 amin = MIN(amin, bf->bf_state.bfs_rc[i].max4msframelen);
 509         }
 510
 511         DPRINTF(sc, ATH_DEBUG_SW_TX_AGGR, "%s: max frame len= %d\n",
 512             __func__, amin);
 513
 514         return amin;
 515 }
 516
 517 /*
 518  * Setup a 11n rate series structure
 519  *
 520  * This should be called for both legacy and MCS rates.
 521  *
 522  * This uses the rate series stuf from ath_tx_rate_fill_rcflags().
 523  *
 524  * It, along with ath_buf_set_rate, must be called -after- a burst
 525  * or aggregate is setup.
 526  */
 527 static void
 528 ath_rateseries_setup(struct ath_softc *sc, struct ieee80211_node *ni,
 529     struct ath_buf *bf, HAL_11N_RATE_SERIES *series)
 530 {
 531         struct ieee80211com *ic = ni->ni_ic;
 532         struct ath_hal *ah = sc->sc_ah;
 533         HAL_BOOL shortPreamble = AH_FALSE;
 534         const HAL_RATE_TABLE *rt = sc->sc_currates;
 535         int i;
 536         int pktlen;
 537         struct ath_rc_series *rc = bf->bf_state.bfs_rc;
 538
 539         if ((ic->ic_flags & IEEE80211_F_SHPREAMBLE) &&
 540             (ni->ni_capinfo & IEEE80211_CAPINFO_SHORT_PREAMBLE))
 541                 shortPreamble = AH_TRUE;
 542
 543         /*
 544          * If this is the first frame in an aggregate series,
 545          * use the aggregate length.
 546          */
 547         if (bf->bf_state.bfs_aggr)
 548                 pktlen = bf->bf_state.bfs_al;
 549         else
 550                 pktlen = bf->bf_state.bfs_pktlen;
 551
 552         /*
 553          * XXX TODO: modify this routine to use the bfs_rc[x].flags
 554          * XXX fields.
 555          */
 556         memset(series, 0, sizeof(HAL_11N_RATE_SERIES) * 4);
 557         for (i = 0; i < ATH_RC_NUM;  i++) {
 558                 /* Only set flags for actual TX attempts */
 559                 if (rc[i].tries == 0)
 560                         continue;
 561
 562                 series[i].Tries = rc[i].tries;
 563
 564                 /*
 565                  * XXX TODO: When the NIC is capable of three stream TX,
 566                  * transmit 1/2 stream rates on two streams.
 567                  *
 568                  * This reduces the power consumption of the NIC and
 569                  * keeps it within the PCIe slot power limits.
 570                  */
 571                 series[i].ChSel = sc->sc_cur_txchainmask;
 572
 573                 /*
 574                  * Setup rate and TX power cap for this series.
 575                  */
 576                 series[i].Rate = rt->info[rc[i].rix].rateCode;
 577                 series[i].RateIndex = rc[i].rix;
 578                 series[i].tx_power_cap = rc[i].tx_power_cap;
 579
 580                 /*
 581                  * Enable RTS/CTS as appropriate.
 582                  */
 583                 if (rc[i].flags & ATH_RC_RTSCTS_FLAG)
 584                         series[i].RateFlags |= HAL_RATESERIES_RTS_CTS;
 585
 586                 /*
 587                  * 11n rate? Update 11n flags.
 588                  */
 589                 if (rc[i].flags & ATH_RC_HT_FLAG) {
 590                         if (rc[i].flags & ATH_RC_CW40_FLAG)
 591                                 series[i].RateFlags |= HAL_RATESERIES_2040;
 592
 593                         if (rc[i].flags & ATH_RC_SGI_FLAG)
 594                                 series[i].RateFlags |= HAL_RATESERIES_HALFGI;
 595
 596                         if (rc[i].flags & ATH_RC_STBC_FLAG)
 597                                 series[i].RateFlags |= HAL_RATESERIES_STBC;
 598                 }
 599
 600                 /*
 601                  * TODO: If we're all doing 11n rates then we can set LDPC.
 602                  * If we've been asked to /do/ LDPC but we are handed a
 603                  * legacy rate, then we should complain.  Loudly.
 604                  */
 605
 606                 /*
 607                  * PktDuration doesn't include slot, ACK, RTS, etc timing -
 608                  * it's just the packet duration
 609                  */
 610                 if (rc[i].flags & ATH_RC_HT_FLAG) {
 611                         series[i].PktDuration =
 612                             ath_computedur_ht(pktlen
 613                                 , series[i].Rate
 614                                 , HT_RC_2_STREAMS(series[i].Rate)
 615                                 , series[i].RateFlags & HAL_RATESERIES_2040
 616                                 , series[i].RateFlags & HAL_RATESERIES_HALFGI);
 617                 } else {
 618                         if (shortPreamble)
 619                                 series[i].Rate |=
 620                                     rt->info[rc[i].rix].shortPreamble;
 621                         series[i].PktDuration = ath_hal_computetxtime(ah,
 622                             rt, pktlen, rc[i].rix, shortPreamble);
 623                 }
 624         }
 625 }
 626
 627 #ifdef  ATH_DEBUG
 628 static void
 629 ath_rateseries_print(struct ath_softc *sc, HAL_11N_RATE_SERIES *series)
 630 {
 631         int i;
 632         for (i = 0; i < ATH_RC_NUM; i++) {
 633                 device_printf(sc->sc_dev ,"series %d: rate %x; tries %d; "
 634                     "pktDuration %d; chSel %d; txpowcap %d, rateFlags %x\n",
 635                     i,
 636                     series[i].Rate,
 637                     series[i].Tries,
 638                     series[i].PktDuration,
 639                     series[i].ChSel,
 640                     series[i].tx_power_cap,
 641                     series[i].RateFlags);
 642         }
 643 }
 644 #endif
 645
 646 /*
 647  * Setup the 11n rate scenario and burst duration for the given TX descriptor
 648  * list.
 649  *
 650  * This isn't useful for sending beacon frames, which has different needs
 651  * wrt what's passed into the rate scenario function.
 652  */
 653 void
 654 ath_buf_set_rate(struct ath_softc *sc, struct ieee80211_node *ni,
 655     struct ath_buf *bf)
 656 {
 657         HAL_11N_RATE_SERIES series[4];
 658         struct ath_desc *ds = bf->bf_desc;
 659         struct ath_hal *ah = sc->sc_ah;
 660         int is_pspoll = (bf->bf_state.bfs_atype == HAL_PKT_TYPE_PSPOLL);
 661         int ctsrate = bf->bf_state.bfs_ctsrate;
 662         int flags = bf->bf_state.bfs_txflags;
 663
 664         /* Setup rate scenario */
 665         memset(&series, 0, sizeof(series));
 666
 667         ath_rateseries_setup(sc, ni, bf, series);
 668
 669 #ifdef  ATH_DEBUG
 670         if (sc->sc_debug & ATH_DEBUG_XMIT)
 671                 ath_rateseries_print(sc, series);
 672 #endif
 673
 674         /* Set rate scenario */
 675         /*
 676          * Note: Don't allow hardware to override the duration on
 677          * ps-poll packets.
 678          */
 679         ath_hal_set11nratescenario(ah, ds,
 680             !is_pspoll, /* whether to override the duration or not */
 681             ctsrate,    /* rts/cts rate */
 682             series,     /* 11n rate series */
 683             4,          /* number of series */
 684             flags);
 685
 686         /* Set burst duration */
 687         /*
 688          * This is only required when doing 11n burst, not aggregation
 689          * ie, if there's a second frame in a RIFS or A-MPDU burst
 690          * w/ >1 A-MPDU frame bursting back to back.
 691          * Normal A-MPDU doesn't do bursting -between- aggregates.
 692          *
 693          * .. and it's highly likely this won't ever be implemented
 694          */
 695         //ath_hal_set11nburstduration(ah, ds, 8192);
 696 }
 697
 698 /*
 699  * Form an aggregate packet list.
 700  *
 701  * This function enforces the aggregate restrictions/requirements.
 702  *
 703  * These are:
 704  *
 705  * + The aggregate size maximum (64k for AR9160 and later, 8K for
 706  *   AR5416 when doing RTS frame protection.)
 707  * + Maximum number of sub-frames for an aggregate
 708  * + The aggregate delimiter size, giving MACs time to do whatever is
 709  *   needed before each frame
 710  * + Enforce the BAW limit
 711  *
 712  * Each descriptor queued should have the DMA setup.
 713  * The rate series, descriptor setup, linking, etc is all done
 714  * externally. This routine simply chains them together.
 715  * ath_tx_setds_11n() will take care of configuring the per-
 716  * descriptor setup, and ath_buf_set_rate() will configure the
 717  * rate control.
 718  *
 719  * The TID lock is required for the entirety of this function.
 720  *
 721  * If some code in another thread adds to the head of this
 722  * list, very strange behaviour will occur. Since retransmission is the
 723  * only reason this will occur, and this routine is designed to be called
 724  * from within the scheduler task, it won't ever clash with the completion
 725  * task.
 726  *
 727  * So if you want to call this from an upper layer context (eg, to direct-
 728  * dispatch aggregate frames to the hardware), please keep this in mind.
 729  */
 730 ATH_AGGR_STATUS
 731 ath_tx_form_aggr(struct ath_softc *sc, struct ath_node *an,
 732     struct ath_tid *tid, ath_bufhead *bf_q)
 733 {
 734         //struct ieee80211_node *ni = &an->an_node;
 735         struct ath_buf *bf, *bf_first = NULL, *bf_prev = NULL;
 736         int nframes = 0;
 737         uint16_t aggr_limit = 0, al = 0, bpad = 0, al_delta, h_baw;
 738         struct ieee80211_tx_ampdu *tap;
 739         int status = ATH_AGGR_DONE;
 740         int prev_frames = 0;    /* XXX for AR5416 burst, not done here */
 741         int prev_al = 0;        /* XXX also for AR5416 burst */
 742
 743         ATH_TX_LOCK_ASSERT(sc);
 744
 745         tap = ath_tx_get_tx_tid(an, tid->tid);
 746         if (tap == NULL) {
 747                 status = ATH_AGGR_ERROR;
 748                 goto finish;
 749         }
 750
 751         h_baw = tap->txa_wnd / 2;
 752
 753         for (;;) {
 754                 bf = ATH_TID_FIRST(tid);
 755                 if (bf_first == NULL)
 756                         bf_first = bf;
 757                 if (bf == NULL) {
 758                         status = ATH_AGGR_DONE;
 759                         break;
 760                 } else {
 761                         /*
 762                          * It's the first frame;
 763                          * set the aggregation limit based on the
 764                          * rate control decision that has been made.
 765                          */
 766                         aggr_limit = ath_get_aggr_limit(sc, bf_first);
 767                 }
 768
 769                 /* Set this early just so things don't get confused */
 770                 bf->bf_next = NULL;
 771
 772                 /*
 773                  * If the frame doesn't have a sequence number that we're
 774                  * tracking in the BAW (eg NULL QOS data frame), we can't
 775                  * aggregate it. Stop the aggregation process; the sender
 776                  * can then TX what's in the list thus far and then
 777                  * TX the frame individually.
 778                  */
 779                 if (! bf->bf_state.bfs_dobaw) {
 780                         status = ATH_AGGR_NONAGGR;
 781                         break;
 782                 }
 783
 784                 /*
 785                  * If any of the rates are non-HT, this packet
 786                  * can't be aggregated.
 787                  * XXX TODO: add a bf_state flag which gets marked
 788                  * if any active rate is non-HT.
 789                  */
 790
 791                 /*
 792                  * do not exceed aggregation limit
 793                  */
 794                 al_delta = ATH_AGGR_DELIM_SZ + bf->bf_state.bfs_pktlen;
 795                 if (nframes &&
 796                     (aggr_limit < (al + bpad + al_delta + prev_al))) {
 797                         status = ATH_AGGR_LIMITED;
 798                         break;
 799                 }
 800
 801                 /*
 802                  * If RTS/CTS is set on the first frame, enforce
 803                  * the RTS aggregate limit.
 804                  */
 805                 if (bf_first->bf_state.bfs_txflags &
 806                     (HAL_TXDESC_CTSENA | HAL_TXDESC_RTSENA)) {
 807                         if (nframes &&
 808                            (sc->sc_rts_aggr_limit <
 809                              (al + bpad + al_delta + prev_al))) {
 810                                 status = ATH_AGGR_8K_LIMITED;
 811                                 break;
 812                         }
 813                 }
 814
 815                 /*
 816                  * Do not exceed subframe limit.
 817                  */
 818                 if ((nframes + prev_frames) >= MIN((h_baw),
 819                     IEEE80211_AMPDU_SUBFRAME_DEFAULT)) {
 820                         status = ATH_AGGR_LIMITED;
 821                         break;
 822                 }
 823
 824                 /*
 825                  * If the current frame has an RTS/CTS configuration
 826                  * that differs from the first frame, override the
 827                  * subsequent frame with this config.
 828                  */
 829                 if (bf != bf_first) {
 830                         bf->bf_state.bfs_txflags &=
 831                             ~ (HAL_TXDESC_RTSENA | HAL_TXDESC_CTSENA);
 832                         bf->bf_state.bfs_txflags |=
 833                             bf_first->bf_state.bfs_txflags &
 834                             (HAL_TXDESC_RTSENA | HAL_TXDESC_CTSENA);
 835                 }
 836
 837                 /*
 838                  * If the packet has a sequence number, do not
 839                  * step outside of the block-ack window.
 840                  */
 841                 if (! BAW_WITHIN(tap->txa_start, tap->txa_wnd,
 842                     SEQNO(bf->bf_state.bfs_seqno))) {
 843                         status = ATH_AGGR_BAW_CLOSED;
 844                         break;
 845                 }
 846
 847                 /*
 848                  * this packet is part of an aggregate.
 849                  */
 850                 ATH_TID_REMOVE(tid, bf, bf_list);
 851
 852                 /* The TID lock is required for the BAW update */
 853                 ath_tx_addto_baw(sc, an, tid, bf);
 854                 bf->bf_state.bfs_addedbaw = 1;
 855
 856                 /*
 857                  * XXX enforce ACK for aggregate frames (this needs to be
 858                  * XXX handled more gracefully?
 859                  */
 860                 if (bf->bf_state.bfs_txflags & HAL_TXDESC_NOACK) {
 861                         device_printf(sc->sc_dev,
 862                             "%s: HAL_TXDESC_NOACK set for an aggregate frame?\n",
 863                             __func__);
 864                         bf->bf_state.bfs_txflags &= (~HAL_TXDESC_NOACK);
 865                 }
 866
 867                 /*
 868                  * Add the now owned buffer (which isn't
 869                  * on the software TXQ any longer) to our
 870                  * aggregate frame list.
 871                  */
 872                 TAILQ_INSERT_TAIL(bf_q, bf, bf_list);
 873                 nframes ++;
 874
 875                 /* Completion handler */
 876                 bf->bf_comp = ath_tx_aggr_comp;
 877
 878                 /*
 879                  * add padding for previous frame to aggregation length
 880                  */
 881                 al += bpad + al_delta;
 882
 883                 /*
 884                  * Calculate delimiters needed for the current frame
 885                  */
 886                 bf->bf_state.bfs_ndelim =
 887                     ath_compute_num_delims(sc, bf_first,
 888                     bf->bf_state.bfs_pktlen);
 889
 890                 /*
 891                  * Calculate the padding needed from this set of delimiters,
 892                  * used when calculating if the next frame will fit in
 893                  * the aggregate.
 894                  */
 895                 bpad = PADBYTES(al_delta) + (bf->bf_state.bfs_ndelim << 2);
 896
 897                 /*
 898                  * Chain the buffers together
 899                  */
 900                 if (bf_prev)
 901                         bf_prev->bf_next = bf;
 902                 bf_prev = bf;
 903
 904                 /*
 905                  * If we're leaking frames, just return at this point;
 906                  * we've queued a single frame and we don't want to add
 907                  * any more.
 908                  */
 909                 if (tid->an->an_leak_count) {
 910                         status = ATH_AGGR_LEAK_CLOSED;
 911                         break;
 912                 }
 913
 914 #if 0
 915                 /*
 916                  * terminate aggregation on a small packet boundary
 917                  */
 918                 if (bf->bf_state.bfs_pktlen < ATH_AGGR_MINPLEN) {
 919                         status = ATH_AGGR_SHORTPKT;
 920                         break;
 921                 }
 922 #endif
 923
 924         }
 925
 926 finish:
 927         /*
 928          * Just in case the list was empty when we tried to
 929          * dequeue a packet ..
 930          */
 931         if (bf_first) {
 932                 bf_first->bf_state.bfs_al = al;
 933                 bf_first->bf_state.bfs_nframes = nframes;
 934         }
 935         return status;
 936 }