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, int is_first)
 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 for
 462          * this exchange, and (b) (done) this is the first sub-frame
 463          * in the aggregate.
 464          */
 465         if (sc->sc_use_ent && (sc->sc_ent_cfg & AH_ENT_RTSCTS_DELIM_WAR)
 466             && ndelim < AH_FIRST_DESC_NDELIMS && is_first)
 467                 ndelim = AH_FIRST_DESC_NDELIMS;
 468
 469         /*
 470          * If sc_delim_min_pad is non-zero, enforce it as the minimum
 471          * pad delimiter count.
 472          */
 473         if (sc->sc_delim_min_pad != 0)
 474                 ndelim = MAX(ndelim, sc->sc_delim_min_pad);
 475
 476         DPRINTF(sc, ATH_DEBUG_SW_TX_AGGR,
 477             "%s: pktlen=%d, ndelim=%d, mpdudensity=%d\n",
 478             __func__, pktlen, ndelim, mpdudensity);
 479
 480         /*
 481          * If the MPDU density is 0, we can return here.
 482          * Otherwise, we need to convert the desired mpdudensity
 483          * into a byte length, based on the rate in the subframe.
 484          */
 485         if (mpdudensity == 0)
 486                 return ndelim;
 487
 488         /*
 489          * Convert desired mpdu density from microeconds to bytes based
 490          * on highest rate in rate series (i.e. first rate) to determine
 491          * required minimum length for subframe. Take into account
 492          * whether high rate is 20 or 40Mhz and half or full GI.
 493          */
 494         rix = first_bf->bf_state.bfs_rc[0].rix;
 495         rc = rt->info[rix].rateCode;
 496         flags = first_bf->bf_state.bfs_rc[0].flags;
 497         width = !! (flags & ATH_RC_CW40_FLAG);
 498         half_gi = !! (flags & ATH_RC_SGI_FLAG);
 499
 500         /*
 501          * mpdudensity is in 1/100th of a usec, so divide by 100
 502          */
 503         if (half_gi)
 504                 nsymbols = NUM_SYMBOLS_PER_USEC_HALFGI(mpdudensity);
 505         else
 506                 nsymbols = NUM_SYMBOLS_PER_USEC(mpdudensity);
 507         nsymbols /= 100;
 508
 509         if (nsymbols == 0)
 510                 nsymbols = 1;
 511
 512         nsymbits = bits_per_symbol[HT_RC_2_MCS(rc)][width];
 513         minlen = (nsymbols * nsymbits) / BITS_PER_BYTE;
 514
 515         /*
 516          * Min length is the minimum frame length for the
 517          * required MPDU density.
 518          */
 519         if (pktlen < minlen) {
 520                 mindelim = (minlen - pktlen) / ATH_AGGR_DELIM_SZ;
 521                 ndelim = MAX(mindelim, ndelim);
 522         }
 523
 524         DPRINTF(sc, ATH_DEBUG_SW_TX_AGGR,
 525             "%s: pktlen=%d, minlen=%d, rix=%x, rc=%x, width=%d, hgi=%d, ndelim=%d\n",
 526             __func__, pktlen, minlen, rix, rc, width, half_gi, ndelim);
 527
 528         return ndelim;
 529 #undef  MS
 530 }
 531
 532 /*
 533  * XXX TODO: put into net80211
 534  */
 535 static int
 536 ath_rx_ampdu_to_byte(char a)
 537 {
 538         switch (a) {
 539         case IEEE80211_HTCAP_MAXRXAMPDU_16K:
 540                 return 16384;
 541                 break;
 542         case IEEE80211_HTCAP_MAXRXAMPDU_32K:
 543                 return 32768;
 544                 break;
 545         case IEEE80211_HTCAP_MAXRXAMPDU_64K:
 546                 return 65536;
 547                 break;
 548         case IEEE80211_HTCAP_MAXRXAMPDU_8K:
 549         default:
 550                 return 8192;
 551                 break;
 552         }
 553 }
 554
 555 /*
 556  * Fetch the aggregation limit.
 557  *
 558  * It's the lowest of the four rate series 4ms frame length.
 559  *
 560  * Also take into account the hardware specific limits (8KiB on AR5416)
 561  * and per-peer limits in non-STA mode.
 562  */
 563 static int
 564 ath_get_aggr_limit(struct ath_softc *sc, struct ieee80211_node *ni,
 565     struct ath_buf *bf)
 566 {
 567         struct ieee80211vap *vap = ni->ni_vap;
 568
 569 #define MS(_v, _f)      (((_v) & _f) >> _f##_S)
 570         int amin = ATH_AGGR_MAXSIZE;
 571         int i;
 572
 573         /* Extract out the maximum configured driver A-MPDU limit */
 574         if (sc->sc_aggr_limit > 0 && sc->sc_aggr_limit < ATH_AGGR_MAXSIZE)
 575                 amin = sc->sc_aggr_limit;
 576
 577         /* Check the vap configured transmit limit */
 578         amin = MIN(amin, ath_rx_ampdu_to_byte(vap->iv_ampdu_limit));
 579
 580         /*
 581          * Check the HTCAP field for the maximum size the node has
 582          * negotiated.  If it's smaller than what we have, cap it there.
 583          */
 584         amin = MIN(amin, ath_rx_ampdu_to_byte(MS(ni->ni_htparam,
 585             IEEE80211_HTCAP_MAXRXAMPDU)));
 586
 587         for (i = 0; i < ATH_RC_NUM; i++) {
 588                 if (bf->bf_state.bfs_rc[i].tries == 0)
 589                         continue;
 590                 amin = MIN(amin, bf->bf_state.bfs_rc[i].max4msframelen);
 591         }
 592
 593         DPRINTF(sc, ATH_DEBUG_SW_TX_AGGR,
 594             "%s: aggr_limit=%d, iv_ampdu_limit=%d, "
 595             "peer maxrxampdu=%d, max frame len=%d\n",
 596             __func__,
 597             sc->sc_aggr_limit,
 598             vap->iv_ampdu_limit,
 599             MS(ni->ni_htparam, IEEE80211_HTCAP_MAXRXAMPDU),
 600             amin);
 601
 602         return amin;
 603 #undef  MS
 604 }
 605
 606 /*
 607  * Setup a 11n rate series structure
 608  *
 609  * This should be called for both legacy and MCS rates.
 610  *
 611  * This uses the rate series stuf from ath_tx_rate_fill_rcflags().
 612  *
 613  * It, along with ath_buf_set_rate, must be called -after- a burst
 614  * or aggregate is setup.
 615  */
 616 static void
 617 ath_rateseries_setup(struct ath_softc *sc, struct ieee80211_node *ni,
 618     struct ath_buf *bf, HAL_11N_RATE_SERIES *series)
 619 {
 620         struct ieee80211com *ic = ni->ni_ic;
 621         struct ath_hal *ah = sc->sc_ah;
 622         HAL_BOOL shortPreamble = AH_FALSE;
 623         const HAL_RATE_TABLE *rt = sc->sc_currates;
 624         int i;
 625         int pktlen;
 626         struct ath_rc_series *rc = bf->bf_state.bfs_rc;
 627
 628         if ((ic->ic_flags & IEEE80211_F_SHPREAMBLE) &&
 629             (ni->ni_capinfo & IEEE80211_CAPINFO_SHORT_PREAMBLE))
 630                 shortPreamble = AH_TRUE;
 631
 632         /*
 633          * If this is the first frame in an aggregate series,
 634          * use the aggregate length.
 635          */
 636         if (bf->bf_state.bfs_aggr)
 637                 pktlen = bf->bf_state.bfs_al;
 638         else
 639                 pktlen = bf->bf_state.bfs_pktlen;
 640
 641         /*
 642          * XXX TODO: modify this routine to use the bfs_rc[x].flags
 643          * XXX fields.
 644          */
 645         memset(series, 0, sizeof(HAL_11N_RATE_SERIES) * 4);
 646         for (i = 0; i < ATH_RC_NUM;  i++) {
 647                 /* Only set flags for actual TX attempts */
 648                 if (rc[i].tries == 0)
 649                         continue;
 650
 651                 series[i].Tries = rc[i].tries;
 652
 653                 /*
 654                  * XXX TODO: When the NIC is capable of three stream TX,
 655                  * transmit 1/2 stream rates on two streams.
 656                  *
 657                  * This reduces the power consumption of the NIC and
 658                  * keeps it within the PCIe slot power limits.
 659                  */
 660                 series[i].ChSel = sc->sc_cur_txchainmask;
 661
 662                 /*
 663                  * Setup rate and TX power cap for this series.
 664                  */
 665                 series[i].Rate = rt->info[rc[i].rix].rateCode;
 666                 series[i].RateIndex = rc[i].rix;
 667                 series[i].tx_power_cap = rc[i].tx_power_cap;
 668
 669                 /*
 670                  * Enable RTS/CTS as appropriate.
 671                  */
 672                 if (rc[i].flags & ATH_RC_RTSCTS_FLAG)
 673                         series[i].RateFlags |= HAL_RATESERIES_RTS_CTS;
 674
 675                 /*
 676                  * 11n rate? Update 11n flags.
 677                  */
 678                 if (rc[i].flags & ATH_RC_HT_FLAG) {
 679                         if (rc[i].flags & ATH_RC_CW40_FLAG)
 680                                 series[i].RateFlags |= HAL_RATESERIES_2040;
 681
 682                         if (rc[i].flags & ATH_RC_SGI_FLAG)
 683                                 series[i].RateFlags |= HAL_RATESERIES_HALFGI;
 684
 685                         if (rc[i].flags & ATH_RC_STBC_FLAG)
 686                                 series[i].RateFlags |= HAL_RATESERIES_STBC;
 687                 }
 688
 689                 /*
 690                  * TODO: If we're all doing 11n rates then we can set LDPC.
 691                  * If we've been asked to /do/ LDPC but we are handed a
 692                  * legacy rate, then we should complain.  Loudly.
 693                  */
 694
 695                 /*
 696                  * PktDuration doesn't include slot, ACK, RTS, etc timing -
 697                  * it's just the packet duration
 698                  */
 699                 if (rc[i].flags & ATH_RC_HT_FLAG) {
 700                         series[i].PktDuration =
 701                             ath_computedur_ht(pktlen
 702                                 , series[i].Rate
 703                                 , HT_RC_2_STREAMS(series[i].Rate)
 704                                 , series[i].RateFlags & HAL_RATESERIES_2040
 705                                 , series[i].RateFlags & HAL_RATESERIES_HALFGI);
 706                 } else {
 707                         if (shortPreamble)
 708                                 series[i].Rate |=
 709                                     rt->info[rc[i].rix].shortPreamble;
 710                         /* XXX TODO: don't include SIFS */
 711                         series[i].PktDuration = ath_hal_computetxtime(ah,
 712                             rt, pktlen, rc[i].rix, shortPreamble, AH_TRUE);
 713                 }
 714         }
 715 }
 716
 717 #ifdef  ATH_DEBUG
 718 static void
 719 ath_rateseries_print(struct ath_softc *sc, HAL_11N_RATE_SERIES *series)
 720 {
 721         int i;
 722         for (i = 0; i < ATH_RC_NUM; i++) {
 723                 device_printf(sc->sc_dev ,"series %d: rate %x; tries %d; "
 724                     "pktDuration %d; chSel %d; txpowcap %d, rateFlags %x\n",
 725                     i,
 726                     series[i].Rate,
 727                     series[i].Tries,
 728                     series[i].PktDuration,
 729                     series[i].ChSel,
 730                     series[i].tx_power_cap,
 731                     series[i].RateFlags);
 732         }
 733 }
 734 #endif
 735
 736 /*
 737  * Setup the 11n rate scenario and burst duration for the given TX descriptor
 738  * list.
 739  *
 740  * This isn't useful for sending beacon frames, which has different needs
 741  * wrt what's passed into the rate scenario function.
 742  */
 743 void
 744 ath_buf_set_rate(struct ath_softc *sc, struct ieee80211_node *ni,
 745     struct ath_buf *bf)
 746 {
 747         HAL_11N_RATE_SERIES series[4];
 748         struct ath_desc *ds = bf->bf_desc;
 749         struct ath_hal *ah = sc->sc_ah;
 750         int is_pspoll = (bf->bf_state.bfs_atype == HAL_PKT_TYPE_PSPOLL);
 751         int ctsrate = bf->bf_state.bfs_ctsrate;
 752         int flags = bf->bf_state.bfs_txflags;
 753
 754         /* Setup rate scenario */
 755         memset(&series, 0, sizeof(series));
 756
 757         ath_rateseries_setup(sc, ni, bf, series);
 758
 759 #ifdef  ATH_DEBUG
 760         if (sc->sc_debug & ATH_DEBUG_XMIT)
 761                 ath_rateseries_print(sc, series);
 762 #endif
 763
 764         /* Set rate scenario */
 765         /*
 766          * Note: Don't allow hardware to override the duration on
 767          * ps-poll packets.
 768          */
 769         ath_hal_set11nratescenario(ah, ds,
 770             !is_pspoll, /* whether to override the duration or not */
 771             ctsrate,    /* rts/cts rate */
 772             series,     /* 11n rate series */
 773             4,          /* number of series */
 774             flags);
 775
 776         /* Set burst duration */
 777         /*
 778          * This is only required when doing 11n burst, not aggregation
 779          * ie, if there's a second frame in a RIFS or A-MPDU burst
 780          * w/ >1 A-MPDU frame bursting back to back.
 781          * Normal A-MPDU doesn't do bursting -between- aggregates.
 782          *
 783          * .. and it's highly likely this won't ever be implemented
 784          */
 785         //ath_hal_set11nburstduration(ah, ds, 8192);
 786 }
 787
 788 /*
 789  * Form an aggregate packet list.
 790  *
 791  * This function enforces the aggregate restrictions/requirements.
 792  *
 793  * These are:
 794  *
 795  * + The aggregate size maximum (64k for AR9160 and later, 8K for
 796  *   AR5416 when doing RTS frame protection.)
 797  * + Maximum number of sub-frames for an aggregate
 798  * + The aggregate delimiter size, giving MACs time to do whatever is
 799  *   needed before each frame
 800  * + Enforce the BAW limit
 801  *
 802  * Each descriptor queued should have the DMA setup.
 803  * The rate series, descriptor setup, linking, etc is all done
 804  * externally. This routine simply chains them together.
 805  * ath_tx_setds_11n() will take care of configuring the per-
 806  * descriptor setup, and ath_buf_set_rate() will configure the
 807  * rate control.
 808  *
 809  * The TID lock is required for the entirety of this function.
 810  *
 811  * If some code in another thread adds to the head of this
 812  * list, very strange behaviour will occur. Since retransmission is the
 813  * only reason this will occur, and this routine is designed to be called
 814  * from within the scheduler task, it won't ever clash with the completion
 815  * task.
 816  *
 817  * So if you want to call this from an upper layer context (eg, to direct-
 818  * dispatch aggregate frames to the hardware), please keep this in mind.
 819  */
 820 ATH_AGGR_STATUS
 821 ath_tx_form_aggr(struct ath_softc *sc, struct ath_node *an,
 822     struct ath_tid *tid, ath_bufhead *bf_q)
 823 {
 824         //struct ieee80211_node *ni = &an->an_node;
 825         struct ath_buf *bf, *bf_first = NULL, *bf_prev = NULL;
 826         int nframes = 0;
 827         uint16_t aggr_limit = 0, al = 0, bpad = 0, al_delta, h_baw;
 828         struct ieee80211_tx_ampdu *tap;
 829         int status = ATH_AGGR_DONE;
 830         int prev_frames = 0;    /* XXX for AR5416 burst, not done here */
 831         int prev_al = 0;        /* XXX also for AR5416 burst */
 832
 833         ATH_TX_LOCK_ASSERT(sc);
 834
 835         tap = ath_tx_get_tx_tid(an, tid->tid);
 836         if (tap == NULL) {
 837                 status = ATH_AGGR_ERROR;
 838                 goto finish;
 839         }
 840
 841         h_baw = tap->txa_wnd / 2;
 842
 843         for (;;) {
 844                 bf = ATH_TID_FIRST(tid);
 845                 if (bf_first == NULL)
 846                         bf_first = bf;
 847                 if (bf == NULL) {
 848                         status = ATH_AGGR_DONE;
 849                         break;
 850                 } else {
 851                         /*
 852                          * It's the first frame;
 853                          * set the aggregation limit based on the
 854                          * rate control decision that has been made.
 855                          */
 856                         aggr_limit = ath_get_aggr_limit(sc, &an->an_node,
 857                             bf_first);
 858                 }
 859
 860                 /* Set this early just so things don't get confused */
 861                 bf->bf_next = NULL;
 862
 863                 /*
 864                  * If the frame doesn't have a sequence number that we're
 865                  * tracking in the BAW (eg NULL QOS data frame), we can't
 866                  * aggregate it. Stop the aggregation process; the sender
 867                  * can then TX what's in the list thus far and then
 868                  * TX the frame individually.
 869                  */
 870                 if (! bf->bf_state.bfs_dobaw) {
 871                         status = ATH_AGGR_NONAGGR;
 872                         break;
 873                 }
 874
 875                 /*
 876                  * If any of the rates are non-HT, this packet
 877                  * can't be aggregated.
 878                  * XXX TODO: add a bf_state flag which gets marked
 879                  * if any active rate is non-HT.
 880                  */
 881
 882                 /*
 883                  * do not exceed aggregation limit
 884                  */
 885                 al_delta = ATH_AGGR_DELIM_SZ + bf->bf_state.bfs_pktlen;
 886                 if (nframes &&
 887                     (aggr_limit < (al + bpad + al_delta + prev_al))) {
 888                         status = ATH_AGGR_LIMITED;
 889                         break;
 890                 }
 891
 892                 /*
 893                  * If RTS/CTS is set on the first frame, enforce
 894                  * the RTS aggregate limit.
 895                  */
 896                 if (bf_first->bf_state.bfs_txflags &
 897                     (HAL_TXDESC_CTSENA | HAL_TXDESC_RTSENA)) {
 898                         if (nframes &&
 899                            (sc->sc_rts_aggr_limit <
 900                              (al + bpad + al_delta + prev_al))) {
 901                                 status = ATH_AGGR_8K_LIMITED;
 902                                 break;
 903                         }
 904                 }
 905
 906                 /*
 907                  * Do not exceed subframe limit.
 908                  */
 909                 if ((nframes + prev_frames) >= MIN((h_baw),
 910                     IEEE80211_AMPDU_SUBFRAME_DEFAULT)) {
 911                         status = ATH_AGGR_LIMITED;
 912                         break;
 913                 }
 914
 915                 /*
 916                  * If the current frame has an RTS/CTS configuration
 917                  * that differs from the first frame, override the
 918                  * subsequent frame with this config.
 919                  */
 920                 if (bf != bf_first) {
 921                         bf->bf_state.bfs_txflags &=
 922                             ~ (HAL_TXDESC_RTSENA | HAL_TXDESC_CTSENA);
 923                         bf->bf_state.bfs_txflags |=
 924                             bf_first->bf_state.bfs_txflags &
 925                             (HAL_TXDESC_RTSENA | HAL_TXDESC_CTSENA);
 926                 }
 927
 928                 /*
 929                  * If the packet has a sequence number, do not
 930                  * step outside of the block-ack window.
 931                  */
 932                 if (! BAW_WITHIN(tap->txa_start, tap->txa_wnd,
 933                     SEQNO(bf->bf_state.bfs_seqno))) {
 934                         status = ATH_AGGR_BAW_CLOSED;
 935                         break;
 936                 }
 937
 938                 /*
 939                  * this packet is part of an aggregate.
 940                  */
 941                 ATH_TID_REMOVE(tid, bf, bf_list);
 942
 943                 /* The TID lock is required for the BAW update */
 944                 ath_tx_addto_baw(sc, an, tid, bf);
 945                 bf->bf_state.bfs_addedbaw = 1;
 946
 947                 /*
 948                  * XXX enforce ACK for aggregate frames (this needs to be
 949                  * XXX handled more gracefully?
 950                  */
 951                 if (bf->bf_state.bfs_txflags & HAL_TXDESC_NOACK) {
 952                         device_printf(sc->sc_dev,
 953                             "%s: HAL_TXDESC_NOACK set for an aggregate frame?\n",
 954                             __func__);
 955                         bf->bf_state.bfs_txflags &= (~HAL_TXDESC_NOACK);
 956                 }
 957
 958                 /*
 959                  * Add the now owned buffer (which isn't
 960                  * on the software TXQ any longer) to our
 961                  * aggregate frame list.
 962                  */
 963                 TAILQ_INSERT_TAIL(bf_q, bf, bf_list);
 964                 nframes ++;
 965
 966                 /* Completion handler */
 967                 bf->bf_comp = ath_tx_aggr_comp;
 968
 969                 /*
 970                  * add padding for previous frame to aggregation length
 971                  */
 972                 al += bpad + al_delta;
 973
 974                 /*
 975                  * Calculate delimiters needed for the current frame
 976                  */
 977                 bf->bf_state.bfs_ndelim =
 978                     ath_compute_num_delims(sc, bf_first,
 979                     bf->bf_state.bfs_pktlen, (bf_first == bf));
 980
 981                 /*
 982                  * Calculate the padding needed from this set of delimiters,
 983                  * used when calculating if the next frame will fit in
 984                  * the aggregate.
 985                  */
 986                 bpad = PADBYTES(al_delta) + (bf->bf_state.bfs_ndelim << 2);
 987
 988                 /*
 989                  * Chain the buffers together
 990                  */
 991                 if (bf_prev)
 992                         bf_prev->bf_next = bf;
 993                 bf_prev = bf;
 994
 995                 /*
 996                  * If we're leaking frames, just return at this point;
 997                  * we've queued a single frame and we don't want to add
 998                  * any more.
 999                  */
1000                 if (tid->an->an_leak_count) {
1001                         status = ATH_AGGR_LEAK_CLOSED;
1002                         break;
1003                 }
1004
1005 #if 0
1006                 /*
1007                  * terminate aggregation on a small packet boundary
1008                  */
1009                 if (bf->bf_state.bfs_pktlen < ATH_AGGR_MINPLEN) {
1010                         status = ATH_AGGR_SHORTPKT;
1011                         break;
1012                 }
1013 #endif
1014
1015         }
1016
1017 finish:
1018         /*
1019          * Just in case the list was empty when we tried to
1020          * dequeue a packet ..
1021          */
1022         if (bf_first) {
1023                 bf_first->bf_state.bfs_al = al;
1024                 bf_first->bf_state.bfs_nframes = nframes;
1025         }
1026         return status;
1027 }