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