2 * Copyright (c) 2010 Broadcom Corporation
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
11 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
13 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
14 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16 #include <net/mac80211.h>
20 #include "phy/phy_hal.h"
25 /* max number of mpdus in an ampdu */
26 #define AMPDU_MAX_MPDU 32
27 /* max number of mpdus in an ampdu to a legacy */
28 #define AMPDU_NUM_MPDU_LEGACY 16
29 /* max Tx ba window size (in pdu) */
30 #define AMPDU_TX_BA_MAX_WSIZE 64
31 /* default Tx ba window size (in pdu) */
32 #define AMPDU_TX_BA_DEF_WSIZE 64
33 /* default Rx ba window size (in pdu) */
34 #define AMPDU_RX_BA_DEF_WSIZE 64
35 /* max Rx ba window size (in pdu) */
36 #define AMPDU_RX_BA_MAX_WSIZE 64
37 /* max dur of tx ampdu (in msec) */
38 #define AMPDU_MAX_DUR 5
39 /* default tx retry limit */
40 #define AMPDU_DEF_RETRY_LIMIT 5
41 /* default tx retry limit at reg rate */
42 #define AMPDU_DEF_RR_RETRY_LIMIT 2
43 /* default weight of ampdu in txfifo */
44 #define AMPDU_DEF_TXPKT_WEIGHT 2
45 /* default ffpld reserved bytes */
46 #define AMPDU_DEF_FFPLD_RSVD 2048
47 /* # of inis to be freed on detach */
48 #define AMPDU_INI_FREE 10
49 /* max # of mpdus released at a time */
50 #define AMPDU_SCB_MAX_RELEASE 20
52 #define NUM_FFPLD_FIFO 4 /* number of fifo concerned by pre-loading */
53 #define FFPLD_TX_MAX_UNFL 200 /* default value of the average number of ampdu
56 #define FFPLD_MPDU_SIZE 1800 /* estimate of maximum mpdu size */
57 #define FFPLD_MAX_MCS 23 /* we don't deal with mcs 32 */
58 #define FFPLD_PLD_INCR 1000 /* increments in bytes */
59 #define FFPLD_MAX_AMPDU_CNT 5000 /* maximum number of ampdu we
60 * accumulate between resets.
63 #define AMPDU_DELIMITER_LEN 4
65 /* max allowed number of mpdus in an ampdu (2 streams) */
66 #define AMPDU_NUM_MPDU 16
68 #define TX_SEQ_TO_INDEX(seq) ((seq) % AMPDU_TX_BA_MAX_WSIZE)
70 /* max possible overhead per mpdu in the ampdu; 3 is for roundup if needed */
71 #define AMPDU_MAX_MPDU_OVERHEAD (FCS_LEN + DOT11_ICV_AES_LEN +\
72 AMPDU_DELIMITER_LEN + 3\
73 + DOT11_A4_HDR_LEN + DOT11_QOS_LEN + DOT11_IV_MAX_LEN)
75 /* modulo add/sub, bound = 2^k */
76 #define MODADD_POW2(x, y, bound) (((x) + (y)) & ((bound) - 1))
77 #define MODSUB_POW2(x, y, bound) (((x) - (y)) & ((bound) - 1))
79 /* structure to hold tx fifo information and pre-loading state
80 * counters specific to tx underflows of ampdus
81 * some counters might be redundant with the ones in wlc or ampdu structures.
82 * This allows to maintain a specific state independently of
83 * how often and/or when the wlc counters are updated.
85 * ampdu_pld_size: number of bytes to be pre-loaded
86 * mcs2ampdu_table: per-mcs max # of mpdus in an ampdu
87 * prev_txfunfl: num of underflows last read from the HW macstats counter
88 * accum_txfunfl: num of underflows since we modified pld params
89 * accum_txampdu: num of tx ampdu since we modified pld params
90 * prev_txampdu: previous reading of tx ampdu
91 * dmaxferrate: estimated dma avg xfer rate in kbits/sec
93 struct brcms_fifo_info {
95 u8 mcs2ampdu_table[FFPLD_MAX_MCS + 1];
103 /* AMPDU module specific state
105 * wlc: pointer to main wlc structure
106 * scb_handle: scb cubby handle to retrieve data from scb
107 * ini_enable: per-tid initiator enable/disable of ampdu
108 * ba_tx_wsize: Tx ba window size (in pdu)
109 * ba_rx_wsize: Rx ba window size (in pdu)
110 * retry_limit: mpdu transmit retry limit
111 * rr_retry_limit: mpdu transmit retry limit at regular rate
112 * retry_limit_tid: per-tid mpdu transmit retry limit
113 * rr_retry_limit_tid: per-tid mpdu transmit retry limit at regular rate
114 * mpdu_density: min mpdu spacing (0-7) ==> 2^(x-1)/8 usec
115 * max_pdu: max pdus allowed in ampdu
116 * dur: max duration of an ampdu (in msec)
117 * txpkt_weight: weight of ampdu in txfifo; reduces rate lag
118 * rx_factor: maximum rx ampdu factor (0-3) ==> 2^(13+x) bytes
119 * ffpld_rsvd: number of bytes to reserve for preload
120 * max_txlen: max size of ampdu per mcs, bw and sgi
121 * mfbr: enable multiple fallback rate
122 * tx_max_funl: underflows should be kept such that
123 * (tx_max_funfl*underflows) < tx frames
124 * fifo_tb: table of fifo infos
127 struct brcms_c_info *wlc;
129 u8 ini_enable[AMPDU_MAX_SCB_TID];
134 u8 retry_limit_tid[AMPDU_MAX_SCB_TID];
135 u8 rr_retry_limit_tid[AMPDU_MAX_SCB_TID];
142 u32 max_txlen[MCS_TABLE_SIZE][2][2];
145 struct brcms_fifo_info fifo_tb[NUM_FFPLD_FIFO];
148 /* used for flushing ampdu packets */
149 struct cb_del_ampdu_pars {
150 struct ieee80211_sta *sta;
154 static void brcms_c_scb_ampdu_update_max_txlen(struct ampdu_info *ampdu, u8 dur)
158 for (mcs = 0; mcs < MCS_TABLE_SIZE; mcs++) {
159 /* rate is in Kbps; dur is in msec ==> len = (rate * dur) / 8 */
161 rate = mcs_2_rate(mcs, false, false);
162 ampdu->max_txlen[mcs][0][0] = (rate * dur) >> 3;
164 rate = mcs_2_rate(mcs, true, false);
165 ampdu->max_txlen[mcs][1][0] = (rate * dur) >> 3;
167 rate = mcs_2_rate(mcs, false, true);
168 ampdu->max_txlen[mcs][0][1] = (rate * dur) >> 3;
170 rate = mcs_2_rate(mcs, true, true);
171 ampdu->max_txlen[mcs][1][1] = (rate * dur) >> 3;
175 static bool brcms_c_ampdu_cap(struct ampdu_info *ampdu)
177 if (BRCMS_PHY_11N_CAP(ampdu->wlc->band))
183 static int brcms_c_ampdu_set(struct ampdu_info *ampdu, bool on)
185 struct brcms_c_info *wlc = ampdu->wlc;
187 wlc->pub->_ampdu = false;
190 if (!(wlc->pub->_n_enab & SUPPORT_11N)) {
191 wiphy_err(ampdu->wlc->wiphy, "wl%d: driver not "
192 "nmode enabled\n", wlc->pub->unit);
195 if (!brcms_c_ampdu_cap(ampdu)) {
196 wiphy_err(ampdu->wlc->wiphy, "wl%d: device not "
197 "ampdu capable\n", wlc->pub->unit);
200 wlc->pub->_ampdu = on;
206 static void brcms_c_ffpld_init(struct ampdu_info *ampdu)
209 struct brcms_fifo_info *fifo;
211 for (j = 0; j < NUM_FFPLD_FIFO; j++) {
212 fifo = (ampdu->fifo_tb + j);
213 fifo->ampdu_pld_size = 0;
214 for (i = 0; i <= FFPLD_MAX_MCS; i++)
215 fifo->mcs2ampdu_table[i] = 255;
216 fifo->dmaxferrate = 0;
217 fifo->accum_txampdu = 0;
218 fifo->prev_txfunfl = 0;
219 fifo->accum_txfunfl = 0;
224 struct ampdu_info *brcms_c_ampdu_attach(struct brcms_c_info *wlc)
226 struct ampdu_info *ampdu;
229 ampdu = kzalloc(sizeof(struct ampdu_info), GFP_ATOMIC);
235 for (i = 0; i < AMPDU_MAX_SCB_TID; i++)
236 ampdu->ini_enable[i] = true;
237 /* Disable ampdu for VO by default */
238 ampdu->ini_enable[PRIO_8021D_VO] = false;
239 ampdu->ini_enable[PRIO_8021D_NC] = false;
241 /* Disable ampdu for BK by default since not enough fifo space */
242 ampdu->ini_enable[PRIO_8021D_NONE] = false;
243 ampdu->ini_enable[PRIO_8021D_BK] = false;
245 ampdu->ba_tx_wsize = AMPDU_TX_BA_DEF_WSIZE;
246 ampdu->ba_rx_wsize = AMPDU_RX_BA_DEF_WSIZE;
247 ampdu->mpdu_density = AMPDU_DEF_MPDU_DENSITY;
248 ampdu->max_pdu = AUTO;
249 ampdu->dur = AMPDU_MAX_DUR;
250 ampdu->txpkt_weight = AMPDU_DEF_TXPKT_WEIGHT;
252 ampdu->ffpld_rsvd = AMPDU_DEF_FFPLD_RSVD;
254 * bump max ampdu rcv size to 64k for all 11n
255 * devices except 4321A0 and 4321A1
257 if (BRCMS_ISNPHY(wlc->band) && NREV_LT(wlc->band->phyrev, 2))
258 ampdu->rx_factor = IEEE80211_HT_MAX_AMPDU_32K;
260 ampdu->rx_factor = IEEE80211_HT_MAX_AMPDU_64K;
261 ampdu->retry_limit = AMPDU_DEF_RETRY_LIMIT;
262 ampdu->rr_retry_limit = AMPDU_DEF_RR_RETRY_LIMIT;
264 for (i = 0; i < AMPDU_MAX_SCB_TID; i++) {
265 ampdu->retry_limit_tid[i] = ampdu->retry_limit;
266 ampdu->rr_retry_limit_tid[i] = ampdu->rr_retry_limit;
269 brcms_c_scb_ampdu_update_max_txlen(ampdu, ampdu->dur);
271 /* try to set ampdu to the default value */
272 brcms_c_ampdu_set(ampdu, wlc->pub->_ampdu);
274 ampdu->tx_max_funl = FFPLD_TX_MAX_UNFL;
275 brcms_c_ffpld_init(ampdu);
280 void brcms_c_ampdu_detach(struct ampdu_info *ampdu)
285 static void brcms_c_scb_ampdu_update_config(struct ampdu_info *ampdu,
288 struct scb_ampdu *scb_ampdu = &scb->scb_ampdu;
291 scb_ampdu->max_pdu = AMPDU_NUM_MPDU;
293 /* go back to legacy size if some preloading is occurring */
294 for (i = 0; i < NUM_FFPLD_FIFO; i++) {
295 if (ampdu->fifo_tb[i].ampdu_pld_size > FFPLD_PLD_INCR)
296 scb_ampdu->max_pdu = AMPDU_NUM_MPDU_LEGACY;
299 /* apply user override */
300 if (ampdu->max_pdu != AUTO)
301 scb_ampdu->max_pdu = (u8) ampdu->max_pdu;
303 scb_ampdu->release = min_t(u8, scb_ampdu->max_pdu,
304 AMPDU_SCB_MAX_RELEASE);
306 if (scb_ampdu->max_rx_ampdu_bytes)
307 scb_ampdu->release = min_t(u8, scb_ampdu->release,
308 scb_ampdu->max_rx_ampdu_bytes / 1600);
310 scb_ampdu->release = min(scb_ampdu->release,
311 ampdu->fifo_tb[TX_AC_BE_FIFO].
312 mcs2ampdu_table[FFPLD_MAX_MCS]);
315 static void brcms_c_scb_ampdu_update_config_all(struct ampdu_info *ampdu)
317 brcms_c_scb_ampdu_update_config(ampdu, &du->wlc->pri_scb);
320 static void brcms_c_ffpld_calc_mcs2ampdu_table(struct ampdu_info *ampdu, int f)
323 u32 phy_rate, dma_rate, tmp;
325 struct brcms_fifo_info *fifo = (ampdu->fifo_tb + f);
327 /* recompute the dma rate */
328 /* note : we divide/multiply by 100 to avoid integer overflows */
329 max_mpdu = min_t(u8, fifo->mcs2ampdu_table[FFPLD_MAX_MCS],
330 AMPDU_NUM_MPDU_LEGACY);
331 phy_rate = mcs_2_rate(FFPLD_MAX_MCS, true, false);
334 (max_mpdu * FFPLD_MPDU_SIZE - fifo->ampdu_pld_size))
335 / (max_mpdu * FFPLD_MPDU_SIZE)) * 100;
336 fifo->dmaxferrate = dma_rate;
338 /* fill up the mcs2ampdu table; do not recalc the last mcs */
339 dma_rate = dma_rate >> 7;
340 for (i = 0; i < FFPLD_MAX_MCS; i++) {
341 /* shifting to keep it within integer range */
342 phy_rate = mcs_2_rate(i, true, false) >> 7;
343 if (phy_rate > dma_rate) {
344 tmp = ((fifo->ampdu_pld_size * phy_rate) /
345 ((phy_rate - dma_rate) * FFPLD_MPDU_SIZE)) + 1;
346 tmp = min_t(u32, tmp, 255);
347 fifo->mcs2ampdu_table[i] = (u8) tmp;
352 /* evaluate the dma transfer rate using the tx underflows as feedback.
353 * If necessary, increase tx fifo preloading. If not enough,
354 * decrease maximum ampdu size for each mcs till underflows stop
355 * Return 1 if pre-loading not active, -1 if not an underflow event,
356 * 0 if pre-loading module took care of the event.
358 static int brcms_c_ffpld_check_txfunfl(struct brcms_c_info *wlc, int fid)
360 struct ampdu_info *ampdu = wlc->ampdu;
361 u32 phy_rate = mcs_2_rate(FFPLD_MAX_MCS, true, false);
364 u32 current_ampdu_cnt = 0;
367 struct brcms_fifo_info *fifo = (ampdu->fifo_tb + fid);
371 /* return if we got here for a different reason than underflows */
372 cur_txunfl = brcms_b_read_shm(wlc->hw,
374 offsetof(struct macstat, txfunfl[fid]));
375 new_txunfl = (u16) (cur_txunfl - fifo->prev_txfunfl);
376 if (new_txunfl == 0) {
377 BCMMSG(wlc->wiphy, "TX status FRAG set but no tx underflows\n");
380 fifo->prev_txfunfl = cur_txunfl;
382 if (!ampdu->tx_max_funl)
385 /* check if fifo is big enough */
386 if (brcms_b_xmtfifo_sz_get(wlc->hw, fid, &xmtfifo_sz))
389 if ((TXFIFO_SIZE_UNIT * (u32) xmtfifo_sz) <= ampdu->ffpld_rsvd)
392 max_pld_size = TXFIFO_SIZE_UNIT * xmtfifo_sz - ampdu->ffpld_rsvd;
393 fifo->accum_txfunfl += new_txunfl;
395 /* we need to wait for at least 10 underflows */
396 if (fifo->accum_txfunfl < 10)
399 BCMMSG(wlc->wiphy, "ampdu_count %d tx_underflows %d\n",
400 current_ampdu_cnt, fifo->accum_txfunfl);
403 compute the current ratio of tx unfl per ampdu.
404 When the current ampdu count becomes too
405 big while the ratio remains small, we reset
406 the current count in order to not
407 introduce too big of a latency in detecting a
408 large amount of tx underflows later.
411 txunfl_ratio = current_ampdu_cnt / fifo->accum_txfunfl;
413 if (txunfl_ratio > ampdu->tx_max_funl) {
414 if (current_ampdu_cnt >= FFPLD_MAX_AMPDU_CNT)
415 fifo->accum_txfunfl = 0;
419 max_mpdu = min_t(u8, fifo->mcs2ampdu_table[FFPLD_MAX_MCS],
420 AMPDU_NUM_MPDU_LEGACY);
422 /* In case max value max_pdu is already lower than
423 the fifo depth, there is nothing more we can do.
426 if (fifo->ampdu_pld_size >= max_mpdu * FFPLD_MPDU_SIZE) {
427 fifo->accum_txfunfl = 0;
431 if (fifo->ampdu_pld_size < max_pld_size) {
433 /* increment by TX_FIFO_PLD_INC bytes */
434 fifo->ampdu_pld_size += FFPLD_PLD_INCR;
435 if (fifo->ampdu_pld_size > max_pld_size)
436 fifo->ampdu_pld_size = max_pld_size;
438 /* update scb release size */
439 brcms_c_scb_ampdu_update_config_all(ampdu);
442 * compute a new dma xfer rate for max_mpdu @ max mcs.
443 * This is the minimum dma rate that can achieve no
444 * underflow condition for the current mpdu size.
446 * note : we divide/multiply by 100 to avoid integer overflows
450 (max_mpdu * FFPLD_MPDU_SIZE - fifo->ampdu_pld_size))
451 / (max_mpdu * FFPLD_MPDU_SIZE)) * 100;
453 BCMMSG(wlc->wiphy, "DMA estimated transfer rate %d; "
454 "pre-load size %d\n",
455 fifo->dmaxferrate, fifo->ampdu_pld_size);
458 /* decrease ampdu size */
459 if (fifo->mcs2ampdu_table[FFPLD_MAX_MCS] > 1) {
460 if (fifo->mcs2ampdu_table[FFPLD_MAX_MCS] == 255)
461 fifo->mcs2ampdu_table[FFPLD_MAX_MCS] =
462 AMPDU_NUM_MPDU_LEGACY - 1;
464 fifo->mcs2ampdu_table[FFPLD_MAX_MCS] -= 1;
466 /* recompute the table */
467 brcms_c_ffpld_calc_mcs2ampdu_table(ampdu, fid);
469 /* update scb release size */
470 brcms_c_scb_ampdu_update_config_all(ampdu);
473 fifo->accum_txfunfl = 0;
478 brcms_c_ampdu_tx_operational(struct brcms_c_info *wlc, u8 tid,
479 u8 ba_wsize, /* negotiated ba window size (in pdu) */
480 uint max_rx_ampdu_bytes) /* from ht_cap in beacon */
482 struct scb_ampdu *scb_ampdu;
483 struct scb_ampdu_tid_ini *ini;
484 struct ampdu_info *ampdu = wlc->ampdu;
485 struct scb *scb = &wlc->pri_scb;
486 scb_ampdu = &scb->scb_ampdu;
488 if (!ampdu->ini_enable[tid]) {
489 wiphy_err(ampdu->wlc->wiphy, "%s: Rejecting tid %d\n",
494 ini = &scb_ampdu->ini[tid];
496 ini->scb = scb_ampdu->scb;
497 ini->ba_wsize = ba_wsize;
498 scb_ampdu->max_rx_ampdu_bytes = max_rx_ampdu_bytes;
502 brcms_c_sendampdu(struct ampdu_info *ampdu, struct brcms_txq_info *qi,
503 struct sk_buff **pdu, int prec)
505 struct brcms_c_info *wlc;
506 struct sk_buff *p, *pkt[AMPDU_MAX_MPDU];
509 u8 preamble_type = BRCMS_GF_PREAMBLE;
510 u8 fbr_preamble_type = BRCMS_GF_PREAMBLE;
511 u8 rts_preamble_type = BRCMS_LONG_PREAMBLE;
512 u8 rts_fbr_preamble_type = BRCMS_LONG_PREAMBLE;
514 bool rr = true, fbr = false;
515 uint i, count = 0, fifo, seg_cnt = 0;
516 u16 plen, len, seq = 0, mcl, mch, index, frameid, dma_len = 0;
517 u32 ampdu_len, max_ampdu_bytes = 0;
518 struct d11txh *txh = NULL;
520 struct ieee80211_hdr *h;
522 struct scb_ampdu *scb_ampdu;
523 struct scb_ampdu_tid_ini *ini;
525 bool use_rts = false, use_cts = false;
526 u32 rspec = 0, rspec_fallback = 0;
527 u32 rts_rspec = 0, rts_rspec_fallback = 0;
528 u16 mimo_ctlchbw = PHY_TXC1_BW_20MHZ;
529 struct ieee80211_rts *rts;
531 struct brcms_fifo_info *f;
533 struct ieee80211_tx_info *tx_info;
541 tid = (u8) (p->priority);
543 f = ampdu->fifo_tb + prio2fifo[tid];
546 scb_ampdu = &scb->scb_ampdu;
547 ini = &scb_ampdu->ini[tid];
549 /* Let pressure continue to build ... */
550 qlen = pktq_plen(&qi->q, prec);
551 if (ini->tx_in_transit > 0 &&
552 qlen < min(scb_ampdu->max_pdu, ini->ba_wsize))
553 /* Collect multiple MPDU's to be sent in the next AMPDU */
556 /* at this point we intend to transmit an AMPDU */
557 rr_retry_limit = ampdu->rr_retry_limit_tid[tid];
561 struct ieee80211_tx_rate *txrate;
563 tx_info = IEEE80211_SKB_CB(p);
564 txrate = tx_info->status.rates;
566 if (tx_info->flags & IEEE80211_TX_CTL_AMPDU) {
567 err = brcms_c_prep_pdu(wlc, p, &fifo);
569 wiphy_err(wiphy, "%s: AMPDU flag is off!\n", __func__);
577 wiphy_err(wiphy, "wl%d: sendampdu: "
578 "prep_xdu retry; seq 0x%x\n",
579 wlc->pub->unit, seq);
584 /* error in the packet; reject it */
585 wiphy_err(wiphy, "wl%d: sendampdu: prep_xdu "
586 "rejected; seq 0x%x\n", wlc->pub->unit, seq);
591 /* pkt is good to be aggregated */
592 txh = (struct d11txh *) p->data;
593 plcp = (u8 *) (txh + 1);
594 h = (struct ieee80211_hdr *)(plcp + D11_PHY_HDR_LEN);
595 seq = le16_to_cpu(h->seq_ctrl) >> SEQNUM_SHIFT;
596 index = TX_SEQ_TO_INDEX(seq);
598 /* check mcl fields and test whether it can be agg'd */
599 mcl = le16_to_cpu(txh->MacTxControlLow);
600 mcl &= ~TXC_AMPDU_MASK;
601 fbr_iscck = !(le16_to_cpu(txh->XtraFrameTypes) & 0x3);
602 txh->PreloadSize = 0; /* always default to 0 */
604 /* Handle retry limits */
605 if (txrate[0].count <= rr_retry_limit) {
615 /* extract the length info */
616 len = fbr_iscck ? BRCMS_GET_CCK_PLCP_LEN(txh->FragPLCPFallback)
617 : BRCMS_GET_MIMO_PLCP_LEN(txh->FragPLCPFallback);
619 /* retrieve null delimiter count */
620 ndelim = txh->RTSPLCPFallback[AMPDU_FBR_NULL_DELIM];
623 BCMMSG(wlc->wiphy, "wl%d: mpdu %d plcp_len %d\n",
624 wlc->pub->unit, count, len);
627 * aggregateable mpdu. For ucode/hw agg,
628 * test whether need to break or change the epoch
631 mcl |= (TXC_AMPDU_FIRST << TXC_AMPDU_SHIFT);
632 /* refill the bits since might be a retx mpdu */
633 mcl |= TXC_STARTMSDU;
634 rts = (struct ieee80211_rts *)&txh->rts_frame;
636 if (ieee80211_is_rts(rts->frame_control)) {
640 if (ieee80211_is_cts(rts->frame_control)) {
645 mcl |= (TXC_AMPDU_MIDDLE << TXC_AMPDU_SHIFT);
646 mcl &= ~(TXC_STARTMSDU | TXC_SENDRTS | TXC_SENDCTS);
649 len = roundup(len, 4);
650 ampdu_len += (len + (ndelim + 1) * AMPDU_DELIMITER_LEN);
652 dma_len += (u16) p->len;
654 BCMMSG(wlc->wiphy, "wl%d: ampdu_len %d"
655 " seg_cnt %d null delim %d\n",
656 wlc->pub->unit, ampdu_len, seg_cnt, ndelim);
658 txh->MacTxControlLow = cpu_to_le16(mcl);
660 /* this packet is added */
663 /* patch the first MPDU */
665 u8 plcp0, plcp3, is40, sgi;
666 struct ieee80211_sta *sta;
668 sta = tx_info->control.sta;
674 plcp0 = txh->FragPLCPFallback[0];
675 plcp3 = txh->FragPLCPFallback[3];
678 is40 = (plcp0 & MIMO_PLCP_40MHZ) ? 1 : 0;
679 sgi = plcp3_issgi(plcp3) ? 1 : 0;
680 mcs = plcp0 & ~MIMO_PLCP_40MHZ;
682 min(scb_ampdu->max_rx_ampdu_bytes,
683 ampdu->max_txlen[mcs][is40][sgi]);
687 CHSPEC_SB_UPPER(wlc_phy_chanspec_get(
689 ? PHY_TXC1_BW_20MHZ_UP : PHY_TXC1_BW_20MHZ;
691 /* rebuild the rspec and rspec_fallback */
692 rspec = RSPEC_MIMORATE;
693 rspec |= plcp[0] & ~MIMO_PLCP_40MHZ;
694 if (plcp[0] & MIMO_PLCP_40MHZ)
695 rspec |= (PHY_TXC1_BW_40MHZ << RSPEC_BW_SHIFT);
697 if (fbr_iscck) /* CCK */
698 rspec_fallback = cck_rspec(cck_phy2mac_rate
699 (txh->FragPLCPFallback[0]));
701 rspec_fallback = RSPEC_MIMORATE;
703 txh->FragPLCPFallback[0] & ~MIMO_PLCP_40MHZ;
704 if (txh->FragPLCPFallback[0] & MIMO_PLCP_40MHZ)
706 (PHY_TXC1_BW_40MHZ <<
710 if (use_rts || use_cts) {
712 brcms_c_rspec_to_rts_rspec(wlc,
713 rspec, false, mimo_ctlchbw);
715 brcms_c_rspec_to_rts_rspec(wlc,
716 rspec_fallback, false, mimo_ctlchbw);
720 /* if (first mpdu for host agg) */
721 /* test whether to add more */
722 if ((mcs_2_rate(mcs, true, false) >= f->dmaxferrate) &&
723 (count == f->mcs2ampdu_table[mcs])) {
724 BCMMSG(wlc->wiphy, "wl%d: PR 37644: stopping"
725 " ampdu at %d for mcs %d\n",
726 wlc->pub->unit, count, mcs);
730 if (count == scb_ampdu->max_pdu)
734 * check to see if the next pkt is
735 * a candidate for aggregation
737 p = pktq_ppeek(&qi->q, prec);
738 /* tx_info must be checked with current p */
739 tx_info = IEEE80211_SKB_CB(p);
742 if ((tx_info->flags & IEEE80211_TX_CTL_AMPDU) &&
743 ((u8) (p->priority) == tid)) {
744 plen = p->len + AMPDU_MAX_MPDU_OVERHEAD;
745 plen = max(scb_ampdu->min_len, plen);
747 if ((plen + ampdu_len) > max_ampdu_bytes) {
753 * check if there are enough
754 * descriptors available
756 if (*wlc->core->txavail[fifo] <= seg_cnt + 1) {
757 wiphy_err(wiphy, "%s: No fifo space "
762 p = brcmu_pktq_pdeq(&qi->q, prec);
769 ini->tx_in_transit += count;
772 /* patch up the last txh */
773 txh = (struct d11txh *) pkt[count - 1]->data;
774 mcl = le16_to_cpu(txh->MacTxControlLow);
775 mcl &= ~TXC_AMPDU_MASK;
776 mcl |= (TXC_AMPDU_LAST << TXC_AMPDU_SHIFT);
777 txh->MacTxControlLow = cpu_to_le16(mcl);
779 /* remove the null delimiter after last mpdu */
780 ndelim = txh->RTSPLCPFallback[AMPDU_FBR_NULL_DELIM];
781 txh->RTSPLCPFallback[AMPDU_FBR_NULL_DELIM] = 0;
782 ampdu_len -= ndelim * AMPDU_DELIMITER_LEN;
784 /* remove the pad len from last mpdu */
785 fbr_iscck = ((le16_to_cpu(txh->XtraFrameTypes) & 0x3) == 0);
786 len = fbr_iscck ? BRCMS_GET_CCK_PLCP_LEN(txh->FragPLCPFallback)
787 : BRCMS_GET_MIMO_PLCP_LEN(txh->FragPLCPFallback);
788 ampdu_len -= roundup(len, 4) - len;
790 /* patch up the first txh & plcp */
791 txh = (struct d11txh *) pkt[0]->data;
792 plcp = (u8 *) (txh + 1);
794 BRCMS_SET_MIMO_PLCP_LEN(plcp, ampdu_len);
795 /* mark plcp to indicate ampdu */
796 BRCMS_SET_MIMO_PLCP_AMPDU(plcp);
798 /* reset the mixed mode header durations */
801 brcms_c_calc_lsig_len(wlc, rspec, ampdu_len);
802 txh->MModeLen = cpu_to_le16(mmodelen);
803 preamble_type = BRCMS_MM_PREAMBLE;
805 if (txh->MModeFbrLen) {
807 brcms_c_calc_lsig_len(wlc, rspec_fallback,
809 txh->MModeFbrLen = cpu_to_le16(mmfbrlen);
810 fbr_preamble_type = BRCMS_MM_PREAMBLE;
813 /* set the preload length */
814 if (mcs_2_rate(mcs, true, false) >= f->dmaxferrate) {
815 dma_len = min(dma_len, f->ampdu_pld_size);
816 txh->PreloadSize = cpu_to_le16(dma_len);
818 txh->PreloadSize = 0;
820 mch = le16_to_cpu(txh->MacTxControlHigh);
822 /* update RTS dur fields */
823 if (use_rts || use_cts) {
825 rts = (struct ieee80211_rts *)&txh->rts_frame;
826 if ((mch & TXC_PREAMBLE_RTS_MAIN_SHORT) ==
827 TXC_PREAMBLE_RTS_MAIN_SHORT)
828 rts_preamble_type = BRCMS_SHORT_PREAMBLE;
830 if ((mch & TXC_PREAMBLE_RTS_FB_SHORT) ==
831 TXC_PREAMBLE_RTS_FB_SHORT)
832 rts_fbr_preamble_type = BRCMS_SHORT_PREAMBLE;
835 brcms_c_compute_rtscts_dur(wlc, use_cts, rts_rspec,
836 rspec, rts_preamble_type,
837 preamble_type, ampdu_len,
839 rts->duration = cpu_to_le16(durid);
840 durid = brcms_c_compute_rtscts_dur(wlc, use_cts,
843 rts_fbr_preamble_type,
846 txh->RTSDurFallback = cpu_to_le16(durid);
847 /* set TxFesTimeNormal */
848 txh->TxFesTimeNormal = rts->duration;
849 /* set fallback rate version of TxFesTimeNormal */
850 txh->TxFesTimeFallback = txh->RTSDurFallback;
853 /* set flag and plcp for fallback rate */
855 mch |= TXC_AMPDU_FBR;
856 txh->MacTxControlHigh = cpu_to_le16(mch);
857 BRCMS_SET_MIMO_PLCP_AMPDU(plcp);
858 BRCMS_SET_MIMO_PLCP_AMPDU(txh->FragPLCPFallback);
861 BCMMSG(wlc->wiphy, "wl%d: count %d ampdu_len %d\n",
862 wlc->pub->unit, count, ampdu_len);
864 /* inform rate_sel if it this is a rate probe pkt */
865 frameid = le16_to_cpu(txh->TxFrameID);
866 if (frameid & TXFID_RATE_PROBE_MASK)
867 wiphy_err(wiphy, "%s: XXX what to do with "
868 "TXFID_RATE_PROBE_MASK!?\n", __func__);
870 for (i = 0; i < count; i++)
871 brcms_c_txfifo(wlc, fifo, pkt[i], i == (count - 1),
872 ampdu->txpkt_weight);
880 brcms_c_ampdu_rate_status(struct brcms_c_info *wlc,
881 struct ieee80211_tx_info *tx_info,
882 struct tx_status *txs, u8 mcs)
884 struct ieee80211_tx_rate *txrate = tx_info->status.rates;
887 /* clear the rest of the rates */
888 for (i = 2; i < IEEE80211_TX_MAX_RATES; i++) {
895 brcms_c_ampdu_dotxstatus_complete(struct ampdu_info *ampdu, struct scb *scb,
896 struct sk_buff *p, struct tx_status *txs,
899 struct scb_ampdu *scb_ampdu;
900 struct brcms_c_info *wlc = ampdu->wlc;
901 struct scb_ampdu_tid_ini *ini;
902 u8 bitmap[8], queue, tid;
905 struct ieee80211_hdr *h;
906 u16 seq, start_seq = 0, bindex, index, mcl;
908 bool ba_recd = false, ack_recd = false;
909 u8 suc_mpdu = 0, tot_mpdu = 0;
911 bool update_rate = true, retry = true, tx_error = false;
914 u8 retry_limit, rr_retry_limit;
915 struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(p);
916 struct wiphy *wiphy = wlc->wiphy;
919 u8 hole[AMPDU_MAX_MPDU];
920 memset(hole, 0, sizeof(hole));
923 scb_ampdu = &scb->scb_ampdu;
924 tid = (u8) (p->priority);
926 ini = &scb_ampdu->ini[tid];
927 retry_limit = ampdu->retry_limit_tid[tid];
928 rr_retry_limit = ampdu->rr_retry_limit_tid[tid];
929 memset(bitmap, 0, sizeof(bitmap));
930 queue = txs->frameid & TXFID_QUEUE_MASK;
931 supr_status = txs->status & TX_STATUS_SUPR_MASK;
933 if (txs->status & TX_STATUS_ACK_RCV) {
934 if (TX_STATUS_SUPR_UF == supr_status)
937 WARN_ON(!(txs->status & TX_STATUS_INTERMEDIATE));
938 start_seq = txs->sequence >> SEQNUM_SHIFT;
939 bitmap[0] = (txs->status & TX_STATUS_BA_BMAP03_MASK) >>
940 TX_STATUS_BA_BMAP03_SHIFT;
942 WARN_ON(s1 & TX_STATUS_INTERMEDIATE);
943 WARN_ON(!(s1 & TX_STATUS_AMPDU));
946 (s1 & TX_STATUS_BA_BMAP47_MASK) <<
947 TX_STATUS_BA_BMAP47_SHIFT;
948 bitmap[1] = (s1 >> 8) & 0xff;
949 bitmap[2] = (s1 >> 16) & 0xff;
950 bitmap[3] = (s1 >> 24) & 0xff;
952 bitmap[4] = s2 & 0xff;
953 bitmap[5] = (s2 >> 8) & 0xff;
954 bitmap[6] = (s2 >> 16) & 0xff;
955 bitmap[7] = (s2 >> 24) & 0xff;
961 if (supr_status == TX_STATUS_SUPR_BADCH) {
962 wiphy_err(wiphy, "%s: Pkt tx suppressed, "
963 "illegal channel possibly %d\n",
964 __func__, CHSPEC_CHANNEL(
965 wlc->default_bss->chanspec));
967 if (supr_status != TX_STATUS_SUPR_FRAG)
968 wiphy_err(wiphy, "%s:"
969 "supr_status 0x%x\n",
970 __func__, supr_status);
972 /* no need to retry for badch; will fail again */
973 if (supr_status == TX_STATUS_SUPR_BADCH ||
974 supr_status == TX_STATUS_SUPR_EXPTIME) {
976 } else if (supr_status == TX_STATUS_SUPR_EXPTIME) {
978 * try tuning pre-loading or ampdu size
980 } else if (supr_status == TX_STATUS_SUPR_FRAG) {
982 * if there were underflows, but pre-loading
983 * is not active, notify rate adaptation.
985 if (brcms_c_ffpld_check_txfunfl(wlc,
989 } else if (txs->phyerr) {
991 wiphy_err(wiphy, "wl%d: ampdu tx phy "
992 "error (0x%x)\n", wlc->pub->unit,
995 if (brcm_msg_level & LOG_ERROR_VAL) {
996 brcmu_prpkt("txpkt (AMPDU)", p);
997 brcms_c_print_txdesc((struct d11txh *) p->data);
999 brcms_c_print_txstatus(txs);
1003 /* loop through all pkts and retry if not acked */
1005 tx_info = IEEE80211_SKB_CB(p);
1006 txh = (struct d11txh *) p->data;
1007 mcl = le16_to_cpu(txh->MacTxControlLow);
1008 plcp = (u8 *) (txh + 1);
1009 h = (struct ieee80211_hdr *)(plcp + D11_PHY_HDR_LEN);
1010 seq = le16_to_cpu(h->seq_ctrl) >> SEQNUM_SHIFT;
1012 if (tot_mpdu == 0) {
1013 mcs = plcp[0] & MIMO_PLCP_MCS_MASK;
1014 mimoantsel = le16_to_cpu(txh->ABI_MimoAntSel);
1017 index = TX_SEQ_TO_INDEX(seq);
1020 bindex = MODSUB_POW2(seq, start_seq, SEQNUM_MAX);
1021 BCMMSG(wlc->wiphy, "tid %d seq %d,"
1022 " start_seq %d, bindex %d set %d, index %d\n",
1023 tid, seq, start_seq, bindex,
1024 isset(bitmap, bindex), index);
1025 /* if acked then clear bit and free packet */
1026 if ((bindex < AMPDU_TX_BA_MAX_WSIZE)
1027 && isset(bitmap, bindex)) {
1028 ini->tx_in_transit--;
1029 ini->txretry[index] = 0;
1033 * number of acked aggregated frames
1035 /* ampdu_len: number of aggregated frames */
1036 brcms_c_ampdu_rate_status(wlc, tx_info, txs,
1038 tx_info->flags |= IEEE80211_TX_STAT_ACK;
1039 tx_info->flags |= IEEE80211_TX_STAT_AMPDU;
1040 tx_info->status.ampdu_ack_len =
1041 tx_info->status.ampdu_len = 1;
1043 skb_pull(p, D11_PHY_HDR_LEN);
1044 skb_pull(p, D11_TXH_LEN);
1046 ieee80211_tx_status_irqsafe(wlc->pub->ieee_hw,
1052 /* either retransmit or send bar if ack not recd */
1054 struct ieee80211_tx_rate *txrate =
1055 tx_info->status.rates;
1056 if (retry && (txrate[0].count < (int)retry_limit)) {
1057 ini->txretry[index]++;
1058 ini->tx_in_transit--;
1060 * Use high prededence for retransmit to
1063 /* brcms_c_txq_enq(wlc, scb, p,
1064 * BRCMS_PRIO_TO_PREC(tid)); */
1065 brcms_c_txq_enq(wlc, scb, p,
1066 BRCMS_PRIO_TO_HI_PREC(tid));
1069 ini->tx_in_transit--;
1070 ieee80211_tx_info_clear_status(tx_info);
1071 tx_info->status.ampdu_ack_len = 0;
1072 tx_info->status.ampdu_len = 1;
1074 IEEE80211_TX_STAT_AMPDU_NO_BACK;
1075 skb_pull(p, D11_PHY_HDR_LEN);
1076 skb_pull(p, D11_TXH_LEN);
1077 wiphy_err(wiphy, "%s: BA Timeout, seq %d, in_"
1078 "transit %d\n", "AMPDU status", seq,
1079 ini->tx_in_transit);
1080 ieee80211_tx_status_irqsafe(wlc->pub->ieee_hw,
1086 /* break out if last packet of ampdu */
1087 if (((mcl & TXC_AMPDU_MASK) >> TXC_AMPDU_SHIFT) ==
1091 p = dma_getnexttxp(wlc->hw->di[queue], DMA_RANGE_TRANSMITTED);
1093 brcms_c_send_q(wlc);
1095 /* update rate state */
1096 antselid = brcms_c_antsel_antsel2id(wlc->asi, mimoantsel);
1098 brcms_c_txfifo_complete(wlc, queue, ampdu->txpkt_weight);
1102 brcms_c_ampdu_dotxstatus(struct ampdu_info *ampdu, struct scb *scb,
1103 struct sk_buff *p, struct tx_status *txs)
1105 struct scb_ampdu *scb_ampdu;
1106 struct brcms_c_info *wlc = ampdu->wlc;
1107 struct scb_ampdu_tid_ini *ini;
1109 struct ieee80211_tx_info *tx_info;
1111 tx_info = IEEE80211_SKB_CB(p);
1113 /* BMAC_NOTE: For the split driver, second level txstatus comes later
1114 * So if the ACK was received then wait for the second level else just
1115 * call the first one
1117 if (txs->status & TX_STATUS_ACK_RCV) {
1118 u8 status_delay = 0;
1120 /* wait till the next 8 bytes of txstatus is available */
1121 while (((s1 = R_REG(&wlc->regs->frmtxstatus)) & TXS_V) == 0) {
1124 if (status_delay > 10)
1125 return; /* error condition */
1128 s2 = R_REG(&wlc->regs->frmtxstatus2);
1132 scb_ampdu = &scb->scb_ampdu;
1133 ini = &scb_ampdu->ini[p->priority];
1134 brcms_c_ampdu_dotxstatus_complete(ampdu, scb, p, txs, s1, s2);
1136 /* loop through all pkts and free */
1137 u8 queue = txs->frameid & TXFID_QUEUE_MASK;
1141 tx_info = IEEE80211_SKB_CB(p);
1142 txh = (struct d11txh *) p->data;
1143 mcl = le16_to_cpu(txh->MacTxControlLow);
1144 brcmu_pkt_buf_free_skb(p);
1145 /* break out if last packet of ampdu */
1146 if (((mcl & TXC_AMPDU_MASK) >> TXC_AMPDU_SHIFT) ==
1149 p = dma_getnexttxp(wlc->hw->di[queue],
1150 DMA_RANGE_TRANSMITTED);
1152 brcms_c_txfifo_complete(wlc, queue, ampdu->txpkt_weight);
1156 void brcms_c_ampdu_macaddr_upd(struct brcms_c_info *wlc)
1158 char template[T_RAM_ACCESS_SZ * 2];
1160 /* driver needs to write the ta in the template; ta is at offset 16 */
1161 memset(template, 0, sizeof(template));
1162 memcpy(template, wlc->pub->cur_etheraddr, ETH_ALEN);
1163 brcms_b_write_template_ram(wlc->hw, (T_BA_TPL_BASE + 16),
1164 (T_RAM_ACCESS_SZ * 2),
1168 bool brcms_c_aggregatable(struct brcms_c_info *wlc, u8 tid)
1170 return wlc->ampdu->ini_enable[tid];
1173 void brcms_c_ampdu_shm_upd(struct ampdu_info *ampdu)
1175 struct brcms_c_info *wlc = ampdu->wlc;
1178 * Extend ucode internal watchdog timer to
1179 * match larger received frames
1181 if ((ampdu->rx_factor & IEEE80211_HT_AMPDU_PARM_FACTOR) ==
1182 IEEE80211_HT_MAX_AMPDU_64K) {
1183 brcms_b_write_shm(wlc->hw, M_MIMO_MAXSYM, MIMO_MAXSYM_MAX);
1184 brcms_b_write_shm(wlc->hw, M_WATCHDOG_8TU, WATCHDOG_8TU_MAX);
1186 brcms_b_write_shm(wlc->hw, M_MIMO_MAXSYM, MIMO_MAXSYM_DEF);
1187 brcms_b_write_shm(wlc->hw, M_WATCHDOG_8TU, WATCHDOG_8TU_DEF);
1192 * callback function that helps flushing ampdu packets from a priority queue
1194 static bool cb_del_ampdu_pkt(struct sk_buff *mpdu, void *arg_a)
1196 struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(mpdu);
1197 struct cb_del_ampdu_pars *ampdu_pars =
1198 (struct cb_del_ampdu_pars *)arg_a;
1201 rc = tx_info->flags & IEEE80211_TX_CTL_AMPDU ? true : false;
1202 rc = rc && (tx_info->control.sta == NULL || ampdu_pars->sta == NULL ||
1203 tx_info->control.sta == ampdu_pars->sta);
1204 rc = rc && ((u8)(mpdu->priority) == ampdu_pars->tid);
1209 * callback function that helps invalidating ampdu packets in a DMA queue
1211 static void dma_cb_fn_ampdu(void *txi, void *arg_a)
1213 struct ieee80211_sta *sta = arg_a;
1214 struct ieee80211_tx_info *tx_info = (struct ieee80211_tx_info *)txi;
1216 if ((tx_info->flags & IEEE80211_TX_CTL_AMPDU) &&
1217 (tx_info->control.sta == sta || sta == NULL))
1218 tx_info->control.sta = NULL;
1222 * When a remote party is no longer available for ampdu communication, any
1223 * pending tx ampdu packets in the driver have to be flushed.
1225 void brcms_c_ampdu_flush(struct brcms_c_info *wlc,
1226 struct ieee80211_sta *sta, u16 tid)
1228 struct brcms_txq_info *qi = wlc->pkt_queue;
1229 struct pktq *pq = &qi->q;
1231 struct cb_del_ampdu_pars ampdu_pars;
1233 ampdu_pars.sta = sta;
1234 ampdu_pars.tid = tid;
1235 for (prec = 0; prec < pq->num_prec; prec++)
1236 brcmu_pktq_pflush(pq, prec, true, cb_del_ampdu_pkt,
1237 (void *)&du_pars);
1238 brcms_c_inval_dma_pkts(wlc->hw, sta, dma_cb_fn_ampdu);