1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
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
ath_tx_rate_fill_rcflags(struct ath_softc * sc,struct ath_buf * bf)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
ath_compute_num_delims(struct ath_softc * sc,struct ath_buf * first_bf,uint16_t pktlen,int is_first)406 ath_compute_num_delims(struct ath_softc *sc, struct ath_buf *first_bf,
407 uint16_t pktlen, int is_first)
408 {
409 #define MS(_v, _f) (((_v) & _f) >> _f##_S)
410 const HAL_RATE_TABLE *rt = sc->sc_currates;
411 struct ieee80211_node *ni = first_bf->bf_node;
412 struct ieee80211vap *vap = ni->ni_vap;
413 int ndelim, mindelim = 0;
414 int mpdudensity; /* in 1/100'th of a microsecond */
415 int peer_mpdudensity; /* net80211 value */
416 uint8_t rc, rix, flags;
417 int width, half_gi;
418 uint32_t nsymbits, nsymbols;
419 uint16_t minlen;
420
421 /*
422 * Get the advertised density from the node.
423 */
424 peer_mpdudensity = MS(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 delimeters
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 #undef MS
532 }
533
534 /*
535 * XXX TODO: put into net80211
536 */
537 static int
ath_rx_ampdu_to_byte(char a)538 ath_rx_ampdu_to_byte(char a)
539 {
540 switch (a) {
541 case IEEE80211_HTCAP_MAXRXAMPDU_16K:
542 return 16384;
543 break;
544 case IEEE80211_HTCAP_MAXRXAMPDU_32K:
545 return 32768;
546 break;
547 case IEEE80211_HTCAP_MAXRXAMPDU_64K:
548 return 65536;
549 break;
550 case IEEE80211_HTCAP_MAXRXAMPDU_8K:
551 default:
552 return 8192;
553 break;
554 }
555 }
556
557 /*
558 * Fetch the aggregation limit.
559 *
560 * It's the lowest of the four rate series 4ms frame length.
561 *
562 * Also take into account the hardware specific limits (8KiB on AR5416)
563 * and per-peer limits in non-STA mode.
564 */
565 static int
ath_get_aggr_limit(struct ath_softc * sc,struct ieee80211_node * ni,struct ath_buf * bf)566 ath_get_aggr_limit(struct ath_softc *sc, struct ieee80211_node *ni,
567 struct ath_buf *bf)
568 {
569 struct ieee80211vap *vap = ni->ni_vap;
570
571 #define MS(_v, _f) (((_v) & _f) >> _f##_S)
572 int amin = ATH_AGGR_MAXSIZE;
573 int i;
574
575 /* Extract out the maximum configured driver A-MPDU limit */
576 if (sc->sc_aggr_limit > 0 && sc->sc_aggr_limit < ATH_AGGR_MAXSIZE)
577 amin = sc->sc_aggr_limit;
578
579 /* Check the vap configured transmit limit */
580 amin = MIN(amin, ath_rx_ampdu_to_byte(vap->iv_ampdu_limit));
581
582 /*
583 * Check the HTCAP field for the maximum size the node has
584 * negotiated. If it's smaller than what we have, cap it there.
585 */
586 amin = MIN(amin, ath_rx_ampdu_to_byte(MS(ni->ni_htparam,
587 IEEE80211_HTCAP_MAXRXAMPDU)));
588
589 for (i = 0; i < ATH_RC_NUM; i++) {
590 if (bf->bf_state.bfs_rc[i].tries == 0)
591 continue;
592 amin = MIN(amin, bf->bf_state.bfs_rc[i].max4msframelen);
593 }
594
595 DPRINTF(sc, ATH_DEBUG_SW_TX_AGGR,
596 "%s: aggr_limit=%d, iv_ampdu_limit=%d, "
597 "peer maxrxampdu=%d, max frame len=%d\n",
598 __func__,
599 sc->sc_aggr_limit,
600 vap->iv_ampdu_limit,
601 MS(ni->ni_htparam, IEEE80211_HTCAP_MAXRXAMPDU),
602 amin);
603
604 return amin;
605 #undef MS
606 }
607
608 /*
609 * Setup a 11n rate series structure
610 *
611 * This should be called for both legacy and MCS rates.
612 *
613 * This uses the rate series stuf from ath_tx_rate_fill_rcflags().
614 *
615 * It, along with ath_buf_set_rate, must be called -after- a burst
616 * or aggregate is setup.
617 */
618 static void
ath_rateseries_setup(struct ath_softc * sc,struct ieee80211_node * ni,struct ath_buf * bf,HAL_11N_RATE_SERIES * series)619 ath_rateseries_setup(struct ath_softc *sc, struct ieee80211_node *ni,
620 struct ath_buf *bf, HAL_11N_RATE_SERIES *series)
621 {
622 struct ieee80211com *ic = ni->ni_ic;
623 struct ath_hal *ah = sc->sc_ah;
624 HAL_BOOL shortPreamble = AH_FALSE;
625 const HAL_RATE_TABLE *rt = sc->sc_currates;
626 int i;
627 int pktlen;
628 struct ath_rc_series *rc = bf->bf_state.bfs_rc;
629
630 if ((ic->ic_flags & IEEE80211_F_SHPREAMBLE) &&
631 (ni->ni_capinfo & IEEE80211_CAPINFO_SHORT_PREAMBLE))
632 shortPreamble = AH_TRUE;
633
634 /*
635 * If this is the first frame in an aggregate series,
636 * use the aggregate length.
637 */
638 if (bf->bf_state.bfs_aggr)
639 pktlen = bf->bf_state.bfs_al;
640 else
641 pktlen = bf->bf_state.bfs_pktlen;
642
643 /*
644 * XXX TODO: modify this routine to use the bfs_rc[x].flags
645 * XXX fields.
646 */
647 memset(series, 0, sizeof(HAL_11N_RATE_SERIES) * 4);
648 for (i = 0; i < ATH_RC_NUM; i++) {
649 /* Only set flags for actual TX attempts */
650 if (rc[i].tries == 0)
651 continue;
652
653 series[i].Tries = rc[i].tries;
654
655 /*
656 * XXX TODO: When the NIC is capable of three stream TX,
657 * transmit 1/2 stream rates on two streams.
658 *
659 * This reduces the power consumption of the NIC and
660 * keeps it within the PCIe slot power limits.
661 */
662 series[i].ChSel = sc->sc_cur_txchainmask;
663
664 /*
665 * Setup rate and TX power cap for this series.
666 */
667 series[i].Rate = rt->info[rc[i].rix].rateCode;
668 series[i].RateIndex = rc[i].rix;
669 series[i].tx_power_cap = rc[i].tx_power_cap;
670
671 /*
672 * Enable RTS/CTS as appropriate.
673 */
674 if (rc[i].flags & ATH_RC_RTSCTS_FLAG)
675 series[i].RateFlags |= HAL_RATESERIES_RTS_CTS;
676
677 /*
678 * 11n rate? Update 11n flags.
679 */
680 if (rc[i].flags & ATH_RC_HT_FLAG) {
681 if (rc[i].flags & ATH_RC_CW40_FLAG)
682 series[i].RateFlags |= HAL_RATESERIES_2040;
683
684 if (rc[i].flags & ATH_RC_SGI_FLAG)
685 series[i].RateFlags |= HAL_RATESERIES_HALFGI;
686
687 if (rc[i].flags & ATH_RC_STBC_FLAG)
688 series[i].RateFlags |= HAL_RATESERIES_STBC;
689 }
690
691 /*
692 * TODO: If we're all doing 11n rates then we can set LDPC.
693 * If we've been asked to /do/ LDPC but we are handed a
694 * legacy rate, then we should complain. Loudly.
695 */
696
697 /*
698 * PktDuration doesn't include slot, ACK, RTS, etc timing -
699 * it's just the packet duration
700 */
701 if (rc[i].flags & ATH_RC_HT_FLAG) {
702 series[i].PktDuration =
703 ath_computedur_ht(pktlen
704 , series[i].Rate
705 , HT_RC_2_STREAMS(series[i].Rate)
706 , series[i].RateFlags & HAL_RATESERIES_2040
707 , series[i].RateFlags & HAL_RATESERIES_HALFGI);
708 } else {
709 if (shortPreamble)
710 series[i].Rate |=
711 rt->info[rc[i].rix].shortPreamble;
712 /* XXX TODO: don't include SIFS */
713 series[i].PktDuration = ath_hal_computetxtime(ah,
714 rt, pktlen, rc[i].rix, shortPreamble, AH_TRUE);
715 }
716 }
717 }
718
719 #ifdef ATH_DEBUG
720 static void
ath_rateseries_print(struct ath_softc * sc,HAL_11N_RATE_SERIES * series)721 ath_rateseries_print(struct ath_softc *sc, HAL_11N_RATE_SERIES *series)
722 {
723 int i;
724 for (i = 0; i < ATH_RC_NUM; i++) {
725 device_printf(sc->sc_dev ,"series %d: rate %x; tries %d; "
726 "pktDuration %d; chSel %d; txpowcap %d, rateFlags %x\n",
727 i,
728 series[i].Rate,
729 series[i].Tries,
730 series[i].PktDuration,
731 series[i].ChSel,
732 series[i].tx_power_cap,
733 series[i].RateFlags);
734 }
735 }
736 #endif
737
738 /*
739 * Setup the 11n rate scenario and burst duration for the given TX descriptor
740 * list.
741 *
742 * This isn't useful for sending beacon frames, which has different needs
743 * wrt what's passed into the rate scenario function.
744 */
745 void
ath_buf_set_rate(struct ath_softc * sc,struct ieee80211_node * ni,struct ath_buf * bf)746 ath_buf_set_rate(struct ath_softc *sc, struct ieee80211_node *ni,
747 struct ath_buf *bf)
748 {
749 HAL_11N_RATE_SERIES series[4];
750 struct ath_desc *ds = bf->bf_desc;
751 struct ath_hal *ah = sc->sc_ah;
752 int is_pspoll = (bf->bf_state.bfs_atype == HAL_PKT_TYPE_PSPOLL);
753 int ctsrate = bf->bf_state.bfs_ctsrate;
754 int flags = bf->bf_state.bfs_txflags;
755
756 /* Setup rate scenario */
757 memset(&series, 0, sizeof(series));
758
759 ath_rateseries_setup(sc, ni, bf, series);
760
761 #ifdef ATH_DEBUG
762 if (sc->sc_debug & ATH_DEBUG_XMIT)
763 ath_rateseries_print(sc, series);
764 #endif
765
766 /* Set rate scenario */
767 /*
768 * Note: Don't allow hardware to override the duration on
769 * ps-poll packets.
770 */
771 ath_hal_set11nratescenario(ah, ds,
772 !is_pspoll, /* whether to override the duration or not */
773 ctsrate, /* rts/cts rate */
774 series, /* 11n rate series */
775 4, /* number of series */
776 flags);
777
778 /* Set burst duration */
779 /*
780 * This is only required when doing 11n burst, not aggregation
781 * ie, if there's a second frame in a RIFS or A-MPDU burst
782 * w/ >1 A-MPDU frame bursting back to back.
783 * Normal A-MPDU doesn't do bursting -between- aggregates.
784 *
785 * .. and it's highly likely this won't ever be implemented
786 */
787 //ath_hal_set11nburstduration(ah, ds, 8192);
788 }
789
790 /*
791 * Form an aggregate packet list.
792 *
793 * This function enforces the aggregate restrictions/requirements.
794 *
795 * These are:
796 *
797 * + The aggregate size maximum (64k for AR9160 and later, 8K for
798 * AR5416 when doing RTS frame protection.)
799 * + Maximum number of sub-frames for an aggregate
800 * + The aggregate delimiter size, giving MACs time to do whatever is
801 * needed before each frame
802 * + Enforce the BAW limit
803 *
804 * Each descriptor queued should have the DMA setup.
805 * The rate series, descriptor setup, linking, etc is all done
806 * externally. This routine simply chains them together.
807 * ath_tx_setds_11n() will take care of configuring the per-
808 * descriptor setup, and ath_buf_set_rate() will configure the
809 * rate control.
810 *
811 * The TID lock is required for the entirety of this function.
812 *
813 * If some code in another thread adds to the head of this
814 * list, very strange behaviour will occur. Since retransmission is the
815 * only reason this will occur, and this routine is designed to be called
816 * from within the scheduler task, it won't ever clash with the completion
817 * task.
818 *
819 * So if you want to call this from an upper layer context (eg, to direct-
820 * dispatch aggregate frames to the hardware), please keep this in mind.
821 */
822 ATH_AGGR_STATUS
ath_tx_form_aggr(struct ath_softc * sc,struct ath_node * an,struct ath_tid * tid,ath_bufhead * bf_q)823 ath_tx_form_aggr(struct ath_softc *sc, struct ath_node *an,
824 struct ath_tid *tid, ath_bufhead *bf_q)
825 {
826 //struct ieee80211_node *ni = &an->an_node;
827 struct ath_buf *bf, *bf_first = NULL, *bf_prev = NULL;
828 int nframes = 0;
829 uint16_t aggr_limit = 0, al = 0, bpad = 0, al_delta, h_baw;
830 struct ieee80211_tx_ampdu *tap;
831 int status = ATH_AGGR_DONE;
832 int prev_frames = 0; /* XXX for AR5416 burst, not done here */
833 int prev_al = 0; /* XXX also for AR5416 burst */
834
835 ATH_TX_LOCK_ASSERT(sc);
836
837 tap = ath_tx_get_tx_tid(an, tid->tid);
838 if (tap == NULL) {
839 status = ATH_AGGR_ERROR;
840 goto finish;
841 }
842
843 h_baw = tap->txa_wnd / 2;
844
845 for (;;) {
846 bf = ATH_TID_FIRST(tid);
847 if (bf_first == NULL)
848 bf_first = bf;
849 if (bf == NULL) {
850 status = ATH_AGGR_DONE;
851 break;
852 } else {
853 /*
854 * It's the first frame;
855 * set the aggregation limit based on the
856 * rate control decision that has been made.
857 */
858 aggr_limit = ath_get_aggr_limit(sc, &an->an_node,
859 bf_first);
860 }
861
862 /* Set this early just so things don't get confused */
863 bf->bf_next = NULL;
864
865 /*
866 * If the frame doesn't have a sequence number that we're
867 * tracking in the BAW (eg NULL QOS data frame), we can't
868 * aggregate it. Stop the aggregation process; the sender
869 * can then TX what's in the list thus far and then
870 * TX the frame individually.
871 */
872 if (! bf->bf_state.bfs_dobaw) {
873 status = ATH_AGGR_NONAGGR;
874 break;
875 }
876
877 /*
878 * If any of the rates are non-HT, this packet
879 * can't be aggregated.
880 * XXX TODO: add a bf_state flag which gets marked
881 * if any active rate is non-HT.
882 */
883
884 /*
885 * do not exceed aggregation limit
886 */
887 al_delta = ATH_AGGR_DELIM_SZ + bf->bf_state.bfs_pktlen;
888 if (nframes &&
889 (aggr_limit < (al + bpad + al_delta + prev_al))) {
890 status = ATH_AGGR_LIMITED;
891 break;
892 }
893
894 /*
895 * If RTS/CTS is set on the first frame, enforce
896 * the RTS aggregate limit.
897 */
898 if (bf_first->bf_state.bfs_txflags &
899 (HAL_TXDESC_CTSENA | HAL_TXDESC_RTSENA)) {
900 if (nframes &&
901 (sc->sc_rts_aggr_limit <
902 (al + bpad + al_delta + prev_al))) {
903 status = ATH_AGGR_8K_LIMITED;
904 break;
905 }
906 }
907
908 /*
909 * Do not exceed subframe limit.
910 */
911 if ((nframes + prev_frames) >= MIN((h_baw),
912 IEEE80211_AMPDU_SUBFRAME_DEFAULT)) {
913 status = ATH_AGGR_LIMITED;
914 break;
915 }
916
917 /*
918 * If the current frame has an RTS/CTS configuration
919 * that differs from the first frame, override the
920 * subsequent frame with this config.
921 */
922 if (bf != bf_first) {
923 bf->bf_state.bfs_txflags &=
924 ~ (HAL_TXDESC_RTSENA | HAL_TXDESC_CTSENA);
925 bf->bf_state.bfs_txflags |=
926 bf_first->bf_state.bfs_txflags &
927 (HAL_TXDESC_RTSENA | HAL_TXDESC_CTSENA);
928 }
929
930 /*
931 * If the packet has a sequence number, do not
932 * step outside of the block-ack window.
933 */
934 if (! BAW_WITHIN(tap->txa_start, tap->txa_wnd,
935 SEQNO(bf->bf_state.bfs_seqno))) {
936 status = ATH_AGGR_BAW_CLOSED;
937 break;
938 }
939
940 /*
941 * this packet is part of an aggregate.
942 */
943 ATH_TID_REMOVE(tid, bf, bf_list);
944
945 /* The TID lock is required for the BAW update */
946 ath_tx_addto_baw(sc, an, tid, bf);
947 bf->bf_state.bfs_addedbaw = 1;
948
949 /*
950 * XXX enforce ACK for aggregate frames (this needs to be
951 * XXX handled more gracefully?
952 */
953 if (bf->bf_state.bfs_txflags & HAL_TXDESC_NOACK) {
954 device_printf(sc->sc_dev,
955 "%s: HAL_TXDESC_NOACK set for an aggregate frame?\n",
956 __func__);
957 bf->bf_state.bfs_txflags &= (~HAL_TXDESC_NOACK);
958 }
959
960 /*
961 * Add the now owned buffer (which isn't
962 * on the software TXQ any longer) to our
963 * aggregate frame list.
964 */
965 TAILQ_INSERT_TAIL(bf_q, bf, bf_list);
966 nframes ++;
967
968 /* Completion handler */
969 bf->bf_comp = ath_tx_aggr_comp;
970
971 /*
972 * add padding for previous frame to aggregation length
973 */
974 al += bpad + al_delta;
975
976 /*
977 * Calculate delimiters needed for the current frame
978 */
979 bf->bf_state.bfs_ndelim =
980 ath_compute_num_delims(sc, bf_first,
981 bf->bf_state.bfs_pktlen, (bf_first == bf));
982
983 /*
984 * Calculate the padding needed from this set of delimiters,
985 * used when calculating if the next frame will fit in
986 * the aggregate.
987 */
988 bpad = PADBYTES(al_delta) + (bf->bf_state.bfs_ndelim << 2);
989
990 /*
991 * Chain the buffers together
992 */
993 if (bf_prev)
994 bf_prev->bf_next = bf;
995 bf_prev = bf;
996
997 /*
998 * If we're leaking frames, just return at this point;
999 * we've queued a single frame and we don't want to add
1000 * any more.
1001 */
1002 if (tid->an->an_leak_count) {
1003 status = ATH_AGGR_LEAK_CLOSED;
1004 break;
1005 }
1006
1007 #if 0
1008 /*
1009 * terminate aggregation on a small packet boundary
1010 */
1011 if (bf->bf_state.bfs_pktlen < ATH_AGGR_MINPLEN) {
1012 status = ATH_AGGR_SHORTPKT;
1013 break;
1014 }
1015 #endif
1016
1017 }
1018
1019 finish:
1020 /*
1021 * Just in case the list was empty when we tried to
1022 * dequeue a packet ..
1023 */
1024 if (bf_first) {
1025 bf_first->bf_state.bfs_al = al;
1026 bf_first->bf_state.bfs_nframes = nframes;
1027 }
1028 return status;
1029 }
1030