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