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