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