xref: /freebsd/sys/dev/ath/if_ath_tx_ht.c (revision 792bbaba989533a1fc93823df1720c8c4aaf0442)
1 /*-
2  * Copyright (c) 2011 Adrian Chadd, Xenion Pty Ltd.
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer,
10  *    without modification.
11  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
12  *    similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
13  *    redistribution must be conditioned upon including a substantially
14  *    similar Disclaimer requirement for further binary redistribution.
15  *
16  * NO WARRANTY
17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19  * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
20  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
21  * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
22  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
25  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
26  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
27  * THE POSSIBILITY OF SUCH DAMAGES.
28  */
29 
30 #include <sys/cdefs.h>
31 __FBSDID("$FreeBSD$");
32 
33 #include "opt_inet.h"
34 #include "opt_ath.h"
35 #include "opt_wlan.h"
36 
37 #include <sys/param.h>
38 #include <sys/systm.h>
39 #include <sys/sysctl.h>
40 #include <sys/mbuf.h>
41 #include <sys/malloc.h>
42 #include <sys/lock.h>
43 #include <sys/mutex.h>
44 #include <sys/kernel.h>
45 #include <sys/socket.h>
46 #include <sys/sockio.h>
47 #include <sys/errno.h>
48 #include <sys/callout.h>
49 #include <sys/bus.h>
50 #include <sys/endian.h>
51 #include <sys/kthread.h>
52 #include <sys/taskqueue.h>
53 #include <sys/priv.h>
54 
55 #include <machine/bus.h>
56 
57 #include <net/if.h>
58 #include <net/if_dl.h>
59 #include <net/if_media.h>
60 #include <net/if_types.h>
61 #include <net/if_arp.h>
62 #include <net/ethernet.h>
63 #include <net/if_llc.h>
64 
65 #include <net80211/ieee80211_var.h>
66 #include <net80211/ieee80211_regdomain.h>
67 #ifdef IEEE80211_SUPPORT_SUPERG
68 #include <net80211/ieee80211_superg.h>
69 #endif
70 #ifdef IEEE80211_SUPPORT_TDMA
71 #include <net80211/ieee80211_tdma.h>
72 #endif
73 
74 #include <net/bpf.h>
75 
76 #ifdef INET
77 #include <netinet/in.h>
78 #include <netinet/if_ether.h>
79 #endif
80 
81 #include <dev/ath/if_athvar.h>
82 #include <dev/ath/ath_hal/ah_devid.h>		/* XXX for softled */
83 #include <dev/ath/ath_hal/ah_diagcodes.h>
84 
85 #ifdef ATH_TX99_DIAG
86 #include <dev/ath/ath_tx99/ath_tx99.h>
87 #endif
88 
89 #include <dev/ath/if_ath_tx.h>		/* XXX for some support functions */
90 #include <dev/ath/if_ath_tx_ht.h>
91 #include <dev/ath/if_athrate.h>
92 #include <dev/ath/if_ath_debug.h>
93 
94 /*
95  * XXX net80211?
96  */
97 #define	IEEE80211_AMPDU_SUBFRAME_DEFAULT		32
98 
99 #define	ATH_AGGR_DELIM_SZ	4	/* delimiter size */
100 #define	ATH_AGGR_MINPLEN	256	/* in bytes, minimum packet length */
101 /* number of delimiters for encryption padding */
102 #define	ATH_AGGR_ENCRYPTDELIM	10
103 
104 /*
105  * returns delimiter padding required given the packet length
106  */
107 #define	ATH_AGGR_GET_NDELIM(_len)					\
108 	    (((((_len) + ATH_AGGR_DELIM_SZ) < ATH_AGGR_MINPLEN) ?	\
109 	    (ATH_AGGR_MINPLEN - (_len) - ATH_AGGR_DELIM_SZ) : 0) >> 2)
110 
111 #define	PADBYTES(_len)		((4 - ((_len) % 4)) % 4)
112 
113 int ath_max_4ms_framelen[4][32] = {
114 	[MCS_HT20] = {
115 		3212,  6432,  9648,  12864,  19300,  25736,  28952,  32172,
116 		6424,  12852, 19280, 25708,  38568,  51424,  57852,  64280,
117 		9628,  19260, 28896, 38528,  57792,  65532,  65532,  65532,
118 		12828, 25656, 38488, 51320,  65532,  65532,  65532,  65532,
119 	},
120 	[MCS_HT20_SGI] = {
121 		3572,  7144,  10720,  14296,  21444,  28596,  32172,  35744,
122 		7140,  14284, 21428,  28568,  42856,  57144,  64288,  65532,
123 		10700, 21408, 32112,  42816,  64228,  65532,  65532,  65532,
124 		14256, 28516, 42780,  57040,  65532,  65532,  65532,  65532,
125 	},
126 	[MCS_HT40] = {
127 		6680,  13360,  20044,  26724,  40092,  53456,  60140,  65532,
128 		13348, 26700,  40052,  53400,  65532,  65532,  65532,  65532,
129 		20004, 40008,  60016,  65532,  65532,  65532,  65532,  65532,
130 		26644, 53292,  65532,  65532,  65532,  65532,  65532,  65532,
131 	},
132 	[MCS_HT40_SGI] = {
133 		7420,  14844,  22272,  29696,  44544,  59396,  65532,  65532,
134 		14832, 29668,  44504,  59340,  65532,  65532,  65532,  65532,
135 		22232, 44464,  65532,  65532,  65532,  65532,  65532,  65532,
136 		29616, 59232,  65532,  65532,  65532,  65532,  65532,  65532,
137 	}
138 };
139 
140 /*
141  * XXX should be in net80211
142  */
143 static int ieee80211_mpdudensity_map[] = {
144 	0,		/* IEEE80211_HTCAP_MPDUDENSITY_NA */
145 	25,		/* IEEE80211_HTCAP_MPDUDENSITY_025 */
146 	50,		/* IEEE80211_HTCAP_MPDUDENSITY_05 */
147 	100,		/* IEEE80211_HTCAP_MPDUDENSITY_1 */
148 	200,		/* IEEE80211_HTCAP_MPDUDENSITY_2 */
149 	400,		/* IEEE80211_HTCAP_MPDUDENSITY_4 */
150 	800,		/* IEEE80211_HTCAP_MPDUDENSITY_8 */
151 	1600,		/* IEEE80211_HTCAP_MPDUDENSITY_16 */
152 };
153 
154 /*
155  * XXX should be in the HAL/net80211 ?
156  */
157 #define	BITS_PER_BYTE		8
158 #define	OFDM_PLCP_BITS		22
159 #define	HT_RC_2_MCS(_rc)	((_rc) & 0x7f)
160 #define	HT_RC_2_STREAMS(_rc)	((((_rc) & 0x78) >> 3) + 1)
161 #define	L_STF			8
162 #define	L_LTF			8
163 #define	L_SIG			4
164 #define	HT_SIG			8
165 #define	HT_STF			4
166 #define	HT_LTF(_ns)		(4 * (_ns))
167 #define	SYMBOL_TIME(_ns)	((_ns) << 2)		// ns * 4 us
168 #define	SYMBOL_TIME_HALFGI(_ns)	(((_ns) * 18 + 4) / 5)	// ns * 3.6 us
169 #define	NUM_SYMBOLS_PER_USEC(_usec)	(_usec >> 2)
170 #define	NUM_SYMBOLS_PER_USEC_HALFGI(_usec)	(((_usec*5)-4)/18)
171 #define	IS_HT_RATE(_rate)	((_rate) & 0x80)
172 
173 const uint32_t bits_per_symbol[][2] = {
174     /* 20MHz 40MHz */
175     {    26,   54 },     //  0: BPSK
176     {    52,  108 },     //  1: QPSK 1/2
177     {    78,  162 },     //  2: QPSK 3/4
178     {   104,  216 },     //  3: 16-QAM 1/2
179     {   156,  324 },     //  4: 16-QAM 3/4
180     {   208,  432 },     //  5: 64-QAM 2/3
181     {   234,  486 },     //  6: 64-QAM 3/4
182     {   260,  540 },     //  7: 64-QAM 5/6
183     {    52,  108 },     //  8: BPSK
184     {   104,  216 },     //  9: QPSK 1/2
185     {   156,  324 },     // 10: QPSK 3/4
186     {   208,  432 },     // 11: 16-QAM 1/2
187     {   312,  648 },     // 12: 16-QAM 3/4
188     {   416,  864 },     // 13: 64-QAM 2/3
189     {   468,  972 },     // 14: 64-QAM 3/4
190     {   520, 1080 },     // 15: 64-QAM 5/6
191     {    78,  162 },     // 16: BPSK
192     {   156,  324 },     // 17: QPSK 1/2
193     {   234,  486 },     // 18: QPSK 3/4
194     {   312,  648 },     // 19: 16-QAM 1/2
195     {   468,  972 },     // 20: 16-QAM 3/4
196     {   624, 1296 },     // 21: 64-QAM 2/3
197     {   702, 1458 },     // 22: 64-QAM 3/4
198     {   780, 1620 },     // 23: 64-QAM 5/6
199     {   104,  216 },     // 24: BPSK
200     {   208,  432 },     // 25: QPSK 1/2
201     {   312,  648 },     // 26: QPSK 3/4
202     {   416,  864 },     // 27: 16-QAM 1/2
203     {   624, 1296 },     // 28: 16-QAM 3/4
204     {   832, 1728 },     // 29: 64-QAM 2/3
205     {   936, 1944 },     // 30: 64-QAM 3/4
206     {  1040, 2160 },     // 31: 64-QAM 5/6
207 };
208 
209 /*
210  * Fill in the rate array information based on the current
211  * node configuration and the choices made by the rate
212  * selection code and ath_buf setup code.
213  *
214  * Later on, this may end up also being made by the
215  * rate control code, but for now it can live here.
216  *
217  * This needs to be called just before the packet is
218  * queued to the software queue or hardware queue,
219  * so all of the needed fields in bf_state are setup.
220  */
221 void
222 ath_tx_rate_fill_rcflags(struct ath_softc *sc, struct ath_buf *bf)
223 {
224 	struct ieee80211_node *ni = bf->bf_node;
225 	struct 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_htcaps & IEEE80211_HTCAP_LDPC) &&
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
404 ath_compute_num_delims(struct ath_softc *sc, struct ath_buf *first_bf,
405     uint16_t pktlen)
406 {
407 #define	MS(_v, _f)	(((_v) & _f) >> _f##_S)
408 	const HAL_RATE_TABLE *rt = sc->sc_currates;
409 	struct ieee80211_node *ni = first_bf->bf_node;
410 	struct ieee80211vap *vap = ni->ni_vap;
411 	int ndelim, mindelim = 0;
412 	int mpdudensity;	/* in 1/100'th of a microsecond */
413 	int peer_mpdudensity;	/* net80211 value */
414 	uint8_t rc, rix, flags;
415 	int width, half_gi;
416 	uint32_t nsymbits, nsymbols;
417 	uint16_t minlen;
418 
419 	/*
420 	 * Get the advertised density from the node.
421 	 */
422 	peer_mpdudensity = MS(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 delimeters
459 	 * required when doing RTS.
460 	 *
461 	 * XXX TODO: this is only needed if (a) RTS/CTS is enabled, and
462 	 * XXX (b) this is the first sub-frame in the aggregate.
463 	 */
464 	if (sc->sc_use_ent && (sc->sc_ent_cfg & AH_ENT_RTSCTS_DELIM_WAR)
465 	    && ndelim < AH_FIRST_DESC_NDELIMS)
466 		ndelim = AH_FIRST_DESC_NDELIMS;
467 
468 	/*
469 	 * If sc_delim_min_pad is non-zero, enforce it as the minimum
470 	 * pad delimiter count.
471 	 */
472 	if (sc->sc_delim_min_pad != 0)
473 		ndelim = MAX(ndelim, sc->sc_delim_min_pad);
474 
475 	DPRINTF(sc, ATH_DEBUG_SW_TX_AGGR,
476 	    "%s: pktlen=%d, ndelim=%d, mpdudensity=%d\n",
477 	    __func__, pktlen, ndelim, mpdudensity);
478 
479 	/*
480 	 * If the MPDU density is 0, we can return here.
481 	 * Otherwise, we need to convert the desired mpdudensity
482 	 * into a byte length, based on the rate in the subframe.
483 	 */
484 	if (mpdudensity == 0)
485 		return ndelim;
486 
487 	/*
488 	 * Convert desired mpdu density from microeconds to bytes based
489 	 * on highest rate in rate series (i.e. first rate) to determine
490 	 * required minimum length for subframe. Take into account
491 	 * whether high rate is 20 or 40Mhz and half or full GI.
492 	 */
493 	rix = first_bf->bf_state.bfs_rc[0].rix;
494 	rc = rt->info[rix].rateCode;
495 	flags = first_bf->bf_state.bfs_rc[0].flags;
496 	width = !! (flags & ATH_RC_CW40_FLAG);
497 	half_gi = !! (flags & ATH_RC_SGI_FLAG);
498 
499 	/*
500 	 * mpdudensity is in 1/100th of a usec, so divide by 100
501 	 */
502 	if (half_gi)
503 		nsymbols = NUM_SYMBOLS_PER_USEC_HALFGI(mpdudensity);
504 	else
505 		nsymbols = NUM_SYMBOLS_PER_USEC(mpdudensity);
506 	nsymbols /= 100;
507 
508 	if (nsymbols == 0)
509 		nsymbols = 1;
510 
511 	nsymbits = bits_per_symbol[HT_RC_2_MCS(rc)][width];
512 	minlen = (nsymbols * nsymbits) / BITS_PER_BYTE;
513 
514 	/*
515 	 * Min length is the minimum frame length for the
516 	 * required MPDU density.
517 	 */
518 	if (pktlen < minlen) {
519 		mindelim = (minlen - pktlen) / ATH_AGGR_DELIM_SZ;
520 		ndelim = MAX(mindelim, ndelim);
521 	}
522 
523 	DPRINTF(sc, ATH_DEBUG_SW_TX_AGGR,
524 	    "%s: pktlen=%d, minlen=%d, rix=%x, rc=%x, width=%d, hgi=%d, ndelim=%d\n",
525 	    __func__, pktlen, minlen, rix, rc, width, half_gi, ndelim);
526 
527 	return ndelim;
528 #undef	MS
529 }
530 
531 /*
532  * XXX TODO: put into net80211
533  */
534 static int
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
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 #define	MS(_v, _f)	(((_v) & _f) >> _f##_S)
569 	int amin = ATH_AGGR_MAXSIZE;
570 	int i;
571 
572 	/* Extract out the maximum configured driver A-MPDU limit */
573 	if (sc->sc_aggr_limit > 0 && sc->sc_aggr_limit < ATH_AGGR_MAXSIZE)
574 		amin = sc->sc_aggr_limit;
575 
576 	/* Check the vap configured transmit limit */
577 	amin = MIN(amin, ath_rx_ampdu_to_byte(vap->iv_ampdu_limit));
578 
579 	/*
580 	 * Check the HTCAP field for the maximum size the node has
581 	 * negotiated.  If it's smaller than what we have, cap it there.
582 	 */
583 	amin = MIN(amin, ath_rx_ampdu_to_byte(MS(ni->ni_htparam,
584 	    IEEE80211_HTCAP_MAXRXAMPDU)));
585 
586 	for (i = 0; i < ATH_RC_NUM; i++) {
587 		if (bf->bf_state.bfs_rc[i].tries == 0)
588 			continue;
589 		amin = MIN(amin, bf->bf_state.bfs_rc[i].max4msframelen);
590 	}
591 
592 	DPRINTF(sc, ATH_DEBUG_SW_TX_AGGR, "%s: max frame len= %d\n",
593 	    __func__, amin);
594 
595 	return amin;
596 #undef	MS
597 }
598 
599 /*
600  * Setup a 11n rate series structure
601  *
602  * This should be called for both legacy and MCS rates.
603  *
604  * This uses the rate series stuf from ath_tx_rate_fill_rcflags().
605  *
606  * It, along with ath_buf_set_rate, must be called -after- a burst
607  * or aggregate is setup.
608  */
609 static void
610 ath_rateseries_setup(struct ath_softc *sc, struct ieee80211_node *ni,
611     struct ath_buf *bf, HAL_11N_RATE_SERIES *series)
612 {
613 	struct ieee80211com *ic = ni->ni_ic;
614 	struct ath_hal *ah = sc->sc_ah;
615 	HAL_BOOL shortPreamble = AH_FALSE;
616 	const HAL_RATE_TABLE *rt = sc->sc_currates;
617 	int i;
618 	int pktlen;
619 	struct ath_rc_series *rc = bf->bf_state.bfs_rc;
620 
621 	if ((ic->ic_flags & IEEE80211_F_SHPREAMBLE) &&
622 	    (ni->ni_capinfo & IEEE80211_CAPINFO_SHORT_PREAMBLE))
623 		shortPreamble = AH_TRUE;
624 
625 	/*
626 	 * If this is the first frame in an aggregate series,
627 	 * use the aggregate length.
628 	 */
629 	if (bf->bf_state.bfs_aggr)
630 		pktlen = bf->bf_state.bfs_al;
631 	else
632 		pktlen = bf->bf_state.bfs_pktlen;
633 
634 	/*
635 	 * XXX TODO: modify this routine to use the bfs_rc[x].flags
636 	 * XXX fields.
637 	 */
638 	memset(series, 0, sizeof(HAL_11N_RATE_SERIES) * 4);
639 	for (i = 0; i < ATH_RC_NUM;  i++) {
640 		/* Only set flags for actual TX attempts */
641 		if (rc[i].tries == 0)
642 			continue;
643 
644 		series[i].Tries = rc[i].tries;
645 
646 		/*
647 		 * XXX TODO: When the NIC is capable of three stream TX,
648 		 * transmit 1/2 stream rates on two streams.
649 		 *
650 		 * This reduces the power consumption of the NIC and
651 		 * keeps it within the PCIe slot power limits.
652 		 */
653 		series[i].ChSel = sc->sc_cur_txchainmask;
654 
655 		/*
656 		 * Setup rate and TX power cap for this series.
657 		 */
658 		series[i].Rate = rt->info[rc[i].rix].rateCode;
659 		series[i].RateIndex = rc[i].rix;
660 		series[i].tx_power_cap = rc[i].tx_power_cap;
661 
662 		/*
663 		 * Enable RTS/CTS as appropriate.
664 		 */
665 		if (rc[i].flags & ATH_RC_RTSCTS_FLAG)
666 			series[i].RateFlags |= HAL_RATESERIES_RTS_CTS;
667 
668 		/*
669 		 * 11n rate? Update 11n flags.
670 		 */
671 		if (rc[i].flags & ATH_RC_HT_FLAG) {
672 			if (rc[i].flags & ATH_RC_CW40_FLAG)
673 				series[i].RateFlags |= HAL_RATESERIES_2040;
674 
675 			if (rc[i].flags & ATH_RC_SGI_FLAG)
676 				series[i].RateFlags |= HAL_RATESERIES_HALFGI;
677 
678 			if (rc[i].flags & ATH_RC_STBC_FLAG)
679 				series[i].RateFlags |= HAL_RATESERIES_STBC;
680 		}
681 
682 		/*
683 		 * TODO: If we're all doing 11n rates then we can set LDPC.
684 		 * If we've been asked to /do/ LDPC but we are handed a
685 		 * legacy rate, then we should complain.  Loudly.
686 		 */
687 
688 		/*
689 		 * PktDuration doesn't include slot, ACK, RTS, etc timing -
690 		 * it's just the packet duration
691 		 */
692 		if (rc[i].flags & ATH_RC_HT_FLAG) {
693 			series[i].PktDuration =
694 			    ath_computedur_ht(pktlen
695 				, series[i].Rate
696 				, HT_RC_2_STREAMS(series[i].Rate)
697 				, series[i].RateFlags & HAL_RATESERIES_2040
698 				, series[i].RateFlags & HAL_RATESERIES_HALFGI);
699 		} else {
700 			if (shortPreamble)
701 				series[i].Rate |=
702 				    rt->info[rc[i].rix].shortPreamble;
703 			/* XXX TODO: don't include SIFS */
704 			series[i].PktDuration = ath_hal_computetxtime(ah,
705 			    rt, pktlen, rc[i].rix, shortPreamble, AH_TRUE);
706 		}
707 	}
708 }
709 
710 #ifdef	ATH_DEBUG
711 static void
712 ath_rateseries_print(struct ath_softc *sc, HAL_11N_RATE_SERIES *series)
713 {
714 	int i;
715 	for (i = 0; i < ATH_RC_NUM; i++) {
716 		device_printf(sc->sc_dev ,"series %d: rate %x; tries %d; "
717 		    "pktDuration %d; chSel %d; txpowcap %d, rateFlags %x\n",
718 		    i,
719 		    series[i].Rate,
720 		    series[i].Tries,
721 		    series[i].PktDuration,
722 		    series[i].ChSel,
723 		    series[i].tx_power_cap,
724 		    series[i].RateFlags);
725 	}
726 }
727 #endif
728 
729 /*
730  * Setup the 11n rate scenario and burst duration for the given TX descriptor
731  * list.
732  *
733  * This isn't useful for sending beacon frames, which has different needs
734  * wrt what's passed into the rate scenario function.
735  */
736 void
737 ath_buf_set_rate(struct ath_softc *sc, struct ieee80211_node *ni,
738     struct ath_buf *bf)
739 {
740 	HAL_11N_RATE_SERIES series[4];
741 	struct ath_desc *ds = bf->bf_desc;
742 	struct ath_hal *ah = sc->sc_ah;
743 	int is_pspoll = (bf->bf_state.bfs_atype == HAL_PKT_TYPE_PSPOLL);
744 	int ctsrate = bf->bf_state.bfs_ctsrate;
745 	int flags = bf->bf_state.bfs_txflags;
746 
747 	/* Setup rate scenario */
748 	memset(&series, 0, sizeof(series));
749 
750 	ath_rateseries_setup(sc, ni, bf, series);
751 
752 #ifdef	ATH_DEBUG
753 	if (sc->sc_debug & ATH_DEBUG_XMIT)
754 		ath_rateseries_print(sc, series);
755 #endif
756 
757 	/* Set rate scenario */
758 	/*
759 	 * Note: Don't allow hardware to override the duration on
760 	 * ps-poll packets.
761 	 */
762 	ath_hal_set11nratescenario(ah, ds,
763 	    !is_pspoll,	/* whether to override the duration or not */
764 	    ctsrate,	/* rts/cts rate */
765 	    series,	/* 11n rate series */
766 	    4,		/* number of series */
767 	    flags);
768 
769 	/* Set burst duration */
770 	/*
771 	 * This is only required when doing 11n burst, not aggregation
772 	 * ie, if there's a second frame in a RIFS or A-MPDU burst
773 	 * w/ >1 A-MPDU frame bursting back to back.
774 	 * Normal A-MPDU doesn't do bursting -between- aggregates.
775 	 *
776 	 * .. and it's highly likely this won't ever be implemented
777 	 */
778 	//ath_hal_set11nburstduration(ah, ds, 8192);
779 }
780 
781 /*
782  * Form an aggregate packet list.
783  *
784  * This function enforces the aggregate restrictions/requirements.
785  *
786  * These are:
787  *
788  * + The aggregate size maximum (64k for AR9160 and later, 8K for
789  *   AR5416 when doing RTS frame protection.)
790  * + Maximum number of sub-frames for an aggregate
791  * + The aggregate delimiter size, giving MACs time to do whatever is
792  *   needed before each frame
793  * + Enforce the BAW limit
794  *
795  * Each descriptor queued should have the DMA setup.
796  * The rate series, descriptor setup, linking, etc is all done
797  * externally. This routine simply chains them together.
798  * ath_tx_setds_11n() will take care of configuring the per-
799  * descriptor setup, and ath_buf_set_rate() will configure the
800  * rate control.
801  *
802  * The TID lock is required for the entirety of this function.
803  *
804  * If some code in another thread adds to the head of this
805  * list, very strange behaviour will occur. Since retransmission is the
806  * only reason this will occur, and this routine is designed to be called
807  * from within the scheduler task, it won't ever clash with the completion
808  * task.
809  *
810  * So if you want to call this from an upper layer context (eg, to direct-
811  * dispatch aggregate frames to the hardware), please keep this in mind.
812  */
813 ATH_AGGR_STATUS
814 ath_tx_form_aggr(struct ath_softc *sc, struct ath_node *an,
815     struct ath_tid *tid, ath_bufhead *bf_q)
816 {
817 	//struct ieee80211_node *ni = &an->an_node;
818 	struct ath_buf *bf, *bf_first = NULL, *bf_prev = NULL;
819 	int nframes = 0;
820 	uint16_t aggr_limit = 0, al = 0, bpad = 0, al_delta, h_baw;
821 	struct ieee80211_tx_ampdu *tap;
822 	int status = ATH_AGGR_DONE;
823 	int prev_frames = 0;	/* XXX for AR5416 burst, not done here */
824 	int prev_al = 0;	/* XXX also for AR5416 burst */
825 
826 	ATH_TX_LOCK_ASSERT(sc);
827 
828 	tap = ath_tx_get_tx_tid(an, tid->tid);
829 	if (tap == NULL) {
830 		status = ATH_AGGR_ERROR;
831 		goto finish;
832 	}
833 
834 	h_baw = tap->txa_wnd / 2;
835 
836 	for (;;) {
837 		bf = ATH_TID_FIRST(tid);
838 		if (bf_first == NULL)
839 			bf_first = bf;
840 		if (bf == NULL) {
841 			status = ATH_AGGR_DONE;
842 			break;
843 		} else {
844 			/*
845 			 * It's the first frame;
846 			 * set the aggregation limit based on the
847 			 * rate control decision that has been made.
848 			 */
849 			aggr_limit = ath_get_aggr_limit(sc, &an->an_node,
850 			    bf_first);
851 		}
852 
853 		/* Set this early just so things don't get confused */
854 		bf->bf_next = NULL;
855 
856 		/*
857 		 * If the frame doesn't have a sequence number that we're
858 		 * tracking in the BAW (eg NULL QOS data frame), we can't
859 		 * aggregate it. Stop the aggregation process; the sender
860 		 * can then TX what's in the list thus far and then
861 		 * TX the frame individually.
862 		 */
863 		if (! bf->bf_state.bfs_dobaw) {
864 			status = ATH_AGGR_NONAGGR;
865 			break;
866 		}
867 
868 		/*
869 		 * If any of the rates are non-HT, this packet
870 		 * can't be aggregated.
871 		 * XXX TODO: add a bf_state flag which gets marked
872 		 * if any active rate is non-HT.
873 		 */
874 
875 		/*
876 		 * do not exceed aggregation limit
877 		 */
878 		al_delta = ATH_AGGR_DELIM_SZ + bf->bf_state.bfs_pktlen;
879 		if (nframes &&
880 		    (aggr_limit < (al + bpad + al_delta + prev_al))) {
881 			status = ATH_AGGR_LIMITED;
882 			break;
883 		}
884 
885 		/*
886 		 * If RTS/CTS is set on the first frame, enforce
887 		 * the RTS aggregate limit.
888 		 */
889 		if (bf_first->bf_state.bfs_txflags &
890 		    (HAL_TXDESC_CTSENA | HAL_TXDESC_RTSENA)) {
891 			if (nframes &&
892 			   (sc->sc_rts_aggr_limit <
893 			     (al + bpad + al_delta + prev_al))) {
894 				status = ATH_AGGR_8K_LIMITED;
895 				break;
896 			}
897 		}
898 
899 		/*
900 		 * Do not exceed subframe limit.
901 		 */
902 		if ((nframes + prev_frames) >= MIN((h_baw),
903 		    IEEE80211_AMPDU_SUBFRAME_DEFAULT)) {
904 			status = ATH_AGGR_LIMITED;
905 			break;
906 		}
907 
908 		/*
909 		 * If the current frame has an RTS/CTS configuration
910 		 * that differs from the first frame, override the
911 		 * subsequent frame with this config.
912 		 */
913 		if (bf != bf_first) {
914 			bf->bf_state.bfs_txflags &=
915 			    ~ (HAL_TXDESC_RTSENA | HAL_TXDESC_CTSENA);
916 			bf->bf_state.bfs_txflags |=
917 			    bf_first->bf_state.bfs_txflags &
918 			    (HAL_TXDESC_RTSENA | HAL_TXDESC_CTSENA);
919 		}
920 
921 		/*
922 		 * If the packet has a sequence number, do not
923 		 * step outside of the block-ack window.
924 		 */
925 		if (! BAW_WITHIN(tap->txa_start, tap->txa_wnd,
926 		    SEQNO(bf->bf_state.bfs_seqno))) {
927 			status = ATH_AGGR_BAW_CLOSED;
928 			break;
929 		}
930 
931 		/*
932 		 * this packet is part of an aggregate.
933 		 */
934 		ATH_TID_REMOVE(tid, bf, bf_list);
935 
936 		/* The TID lock is required for the BAW update */
937 		ath_tx_addto_baw(sc, an, tid, bf);
938 		bf->bf_state.bfs_addedbaw = 1;
939 
940 		/*
941 		 * XXX enforce ACK for aggregate frames (this needs to be
942 		 * XXX handled more gracefully?
943 		 */
944 		if (bf->bf_state.bfs_txflags & HAL_TXDESC_NOACK) {
945 			device_printf(sc->sc_dev,
946 			    "%s: HAL_TXDESC_NOACK set for an aggregate frame?\n",
947 			    __func__);
948 			bf->bf_state.bfs_txflags &= (~HAL_TXDESC_NOACK);
949 		}
950 
951 		/*
952 		 * Add the now owned buffer (which isn't
953 		 * on the software TXQ any longer) to our
954 		 * aggregate frame list.
955 		 */
956 		TAILQ_INSERT_TAIL(bf_q, bf, bf_list);
957 		nframes ++;
958 
959 		/* Completion handler */
960 		bf->bf_comp = ath_tx_aggr_comp;
961 
962 		/*
963 		 * add padding for previous frame to aggregation length
964 		 */
965 		al += bpad + al_delta;
966 
967 		/*
968 		 * Calculate delimiters needed for the current frame
969 		 */
970 		bf->bf_state.bfs_ndelim =
971 		    ath_compute_num_delims(sc, bf_first,
972 		    bf->bf_state.bfs_pktlen);
973 
974 		/*
975 		 * Calculate the padding needed from this set of delimiters,
976 		 * used when calculating if the next frame will fit in
977 		 * the aggregate.
978 		 */
979 		bpad = PADBYTES(al_delta) + (bf->bf_state.bfs_ndelim << 2);
980 
981 		/*
982 		 * Chain the buffers together
983 		 */
984 		if (bf_prev)
985 			bf_prev->bf_next = bf;
986 		bf_prev = bf;
987 
988 		/*
989 		 * If we're leaking frames, just return at this point;
990 		 * we've queued a single frame and we don't want to add
991 		 * any more.
992 		 */
993 		if (tid->an->an_leak_count) {
994 			status = ATH_AGGR_LEAK_CLOSED;
995 			break;
996 		}
997 
998 #if 0
999 		/*
1000 		 * terminate aggregation on a small packet boundary
1001 		 */
1002 		if (bf->bf_state.bfs_pktlen < ATH_AGGR_MINPLEN) {
1003 			status = ATH_AGGR_SHORTPKT;
1004 			break;
1005 		}
1006 #endif
1007 
1008 	}
1009 
1010 finish:
1011 	/*
1012 	 * Just in case the list was empty when we tried to
1013 	 * dequeue a packet ..
1014 	 */
1015 	if (bf_first) {
1016 		bf_first->bf_state.bfs_al = al;
1017 		bf_first->bf_state.bfs_nframes = nframes;
1018 	}
1019 	return status;
1020 }
1021