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