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