1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 2011 Adrian Chadd, Xenion Pty Ltd. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer, 12 * without modification. 13 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 14 * similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any 15 * redistribution must be conditioned upon including a substantially 16 * similar Disclaimer requirement for further binary redistribution. 17 * 18 * NO WARRANTY 19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 21 * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY 22 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 23 * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, 24 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 27 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 29 * THE POSSIBILITY OF SUCH DAMAGES. 30 */ 31 32 #include <sys/cdefs.h> 33 __FBSDID("$FreeBSD$"); 34 35 #include "opt_inet.h" 36 #include "opt_ath.h" 37 #include "opt_wlan.h" 38 39 #include <sys/param.h> 40 #include <sys/systm.h> 41 #include <sys/sysctl.h> 42 #include <sys/mbuf.h> 43 #include <sys/malloc.h> 44 #include <sys/lock.h> 45 #include <sys/mutex.h> 46 #include <sys/kernel.h> 47 #include <sys/socket.h> 48 #include <sys/sockio.h> 49 #include <sys/errno.h> 50 #include <sys/callout.h> 51 #include <sys/bus.h> 52 #include <sys/endian.h> 53 #include <sys/kthread.h> 54 #include <sys/taskqueue.h> 55 #include <sys/priv.h> 56 57 #include <machine/bus.h> 58 59 #include <net/if.h> 60 #include <net/if_dl.h> 61 #include <net/if_media.h> 62 #include <net/if_types.h> 63 #include <net/if_arp.h> 64 #include <net/ethernet.h> 65 #include <net/if_llc.h> 66 67 #include <net80211/ieee80211_var.h> 68 #include <net80211/ieee80211_regdomain.h> 69 #ifdef IEEE80211_SUPPORT_SUPERG 70 #include <net80211/ieee80211_superg.h> 71 #endif 72 #ifdef IEEE80211_SUPPORT_TDMA 73 #include <net80211/ieee80211_tdma.h> 74 #endif 75 76 #include <net/bpf.h> 77 78 #ifdef INET 79 #include <netinet/in.h> 80 #include <netinet/if_ether.h> 81 #endif 82 83 #include <dev/ath/if_athvar.h> 84 #include <dev/ath/ath_hal/ah_devid.h> /* XXX for softled */ 85 #include <dev/ath/ath_hal/ah_diagcodes.h> 86 87 #ifdef ATH_TX99_DIAG 88 #include <dev/ath/ath_tx99/ath_tx99.h> 89 #endif 90 91 #include <dev/ath/if_ath_tx.h> /* XXX for some support functions */ 92 #include <dev/ath/if_ath_tx_ht.h> 93 #include <dev/ath/if_athrate.h> 94 #include <dev/ath/if_ath_debug.h> 95 96 /* 97 * XXX net80211? 98 */ 99 #define IEEE80211_AMPDU_SUBFRAME_DEFAULT 32 100 101 #define ATH_AGGR_DELIM_SZ 4 /* delimiter size */ 102 #define ATH_AGGR_MINPLEN 256 /* in bytes, minimum packet length */ 103 /* number of delimiters for encryption padding */ 104 #define ATH_AGGR_ENCRYPTDELIM 10 105 106 /* 107 * returns delimiter padding required given the packet length 108 */ 109 #define ATH_AGGR_GET_NDELIM(_len) \ 110 (((((_len) + ATH_AGGR_DELIM_SZ) < ATH_AGGR_MINPLEN) ? \ 111 (ATH_AGGR_MINPLEN - (_len) - ATH_AGGR_DELIM_SZ) : 0) >> 2) 112 113 #define PADBYTES(_len) ((4 - ((_len) % 4)) % 4) 114 115 int ath_max_4ms_framelen[4][32] = { 116 [MCS_HT20] = { 117 3212, 6432, 9648, 12864, 19300, 25736, 28952, 32172, 118 6424, 12852, 19280, 25708, 38568, 51424, 57852, 64280, 119 9628, 19260, 28896, 38528, 57792, 65532, 65532, 65532, 120 12828, 25656, 38488, 51320, 65532, 65532, 65532, 65532, 121 }, 122 [MCS_HT20_SGI] = { 123 3572, 7144, 10720, 14296, 21444, 28596, 32172, 35744, 124 7140, 14284, 21428, 28568, 42856, 57144, 64288, 65532, 125 10700, 21408, 32112, 42816, 64228, 65532, 65532, 65532, 126 14256, 28516, 42780, 57040, 65532, 65532, 65532, 65532, 127 }, 128 [MCS_HT40] = { 129 6680, 13360, 20044, 26724, 40092, 53456, 60140, 65532, 130 13348, 26700, 40052, 53400, 65532, 65532, 65532, 65532, 131 20004, 40008, 60016, 65532, 65532, 65532, 65532, 65532, 132 26644, 53292, 65532, 65532, 65532, 65532, 65532, 65532, 133 }, 134 [MCS_HT40_SGI] = { 135 7420, 14844, 22272, 29696, 44544, 59396, 65532, 65532, 136 14832, 29668, 44504, 59340, 65532, 65532, 65532, 65532, 137 22232, 44464, 65532, 65532, 65532, 65532, 65532, 65532, 138 29616, 59232, 65532, 65532, 65532, 65532, 65532, 65532, 139 } 140 }; 141 142 /* 143 * XXX should be in net80211 144 */ 145 static int ieee80211_mpdudensity_map[] = { 146 0, /* IEEE80211_HTCAP_MPDUDENSITY_NA */ 147 25, /* IEEE80211_HTCAP_MPDUDENSITY_025 */ 148 50, /* IEEE80211_HTCAP_MPDUDENSITY_05 */ 149 100, /* IEEE80211_HTCAP_MPDUDENSITY_1 */ 150 200, /* IEEE80211_HTCAP_MPDUDENSITY_2 */ 151 400, /* IEEE80211_HTCAP_MPDUDENSITY_4 */ 152 800, /* IEEE80211_HTCAP_MPDUDENSITY_8 */ 153 1600, /* IEEE80211_HTCAP_MPDUDENSITY_16 */ 154 }; 155 156 /* 157 * XXX should be in the HAL/net80211 ? 158 */ 159 #define BITS_PER_BYTE 8 160 #define OFDM_PLCP_BITS 22 161 #define HT_RC_2_MCS(_rc) ((_rc) & 0x7f) 162 #define HT_RC_2_STREAMS(_rc) ((((_rc) & 0x78) >> 3) + 1) 163 #define L_STF 8 164 #define L_LTF 8 165 #define L_SIG 4 166 #define HT_SIG 8 167 #define HT_STF 4 168 #define HT_LTF(_ns) (4 * (_ns)) 169 #define SYMBOL_TIME(_ns) ((_ns) << 2) // ns * 4 us 170 #define SYMBOL_TIME_HALFGI(_ns) (((_ns) * 18 + 4) / 5) // ns * 3.6 us 171 #define NUM_SYMBOLS_PER_USEC(_usec) (_usec >> 2) 172 #define NUM_SYMBOLS_PER_USEC_HALFGI(_usec) (((_usec*5)-4)/18) 173 #define IS_HT_RATE(_rate) ((_rate) & 0x80) 174 175 const uint32_t bits_per_symbol[][2] = { 176 /* 20MHz 40MHz */ 177 { 26, 54 }, // 0: BPSK 178 { 52, 108 }, // 1: QPSK 1/2 179 { 78, 162 }, // 2: QPSK 3/4 180 { 104, 216 }, // 3: 16-QAM 1/2 181 { 156, 324 }, // 4: 16-QAM 3/4 182 { 208, 432 }, // 5: 64-QAM 2/3 183 { 234, 486 }, // 6: 64-QAM 3/4 184 { 260, 540 }, // 7: 64-QAM 5/6 185 { 52, 108 }, // 8: BPSK 186 { 104, 216 }, // 9: QPSK 1/2 187 { 156, 324 }, // 10: QPSK 3/4 188 { 208, 432 }, // 11: 16-QAM 1/2 189 { 312, 648 }, // 12: 16-QAM 3/4 190 { 416, 864 }, // 13: 64-QAM 2/3 191 { 468, 972 }, // 14: 64-QAM 3/4 192 { 520, 1080 }, // 15: 64-QAM 5/6 193 { 78, 162 }, // 16: BPSK 194 { 156, 324 }, // 17: QPSK 1/2 195 { 234, 486 }, // 18: QPSK 3/4 196 { 312, 648 }, // 19: 16-QAM 1/2 197 { 468, 972 }, // 20: 16-QAM 3/4 198 { 624, 1296 }, // 21: 64-QAM 2/3 199 { 702, 1458 }, // 22: 64-QAM 3/4 200 { 780, 1620 }, // 23: 64-QAM 5/6 201 { 104, 216 }, // 24: BPSK 202 { 208, 432 }, // 25: QPSK 1/2 203 { 312, 648 }, // 26: QPSK 3/4 204 { 416, 864 }, // 27: 16-QAM 1/2 205 { 624, 1296 }, // 28: 16-QAM 3/4 206 { 832, 1728 }, // 29: 64-QAM 2/3 207 { 936, 1944 }, // 30: 64-QAM 3/4 208 { 1040, 2160 }, // 31: 64-QAM 5/6 209 }; 210 211 /* 212 * Fill in the rate array information based on the current 213 * node configuration and the choices made by the rate 214 * selection code and ath_buf setup code. 215 * 216 * Later on, this may end up also being made by the 217 * rate control code, but for now it can live here. 218 * 219 * This needs to be called just before the packet is 220 * queued to the software queue or hardware queue, 221 * so all of the needed fields in bf_state are setup. 222 */ 223 void 224 ath_tx_rate_fill_rcflags(struct ath_softc *sc, struct ath_buf *bf) 225 { 226 struct ieee80211_node *ni = bf->bf_node; 227 struct ieee80211vap *vap = ni->ni_vap; 228 struct ieee80211com *ic = ni->ni_ic; 229 const HAL_RATE_TABLE *rt = sc->sc_currates; 230 struct ath_rc_series *rc = bf->bf_state.bfs_rc; 231 uint8_t rate; 232 int i; 233 int do_ldpc; 234 int do_stbc; 235 236 /* 237 * We only do LDPC if the rate is 11n, both we and the 238 * receiver support LDPC and it's enabled. 239 * 240 * It's a global flag, not a per-try flag, so we clear 241 * it if any of the rate entries aren't 11n. 242 */ 243 do_ldpc = 0; 244 if ((ni->ni_vap->iv_flags_ht & IEEE80211_FHT_LDPC_TX) && 245 (ni->ni_htcap & IEEE80211_HTCAP_LDPC)) 246 do_ldpc = 1; 247 248 /* 249 * The 11n duration calculation doesn't know about LDPC, 250 * so don't enable it for positioning. 251 */ 252 if (bf->bf_flags & ATH_BUF_TOA_PROBE) 253 do_ldpc = 0; 254 255 do_stbc = 0; 256 257 for (i = 0; i < ATH_RC_NUM; i++) { 258 rc[i].flags = 0; 259 if (rc[i].tries == 0) 260 continue; 261 262 rate = rt->info[rc[i].rix].rateCode; 263 264 /* 265 * Only enable short preamble for legacy rates 266 */ 267 if ((! IS_HT_RATE(rate)) && bf->bf_state.bfs_shpream) 268 rate |= rt->info[rc[i].rix].shortPreamble; 269 270 /* 271 * Save this, used by the TX and completion code 272 */ 273 rc[i].ratecode = rate; 274 275 if (bf->bf_state.bfs_txflags & 276 (HAL_TXDESC_RTSENA | HAL_TXDESC_CTSENA)) 277 rc[i].flags |= ATH_RC_RTSCTS_FLAG; 278 279 /* 280 * If we can't do LDPC, don't. 281 */ 282 if (! IS_HT_RATE(rate)) 283 do_ldpc = 0; 284 285 /* Only enable shortgi, 2040, dual-stream if HT is set */ 286 if (IS_HT_RATE(rate)) { 287 rc[i].flags |= ATH_RC_HT_FLAG; 288 289 if (ni->ni_chw == 40) 290 rc[i].flags |= ATH_RC_CW40_FLAG; 291 292 /* 293 * NOTE: Don't do short-gi for positioning frames. 294 * 295 * For now, the ath_hal and net80211 HT duration 296 * calculation rounds up the 11n data txtime 297 * to the nearest multiple of 3.6 microseconds 298 * and doesn't return the fractional part, so 299 * we are always "out" by some amount. 300 */ 301 if (ni->ni_chw == 40 && 302 ic->ic_htcaps & IEEE80211_HTCAP_SHORTGI40 && 303 ni->ni_htcap & IEEE80211_HTCAP_SHORTGI40 && 304 vap->iv_flags_ht & IEEE80211_FHT_SHORTGI40 && 305 (bf->bf_flags & ATH_BUF_TOA_PROBE) == 0) { 306 rc[i].flags |= ATH_RC_SGI_FLAG; 307 } 308 309 if (ni->ni_chw == 20 && 310 ic->ic_htcaps & IEEE80211_HTCAP_SHORTGI20 && 311 ni->ni_htcap & IEEE80211_HTCAP_SHORTGI20 && 312 vap->iv_flags_ht & IEEE80211_FHT_SHORTGI20 && 313 (bf->bf_flags & ATH_BUF_TOA_PROBE) == 0) { 314 rc[i].flags |= ATH_RC_SGI_FLAG; 315 } 316 317 /* 318 * If we have STBC TX enabled and the receiver 319 * can receive (at least) 1 stream STBC, AND it's 320 * MCS 0-7, AND we have at least two chains enabled, 321 * and we're not doing positioning, enable STBC. 322 */ 323 if (ic->ic_htcaps & IEEE80211_HTCAP_TXSTBC && 324 (ni->ni_vap->iv_flags_ht & IEEE80211_FHT_STBC_TX) && 325 (ni->ni_htcap & IEEE80211_HTCAP_RXSTBC) && 326 (sc->sc_cur_txchainmask > 1) && 327 (HT_RC_2_STREAMS(rate) == 1) && 328 (bf->bf_flags & ATH_BUF_TOA_PROBE) == 0) { 329 rc[i].flags |= ATH_RC_STBC_FLAG; 330 do_stbc = 1; 331 } 332 333 /* 334 * Dual / Triple stream rate? 335 */ 336 if (HT_RC_2_STREAMS(rate) == 2) 337 rc[i].flags |= ATH_RC_DS_FLAG; 338 else if (HT_RC_2_STREAMS(rate) == 3) 339 rc[i].flags |= ATH_RC_TS_FLAG; 340 } 341 342 /* 343 * Calculate the maximum TX power cap for the current 344 * node. 345 */ 346 rc[i].tx_power_cap = ieee80211_get_node_txpower(ni); 347 348 /* 349 * Calculate the maximum 4ms frame length based 350 * on the MCS rate, SGI and channel width flags. 351 */ 352 if ((rc[i].flags & ATH_RC_HT_FLAG) && 353 (HT_RC_2_MCS(rate) < 32)) { 354 int j; 355 if (rc[i].flags & ATH_RC_CW40_FLAG) { 356 if (rc[i].flags & ATH_RC_SGI_FLAG) 357 j = MCS_HT40_SGI; 358 else 359 j = MCS_HT40; 360 } else { 361 if (rc[i].flags & ATH_RC_SGI_FLAG) 362 j = MCS_HT20_SGI; 363 else 364 j = MCS_HT20; 365 } 366 rc[i].max4msframelen = 367 ath_max_4ms_framelen[j][HT_RC_2_MCS(rate)]; 368 } else 369 rc[i].max4msframelen = 0; 370 DPRINTF(sc, ATH_DEBUG_SW_TX_AGGR, 371 "%s: i=%d, rate=0x%x, flags=0x%x, max4ms=%d\n", 372 __func__, i, rate, rc[i].flags, rc[i].max4msframelen); 373 } 374 375 /* 376 * LDPC is a global flag, so ... 377 */ 378 if (do_ldpc) { 379 bf->bf_state.bfs_txflags |= HAL_TXDESC_LDPC; 380 sc->sc_stats.ast_tx_ldpc++; 381 } 382 383 if (do_stbc) { 384 sc->sc_stats.ast_tx_stbc++; 385 } 386 } 387 388 /* 389 * Return the number of delimiters to be added to 390 * meet the minimum required mpdudensity. 391 * 392 * Caller should make sure that the rate is HT. 393 * 394 * TODO: is this delimiter calculation supposed to be the 395 * total frame length, the hdr length, the data length (including 396 * delimiters, padding, CRC, etc) or ? 397 * 398 * TODO: this should ensure that the rate control information 399 * HAS been setup for the first rate. 400 * 401 * TODO: ensure this is only called for MCS rates. 402 * 403 * TODO: enforce MCS < 31 404 */ 405 static int 406 ath_compute_num_delims(struct ath_softc *sc, struct ath_buf *first_bf, 407 uint16_t pktlen, int is_first) 408 { 409 const HAL_RATE_TABLE *rt = sc->sc_currates; 410 struct ieee80211_node *ni = first_bf->bf_node; 411 struct ieee80211vap *vap = ni->ni_vap; 412 int ndelim, mindelim = 0; 413 int mpdudensity; /* in 1/100'th of a microsecond */ 414 int peer_mpdudensity; /* net80211 value */ 415 uint8_t rc, rix, flags; 416 int width, half_gi; 417 uint32_t nsymbits, nsymbols; 418 uint16_t minlen; 419 420 /* 421 * Get the advertised density from the node. 422 */ 423 peer_mpdudensity = 424 _IEEE80211_MASKSHIFT(ni->ni_htparam, IEEE80211_HTCAP_MPDUDENSITY); 425 426 /* 427 * vap->iv_ampdu_density is a net80211 value, rather than the actual 428 * density. Larger values are longer A-MPDU density spacing values, 429 * and we want to obey larger configured / negotiated density values 430 * per station if we get it. 431 */ 432 if (vap->iv_ampdu_density > peer_mpdudensity) 433 peer_mpdudensity = vap->iv_ampdu_density; 434 435 /* 436 * Convert the A-MPDU density net80211 value to a 1/100 microsecond 437 * value for subsequent calculations. 438 */ 439 if (peer_mpdudensity > IEEE80211_HTCAP_MPDUDENSITY_16) 440 mpdudensity = 1600; /* maximum density */ 441 else 442 mpdudensity = ieee80211_mpdudensity_map[peer_mpdudensity]; 443 444 /* Select standard number of delimiters based on frame length */ 445 ndelim = ATH_AGGR_GET_NDELIM(pktlen); 446 447 /* 448 * If encryption is enabled, add extra delimiters to let the 449 * crypto hardware catch up. This could be tuned per-MAC and 450 * per-rate, but for now we'll simply assume encryption is 451 * always enabled. 452 * 453 * Also note that the Atheros reference driver inserts two 454 * delimiters by default for pre-AR9380 peers. This will 455 * include "that" required delimiter. 456 */ 457 ndelim += ATH_AGGR_ENCRYPTDELIM; 458 459 /* 460 * For AR9380, there's a minimum number of delimiters 461 * required when doing RTS. 462 * 463 * XXX TODO: this is only needed if (a) RTS/CTS is enabled for 464 * this exchange, and (b) (done) this is the first sub-frame 465 * in the aggregate. 466 */ 467 if (sc->sc_use_ent && (sc->sc_ent_cfg & AH_ENT_RTSCTS_DELIM_WAR) 468 && ndelim < AH_FIRST_DESC_NDELIMS && is_first) 469 ndelim = AH_FIRST_DESC_NDELIMS; 470 471 /* 472 * If sc_delim_min_pad is non-zero, enforce it as the minimum 473 * pad delimiter count. 474 */ 475 if (sc->sc_delim_min_pad != 0) 476 ndelim = MAX(ndelim, sc->sc_delim_min_pad); 477 478 DPRINTF(sc, ATH_DEBUG_SW_TX_AGGR, 479 "%s: pktlen=%d, ndelim=%d, mpdudensity=%d\n", 480 __func__, pktlen, ndelim, mpdudensity); 481 482 /* 483 * If the MPDU density is 0, we can return here. 484 * Otherwise, we need to convert the desired mpdudensity 485 * into a byte length, based on the rate in the subframe. 486 */ 487 if (mpdudensity == 0) 488 return ndelim; 489 490 /* 491 * Convert desired mpdu density from microeconds to bytes based 492 * on highest rate in rate series (i.e. first rate) to determine 493 * required minimum length for subframe. Take into account 494 * whether high rate is 20 or 40Mhz and half or full GI. 495 */ 496 rix = first_bf->bf_state.bfs_rc[0].rix; 497 rc = rt->info[rix].rateCode; 498 flags = first_bf->bf_state.bfs_rc[0].flags; 499 width = !! (flags & ATH_RC_CW40_FLAG); 500 half_gi = !! (flags & ATH_RC_SGI_FLAG); 501 502 /* 503 * mpdudensity is in 1/100th of a usec, so divide by 100 504 */ 505 if (half_gi) 506 nsymbols = NUM_SYMBOLS_PER_USEC_HALFGI(mpdudensity); 507 else 508 nsymbols = NUM_SYMBOLS_PER_USEC(mpdudensity); 509 nsymbols /= 100; 510 511 if (nsymbols == 0) 512 nsymbols = 1; 513 514 nsymbits = bits_per_symbol[HT_RC_2_MCS(rc)][width]; 515 minlen = (nsymbols * nsymbits) / BITS_PER_BYTE; 516 517 /* 518 * Min length is the minimum frame length for the 519 * required MPDU density. 520 */ 521 if (pktlen < minlen) { 522 mindelim = (minlen - pktlen) / ATH_AGGR_DELIM_SZ; 523 ndelim = MAX(mindelim, ndelim); 524 } 525 526 DPRINTF(sc, ATH_DEBUG_SW_TX_AGGR, 527 "%s: pktlen=%d, minlen=%d, rix=%x, rc=%x, width=%d, hgi=%d, ndelim=%d\n", 528 __func__, pktlen, minlen, rix, rc, width, half_gi, ndelim); 529 530 return ndelim; 531 } 532 533 /* 534 * XXX TODO: put into net80211 535 */ 536 static int 537 ath_rx_ampdu_to_byte(char a) 538 { 539 switch (a) { 540 case IEEE80211_HTCAP_MAXRXAMPDU_16K: 541 return 16384; 542 break; 543 case IEEE80211_HTCAP_MAXRXAMPDU_32K: 544 return 32768; 545 break; 546 case IEEE80211_HTCAP_MAXRXAMPDU_64K: 547 return 65536; 548 break; 549 case IEEE80211_HTCAP_MAXRXAMPDU_8K: 550 default: 551 return 8192; 552 break; 553 } 554 } 555 556 /* 557 * Fetch the aggregation limit. 558 * 559 * It's the lowest of the four rate series 4ms frame length. 560 * 561 * Also take into account the hardware specific limits (8KiB on AR5416) 562 * and per-peer limits in non-STA mode. 563 */ 564 static int 565 ath_get_aggr_limit(struct ath_softc *sc, struct ieee80211_node *ni, 566 struct ath_buf *bf) 567 { 568 struct ieee80211vap *vap = ni->ni_vap; 569 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( 585 _IEEE80211_MASKSHIFT(ni->ni_htparam, 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 _IEEE80211_MASKSHIFT(ni->ni_htparam, IEEE80211_HTCAP_MAXRXAMPDU), 600 amin); 601 602 return amin; 603 } 604 605 /* 606 * Setup a 11n rate series structure 607 * 608 * This should be called for both legacy and MCS rates. 609 * 610 * This uses the rate series stuf from ath_tx_rate_fill_rcflags(). 611 * 612 * It, along with ath_buf_set_rate, must be called -after- a burst 613 * or aggregate is setup. 614 */ 615 static void 616 ath_rateseries_setup(struct ath_softc *sc, struct ieee80211_node *ni, 617 struct ath_buf *bf, HAL_11N_RATE_SERIES *series) 618 { 619 struct ieee80211com *ic = ni->ni_ic; 620 struct ath_hal *ah = sc->sc_ah; 621 HAL_BOOL shortPreamble = AH_FALSE; 622 const HAL_RATE_TABLE *rt = sc->sc_currates; 623 int i; 624 int pktlen; 625 struct ath_rc_series *rc = bf->bf_state.bfs_rc; 626 627 if ((ic->ic_flags & IEEE80211_F_SHPREAMBLE) && 628 (ni->ni_capinfo & IEEE80211_CAPINFO_SHORT_PREAMBLE)) 629 shortPreamble = AH_TRUE; 630 631 /* 632 * If this is the first frame in an aggregate series, 633 * use the aggregate length. 634 */ 635 if (bf->bf_state.bfs_aggr) 636 pktlen = bf->bf_state.bfs_al; 637 else 638 pktlen = bf->bf_state.bfs_pktlen; 639 640 /* 641 * XXX TODO: modify this routine to use the bfs_rc[x].flags 642 * XXX fields. 643 */ 644 memset(series, 0, sizeof(HAL_11N_RATE_SERIES) * 4); 645 for (i = 0; i < ATH_RC_NUM; i++) { 646 /* Only set flags for actual TX attempts */ 647 if (rc[i].tries == 0) 648 continue; 649 650 series[i].Tries = rc[i].tries; 651 652 /* 653 * XXX TODO: When the NIC is capable of three stream TX, 654 * transmit 1/2 stream rates on two streams. 655 * 656 * This reduces the power consumption of the NIC and 657 * keeps it within the PCIe slot power limits. 658 */ 659 series[i].ChSel = sc->sc_cur_txchainmask; 660 661 /* 662 * Setup rate and TX power cap for this series. 663 */ 664 series[i].Rate = rt->info[rc[i].rix].rateCode; 665 series[i].RateIndex = rc[i].rix; 666 series[i].tx_power_cap = rc[i].tx_power_cap; 667 668 /* 669 * Enable RTS/CTS as appropriate. 670 */ 671 if (rc[i].flags & ATH_RC_RTSCTS_FLAG) 672 series[i].RateFlags |= HAL_RATESERIES_RTS_CTS; 673 674 /* 675 * 11n rate? Update 11n flags. 676 */ 677 if (rc[i].flags & ATH_RC_HT_FLAG) { 678 if (rc[i].flags & ATH_RC_CW40_FLAG) 679 series[i].RateFlags |= HAL_RATESERIES_2040; 680 681 if (rc[i].flags & ATH_RC_SGI_FLAG) 682 series[i].RateFlags |= HAL_RATESERIES_HALFGI; 683 684 if (rc[i].flags & ATH_RC_STBC_FLAG) 685 series[i].RateFlags |= HAL_RATESERIES_STBC; 686 } 687 688 /* 689 * TODO: If we're all doing 11n rates then we can set LDPC. 690 * If we've been asked to /do/ LDPC but we are handed a 691 * legacy rate, then we should complain. Loudly. 692 */ 693 694 /* 695 * PktDuration doesn't include slot, ACK, RTS, etc timing - 696 * it's just the packet duration 697 */ 698 if (rc[i].flags & ATH_RC_HT_FLAG) { 699 series[i].PktDuration = 700 ath_computedur_ht(pktlen 701 , series[i].Rate 702 , HT_RC_2_STREAMS(series[i].Rate) 703 , series[i].RateFlags & HAL_RATESERIES_2040 704 , series[i].RateFlags & HAL_RATESERIES_HALFGI); 705 } else { 706 if (shortPreamble) 707 series[i].Rate |= 708 rt->info[rc[i].rix].shortPreamble; 709 /* XXX TODO: don't include SIFS */ 710 series[i].PktDuration = ath_hal_computetxtime(ah, 711 rt, pktlen, rc[i].rix, shortPreamble, AH_TRUE); 712 } 713 } 714 } 715 716 #ifdef ATH_DEBUG 717 static void 718 ath_rateseries_print(struct ath_softc *sc, HAL_11N_RATE_SERIES *series) 719 { 720 int i; 721 for (i = 0; i < ATH_RC_NUM; i++) { 722 device_printf(sc->sc_dev ,"series %d: rate %x; tries %d; " 723 "pktDuration %d; chSel %d; txpowcap %d, rateFlags %x\n", 724 i, 725 series[i].Rate, 726 series[i].Tries, 727 series[i].PktDuration, 728 series[i].ChSel, 729 series[i].tx_power_cap, 730 series[i].RateFlags); 731 } 732 } 733 #endif 734 735 /* 736 * Setup the 11n rate scenario and burst duration for the given TX descriptor 737 * list. 738 * 739 * This isn't useful for sending beacon frames, which has different needs 740 * wrt what's passed into the rate scenario function. 741 */ 742 void 743 ath_buf_set_rate(struct ath_softc *sc, struct ieee80211_node *ni, 744 struct ath_buf *bf) 745 { 746 HAL_11N_RATE_SERIES series[4]; 747 struct ath_desc *ds = bf->bf_desc; 748 struct ath_hal *ah = sc->sc_ah; 749 int is_pspoll = (bf->bf_state.bfs_atype == HAL_PKT_TYPE_PSPOLL); 750 int ctsrate = bf->bf_state.bfs_ctsrate; 751 int flags = bf->bf_state.bfs_txflags; 752 753 /* Setup rate scenario */ 754 memset(&series, 0, sizeof(series)); 755 756 ath_rateseries_setup(sc, ni, bf, series); 757 758 #ifdef ATH_DEBUG 759 if (sc->sc_debug & ATH_DEBUG_XMIT) 760 ath_rateseries_print(sc, series); 761 #endif 762 763 /* Set rate scenario */ 764 /* 765 * Note: Don't allow hardware to override the duration on 766 * ps-poll packets. 767 */ 768 ath_hal_set11nratescenario(ah, ds, 769 !is_pspoll, /* whether to override the duration or not */ 770 ctsrate, /* rts/cts rate */ 771 series, /* 11n rate series */ 772 4, /* number of series */ 773 flags); 774 775 /* Set burst duration */ 776 /* 777 * This is only required when doing 11n burst, not aggregation 778 * ie, if there's a second frame in a RIFS or A-MPDU burst 779 * w/ >1 A-MPDU frame bursting back to back. 780 * Normal A-MPDU doesn't do bursting -between- aggregates. 781 * 782 * .. and it's highly likely this won't ever be implemented 783 */ 784 //ath_hal_set11nburstduration(ah, ds, 8192); 785 } 786 787 /* 788 * Form an aggregate packet list. 789 * 790 * This function enforces the aggregate restrictions/requirements. 791 * 792 * These are: 793 * 794 * + The aggregate size maximum (64k for AR9160 and later, 8K for 795 * AR5416 when doing RTS frame protection.) 796 * + Maximum number of sub-frames for an aggregate 797 * + The aggregate delimiter size, giving MACs time to do whatever is 798 * needed before each frame 799 * + Enforce the BAW limit 800 * 801 * Each descriptor queued should have the DMA setup. 802 * The rate series, descriptor setup, linking, etc is all done 803 * externally. This routine simply chains them together. 804 * ath_tx_setds_11n() will take care of configuring the per- 805 * descriptor setup, and ath_buf_set_rate() will configure the 806 * rate control. 807 * 808 * The TID lock is required for the entirety of this function. 809 * 810 * If some code in another thread adds to the head of this 811 * list, very strange behaviour will occur. Since retransmission is the 812 * only reason this will occur, and this routine is designed to be called 813 * from within the scheduler task, it won't ever clash with the completion 814 * task. 815 * 816 * So if you want to call this from an upper layer context (eg, to direct- 817 * dispatch aggregate frames to the hardware), please keep this in mind. 818 */ 819 ATH_AGGR_STATUS 820 ath_tx_form_aggr(struct ath_softc *sc, struct ath_node *an, 821 struct ath_tid *tid, ath_bufhead *bf_q) 822 { 823 //struct ieee80211_node *ni = &an->an_node; 824 struct ath_buf *bf, *bf_first = NULL, *bf_prev = NULL; 825 int nframes = 0; 826 uint16_t aggr_limit = 0, al = 0, bpad = 0, al_delta, h_baw; 827 struct ieee80211_tx_ampdu *tap; 828 int status = ATH_AGGR_DONE; 829 int prev_frames = 0; /* XXX for AR5416 burst, not done here */ 830 int prev_al = 0; /* XXX also for AR5416 burst */ 831 832 ATH_TX_LOCK_ASSERT(sc); 833 834 tap = ath_tx_get_tx_tid(an, tid->tid); 835 if (tap == NULL) { 836 status = ATH_AGGR_ERROR; 837 goto finish; 838 } 839 840 /* 841 * Limit the maximum number of frames in this A-MPDU 842 * to half of the window size. This is done to prevent 843 * sending a LOT of frames that may fail in one batch 844 * when operating in higher MCS rates. If there are more 845 * frames available to send then up to two A-MPDUs will 846 * be queued per hardware queue, so we'll "just" get 847 * a second A-MPDU. 848 */ 849 h_baw = tap->txa_wnd / 2; 850 851 for (;;) { 852 bf = ATH_TID_FIRST(tid); 853 if (bf == NULL) { 854 status = ATH_AGGR_DONE; 855 break; 856 } 857 if (bf_first == NULL) { 858 bf_first = bf; 859 /* 860 * It's the first frame; 861 * set the aggregation limit based on the 862 * rate control decision that has been made. 863 */ 864 aggr_limit = ath_get_aggr_limit(sc, &an->an_node, 865 bf_first); 866 if (bf_first->bf_state.bfs_rc_maxpktlen > 0) { 867 aggr_limit = MIN(aggr_limit, 868 bf_first->bf_state.bfs_rc_maxpktlen); 869 } 870 } 871 872 /* Set this early just so things don't get confused */ 873 bf->bf_next = NULL; 874 875 /* 876 * If the frame doesn't have a sequence number that we're 877 * tracking in the BAW (eg NULL QOS data frame), we can't 878 * aggregate it. Stop the aggregation process; the sender 879 * can then TX what's in the list thus far and then 880 * TX the frame individually. 881 */ 882 if (! bf->bf_state.bfs_dobaw) { 883 status = ATH_AGGR_NONAGGR; 884 break; 885 } 886 887 /* 888 * If any of the rates are non-HT, this packet 889 * can't be aggregated. 890 * XXX TODO: add a bf_state flag which gets marked 891 * if any active rate is non-HT. 892 */ 893 894 /* 895 * do not exceed aggregation limit 896 */ 897 al_delta = ATH_AGGR_DELIM_SZ + bf->bf_state.bfs_pktlen; 898 if (nframes && 899 (aggr_limit < (al + bpad + al_delta + prev_al))) { 900 status = ATH_AGGR_LIMITED; 901 break; 902 } 903 904 /* 905 * If RTS/CTS is set on the first frame, enforce 906 * the RTS aggregate limit. 907 */ 908 if (bf_first->bf_state.bfs_txflags & 909 (HAL_TXDESC_CTSENA | HAL_TXDESC_RTSENA)) { 910 if (nframes && 911 (sc->sc_rts_aggr_limit < 912 (al + bpad + al_delta + prev_al))) { 913 status = ATH_AGGR_8K_LIMITED; 914 break; 915 } 916 } 917 918 /* 919 * Do not exceed subframe limit. 920 */ 921 if ((nframes + prev_frames) >= MIN((h_baw), 922 IEEE80211_AMPDU_SUBFRAME_DEFAULT)) { 923 status = ATH_AGGR_LIMITED; 924 break; 925 } 926 927 /* 928 * If the current frame has an RTS/CTS configuration 929 * that differs from the first frame, override the 930 * subsequent frame with this config. 931 */ 932 if (bf != bf_first) { 933 bf->bf_state.bfs_txflags &= 934 ~ (HAL_TXDESC_RTSENA | HAL_TXDESC_CTSENA); 935 bf->bf_state.bfs_txflags |= 936 bf_first->bf_state.bfs_txflags & 937 (HAL_TXDESC_RTSENA | HAL_TXDESC_CTSENA); 938 } 939 940 /* 941 * If the packet has a sequence number, do not 942 * step outside of the block-ack window. 943 */ 944 if (! BAW_WITHIN(tap->txa_start, tap->txa_wnd, 945 SEQNO(bf->bf_state.bfs_seqno))) { 946 status = ATH_AGGR_BAW_CLOSED; 947 break; 948 } 949 950 /* 951 * this packet is part of an aggregate. 952 */ 953 ATH_TID_REMOVE(tid, bf, bf_list); 954 955 /* The TID lock is required for the BAW update */ 956 ath_tx_addto_baw(sc, an, tid, bf); 957 bf->bf_state.bfs_addedbaw = 1; 958 959 /* 960 * XXX enforce ACK for aggregate frames (this needs to be 961 * XXX handled more gracefully? 962 */ 963 if (bf->bf_state.bfs_txflags & HAL_TXDESC_NOACK) { 964 device_printf(sc->sc_dev, 965 "%s: HAL_TXDESC_NOACK set for an aggregate frame?\n", 966 __func__); 967 bf->bf_state.bfs_txflags &= (~HAL_TXDESC_NOACK); 968 } 969 970 /* 971 * Add the now owned buffer (which isn't 972 * on the software TXQ any longer) to our 973 * aggregate frame list. 974 */ 975 TAILQ_INSERT_TAIL(bf_q, bf, bf_list); 976 nframes ++; 977 978 /* Completion handler */ 979 bf->bf_comp = ath_tx_aggr_comp; 980 981 /* 982 * add padding for previous frame to aggregation length 983 */ 984 al += bpad + al_delta; 985 986 /* 987 * Calculate delimiters needed for the current frame 988 */ 989 bf->bf_state.bfs_ndelim = 990 ath_compute_num_delims(sc, bf_first, 991 bf->bf_state.bfs_pktlen, (bf_first == bf)); 992 993 /* 994 * Calculate the padding needed from this set of delimiters, 995 * used when calculating if the next frame will fit in 996 * the aggregate. 997 */ 998 bpad = PADBYTES(al_delta) + (bf->bf_state.bfs_ndelim << 2); 999 1000 /* 1001 * Chain the buffers together 1002 */ 1003 if (bf_prev) 1004 bf_prev->bf_next = bf; 1005 bf_prev = bf; 1006 1007 /* 1008 * If we're leaking frames, just return at this point; 1009 * we've queued a single frame and we don't want to add 1010 * any more. 1011 */ 1012 if (tid->an->an_leak_count) { 1013 status = ATH_AGGR_LEAK_CLOSED; 1014 break; 1015 } 1016 1017 #if 0 1018 /* 1019 * terminate aggregation on a small packet boundary 1020 */ 1021 if (bf->bf_state.bfs_pktlen < ATH_AGGR_MINPLEN) { 1022 status = ATH_AGGR_SHORTPKT; 1023 break; 1024 } 1025 #endif 1026 } 1027 1028 finish: 1029 /* 1030 * Just in case the list was empty when we tried to 1031 * dequeue a packet .. 1032 */ 1033 if (bf_first) { 1034 DPRINTF(sc, ATH_DEBUG_SW_TX_AGGR, 1035 "%s: al=%d bytes; requested %d bytes\n", 1036 __func__, al, bf_first->bf_state.bfs_rc_maxpktlen); 1037 1038 bf_first->bf_state.bfs_al = al; 1039 bf_first->bf_state.bfs_nframes = nframes; 1040 } 1041 return status; 1042 } 1043