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