ath9k: We don't support non-HT devices, so remove superfluous code.
[linux-2.6.git] / drivers / net / wireless / ath9k / xmit.c
1 /*
2  * Copyright (c) 2008 Atheros Communications Inc.
3  *
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.
7  *
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
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16
17 #include "core.h"
18
19 #define BITS_PER_BYTE           8
20 #define OFDM_PLCP_BITS          22
21 #define HT_RC_2_MCS(_rc)        ((_rc) & 0x0f)
22 #define HT_RC_2_STREAMS(_rc)    ((((_rc) & 0x78) >> 3) + 1)
23 #define L_STF                   8
24 #define L_LTF                   8
25 #define L_SIG                   4
26 #define HT_SIG                  8
27 #define HT_STF                  4
28 #define HT_LTF(_ns)             (4 * (_ns))
29 #define SYMBOL_TIME(_ns)        ((_ns) << 2) /* ns * 4 us */
30 #define SYMBOL_TIME_HALFGI(_ns) (((_ns) * 18 + 4) / 5)  /* ns * 3.6 us */
31 #define NUM_SYMBOLS_PER_USEC(_usec) (_usec >> 2)
32 #define NUM_SYMBOLS_PER_USEC_HALFGI(_usec) (((_usec*5)-4)/18)
33
34 #define OFDM_SIFS_TIME              16
35
36 static u32 bits_per_symbol[][2] = {
37         /* 20MHz 40MHz */
38         {    26,   54 },     /*  0: BPSK */
39         {    52,  108 },     /*  1: QPSK 1/2 */
40         {    78,  162 },     /*  2: QPSK 3/4 */
41         {   104,  216 },     /*  3: 16-QAM 1/2 */
42         {   156,  324 },     /*  4: 16-QAM 3/4 */
43         {   208,  432 },     /*  5: 64-QAM 2/3 */
44         {   234,  486 },     /*  6: 64-QAM 3/4 */
45         {   260,  540 },     /*  7: 64-QAM 5/6 */
46         {    52,  108 },     /*  8: BPSK */
47         {   104,  216 },     /*  9: QPSK 1/2 */
48         {   156,  324 },     /* 10: QPSK 3/4 */
49         {   208,  432 },     /* 11: 16-QAM 1/2 */
50         {   312,  648 },     /* 12: 16-QAM 3/4 */
51         {   416,  864 },     /* 13: 64-QAM 2/3 */
52         {   468,  972 },     /* 14: 64-QAM 3/4 */
53         {   520, 1080 },     /* 15: 64-QAM 5/6 */
54 };
55
56 #define IS_HT_RATE(_rate)     ((_rate) & 0x80)
57
58 /*
59  * Insert a chain of ath_buf (descriptors) on a txq and
60  * assume the descriptors are already chained together by caller.
61  * NB: must be called with txq lock held
62  */
63
64 static void ath_tx_txqaddbuf(struct ath_softc *sc, struct ath_txq *txq,
65                              struct list_head *head)
66 {
67         struct ath_hal *ah = sc->sc_ah;
68         struct ath_buf *bf;
69
70         /*
71          * Insert the frame on the outbound list and
72          * pass it on to the hardware.
73          */
74
75         if (list_empty(head))
76                 return;
77
78         bf = list_first_entry(head, struct ath_buf, list);
79
80         list_splice_tail_init(head, &txq->axq_q);
81         txq->axq_depth++;
82         txq->axq_totalqueued++;
83         txq->axq_linkbuf = list_entry(txq->axq_q.prev, struct ath_buf, list);
84
85         DPRINTF(sc, ATH_DBG_QUEUE,
86                 "%s: txq depth = %d\n", __func__, txq->axq_depth);
87
88         if (txq->axq_link == NULL) {
89                 ath9k_hw_puttxbuf(ah, txq->axq_qnum, bf->bf_daddr);
90                 DPRINTF(sc, ATH_DBG_XMIT,
91                         "%s: TXDP[%u] = %llx (%p)\n",
92                         __func__, txq->axq_qnum,
93                         ito64(bf->bf_daddr), bf->bf_desc);
94         } else {
95                 *txq->axq_link = bf->bf_daddr;
96                 DPRINTF(sc, ATH_DBG_XMIT, "%s: link[%u] (%p)=%llx (%p)\n",
97                         __func__,
98                         txq->axq_qnum, txq->axq_link,
99                         ito64(bf->bf_daddr), bf->bf_desc);
100         }
101         txq->axq_link = &(bf->bf_lastbf->bf_desc->ds_link);
102         ath9k_hw_txstart(ah, txq->axq_qnum);
103 }
104
105 /* Get transmit rate index using rate in Kbps */
106
107 static int ath_tx_findindex(const struct ath9k_rate_table *rt, int rate)
108 {
109         int i;
110         int ndx = 0;
111
112         for (i = 0; i < rt->rateCount; i++) {
113                 if (rt->info[i].rateKbps == rate) {
114                         ndx = i;
115                         break;
116                 }
117         }
118
119         return ndx;
120 }
121
122 /* Check if it's okay to send out aggregates */
123
124 static int ath_aggr_query(struct ath_softc *sc, struct ath_node *an, u8 tidno)
125 {
126         struct ath_atx_tid *tid;
127         tid = ATH_AN_2_TID(an, tidno);
128
129         if (tid->state & AGGR_ADDBA_COMPLETE ||
130             tid->state & AGGR_ADDBA_PROGRESS)
131                 return 1;
132         else
133                 return 0;
134 }
135
136 /* Calculate Atheros packet type from IEEE80211 packet header */
137
138 static enum ath9k_pkt_type get_hw_packet_type(struct sk_buff *skb)
139 {
140         struct ieee80211_hdr *hdr;
141         enum ath9k_pkt_type htype;
142         __le16 fc;
143
144         hdr = (struct ieee80211_hdr *)skb->data;
145         fc = hdr->frame_control;
146
147         if (ieee80211_is_beacon(fc))
148                 htype = ATH9K_PKT_TYPE_BEACON;
149         else if (ieee80211_is_probe_resp(fc))
150                 htype = ATH9K_PKT_TYPE_PROBE_RESP;
151         else if (ieee80211_is_atim(fc))
152                 htype = ATH9K_PKT_TYPE_ATIM;
153         else if (ieee80211_is_pspoll(fc))
154                 htype = ATH9K_PKT_TYPE_PSPOLL;
155         else
156                 htype = ATH9K_PKT_TYPE_NORMAL;
157
158         return htype;
159 }
160
161 static bool check_min_rate(struct sk_buff *skb)
162 {
163         struct ieee80211_hdr *hdr;
164         bool use_minrate = false;
165         __le16 fc;
166
167         hdr = (struct ieee80211_hdr *)skb->data;
168         fc = hdr->frame_control;
169
170         if (ieee80211_is_mgmt(fc) || ieee80211_is_ctl(fc)) {
171                 use_minrate = true;
172         } else if (ieee80211_is_data(fc)) {
173                 if (ieee80211_is_nullfunc(fc) ||
174                     /* Port Access Entity (IEEE 802.1X) */
175                     (skb->protocol == cpu_to_be16(ETH_P_PAE))) {
176                         use_minrate = true;
177                 }
178         }
179
180         return use_minrate;
181 }
182
183 static int get_hw_crypto_keytype(struct sk_buff *skb)
184 {
185         struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
186
187         if (tx_info->control.hw_key) {
188                 if (tx_info->control.hw_key->alg == ALG_WEP)
189                         return ATH9K_KEY_TYPE_WEP;
190                 else if (tx_info->control.hw_key->alg == ALG_TKIP)
191                         return ATH9K_KEY_TYPE_TKIP;
192                 else if (tx_info->control.hw_key->alg == ALG_CCMP)
193                         return ATH9K_KEY_TYPE_AES;
194         }
195
196         return ATH9K_KEY_TYPE_CLEAR;
197 }
198
199 static void setup_rate_retries(struct ath_softc *sc, struct sk_buff *skb)
200 {
201         struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
202         struct ath_tx_info_priv *tx_info_priv;
203         struct ath_rc_series *rcs;
204         struct ieee80211_hdr *hdr;
205         const struct ath9k_rate_table *rt;
206         bool use_minrate;
207         __le16 fc;
208         u8 rix;
209
210         rt = sc->sc_currates;
211         BUG_ON(!rt);
212
213         hdr = (struct ieee80211_hdr *)skb->data;
214         fc = hdr->frame_control;
215         tx_info_priv = (struct ath_tx_info_priv *)tx_info->control.vif; /* HACK */
216         rcs = tx_info_priv->rcs;
217
218         /* Check if min rates have to be used */
219         use_minrate = check_min_rate(skb);
220
221         if (ieee80211_is_data(fc) && !use_minrate) {
222                 if (is_multicast_ether_addr(hdr->addr1)) {
223                         rcs[0].rix =
224                                 ath_tx_findindex(rt, tx_info_priv->min_rate);
225                         /* mcast packets are not re-tried */
226                         rcs[0].tries = 1;
227                 }
228         } else {
229                 /* for management and control frames,
230                    or for NULL and EAPOL frames */
231                 if (use_minrate)
232                         rcs[0].rix = ath_rate_findrateix(sc, tx_info_priv->min_rate);
233                 else
234                         rcs[0].rix = 0;
235                 rcs[0].tries = ATH_MGT_TXMAXTRY;
236         }
237
238         rix = rcs[0].rix;
239
240         if (ieee80211_has_morefrags(fc) ||
241             (le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_FRAG)) {
242                 rcs[1].tries = rcs[2].tries = rcs[3].tries = 0;
243                 rcs[1].rix = rcs[2].rix = rcs[3].rix = 0;
244                 /* reset tries but keep rate index */
245                 rcs[0].tries = ATH_TXMAXTRY;
246         }
247 }
248
249 /* Called only when tx aggregation is enabled and HT is supported */
250
251 static void assign_aggr_tid_seqno(struct sk_buff *skb,
252                                   struct ath_buf *bf)
253 {
254         struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
255         struct ieee80211_hdr *hdr;
256         struct ath_node *an;
257         struct ath_atx_tid *tid;
258         __le16 fc;
259         u8 *qc;
260
261         if (!tx_info->control.sta)
262                 return;
263
264         an = (struct ath_node *)tx_info->control.sta->drv_priv;
265         hdr = (struct ieee80211_hdr *)skb->data;
266         fc = hdr->frame_control;
267
268         /* Get tidno */
269
270         if (ieee80211_is_data_qos(fc)) {
271                 qc = ieee80211_get_qos_ctl(hdr);
272                 bf->bf_tidno = qc[0] & 0xf;
273         }
274
275         /* Get seqno */
276
277         if (ieee80211_is_data(fc) && !check_min_rate(skb)) {
278                 /* For HT capable stations, we save tidno for later use.
279                  * We also override seqno set by upper layer with the one
280                  * in tx aggregation state.
281                  *
282                  * If fragmentation is on, the sequence number is
283                  * not overridden, since it has been
284                  * incremented by the fragmentation routine.
285                  *
286                  * FIXME: check if the fragmentation threshold exceeds
287                  * IEEE80211 max.
288                  */
289                 tid = ATH_AN_2_TID(an, bf->bf_tidno);
290                 hdr->seq_ctrl = cpu_to_le16(tid->seq_next <<
291                                             IEEE80211_SEQ_SEQ_SHIFT);
292                 bf->bf_seqno = tid->seq_next;
293                 INCR(tid->seq_next, IEEE80211_SEQ_MAX);
294         }
295 }
296
297 static int setup_tx_flags(struct ath_softc *sc, struct sk_buff *skb,
298                           struct ath_txq *txq)
299 {
300         struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
301         int flags = 0;
302
303         flags |= ATH9K_TXDESC_CLRDMASK; /* needed for crypto errors */
304         flags |= ATH9K_TXDESC_INTREQ;
305
306         if (tx_info->flags & IEEE80211_TX_CTL_NO_ACK)
307                 flags |= ATH9K_TXDESC_NOACK;
308         if (tx_info->control.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS)
309                 flags |= ATH9K_TXDESC_RTSENA;
310
311         return flags;
312 }
313
314 static struct ath_buf *ath_tx_get_buffer(struct ath_softc *sc)
315 {
316         struct ath_buf *bf = NULL;
317
318         spin_lock_bh(&sc->sc_txbuflock);
319
320         if (unlikely(list_empty(&sc->sc_txbuf))) {
321                 spin_unlock_bh(&sc->sc_txbuflock);
322                 return NULL;
323         }
324
325         bf = list_first_entry(&sc->sc_txbuf, struct ath_buf, list);
326         list_del(&bf->list);
327
328         spin_unlock_bh(&sc->sc_txbuflock);
329
330         return bf;
331 }
332
333 /* To complete a chain of buffers associated a frame */
334
335 static void ath_tx_complete_buf(struct ath_softc *sc,
336                                 struct ath_buf *bf,
337                                 struct list_head *bf_q,
338                                 int txok, int sendbar)
339 {
340         struct sk_buff *skb = bf->bf_mpdu;
341         struct ath_xmit_status tx_status;
342
343         /*
344          * Set retry information.
345          * NB: Don't use the information in the descriptor, because the frame
346          * could be software retried.
347          */
348         tx_status.retries = bf->bf_retries;
349         tx_status.flags = 0;
350
351         if (sendbar)
352                 tx_status.flags = ATH_TX_BAR;
353
354         if (!txok) {
355                 tx_status.flags |= ATH_TX_ERROR;
356
357                 if (bf_isxretried(bf))
358                         tx_status.flags |= ATH_TX_XRETRY;
359         }
360
361         /* Unmap this frame */
362         pci_unmap_single(sc->pdev,
363                          bf->bf_dmacontext,
364                          skb->len,
365                          PCI_DMA_TODEVICE);
366         /* complete this frame */
367         ath_tx_complete(sc, skb, &tx_status);
368
369         /*
370          * Return the list of ath_buf of this mpdu to free queue
371          */
372         spin_lock_bh(&sc->sc_txbuflock);
373         list_splice_tail_init(bf_q, &sc->sc_txbuf);
374         spin_unlock_bh(&sc->sc_txbuflock);
375 }
376
377 /*
378  * queue up a dest/ac pair for tx scheduling
379  * NB: must be called with txq lock held
380  */
381
382 static void ath_tx_queue_tid(struct ath_txq *txq, struct ath_atx_tid *tid)
383 {
384         struct ath_atx_ac *ac = tid->ac;
385
386         /*
387          * if tid is paused, hold off
388          */
389         if (tid->paused)
390                 return;
391
392         /*
393          * add tid to ac atmost once
394          */
395         if (tid->sched)
396                 return;
397
398         tid->sched = true;
399         list_add_tail(&tid->list, &ac->tid_q);
400
401         /*
402          * add node ac to txq atmost once
403          */
404         if (ac->sched)
405                 return;
406
407         ac->sched = true;
408         list_add_tail(&ac->list, &txq->axq_acq);
409 }
410
411 /* pause a tid */
412
413 static void ath_tx_pause_tid(struct ath_softc *sc, struct ath_atx_tid *tid)
414 {
415         struct ath_txq *txq = &sc->sc_txq[tid->ac->qnum];
416
417         spin_lock_bh(&txq->axq_lock);
418
419         tid->paused++;
420
421         spin_unlock_bh(&txq->axq_lock);
422 }
423
424 /* resume a tid and schedule aggregate */
425
426 void ath_tx_resume_tid(struct ath_softc *sc, struct ath_atx_tid *tid)
427 {
428         struct ath_txq *txq = &sc->sc_txq[tid->ac->qnum];
429
430         ASSERT(tid->paused > 0);
431         spin_lock_bh(&txq->axq_lock);
432
433         tid->paused--;
434
435         if (tid->paused > 0)
436                 goto unlock;
437
438         if (list_empty(&tid->buf_q))
439                 goto unlock;
440
441         /*
442          * Add this TID to scheduler and try to send out aggregates
443          */
444         ath_tx_queue_tid(txq, tid);
445         ath_txq_schedule(sc, txq);
446 unlock:
447         spin_unlock_bh(&txq->axq_lock);
448 }
449
450 /* Compute the number of bad frames */
451
452 static int ath_tx_num_badfrms(struct ath_softc *sc, struct ath_buf *bf,
453                               int txok)
454 {
455         struct ath_buf *bf_last = bf->bf_lastbf;
456         struct ath_desc *ds = bf_last->bf_desc;
457         u16 seq_st = 0;
458         u32 ba[WME_BA_BMP_SIZE >> 5];
459         int ba_index;
460         int nbad = 0;
461         int isaggr = 0;
462
463         if (ds->ds_txstat.ts_flags == ATH9K_TX_SW_ABORTED)
464                 return 0;
465
466         isaggr = bf_isaggr(bf);
467         if (isaggr) {
468                 seq_st = ATH_DS_BA_SEQ(ds);
469                 memcpy(ba, ATH_DS_BA_BITMAP(ds), WME_BA_BMP_SIZE >> 3);
470         }
471
472         while (bf) {
473                 ba_index = ATH_BA_INDEX(seq_st, bf->bf_seqno);
474                 if (!txok || (isaggr && !ATH_BA_ISSET(ba, ba_index)))
475                         nbad++;
476
477                 bf = bf->bf_next;
478         }
479
480         return nbad;
481 }
482
483 static void ath_tx_set_retry(struct ath_softc *sc, struct ath_buf *bf)
484 {
485         struct sk_buff *skb;
486         struct ieee80211_hdr *hdr;
487
488         bf->bf_state.bf_type |= BUF_RETRY;
489         bf->bf_retries++;
490
491         skb = bf->bf_mpdu;
492         hdr = (struct ieee80211_hdr *)skb->data;
493         hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_RETRY);
494 }
495
496 /* Update block ack window */
497
498 static void ath_tx_update_baw(struct ath_softc *sc, struct ath_atx_tid *tid,
499                               int seqno)
500 {
501         int index, cindex;
502
503         index  = ATH_BA_INDEX(tid->seq_start, seqno);
504         cindex = (tid->baw_head + index) & (ATH_TID_MAX_BUFS - 1);
505
506         tid->tx_buf[cindex] = NULL;
507
508         while (tid->baw_head != tid->baw_tail && !tid->tx_buf[tid->baw_head]) {
509                 INCR(tid->seq_start, IEEE80211_SEQ_MAX);
510                 INCR(tid->baw_head, ATH_TID_MAX_BUFS);
511         }
512 }
513
514 /*
515  * ath_pkt_dur - compute packet duration (NB: not NAV)
516  *
517  * rix - rate index
518  * pktlen - total bytes (delims + data + fcs + pads + pad delims)
519  * width  - 0 for 20 MHz, 1 for 40 MHz
520  * half_gi - to use 4us v/s 3.6 us for symbol time
521  */
522
523 static u32 ath_pkt_duration(struct ath_softc *sc, u8 rix, struct ath_buf *bf,
524                             int width, int half_gi, bool shortPreamble)
525 {
526         const struct ath9k_rate_table *rt = sc->sc_currates;
527         u32 nbits, nsymbits, duration, nsymbols;
528         u8 rc;
529         int streams, pktlen;
530
531         pktlen = bf_isaggr(bf) ? bf->bf_al : bf->bf_frmlen;
532         rc = rt->info[rix].rateCode;
533
534         /*
535          * for legacy rates, use old function to compute packet duration
536          */
537         if (!IS_HT_RATE(rc))
538                 return ath9k_hw_computetxtime(sc->sc_ah, rt, pktlen, rix,
539                                               shortPreamble);
540         /*
541          * find number of symbols: PLCP + data
542          */
543         nbits = (pktlen << 3) + OFDM_PLCP_BITS;
544         nsymbits = bits_per_symbol[HT_RC_2_MCS(rc)][width];
545         nsymbols = (nbits + nsymbits - 1) / nsymbits;
546
547         if (!half_gi)
548                 duration = SYMBOL_TIME(nsymbols);
549         else
550                 duration = SYMBOL_TIME_HALFGI(nsymbols);
551
552         /*
553          * addup duration for legacy/ht training and signal fields
554          */
555         streams = HT_RC_2_STREAMS(rc);
556         duration += L_STF + L_LTF + L_SIG + HT_SIG + HT_STF + HT_LTF(streams);
557
558         return duration;
559 }
560
561 /* Rate module function to set rate related fields in tx descriptor */
562
563 static void ath_buf_set_rate(struct ath_softc *sc, struct ath_buf *bf)
564 {
565         struct ath_hal *ah = sc->sc_ah;
566         const struct ath9k_rate_table *rt;
567         struct ath_desc *ds = bf->bf_desc;
568         struct ath_desc *lastds = bf->bf_lastbf->bf_desc;
569         struct ath9k_11n_rate_series series[4];
570         int i, flags, rtsctsena = 0;
571         u32 ctsduration = 0;
572         u8 rix = 0, cix, ctsrate = 0;
573         struct ath_node *an = NULL;
574         struct sk_buff *skb;
575         struct ieee80211_tx_info *tx_info;
576
577         skb = (struct sk_buff *)bf->bf_mpdu;
578         tx_info = IEEE80211_SKB_CB(skb);
579
580         if (tx_info->control.sta)
581                 an = (struct ath_node *)tx_info->control.sta->drv_priv;
582
583         /*
584          * get the cix for the lowest valid rix.
585          */
586         rt = sc->sc_currates;
587         for (i = 4; i--;) {
588                 if (bf->bf_rcs[i].tries) {
589                         rix = bf->bf_rcs[i].rix;
590                         break;
591                 }
592         }
593         flags = (bf->bf_flags & (ATH9K_TXDESC_RTSENA | ATH9K_TXDESC_CTSENA));
594         cix = rt->info[rix].controlRate;
595
596         /*
597          * If 802.11g protection is enabled, determine whether
598          * to use RTS/CTS or just CTS.  Note that this is only
599          * done for OFDM/HT unicast frames.
600          */
601         if (sc->sc_protmode != PROT_M_NONE &&
602             (rt->info[rix].phy == PHY_OFDM ||
603              rt->info[rix].phy == PHY_HT) &&
604             (bf->bf_flags & ATH9K_TXDESC_NOACK) == 0) {
605                 if (sc->sc_protmode == PROT_M_RTSCTS)
606                         flags = ATH9K_TXDESC_RTSENA;
607                 else if (sc->sc_protmode == PROT_M_CTSONLY)
608                         flags = ATH9K_TXDESC_CTSENA;
609
610                 cix = rt->info[sc->sc_protrix].controlRate;
611                 rtsctsena = 1;
612         }
613
614         /* For 11n, the default behavior is to enable RTS for
615          * hw retried frames. We enable the global flag here and
616          * let rate series flags determine which rates will actually
617          * use RTS.
618          */
619         if ((ah->ah_caps.hw_caps & ATH9K_HW_CAP_HT) && bf_isdata(bf)) {
620                 /*
621                  * 802.11g protection not needed, use our default behavior
622                  */
623                 if (!rtsctsena)
624                         flags = ATH9K_TXDESC_RTSENA;
625         }
626
627         /*
628          * Set protection if aggregate protection on
629          */
630         if (sc->sc_config.ath_aggr_prot &&
631             (!bf_isaggr(bf) || (bf_isaggr(bf) && bf->bf_al < 8192))) {
632                 flags = ATH9K_TXDESC_RTSENA;
633                 cix = rt->info[sc->sc_protrix].controlRate;
634                 rtsctsena = 1;
635         }
636
637         /*
638          *  For AR5416 - RTS cannot be followed by a frame larger than 8K.
639          */
640         if (bf_isaggr(bf) && (bf->bf_al > ah->ah_caps.rts_aggr_limit)) {
641                 /*
642                  * Ensure that in the case of SM Dynamic power save
643                  * while we are bursting the second aggregate the
644                  * RTS is cleared.
645                  */
646                 flags &= ~(ATH9K_TXDESC_RTSENA);
647         }
648
649         /*
650          * CTS transmit rate is derived from the transmit rate
651          * by looking in the h/w rate table.  We must also factor
652          * in whether or not a short preamble is to be used.
653          * NB: cix is set above where RTS/CTS is enabled
654          */
655         BUG_ON(cix == 0xff);
656         ctsrate = rt->info[cix].rateCode |
657                 (bf_isshpreamble(bf) ? rt->info[cix].shortPreamble : 0);
658
659         /*
660          * Setup HAL rate series
661          */
662         memset(series, 0, sizeof(struct ath9k_11n_rate_series) * 4);
663
664         for (i = 0; i < 4; i++) {
665                 if (!bf->bf_rcs[i].tries)
666                         continue;
667
668                 rix = bf->bf_rcs[i].rix;
669
670                 series[i].Rate = rt->info[rix].rateCode |
671                         (bf_isshpreamble(bf) ? rt->info[rix].shortPreamble : 0);
672
673                 series[i].Tries = bf->bf_rcs[i].tries;
674
675                 series[i].RateFlags = (
676                         (bf->bf_rcs[i].flags & ATH_RC_RTSCTS_FLAG) ?
677                                 ATH9K_RATESERIES_RTS_CTS : 0) |
678                         ((bf->bf_rcs[i].flags & ATH_RC_CW40_FLAG) ?
679                                 ATH9K_RATESERIES_2040 : 0) |
680                         ((bf->bf_rcs[i].flags & ATH_RC_SGI_FLAG) ?
681                                 ATH9K_RATESERIES_HALFGI : 0);
682
683                 series[i].PktDuration = ath_pkt_duration(sc, rix, bf,
684                          (bf->bf_rcs[i].flags & ATH_RC_CW40_FLAG) != 0,
685                          (bf->bf_rcs[i].flags & ATH_RC_SGI_FLAG),
686                          bf_isshpreamble(bf));
687
688                 if (bf_isht(bf) && an)
689                         series[i].ChSel = ath_chainmask_sel_logic(sc, an);
690                 else
691                         series[i].ChSel = sc->sc_tx_chainmask;
692
693                 if (rtsctsena)
694                         series[i].RateFlags |= ATH9K_RATESERIES_RTS_CTS;
695         }
696
697         /*
698          * set dur_update_en for l-sig computation except for PS-Poll frames
699          */
700         ath9k_hw_set11n_ratescenario(ah, ds, lastds,
701                                      !bf_ispspoll(bf),
702                                      ctsrate,
703                                      ctsduration,
704                                      series, 4, flags);
705
706         if (sc->sc_config.ath_aggr_prot && flags)
707                 ath9k_hw_set11n_burstduration(ah, ds, 8192);
708 }
709
710 /*
711  * Function to send a normal HT (non-AMPDU) frame
712  * NB: must be called with txq lock held
713  */
714
715 static int ath_tx_send_normal(struct ath_softc *sc,
716                               struct ath_txq *txq,
717                               struct ath_atx_tid *tid,
718                               struct list_head *bf_head)
719 {
720         struct ath_buf *bf;
721         struct sk_buff *skb;
722         struct ieee80211_tx_info *tx_info;
723         struct ath_tx_info_priv *tx_info_priv;
724
725         BUG_ON(list_empty(bf_head));
726
727         bf = list_first_entry(bf_head, struct ath_buf, list);
728         bf->bf_state.bf_type &= ~BUF_AMPDU; /* regular HT frame */
729
730         skb = (struct sk_buff *)bf->bf_mpdu;
731         tx_info = IEEE80211_SKB_CB(skb);
732
733         /* XXX: HACK! */
734         tx_info_priv = (struct ath_tx_info_priv *)tx_info->control.vif;
735         memcpy(bf->bf_rcs, tx_info_priv->rcs, 4 * sizeof(tx_info_priv->rcs[0]));
736
737         /* update starting sequence number for subsequent ADDBA request */
738         INCR(tid->seq_start, IEEE80211_SEQ_MAX);
739
740         /* Queue to h/w without aggregation */
741         bf->bf_nframes = 1;
742         bf->bf_lastbf = bf->bf_lastfrm; /* one single frame */
743         ath_buf_set_rate(sc, bf);
744         ath_tx_txqaddbuf(sc, txq, bf_head);
745
746         return 0;
747 }
748
749 /* flush tid's software queue and send frames as non-ampdu's */
750
751 static void ath_tx_flush_tid(struct ath_softc *sc, struct ath_atx_tid *tid)
752 {
753         struct ath_txq *txq = &sc->sc_txq[tid->ac->qnum];
754         struct ath_buf *bf;
755         struct list_head bf_head;
756         INIT_LIST_HEAD(&bf_head);
757
758         ASSERT(tid->paused > 0);
759         spin_lock_bh(&txq->axq_lock);
760
761         tid->paused--;
762
763         if (tid->paused > 0) {
764                 spin_unlock_bh(&txq->axq_lock);
765                 return;
766         }
767
768         while (!list_empty(&tid->buf_q)) {
769                 bf = list_first_entry(&tid->buf_q, struct ath_buf, list);
770                 ASSERT(!bf_isretried(bf));
771                 list_cut_position(&bf_head, &tid->buf_q, &bf->bf_lastfrm->list);
772                 ath_tx_send_normal(sc, txq, tid, &bf_head);
773         }
774
775         spin_unlock_bh(&txq->axq_lock);
776 }
777
778 /* Completion routine of an aggregate */
779
780 static void ath_tx_complete_aggr_rifs(struct ath_softc *sc,
781                                       struct ath_txq *txq,
782                                       struct ath_buf *bf,
783                                       struct list_head *bf_q,
784                                       int txok)
785 {
786         struct ath_node *an = NULL;
787         struct sk_buff *skb;
788         struct ieee80211_tx_info *tx_info;
789         struct ath_atx_tid *tid = NULL;
790         struct ath_buf *bf_last = bf->bf_lastbf;
791         struct ath_desc *ds = bf_last->bf_desc;
792         struct ath_buf *bf_next, *bf_lastq = NULL;
793         struct list_head bf_head, bf_pending;
794         u16 seq_st = 0;
795         u32 ba[WME_BA_BMP_SIZE >> 5];
796         int isaggr, txfail, txpending, sendbar = 0, needreset = 0;
797
798         skb = (struct sk_buff *)bf->bf_mpdu;
799         tx_info = IEEE80211_SKB_CB(skb);
800
801         if (tx_info->control.sta) {
802                 an = (struct ath_node *)tx_info->control.sta->drv_priv;
803                 tid = ATH_AN_2_TID(an, bf->bf_tidno);
804         }
805
806         isaggr = bf_isaggr(bf);
807         if (isaggr) {
808                 if (txok) {
809                         if (ATH_DS_TX_BA(ds)) {
810                                 /*
811                                  * extract starting sequence and
812                                  * block-ack bitmap
813                                  */
814                                 seq_st = ATH_DS_BA_SEQ(ds);
815                                 memcpy(ba,
816                                         ATH_DS_BA_BITMAP(ds),
817                                         WME_BA_BMP_SIZE >> 3);
818                         } else {
819                                 memset(ba, 0, WME_BA_BMP_SIZE >> 3);
820
821                                 /*
822                                  * AR5416 can become deaf/mute when BA
823                                  * issue happens. Chip needs to be reset.
824                                  * But AP code may have sychronization issues
825                                  * when perform internal reset in this routine.
826                                  * Only enable reset in STA mode for now.
827                                  */
828                                 if (sc->sc_ah->ah_opmode == ATH9K_M_STA)
829                                         needreset = 1;
830                         }
831                 } else {
832                         memset(ba, 0, WME_BA_BMP_SIZE >> 3);
833                 }
834         }
835
836         INIT_LIST_HEAD(&bf_pending);
837         INIT_LIST_HEAD(&bf_head);
838
839         while (bf) {
840                 txfail = txpending = 0;
841                 bf_next = bf->bf_next;
842
843                 if (ATH_BA_ISSET(ba, ATH_BA_INDEX(seq_st, bf->bf_seqno))) {
844                         /* transmit completion, subframe is
845                          * acked by block ack */
846                 } else if (!isaggr && txok) {
847                         /* transmit completion */
848                 } else {
849
850                         if (!(tid->state & AGGR_CLEANUP) &&
851                             ds->ds_txstat.ts_flags != ATH9K_TX_SW_ABORTED) {
852                                 if (bf->bf_retries < ATH_MAX_SW_RETRIES) {
853                                         ath_tx_set_retry(sc, bf);
854                                         txpending = 1;
855                                 } else {
856                                         bf->bf_state.bf_type |= BUF_XRETRY;
857                                         txfail = 1;
858                                         sendbar = 1;
859                                 }
860                         } else {
861                                 /*
862                                  * cleanup in progress, just fail
863                                  * the un-acked sub-frames
864                                  */
865                                 txfail = 1;
866                         }
867                 }
868                 /*
869                  * Remove ath_buf's of this sub-frame from aggregate queue.
870                  */
871                 if (bf_next == NULL) {  /* last subframe in the aggregate */
872                         ASSERT(bf->bf_lastfrm == bf_last);
873
874                         /*
875                          * The last descriptor of the last sub frame could be
876                          * a holding descriptor for h/w. If that's the case,
877                          * bf->bf_lastfrm won't be in the bf_q.
878                          * Make sure we handle bf_q properly here.
879                          */
880
881                         if (!list_empty(bf_q)) {
882                                 bf_lastq = list_entry(bf_q->prev,
883                                         struct ath_buf, list);
884                                 list_cut_position(&bf_head,
885                                         bf_q, &bf_lastq->list);
886                         } else {
887                                 /*
888                                  * XXX: if the last subframe only has one
889                                  * descriptor which is also being used as
890                                  * a holding descriptor. Then the ath_buf
891                                  * is not in the bf_q at all.
892                                  */
893                                 INIT_LIST_HEAD(&bf_head);
894                         }
895                 } else {
896                         ASSERT(!list_empty(bf_q));
897                         list_cut_position(&bf_head,
898                                 bf_q, &bf->bf_lastfrm->list);
899                 }
900
901                 if (!txpending) {
902                         /*
903                          * complete the acked-ones/xretried ones; update
904                          * block-ack window
905                          */
906                         spin_lock_bh(&txq->axq_lock);
907                         ath_tx_update_baw(sc, tid, bf->bf_seqno);
908                         spin_unlock_bh(&txq->axq_lock);
909
910                         /* complete this sub-frame */
911                         ath_tx_complete_buf(sc, bf, &bf_head, !txfail, sendbar);
912                 } else {
913                         /*
914                          * retry the un-acked ones
915                          */
916                         /*
917                          * XXX: if the last descriptor is holding descriptor,
918                          * in order to requeue the frame to software queue, we
919                          * need to allocate a new descriptor and
920                          * copy the content of holding descriptor to it.
921                          */
922                         if (bf->bf_next == NULL &&
923                             bf_last->bf_status & ATH_BUFSTATUS_STALE) {
924                                 struct ath_buf *tbf;
925
926                                 /* allocate new descriptor */
927                                 spin_lock_bh(&sc->sc_txbuflock);
928                                 ASSERT(!list_empty((&sc->sc_txbuf)));
929                                 tbf = list_first_entry(&sc->sc_txbuf,
930                                                 struct ath_buf, list);
931                                 list_del(&tbf->list);
932                                 spin_unlock_bh(&sc->sc_txbuflock);
933
934                                 ATH_TXBUF_RESET(tbf);
935
936                                 /* copy descriptor content */
937                                 tbf->bf_mpdu = bf_last->bf_mpdu;
938                                 tbf->bf_buf_addr = bf_last->bf_buf_addr;
939                                 *(tbf->bf_desc) = *(bf_last->bf_desc);
940
941                                 /* link it to the frame */
942                                 if (bf_lastq) {
943                                         bf_lastq->bf_desc->ds_link =
944                                                 tbf->bf_daddr;
945                                         bf->bf_lastfrm = tbf;
946                                         ath9k_hw_cleartxdesc(sc->sc_ah,
947                                                 bf->bf_lastfrm->bf_desc);
948                                 } else {
949                                         tbf->bf_state = bf_last->bf_state;
950                                         tbf->bf_lastfrm = tbf;
951                                         ath9k_hw_cleartxdesc(sc->sc_ah,
952                                                 tbf->bf_lastfrm->bf_desc);
953
954                                         /* copy the DMA context */
955                                         tbf->bf_dmacontext =
956                                                 bf_last->bf_dmacontext;
957                                 }
958                                 list_add_tail(&tbf->list, &bf_head);
959                         } else {
960                                 /*
961                                  * Clear descriptor status words for
962                                  * software retry
963                                  */
964                                 ath9k_hw_cleartxdesc(sc->sc_ah,
965                                                      bf->bf_lastfrm->bf_desc);
966                         }
967
968                         /*
969                          * Put this buffer to the temporary pending
970                          * queue to retain ordering
971                          */
972                         list_splice_tail_init(&bf_head, &bf_pending);
973                 }
974
975                 bf = bf_next;
976         }
977
978         if (tid->state & AGGR_CLEANUP) {
979                 /* check to see if we're done with cleaning the h/w queue */
980                 spin_lock_bh(&txq->axq_lock);
981
982                 if (tid->baw_head == tid->baw_tail) {
983                         tid->state &= ~AGGR_ADDBA_COMPLETE;
984                         tid->addba_exchangeattempts = 0;
985                         spin_unlock_bh(&txq->axq_lock);
986
987                         tid->state &= ~AGGR_CLEANUP;
988
989                         /* send buffered frames as singles */
990                         ath_tx_flush_tid(sc, tid);
991                 } else
992                         spin_unlock_bh(&txq->axq_lock);
993
994                 return;
995         }
996
997         /*
998          * prepend un-acked frames to the beginning of the pending frame queue
999          */
1000         if (!list_empty(&bf_pending)) {
1001                 spin_lock_bh(&txq->axq_lock);
1002                 /* Note: we _prepend_, we _do_not_ at to
1003                  * the end of the queue ! */
1004                 list_splice(&bf_pending, &tid->buf_q);
1005                 ath_tx_queue_tid(txq, tid);
1006                 spin_unlock_bh(&txq->axq_lock);
1007         }
1008
1009         if (needreset)
1010                 ath_reset(sc, false);
1011
1012         return;
1013 }
1014
1015 /* Process completed xmit descriptors from the specified queue */
1016
1017 static int ath_tx_processq(struct ath_softc *sc, struct ath_txq *txq)
1018 {
1019         struct ath_hal *ah = sc->sc_ah;
1020         struct ath_buf *bf, *lastbf, *bf_held = NULL;
1021         struct list_head bf_head;
1022         struct ath_desc *ds, *tmp_ds;
1023         struct sk_buff *skb;
1024         struct ieee80211_tx_info *tx_info;
1025         struct ath_tx_info_priv *tx_info_priv;
1026         int nacked, txok, nbad = 0, isrifs = 0;
1027         int status;
1028
1029         DPRINTF(sc, ATH_DBG_QUEUE,
1030                 "%s: tx queue %d (%x), link %p\n", __func__,
1031                 txq->axq_qnum, ath9k_hw_gettxbuf(sc->sc_ah, txq->axq_qnum),
1032                 txq->axq_link);
1033
1034         nacked = 0;
1035         for (;;) {
1036                 spin_lock_bh(&txq->axq_lock);
1037                 if (list_empty(&txq->axq_q)) {
1038                         txq->axq_link = NULL;
1039                         txq->axq_linkbuf = NULL;
1040                         spin_unlock_bh(&txq->axq_lock);
1041                         break;
1042                 }
1043                 bf = list_first_entry(&txq->axq_q, struct ath_buf, list);
1044
1045                 /*
1046                  * There is a race condition that a BH gets scheduled
1047                  * after sw writes TxE and before hw re-load the last
1048                  * descriptor to get the newly chained one.
1049                  * Software must keep the last DONE descriptor as a
1050                  * holding descriptor - software does so by marking
1051                  * it with the STALE flag.
1052                  */
1053                 bf_held = NULL;
1054                 if (bf->bf_status & ATH_BUFSTATUS_STALE) {
1055                         bf_held = bf;
1056                         if (list_is_last(&bf_held->list, &txq->axq_q)) {
1057                                 /* FIXME:
1058                                  * The holding descriptor is the last
1059                                  * descriptor in queue. It's safe to remove
1060                                  * the last holding descriptor in BH context.
1061                                  */
1062                                 spin_unlock_bh(&txq->axq_lock);
1063                                 break;
1064                         } else {
1065                                 /* Lets work with the next buffer now */
1066                                 bf = list_entry(bf_held->list.next,
1067                                         struct ath_buf, list);
1068                         }
1069                 }
1070
1071                 lastbf = bf->bf_lastbf;
1072                 ds = lastbf->bf_desc;    /* NB: last decriptor */
1073
1074                 status = ath9k_hw_txprocdesc(ah, ds);
1075                 if (status == -EINPROGRESS) {
1076                         spin_unlock_bh(&txq->axq_lock);
1077                         break;
1078                 }
1079                 if (bf->bf_desc == txq->axq_lastdsWithCTS)
1080                         txq->axq_lastdsWithCTS = NULL;
1081                 if (ds == txq->axq_gatingds)
1082                         txq->axq_gatingds = NULL;
1083
1084                 /*
1085                  * Remove ath_buf's of the same transmit unit from txq,
1086                  * however leave the last descriptor back as the holding
1087                  * descriptor for hw.
1088                  */
1089                 lastbf->bf_status |= ATH_BUFSTATUS_STALE;
1090                 INIT_LIST_HEAD(&bf_head);
1091
1092                 if (!list_is_singular(&lastbf->list))
1093                         list_cut_position(&bf_head,
1094                                 &txq->axq_q, lastbf->list.prev);
1095
1096                 txq->axq_depth--;
1097
1098                 if (bf_isaggr(bf))
1099                         txq->axq_aggr_depth--;
1100
1101                 txok = (ds->ds_txstat.ts_status == 0);
1102
1103                 spin_unlock_bh(&txq->axq_lock);
1104
1105                 if (bf_held) {
1106                         list_del(&bf_held->list);
1107                         spin_lock_bh(&sc->sc_txbuflock);
1108                         list_add_tail(&bf_held->list, &sc->sc_txbuf);
1109                         spin_unlock_bh(&sc->sc_txbuflock);
1110                 }
1111
1112                 if (!bf_isampdu(bf)) {
1113                         /*
1114                          * This frame is sent out as a single frame.
1115                          * Use hardware retry status for this frame.
1116                          */
1117                         bf->bf_retries = ds->ds_txstat.ts_longretry;
1118                         if (ds->ds_txstat.ts_status & ATH9K_TXERR_XRETRY)
1119                                 bf->bf_state.bf_type |= BUF_XRETRY;
1120                         nbad = 0;
1121                 } else {
1122                         nbad = ath_tx_num_badfrms(sc, bf, txok);
1123                 }
1124                 skb = bf->bf_mpdu;
1125                 tx_info = IEEE80211_SKB_CB(skb);
1126
1127                 /* XXX: HACK! */
1128                 tx_info_priv = (struct ath_tx_info_priv *) tx_info->control.vif;
1129                 if (ds->ds_txstat.ts_status & ATH9K_TXERR_FILT)
1130                         tx_info->flags |= IEEE80211_TX_STAT_TX_FILTERED;
1131                 if ((ds->ds_txstat.ts_status & ATH9K_TXERR_FILT) == 0 &&
1132                                 (bf->bf_flags & ATH9K_TXDESC_NOACK) == 0) {
1133                         if (ds->ds_txstat.ts_status == 0)
1134                                 nacked++;
1135
1136                         if (bf_isdata(bf)) {
1137                                 if (isrifs)
1138                                         tmp_ds = bf->bf_rifslast->bf_desc;
1139                                 else
1140                                         tmp_ds = ds;
1141                                 memcpy(&tx_info_priv->tx,
1142                                         &tmp_ds->ds_txstat,
1143                                         sizeof(tx_info_priv->tx));
1144                                 tx_info_priv->n_frames = bf->bf_nframes;
1145                                 tx_info_priv->n_bad_frames = nbad;
1146                         }
1147                 }
1148
1149                 /*
1150                  * Complete this transmit unit
1151                  */
1152                 if (bf_isampdu(bf))
1153                         ath_tx_complete_aggr_rifs(sc, txq, bf, &bf_head, txok);
1154                 else
1155                         ath_tx_complete_buf(sc, bf, &bf_head, txok, 0);
1156
1157                 /* Wake up mac80211 queue */
1158
1159                 spin_lock_bh(&txq->axq_lock);
1160                 if (txq->stopped && ath_txq_depth(sc, txq->axq_qnum) <=
1161                                 (ATH_TXBUF - 20)) {
1162                         int qnum;
1163                         qnum = ath_get_mac80211_qnum(txq->axq_qnum, sc);
1164                         if (qnum != -1) {
1165                                 ieee80211_wake_queue(sc->hw, qnum);
1166                                 txq->stopped = 0;
1167                         }
1168
1169                 }
1170
1171                 /*
1172                  * schedule any pending packets if aggregation is enabled
1173                  */
1174                 if (sc->sc_flags & SC_OP_TXAGGR)
1175                         ath_txq_schedule(sc, txq);
1176                 spin_unlock_bh(&txq->axq_lock);
1177         }
1178         return nacked;
1179 }
1180
1181 static void ath_tx_stopdma(struct ath_softc *sc, struct ath_txq *txq)
1182 {
1183         struct ath_hal *ah = sc->sc_ah;
1184
1185         (void) ath9k_hw_stoptxdma(ah, txq->axq_qnum);
1186         DPRINTF(sc, ATH_DBG_XMIT, "%s: tx queue [%u] %x, link %p\n",
1187                 __func__, txq->axq_qnum,
1188                 ath9k_hw_gettxbuf(ah, txq->axq_qnum), txq->axq_link);
1189 }
1190
1191 /* Drain only the data queues */
1192
1193 static void ath_drain_txdataq(struct ath_softc *sc, bool retry_tx)
1194 {
1195         struct ath_hal *ah = sc->sc_ah;
1196         int i, status, npend = 0;
1197
1198         if (!(sc->sc_flags & SC_OP_INVALID)) {
1199                 for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
1200                         if (ATH_TXQ_SETUP(sc, i)) {
1201                                 ath_tx_stopdma(sc, &sc->sc_txq[i]);
1202                                 /* The TxDMA may not really be stopped.
1203                                  * Double check the hal tx pending count */
1204                                 npend += ath9k_hw_numtxpending(ah,
1205                                                        sc->sc_txq[i].axq_qnum);
1206                         }
1207                 }
1208         }
1209
1210         if (npend) {
1211                 /* TxDMA not stopped, reset the hal */
1212                 DPRINTF(sc, ATH_DBG_XMIT,
1213                         "%s: Unable to stop TxDMA. Reset HAL!\n", __func__);
1214
1215                 spin_lock_bh(&sc->sc_resetlock);
1216                 if (!ath9k_hw_reset(ah,
1217                                     sc->sc_ah->ah_curchan,
1218                                     sc->sc_ht_info.tx_chan_width,
1219                                     sc->sc_tx_chainmask, sc->sc_rx_chainmask,
1220                                     sc->sc_ht_extprotspacing, true, &status)) {
1221
1222                         DPRINTF(sc, ATH_DBG_FATAL,
1223                                 "%s: unable to reset hardware; hal status %u\n",
1224                                 __func__,
1225                                 status);
1226                 }
1227                 spin_unlock_bh(&sc->sc_resetlock);
1228         }
1229
1230         for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
1231                 if (ATH_TXQ_SETUP(sc, i))
1232                         ath_tx_draintxq(sc, &sc->sc_txq[i], retry_tx);
1233         }
1234 }
1235
1236 /* Add a sub-frame to block ack window */
1237
1238 static void ath_tx_addto_baw(struct ath_softc *sc,
1239                              struct ath_atx_tid *tid,
1240                              struct ath_buf *bf)
1241 {
1242         int index, cindex;
1243
1244         if (bf_isretried(bf))
1245                 return;
1246
1247         index  = ATH_BA_INDEX(tid->seq_start, bf->bf_seqno);
1248         cindex = (tid->baw_head + index) & (ATH_TID_MAX_BUFS - 1);
1249
1250         ASSERT(tid->tx_buf[cindex] == NULL);
1251         tid->tx_buf[cindex] = bf;
1252
1253         if (index >= ((tid->baw_tail - tid->baw_head) &
1254                 (ATH_TID_MAX_BUFS - 1))) {
1255                 tid->baw_tail = cindex;
1256                 INCR(tid->baw_tail, ATH_TID_MAX_BUFS);
1257         }
1258 }
1259
1260 /*
1261  * Function to send an A-MPDU
1262  * NB: must be called with txq lock held
1263  */
1264
1265 static int ath_tx_send_ampdu(struct ath_softc *sc,
1266                              struct ath_atx_tid *tid,
1267                              struct list_head *bf_head,
1268                              struct ath_tx_control *txctl)
1269 {
1270         struct ath_buf *bf;
1271         struct sk_buff *skb;
1272         struct ieee80211_tx_info *tx_info;
1273         struct ath_tx_info_priv *tx_info_priv;
1274
1275         BUG_ON(list_empty(bf_head));
1276
1277         bf = list_first_entry(bf_head, struct ath_buf, list);
1278         bf->bf_state.bf_type |= BUF_AMPDU;
1279
1280         /*
1281          * Do not queue to h/w when any of the following conditions is true:
1282          * - there are pending frames in software queue
1283          * - the TID is currently paused for ADDBA/BAR request
1284          * - seqno is not within block-ack window
1285          * - h/w queue depth exceeds low water mark
1286          */
1287         if (!list_empty(&tid->buf_q) || tid->paused ||
1288             !BAW_WITHIN(tid->seq_start, tid->baw_size, bf->bf_seqno) ||
1289             txctl->txq->axq_depth >= ATH_AGGR_MIN_QDEPTH) {
1290                 /*
1291                  * Add this frame to software queue for scheduling later
1292                  * for aggregation.
1293                  */
1294                 list_splice_tail_init(bf_head, &tid->buf_q);
1295                 ath_tx_queue_tid(txctl->txq, tid);
1296                 return 0;
1297         }
1298
1299         skb = (struct sk_buff *)bf->bf_mpdu;
1300         tx_info = IEEE80211_SKB_CB(skb);
1301         /* XXX: HACK! */
1302         tx_info_priv = (struct ath_tx_info_priv *)tx_info->control.vif;
1303         memcpy(bf->bf_rcs, tx_info_priv->rcs, 4 * sizeof(tx_info_priv->rcs[0]));
1304
1305         /* Add sub-frame to BAW */
1306         ath_tx_addto_baw(sc, tid, bf);
1307
1308         /* Queue to h/w without aggregation */
1309         bf->bf_nframes = 1;
1310         bf->bf_lastbf = bf->bf_lastfrm; /* one single frame */
1311         ath_buf_set_rate(sc, bf);
1312         ath_tx_txqaddbuf(sc, txctl->txq, bf_head);
1313
1314         return 0;
1315 }
1316
1317 /*
1318  * looks up the rate
1319  * returns aggr limit based on lowest of the rates
1320  */
1321
1322 static u32 ath_lookup_rate(struct ath_softc *sc,
1323                            struct ath_buf *bf,
1324                            struct ath_atx_tid *tid)
1325 {
1326         const struct ath9k_rate_table *rt = sc->sc_currates;
1327         struct sk_buff *skb;
1328         struct ieee80211_tx_info *tx_info;
1329         struct ath_tx_info_priv *tx_info_priv;
1330         u32 max_4ms_framelen, frame_length;
1331         u16 aggr_limit, legacy = 0, maxampdu;
1332         int i;
1333
1334         skb = (struct sk_buff *)bf->bf_mpdu;
1335         tx_info = IEEE80211_SKB_CB(skb);
1336         tx_info_priv = (struct ath_tx_info_priv *)
1337                 tx_info->control.vif; /* XXX: HACK! */
1338         memcpy(bf->bf_rcs,
1339                 tx_info_priv->rcs, 4 * sizeof(tx_info_priv->rcs[0]));
1340
1341         /*
1342          * Find the lowest frame length among the rate series that will have a
1343          * 4ms transmit duration.
1344          * TODO - TXOP limit needs to be considered.
1345          */
1346         max_4ms_framelen = ATH_AMPDU_LIMIT_MAX;
1347
1348         for (i = 0; i < 4; i++) {
1349                 if (bf->bf_rcs[i].tries) {
1350                         frame_length = bf->bf_rcs[i].max_4ms_framelen;
1351
1352                         if (rt->info[bf->bf_rcs[i].rix].phy != PHY_HT) {
1353                                 legacy = 1;
1354                                 break;
1355                         }
1356
1357                         max_4ms_framelen = min(max_4ms_framelen, frame_length);
1358                 }
1359         }
1360
1361         /*
1362          * limit aggregate size by the minimum rate if rate selected is
1363          * not a probe rate, if rate selected is a probe rate then
1364          * avoid aggregation of this packet.
1365          */
1366         if (tx_info->flags & IEEE80211_TX_CTL_RATE_CTRL_PROBE || legacy)
1367                 return 0;
1368
1369         aggr_limit = min(max_4ms_framelen,
1370                 (u32)ATH_AMPDU_LIMIT_DEFAULT);
1371
1372         /*
1373          * h/w can accept aggregates upto 16 bit lengths (65535).
1374          * The IE, however can hold upto 65536, which shows up here
1375          * as zero. Ignore 65536 since we  are constrained by hw.
1376          */
1377         maxampdu = tid->an->maxampdu;
1378         if (maxampdu)
1379                 aggr_limit = min(aggr_limit, maxampdu);
1380
1381         return aggr_limit;
1382 }
1383
1384 /*
1385  * returns the number of delimiters to be added to
1386  * meet the minimum required mpdudensity.
1387  * caller should make sure that the rate is  HT rate .
1388  */
1389
1390 static int ath_compute_num_delims(struct ath_softc *sc,
1391                                   struct ath_atx_tid *tid,
1392                                   struct ath_buf *bf,
1393                                   u16 frmlen)
1394 {
1395         const struct ath9k_rate_table *rt = sc->sc_currates;
1396         u32 nsymbits, nsymbols, mpdudensity;
1397         u16 minlen;
1398         u8 rc, flags, rix;
1399         int width, half_gi, ndelim, mindelim;
1400
1401         /* Select standard number of delimiters based on frame length alone */
1402         ndelim = ATH_AGGR_GET_NDELIM(frmlen);
1403
1404         /*
1405          * If encryption enabled, hardware requires some more padding between
1406          * subframes.
1407          * TODO - this could be improved to be dependent on the rate.
1408          *      The hardware can keep up at lower rates, but not higher rates
1409          */
1410         if (bf->bf_keytype != ATH9K_KEY_TYPE_CLEAR)
1411                 ndelim += ATH_AGGR_ENCRYPTDELIM;
1412
1413         /*
1414          * Convert desired mpdu density from microeconds to bytes based
1415          * on highest rate in rate series (i.e. first rate) to determine
1416          * required minimum length for subframe. Take into account
1417          * whether high rate is 20 or 40Mhz and half or full GI.
1418          */
1419         mpdudensity = tid->an->mpdudensity;
1420
1421         /*
1422          * If there is no mpdu density restriction, no further calculation
1423          * is needed.
1424          */
1425         if (mpdudensity == 0)
1426                 return ndelim;
1427
1428         rix = bf->bf_rcs[0].rix;
1429         flags = bf->bf_rcs[0].flags;
1430         rc = rt->info[rix].rateCode;
1431         width = (flags & ATH_RC_CW40_FLAG) ? 1 : 0;
1432         half_gi = (flags & ATH_RC_SGI_FLAG) ? 1 : 0;
1433
1434         if (half_gi)
1435                 nsymbols = NUM_SYMBOLS_PER_USEC_HALFGI(mpdudensity);
1436         else
1437                 nsymbols = NUM_SYMBOLS_PER_USEC(mpdudensity);
1438
1439         if (nsymbols == 0)
1440                 nsymbols = 1;
1441
1442         nsymbits = bits_per_symbol[HT_RC_2_MCS(rc)][width];
1443         minlen = (nsymbols * nsymbits) / BITS_PER_BYTE;
1444
1445         /* Is frame shorter than required minimum length? */
1446         if (frmlen < minlen) {
1447                 /* Get the minimum number of delimiters required. */
1448                 mindelim = (minlen - frmlen) / ATH_AGGR_DELIM_SZ;
1449                 ndelim = max(mindelim, ndelim);
1450         }
1451
1452         return ndelim;
1453 }
1454
1455 /*
1456  * For aggregation from software buffer queue.
1457  * NB: must be called with txq lock held
1458  */
1459
1460 static enum ATH_AGGR_STATUS ath_tx_form_aggr(struct ath_softc *sc,
1461                                         struct ath_atx_tid *tid,
1462                                         struct list_head *bf_q,
1463                                         struct ath_buf **bf_last,
1464                                         struct aggr_rifs_param *param,
1465                                         int *prev_frames)
1466 {
1467 #define PADBYTES(_len) ((4 - ((_len) % 4)) % 4)
1468         struct ath_buf *bf, *tbf, *bf_first, *bf_prev = NULL;
1469         struct list_head bf_head;
1470         int rl = 0, nframes = 0, ndelim;
1471         u16 aggr_limit = 0, al = 0, bpad = 0,
1472                 al_delta, h_baw = tid->baw_size / 2;
1473         enum ATH_AGGR_STATUS status = ATH_AGGR_DONE;
1474         int prev_al = 0, is_ds_rate = 0;
1475         INIT_LIST_HEAD(&bf_head);
1476
1477         BUG_ON(list_empty(&tid->buf_q));
1478
1479         bf_first = list_first_entry(&tid->buf_q, struct ath_buf, list);
1480
1481         do {
1482                 bf = list_first_entry(&tid->buf_q, struct ath_buf, list);
1483
1484                 /*
1485                  * do not step over block-ack window
1486                  */
1487                 if (!BAW_WITHIN(tid->seq_start, tid->baw_size, bf->bf_seqno)) {
1488                         status = ATH_AGGR_BAW_CLOSED;
1489                         break;
1490                 }
1491
1492                 if (!rl) {
1493                         aggr_limit = ath_lookup_rate(sc, bf, tid);
1494                         rl = 1;
1495                         /*
1496                          * Is rate dual stream
1497                          */
1498                         is_ds_rate =
1499                                 (bf->bf_rcs[0].flags & ATH_RC_DS_FLAG) ? 1 : 0;
1500                 }
1501
1502                 /*
1503                  * do not exceed aggregation limit
1504                  */
1505                 al_delta = ATH_AGGR_DELIM_SZ + bf->bf_frmlen;
1506
1507                 if (nframes && (aggr_limit <
1508                         (al + bpad + al_delta + prev_al))) {
1509                         status = ATH_AGGR_LIMITED;
1510                         break;
1511                 }
1512
1513                 /*
1514                  * do not exceed subframe limit
1515                  */
1516                 if ((nframes + *prev_frames) >=
1517                     min((int)h_baw, ATH_AMPDU_SUBFRAME_DEFAULT)) {
1518                         status = ATH_AGGR_LIMITED;
1519                         break;
1520                 }
1521
1522                 /*
1523                  * add padding for previous frame to aggregation length
1524                  */
1525                 al += bpad + al_delta;
1526
1527                 /*
1528                  * Get the delimiters needed to meet the MPDU
1529                  * density for this node.
1530                  */
1531                 ndelim = ath_compute_num_delims(sc, tid, bf_first, bf->bf_frmlen);
1532
1533                 bpad = PADBYTES(al_delta) + (ndelim << 2);
1534
1535                 bf->bf_next = NULL;
1536                 bf->bf_lastfrm->bf_desc->ds_link = 0;
1537
1538                 /*
1539                  * this packet is part of an aggregate
1540                  * - remove all descriptors belonging to this frame from
1541                  *   software queue
1542                  * - add it to block ack window
1543                  * - set up descriptors for aggregation
1544                  */
1545                 list_cut_position(&bf_head, &tid->buf_q, &bf->bf_lastfrm->list);
1546                 ath_tx_addto_baw(sc, tid, bf);
1547
1548                 list_for_each_entry(tbf, &bf_head, list) {
1549                         ath9k_hw_set11n_aggr_middle(sc->sc_ah,
1550                                 tbf->bf_desc, ndelim);
1551                 }
1552
1553                 /*
1554                  * link buffers of this frame to the aggregate
1555                  */
1556                 list_splice_tail_init(&bf_head, bf_q);
1557                 nframes++;
1558
1559                 if (bf_prev) {
1560                         bf_prev->bf_next = bf;
1561                         bf_prev->bf_lastfrm->bf_desc->ds_link = bf->bf_daddr;
1562                 }
1563                 bf_prev = bf;
1564
1565 #ifdef AGGR_NOSHORT
1566                 /*
1567                  * terminate aggregation on a small packet boundary
1568                  */
1569                 if (bf->bf_frmlen < ATH_AGGR_MINPLEN) {
1570                         status = ATH_AGGR_SHORTPKT;
1571                         break;
1572                 }
1573 #endif
1574         } while (!list_empty(&tid->buf_q));
1575
1576         bf_first->bf_al = al;
1577         bf_first->bf_nframes = nframes;
1578         *bf_last = bf_prev;
1579         return status;
1580 #undef PADBYTES
1581 }
1582
1583 /*
1584  * process pending frames possibly doing a-mpdu aggregation
1585  * NB: must be called with txq lock held
1586  */
1587
1588 static void ath_tx_sched_aggr(struct ath_softc *sc,
1589         struct ath_txq *txq, struct ath_atx_tid *tid)
1590 {
1591         struct ath_buf *bf, *tbf, *bf_last, *bf_lastaggr = NULL;
1592         enum ATH_AGGR_STATUS status;
1593         struct list_head bf_q;
1594         struct aggr_rifs_param param = {0, 0, 0, 0, NULL};
1595         int prev_frames = 0;
1596
1597         do {
1598                 if (list_empty(&tid->buf_q))
1599                         return;
1600
1601                 INIT_LIST_HEAD(&bf_q);
1602
1603                 status = ath_tx_form_aggr(sc, tid, &bf_q, &bf_lastaggr, &param,
1604                                           &prev_frames);
1605
1606                 /*
1607                  * no frames picked up to be aggregated; block-ack
1608                  * window is not open
1609                  */
1610                 if (list_empty(&bf_q))
1611                         break;
1612
1613                 bf = list_first_entry(&bf_q, struct ath_buf, list);
1614                 bf_last = list_entry(bf_q.prev, struct ath_buf, list);
1615                 bf->bf_lastbf = bf_last;
1616
1617                 /*
1618                  * if only one frame, send as non-aggregate
1619                  */
1620                 if (bf->bf_nframes == 1) {
1621                         ASSERT(bf->bf_lastfrm == bf_last);
1622
1623                         bf->bf_state.bf_type &= ~BUF_AGGR;
1624                         /*
1625                          * clear aggr bits for every descriptor
1626                          * XXX TODO: is there a way to optimize it?
1627                          */
1628                         list_for_each_entry(tbf, &bf_q, list) {
1629                                 ath9k_hw_clr11n_aggr(sc->sc_ah, tbf->bf_desc);
1630                         }
1631
1632                         ath_buf_set_rate(sc, bf);
1633                         ath_tx_txqaddbuf(sc, txq, &bf_q);
1634                         continue;
1635                 }
1636
1637                 /*
1638                  * setup first desc with rate and aggr info
1639                  */
1640                 bf->bf_state.bf_type |= BUF_AGGR;
1641                 ath_buf_set_rate(sc, bf);
1642                 ath9k_hw_set11n_aggr_first(sc->sc_ah, bf->bf_desc, bf->bf_al);
1643
1644                 /*
1645                  * anchor last frame of aggregate correctly
1646                  */
1647                 ASSERT(bf_lastaggr);
1648                 ASSERT(bf_lastaggr->bf_lastfrm == bf_last);
1649                 tbf = bf_lastaggr;
1650                 ath9k_hw_set11n_aggr_last(sc->sc_ah, tbf->bf_desc);
1651
1652                 /* XXX: We don't enter into this loop, consider removing this */
1653                 while (!list_empty(&bf_q) && !list_is_last(&tbf->list, &bf_q)) {
1654                         tbf = list_entry(tbf->list.next, struct ath_buf, list);
1655                         ath9k_hw_set11n_aggr_last(sc->sc_ah, tbf->bf_desc);
1656                 }
1657
1658                 txq->axq_aggr_depth++;
1659
1660                 /*
1661                  * Normal aggregate, queue to hardware
1662                  */
1663                 ath_tx_txqaddbuf(sc, txq, &bf_q);
1664
1665         } while (txq->axq_depth < ATH_AGGR_MIN_QDEPTH &&
1666                  status != ATH_AGGR_BAW_CLOSED);
1667 }
1668
1669 /* Called with txq lock held */
1670
1671 static void ath_tid_drain(struct ath_softc *sc,
1672                           struct ath_txq *txq,
1673                           struct ath_atx_tid *tid)
1674
1675 {
1676         struct ath_buf *bf;
1677         struct list_head bf_head;
1678         INIT_LIST_HEAD(&bf_head);
1679
1680         for (;;) {
1681                 if (list_empty(&tid->buf_q))
1682                         break;
1683                 bf = list_first_entry(&tid->buf_q, struct ath_buf, list);
1684
1685                 list_cut_position(&bf_head, &tid->buf_q, &bf->bf_lastfrm->list);
1686
1687                 /* update baw for software retried frame */
1688                 if (bf_isretried(bf))
1689                         ath_tx_update_baw(sc, tid, bf->bf_seqno);
1690
1691                 /*
1692                  * do not indicate packets while holding txq spinlock.
1693                  * unlock is intentional here
1694                  */
1695                 spin_unlock(&txq->axq_lock);
1696
1697                 /* complete this sub-frame */
1698                 ath_tx_complete_buf(sc, bf, &bf_head, 0, 0);
1699
1700                 spin_lock(&txq->axq_lock);
1701         }
1702
1703         /*
1704          * TODO: For frame(s) that are in the retry state, we will reuse the
1705          * sequence number(s) without setting the retry bit. The
1706          * alternative is to give up on these and BAR the receiver's window
1707          * forward.
1708          */
1709         tid->seq_next = tid->seq_start;
1710         tid->baw_tail = tid->baw_head;
1711 }
1712
1713 /*
1714  * Drain all pending buffers
1715  * NB: must be called with txq lock held
1716  */
1717
1718 static void ath_txq_drain_pending_buffers(struct ath_softc *sc,
1719                                           struct ath_txq *txq)
1720 {
1721         struct ath_atx_ac *ac, *ac_tmp;
1722         struct ath_atx_tid *tid, *tid_tmp;
1723
1724         list_for_each_entry_safe(ac, ac_tmp, &txq->axq_acq, list) {
1725                 list_del(&ac->list);
1726                 ac->sched = false;
1727                 list_for_each_entry_safe(tid, tid_tmp, &ac->tid_q, list) {
1728                         list_del(&tid->list);
1729                         tid->sched = false;
1730                         ath_tid_drain(sc, txq, tid);
1731                 }
1732         }
1733 }
1734
1735 static void ath_tx_setup_buffer(struct ath_softc *sc, struct ath_buf *bf,
1736                                 struct sk_buff *skb, struct scatterlist *sg,
1737                                 struct ath_tx_control *txctl)
1738 {
1739         struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
1740         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1741         struct ath_tx_info_priv *tx_info_priv;
1742         struct ath_rc_series *rcs;
1743         int hdrlen;
1744         __le16 fc;
1745
1746         tx_info_priv = (struct ath_tx_info_priv *)tx_info->control.vif;
1747         hdrlen = ieee80211_get_hdrlen_from_skb(skb);
1748         fc = hdr->frame_control;
1749         rcs = tx_info_priv->rcs;
1750
1751         ATH_TXBUF_RESET(bf);
1752
1753         /* Frame type */
1754
1755         bf->bf_frmlen = skb->len + FCS_LEN - (hdrlen & 3);
1756
1757         ieee80211_is_data(fc) ?
1758                 (bf->bf_state.bf_type |= BUF_DATA) :
1759                 (bf->bf_state.bf_type &= ~BUF_DATA);
1760         ieee80211_is_back_req(fc) ?
1761                 (bf->bf_state.bf_type |= BUF_BAR) :
1762                 (bf->bf_state.bf_type &= ~BUF_BAR);
1763         ieee80211_is_pspoll(fc) ?
1764                 (bf->bf_state.bf_type |= BUF_PSPOLL) :
1765                 (bf->bf_state.bf_type &= ~BUF_PSPOLL);
1766         (sc->sc_flags & SC_OP_PREAMBLE_SHORT) ?
1767                 (bf->bf_state.bf_type |= BUF_SHORT_PREAMBLE) :
1768                 (bf->bf_state.bf_type &= ~BUF_SHORT_PREAMBLE);
1769         (sc->hw->conf.ht.enabled &&
1770          (tx_info->flags & IEEE80211_TX_CTL_AMPDU)) ?
1771                 (bf->bf_state.bf_type |= BUF_HT) :
1772                 (bf->bf_state.bf_type &= ~BUF_HT);
1773
1774         bf->bf_flags = setup_tx_flags(sc, skb, txctl->txq);
1775
1776         /* Crypto */
1777
1778         bf->bf_keytype = get_hw_crypto_keytype(skb);
1779
1780         if (bf->bf_keytype != ATH9K_KEY_TYPE_CLEAR) {
1781                 bf->bf_frmlen += tx_info->control.hw_key->icv_len;
1782                 bf->bf_keyix = tx_info->control.hw_key->hw_key_idx;
1783         } else {
1784                 bf->bf_keyix = ATH9K_TXKEYIX_INVALID;
1785         }
1786
1787         /* Rate series */
1788
1789         setup_rate_retries(sc, skb);
1790
1791         bf->bf_rcs[0] = rcs[0];
1792         bf->bf_rcs[1] = rcs[1];
1793         bf->bf_rcs[2] = rcs[2];
1794         bf->bf_rcs[3] = rcs[3];
1795
1796         /* Assign seqno, tidno */
1797
1798         if (bf_isht(bf) && (sc->sc_flags & SC_OP_TXAGGR))
1799                 assign_aggr_tid_seqno(skb, bf);
1800
1801         /* DMA setup */
1802
1803         bf->bf_mpdu = skb;
1804         bf->bf_dmacontext = pci_map_single(sc->pdev, skb->data,
1805                                            skb->len, PCI_DMA_TODEVICE);
1806         bf->bf_buf_addr = bf->bf_dmacontext;
1807 }
1808
1809 /* FIXME: tx power */
1810 static void ath_tx_start_dma(struct ath_softc *sc, struct ath_buf *bf,
1811                              struct scatterlist *sg, u32 n_sg,
1812                              struct ath_tx_control *txctl)
1813 {
1814         struct sk_buff *skb = (struct sk_buff *)bf->bf_mpdu;
1815         struct ieee80211_tx_info *tx_info =  IEEE80211_SKB_CB(skb);
1816         struct ath_node *an = NULL;
1817         struct list_head bf_head;
1818         struct ath_desc *ds;
1819         struct ath_atx_tid *tid;
1820         struct ath_hal *ah = sc->sc_ah;
1821         int frm_type;
1822
1823         frm_type = get_hw_packet_type(skb);
1824
1825         INIT_LIST_HEAD(&bf_head);
1826         list_add_tail(&bf->list, &bf_head);
1827
1828         /* setup descriptor */
1829
1830         ds = bf->bf_desc;
1831         ds->ds_link = 0;
1832         ds->ds_data = bf->bf_buf_addr;
1833
1834         /* Formulate first tx descriptor with tx controls */
1835
1836         ath9k_hw_set11n_txdesc(ah, ds, bf->bf_frmlen, frm_type, MAX_RATE_POWER,
1837                                bf->bf_keyix, bf->bf_keytype, bf->bf_flags);
1838
1839         ath9k_hw_filltxdesc(ah, ds,
1840                             sg_dma_len(sg),             /* segment length */
1841                             true,                       /* first segment */
1842                             (n_sg == 1) ? true : false, /* last segment */
1843                             ds);                        /* first descriptor */
1844
1845         bf->bf_lastfrm = bf;
1846
1847         spin_lock_bh(&txctl->txq->axq_lock);
1848
1849         if (bf_isht(bf) && (sc->sc_flags & SC_OP_TXAGGR) &&
1850             tx_info->control.sta) {
1851                 an = (struct ath_node *)tx_info->control.sta->drv_priv;
1852                 tid = ATH_AN_2_TID(an, bf->bf_tidno);
1853
1854                 if (ath_aggr_query(sc, an, bf->bf_tidno)) {
1855                         /*
1856                          * Try aggregation if it's a unicast data frame
1857                          * and the destination is HT capable.
1858                          */
1859                         ath_tx_send_ampdu(sc, tid, &bf_head, txctl);
1860                 } else {
1861                         /*
1862                          * Send this frame as regular when ADDBA
1863                          * exchange is neither complete nor pending.
1864                          */
1865                         ath_tx_send_normal(sc, txctl->txq,
1866                                            tid, &bf_head);
1867                 }
1868         } else {
1869                 bf->bf_lastbf = bf;
1870                 bf->bf_nframes = 1;
1871
1872                 ath_buf_set_rate(sc, bf);
1873                 ath_tx_txqaddbuf(sc, txctl->txq, &bf_head);
1874         }
1875
1876         spin_unlock_bh(&txctl->txq->axq_lock);
1877 }
1878
1879 int ath_tx_start(struct ath_softc *sc, struct sk_buff *skb,
1880                  struct ath_tx_control *txctl)
1881 {
1882         struct ath_buf *bf;
1883         struct scatterlist sg;
1884
1885         /* Check if a tx buffer is available */
1886
1887         bf = ath_tx_get_buffer(sc);
1888         if (!bf) {
1889                 DPRINTF(sc, ATH_DBG_XMIT, "%s: TX buffers are full\n",
1890                         __func__);
1891                 return -1;
1892         }
1893
1894         ath_tx_setup_buffer(sc, bf, skb, &sg, txctl);
1895
1896         /* Setup S/G */
1897
1898         memset(&sg, 0, sizeof(struct scatterlist));
1899         sg_dma_address(&sg) = bf->bf_dmacontext;
1900         sg_dma_len(&sg) = skb->len;
1901
1902         ath_tx_start_dma(sc, bf, &sg, 1, txctl);
1903
1904         return 0;
1905 }
1906
1907 /* Initialize TX queue and h/w */
1908
1909 int ath_tx_init(struct ath_softc *sc, int nbufs)
1910 {
1911         int error = 0;
1912
1913         do {
1914                 spin_lock_init(&sc->sc_txbuflock);
1915
1916                 /* Setup tx descriptors */
1917                 error = ath_descdma_setup(sc, &sc->sc_txdma, &sc->sc_txbuf,
1918                         "tx", nbufs, 1);
1919                 if (error != 0) {
1920                         DPRINTF(sc, ATH_DBG_FATAL,
1921                                 "%s: failed to allocate tx descriptors: %d\n",
1922                                 __func__, error);
1923                         break;
1924                 }
1925
1926                 /* XXX allocate beacon state together with vap */
1927                 error = ath_descdma_setup(sc, &sc->sc_bdma, &sc->sc_bbuf,
1928                                           "beacon", ATH_BCBUF, 1);
1929                 if (error != 0) {
1930                         DPRINTF(sc, ATH_DBG_FATAL,
1931                                 "%s: failed to allocate "
1932                                 "beacon descripotrs: %d\n",
1933                                 __func__, error);
1934                         break;
1935                 }
1936
1937         } while (0);
1938
1939         if (error != 0)
1940                 ath_tx_cleanup(sc);
1941
1942         return error;
1943 }
1944
1945 /* Reclaim all tx queue resources */
1946
1947 int ath_tx_cleanup(struct ath_softc *sc)
1948 {
1949         /* cleanup beacon descriptors */
1950         if (sc->sc_bdma.dd_desc_len != 0)
1951                 ath_descdma_cleanup(sc, &sc->sc_bdma, &sc->sc_bbuf);
1952
1953         /* cleanup tx descriptors */
1954         if (sc->sc_txdma.dd_desc_len != 0)
1955                 ath_descdma_cleanup(sc, &sc->sc_txdma, &sc->sc_txbuf);
1956
1957         return 0;
1958 }
1959
1960 /* Setup a h/w transmit queue */
1961
1962 struct ath_txq *ath_txq_setup(struct ath_softc *sc, int qtype, int subtype)
1963 {
1964         struct ath_hal *ah = sc->sc_ah;
1965         struct ath9k_tx_queue_info qi;
1966         int qnum;
1967
1968         memset(&qi, 0, sizeof(qi));
1969         qi.tqi_subtype = subtype;
1970         qi.tqi_aifs = ATH9K_TXQ_USEDEFAULT;
1971         qi.tqi_cwmin = ATH9K_TXQ_USEDEFAULT;
1972         qi.tqi_cwmax = ATH9K_TXQ_USEDEFAULT;
1973         qi.tqi_physCompBuf = 0;
1974
1975         /*
1976          * Enable interrupts only for EOL and DESC conditions.
1977          * We mark tx descriptors to receive a DESC interrupt
1978          * when a tx queue gets deep; otherwise waiting for the
1979          * EOL to reap descriptors.  Note that this is done to
1980          * reduce interrupt load and this only defers reaping
1981          * descriptors, never transmitting frames.  Aside from
1982          * reducing interrupts this also permits more concurrency.
1983          * The only potential downside is if the tx queue backs
1984          * up in which case the top half of the kernel may backup
1985          * due to a lack of tx descriptors.
1986          *
1987          * The UAPSD queue is an exception, since we take a desc-
1988          * based intr on the EOSP frames.
1989          */
1990         if (qtype == ATH9K_TX_QUEUE_UAPSD)
1991                 qi.tqi_qflags = TXQ_FLAG_TXDESCINT_ENABLE;
1992         else
1993                 qi.tqi_qflags = TXQ_FLAG_TXEOLINT_ENABLE |
1994                         TXQ_FLAG_TXDESCINT_ENABLE;
1995         qnum = ath9k_hw_setuptxqueue(ah, qtype, &qi);
1996         if (qnum == -1) {
1997                 /*
1998                  * NB: don't print a message, this happens
1999                  * normally on parts with too few tx queues
2000                  */
2001                 return NULL;
2002         }
2003         if (qnum >= ARRAY_SIZE(sc->sc_txq)) {
2004                 DPRINTF(sc, ATH_DBG_FATAL,
2005                         "%s: hal qnum %u out of range, max %u!\n",
2006                         __func__, qnum, (unsigned int)ARRAY_SIZE(sc->sc_txq));
2007                 ath9k_hw_releasetxqueue(ah, qnum);
2008                 return NULL;
2009         }
2010         if (!ATH_TXQ_SETUP(sc, qnum)) {
2011                 struct ath_txq *txq = &sc->sc_txq[qnum];
2012
2013                 txq->axq_qnum = qnum;
2014                 txq->axq_link = NULL;
2015                 INIT_LIST_HEAD(&txq->axq_q);
2016                 INIT_LIST_HEAD(&txq->axq_acq);
2017                 spin_lock_init(&txq->axq_lock);
2018                 txq->axq_depth = 0;
2019                 txq->axq_aggr_depth = 0;
2020                 txq->axq_totalqueued = 0;
2021                 txq->axq_linkbuf = NULL;
2022                 sc->sc_txqsetup |= 1<<qnum;
2023         }
2024         return &sc->sc_txq[qnum];
2025 }
2026
2027 /* Reclaim resources for a setup queue */
2028
2029 void ath_tx_cleanupq(struct ath_softc *sc, struct ath_txq *txq)
2030 {
2031         ath9k_hw_releasetxqueue(sc->sc_ah, txq->axq_qnum);
2032         sc->sc_txqsetup &= ~(1<<txq->axq_qnum);
2033 }
2034
2035 /*
2036  * Setup a hardware data transmit queue for the specified
2037  * access control.  The hal may not support all requested
2038  * queues in which case it will return a reference to a
2039  * previously setup queue.  We record the mapping from ac's
2040  * to h/w queues for use by ath_tx_start and also track
2041  * the set of h/w queues being used to optimize work in the
2042  * transmit interrupt handler and related routines.
2043  */
2044
2045 int ath_tx_setup(struct ath_softc *sc, int haltype)
2046 {
2047         struct ath_txq *txq;
2048
2049         if (haltype >= ARRAY_SIZE(sc->sc_haltype2q)) {
2050                 DPRINTF(sc, ATH_DBG_FATAL,
2051                         "%s: HAL AC %u out of range, max %zu!\n",
2052                         __func__, haltype, ARRAY_SIZE(sc->sc_haltype2q));
2053                 return 0;
2054         }
2055         txq = ath_txq_setup(sc, ATH9K_TX_QUEUE_DATA, haltype);
2056         if (txq != NULL) {
2057                 sc->sc_haltype2q[haltype] = txq->axq_qnum;
2058                 return 1;
2059         } else
2060                 return 0;
2061 }
2062
2063 int ath_tx_get_qnum(struct ath_softc *sc, int qtype, int haltype)
2064 {
2065         int qnum;
2066
2067         switch (qtype) {
2068         case ATH9K_TX_QUEUE_DATA:
2069                 if (haltype >= ARRAY_SIZE(sc->sc_haltype2q)) {
2070                         DPRINTF(sc, ATH_DBG_FATAL,
2071                                 "%s: HAL AC %u out of range, max %zu!\n",
2072                                 __func__,
2073                                 haltype, ARRAY_SIZE(sc->sc_haltype2q));
2074                         return -1;
2075                 }
2076                 qnum = sc->sc_haltype2q[haltype];
2077                 break;
2078         case ATH9K_TX_QUEUE_BEACON:
2079                 qnum = sc->sc_bhalq;
2080                 break;
2081         case ATH9K_TX_QUEUE_CAB:
2082                 qnum = sc->sc_cabq->axq_qnum;
2083                 break;
2084         default:
2085                 qnum = -1;
2086         }
2087         return qnum;
2088 }
2089
2090 /* Get a transmit queue, if available */
2091
2092 struct ath_txq *ath_test_get_txq(struct ath_softc *sc, struct sk_buff *skb)
2093 {
2094         struct ath_txq *txq = NULL;
2095         int qnum;
2096
2097         qnum = ath_get_hal_qnum(skb_get_queue_mapping(skb), sc);
2098         txq = &sc->sc_txq[qnum];
2099
2100         spin_lock_bh(&txq->axq_lock);
2101
2102         /* Try to avoid running out of descriptors */
2103         if (txq->axq_depth >= (ATH_TXBUF - 20)) {
2104                 DPRINTF(sc, ATH_DBG_FATAL,
2105                         "%s: TX queue: %d is full, depth: %d\n",
2106                         __func__, qnum, txq->axq_depth);
2107                 ieee80211_stop_queue(sc->hw, skb_get_queue_mapping(skb));
2108                 txq->stopped = 1;
2109                 spin_unlock_bh(&txq->axq_lock);
2110                 return NULL;
2111         }
2112
2113         spin_unlock_bh(&txq->axq_lock);
2114
2115         return txq;
2116 }
2117
2118 /* Update parameters for a transmit queue */
2119
2120 int ath_txq_update(struct ath_softc *sc, int qnum,
2121                    struct ath9k_tx_queue_info *qinfo)
2122 {
2123         struct ath_hal *ah = sc->sc_ah;
2124         int error = 0;
2125         struct ath9k_tx_queue_info qi;
2126
2127         if (qnum == sc->sc_bhalq) {
2128                 /*
2129                  * XXX: for beacon queue, we just save the parameter.
2130                  * It will be picked up by ath_beaconq_config when
2131                  * it's necessary.
2132                  */
2133                 sc->sc_beacon_qi = *qinfo;
2134                 return 0;
2135         }
2136
2137         ASSERT(sc->sc_txq[qnum].axq_qnum == qnum);
2138
2139         ath9k_hw_get_txq_props(ah, qnum, &qi);
2140         qi.tqi_aifs = qinfo->tqi_aifs;
2141         qi.tqi_cwmin = qinfo->tqi_cwmin;
2142         qi.tqi_cwmax = qinfo->tqi_cwmax;
2143         qi.tqi_burstTime = qinfo->tqi_burstTime;
2144         qi.tqi_readyTime = qinfo->tqi_readyTime;
2145
2146         if (!ath9k_hw_set_txq_props(ah, qnum, &qi)) {
2147                 DPRINTF(sc, ATH_DBG_FATAL,
2148                         "%s: unable to update hardware queue %u!\n",
2149                         __func__, qnum);
2150                 error = -EIO;
2151         } else {
2152                 ath9k_hw_resettxqueue(ah, qnum); /* push to h/w */
2153         }
2154
2155         return error;
2156 }
2157
2158 int ath_cabq_update(struct ath_softc *sc)
2159 {
2160         struct ath9k_tx_queue_info qi;
2161         int qnum = sc->sc_cabq->axq_qnum;
2162         struct ath_beacon_config conf;
2163
2164         ath9k_hw_get_txq_props(sc->sc_ah, qnum, &qi);
2165         /*
2166          * Ensure the readytime % is within the bounds.
2167          */
2168         if (sc->sc_config.cabqReadytime < ATH9K_READY_TIME_LO_BOUND)
2169                 sc->sc_config.cabqReadytime = ATH9K_READY_TIME_LO_BOUND;
2170         else if (sc->sc_config.cabqReadytime > ATH9K_READY_TIME_HI_BOUND)
2171                 sc->sc_config.cabqReadytime = ATH9K_READY_TIME_HI_BOUND;
2172
2173         ath_get_beaconconfig(sc, ATH_IF_ID_ANY, &conf);
2174         qi.tqi_readyTime =
2175                 (conf.beacon_interval * sc->sc_config.cabqReadytime) / 100;
2176         ath_txq_update(sc, qnum, &qi);
2177
2178         return 0;
2179 }
2180
2181 /* Deferred processing of transmit interrupt */
2182
2183 void ath_tx_tasklet(struct ath_softc *sc)
2184 {
2185         int i;
2186         u32 qcumask = ((1 << ATH9K_NUM_TX_QUEUES) - 1);
2187
2188         ath9k_hw_gettxintrtxqs(sc->sc_ah, &qcumask);
2189
2190         /*
2191          * Process each active queue.
2192          */
2193         for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
2194                 if (ATH_TXQ_SETUP(sc, i) && (qcumask & (1 << i)))
2195                         ath_tx_processq(sc, &sc->sc_txq[i]);
2196         }
2197 }
2198
2199 void ath_tx_draintxq(struct ath_softc *sc,
2200         struct ath_txq *txq, bool retry_tx)
2201 {
2202         struct ath_buf *bf, *lastbf;
2203         struct list_head bf_head;
2204
2205         INIT_LIST_HEAD(&bf_head);
2206
2207         /*
2208          * NB: this assumes output has been stopped and
2209          *     we do not need to block ath_tx_tasklet
2210          */
2211         for (;;) {
2212                 spin_lock_bh(&txq->axq_lock);
2213
2214                 if (list_empty(&txq->axq_q)) {
2215                         txq->axq_link = NULL;
2216                         txq->axq_linkbuf = NULL;
2217                         spin_unlock_bh(&txq->axq_lock);
2218                         break;
2219                 }
2220
2221                 bf = list_first_entry(&txq->axq_q, struct ath_buf, list);
2222
2223                 if (bf->bf_status & ATH_BUFSTATUS_STALE) {
2224                         list_del(&bf->list);
2225                         spin_unlock_bh(&txq->axq_lock);
2226
2227                         spin_lock_bh(&sc->sc_txbuflock);
2228                         list_add_tail(&bf->list, &sc->sc_txbuf);
2229                         spin_unlock_bh(&sc->sc_txbuflock);
2230                         continue;
2231                 }
2232
2233                 lastbf = bf->bf_lastbf;
2234                 if (!retry_tx)
2235                         lastbf->bf_desc->ds_txstat.ts_flags =
2236                                 ATH9K_TX_SW_ABORTED;
2237
2238                 /* remove ath_buf's of the same mpdu from txq */
2239                 list_cut_position(&bf_head, &txq->axq_q, &lastbf->list);
2240                 txq->axq_depth--;
2241
2242                 spin_unlock_bh(&txq->axq_lock);
2243
2244                 if (bf_isampdu(bf))
2245                         ath_tx_complete_aggr_rifs(sc, txq, bf, &bf_head, 0);
2246                 else
2247                         ath_tx_complete_buf(sc, bf, &bf_head, 0, 0);
2248         }
2249
2250         /* flush any pending frames if aggregation is enabled */
2251         if (sc->sc_flags & SC_OP_TXAGGR) {
2252                 if (!retry_tx) {
2253                         spin_lock_bh(&txq->axq_lock);
2254                         ath_txq_drain_pending_buffers(sc, txq);
2255                         spin_unlock_bh(&txq->axq_lock);
2256                 }
2257         }
2258 }
2259
2260 /* Drain the transmit queues and reclaim resources */
2261
2262 void ath_draintxq(struct ath_softc *sc, bool retry_tx)
2263 {
2264         /* stop beacon queue. The beacon will be freed when
2265          * we go to INIT state */
2266         if (!(sc->sc_flags & SC_OP_INVALID)) {
2267                 (void) ath9k_hw_stoptxdma(sc->sc_ah, sc->sc_bhalq);
2268                 DPRINTF(sc, ATH_DBG_XMIT, "%s: beacon queue %x\n", __func__,
2269                         ath9k_hw_gettxbuf(sc->sc_ah, sc->sc_bhalq));
2270         }
2271
2272         ath_drain_txdataq(sc, retry_tx);
2273 }
2274
2275 u32 ath_txq_depth(struct ath_softc *sc, int qnum)
2276 {
2277         return sc->sc_txq[qnum].axq_depth;
2278 }
2279
2280 u32 ath_txq_aggr_depth(struct ath_softc *sc, int qnum)
2281 {
2282         return sc->sc_txq[qnum].axq_aggr_depth;
2283 }
2284
2285 bool ath_tx_aggr_check(struct ath_softc *sc, struct ath_node *an, u8 tidno)
2286 {
2287         struct ath_atx_tid *txtid;
2288
2289         if (!(sc->sc_flags & SC_OP_TXAGGR))
2290                 return false;
2291
2292         txtid = ATH_AN_2_TID(an, tidno);
2293
2294         if (!(txtid->state & AGGR_ADDBA_COMPLETE)) {
2295                 if (!(txtid->state & AGGR_ADDBA_PROGRESS) &&
2296                     (txtid->addba_exchangeattempts < ADDBA_EXCHANGE_ATTEMPTS)) {
2297                         txtid->addba_exchangeattempts++;
2298                         return true;
2299                 }
2300         }
2301
2302         return false;
2303 }
2304
2305 /* Start TX aggregation */
2306
2307 int ath_tx_aggr_start(struct ath_softc *sc, struct ieee80211_sta *sta,
2308                       u16 tid, u16 *ssn)
2309 {
2310         struct ath_atx_tid *txtid;
2311         struct ath_node *an;
2312
2313         an = (struct ath_node *)sta->drv_priv;
2314
2315         if (sc->sc_flags & SC_OP_TXAGGR) {
2316                 txtid = ATH_AN_2_TID(an, tid);
2317                 txtid->state |= AGGR_ADDBA_PROGRESS;
2318                 ath_tx_pause_tid(sc, txtid);
2319         }
2320
2321         return 0;
2322 }
2323
2324 /* Stop tx aggregation */
2325
2326 int ath_tx_aggr_stop(struct ath_softc *sc, struct ieee80211_sta *sta, u16 tid)
2327 {
2328         struct ath_node *an = (struct ath_node *)sta->drv_priv;
2329
2330         ath_tx_aggr_teardown(sc, an, tid);
2331         return 0;
2332 }
2333
2334 /* Resume tx aggregation */
2335
2336 void ath_tx_aggr_resume(struct ath_softc *sc, struct ieee80211_sta *sta, u16 tid)
2337 {
2338         struct ath_atx_tid *txtid;
2339         struct ath_node *an;
2340
2341         an = (struct ath_node *)sta->drv_priv;
2342
2343         if (sc->sc_flags & SC_OP_TXAGGR) {
2344                 txtid = ATH_AN_2_TID(an, tid);
2345                 txtid->baw_size =
2346                         IEEE80211_MIN_AMPDU_BUF << sta->ht_cap.ampdu_factor;
2347                 txtid->state |= AGGR_ADDBA_COMPLETE;
2348                 txtid->state &= ~AGGR_ADDBA_PROGRESS;
2349                 ath_tx_resume_tid(sc, txtid);
2350         }
2351 }
2352
2353 /*
2354  * Performs transmit side cleanup when TID changes from aggregated to
2355  * unaggregated.
2356  * - Pause the TID and mark cleanup in progress
2357  * - Discard all retry frames from the s/w queue.
2358  */
2359
2360 void ath_tx_aggr_teardown(struct ath_softc *sc, struct ath_node *an, u8 tid)
2361 {
2362         struct ath_atx_tid *txtid = ATH_AN_2_TID(an, tid);
2363         struct ath_txq *txq = &sc->sc_txq[txtid->ac->qnum];
2364         struct ath_buf *bf;
2365         struct list_head bf_head;
2366         INIT_LIST_HEAD(&bf_head);
2367
2368         DPRINTF(sc, ATH_DBG_AGGR, "%s: teardown TX aggregation\n", __func__);
2369
2370         if (txtid->state & AGGR_CLEANUP) /* cleanup is in progress */
2371                 return;
2372
2373         if (!(txtid->state & AGGR_ADDBA_COMPLETE)) {
2374                 txtid->addba_exchangeattempts = 0;
2375                 return;
2376         }
2377
2378         /* TID must be paused first */
2379         ath_tx_pause_tid(sc, txtid);
2380
2381         /* drop all software retried frames and mark this TID */
2382         spin_lock_bh(&txq->axq_lock);
2383         while (!list_empty(&txtid->buf_q)) {
2384                 bf = list_first_entry(&txtid->buf_q, struct ath_buf, list);
2385                 if (!bf_isretried(bf)) {
2386                         /*
2387                          * NB: it's based on the assumption that
2388                          * software retried frame will always stay
2389                          * at the head of software queue.
2390                          */
2391                         break;
2392                 }
2393                 list_cut_position(&bf_head,
2394                         &txtid->buf_q, &bf->bf_lastfrm->list);
2395                 ath_tx_update_baw(sc, txtid, bf->bf_seqno);
2396
2397                 /* complete this sub-frame */
2398                 ath_tx_complete_buf(sc, bf, &bf_head, 0, 0);
2399         }
2400
2401         if (txtid->baw_head != txtid->baw_tail) {
2402                 spin_unlock_bh(&txq->axq_lock);
2403                 txtid->state |= AGGR_CLEANUP;
2404         } else {
2405                 txtid->state &= ~AGGR_ADDBA_COMPLETE;
2406                 txtid->addba_exchangeattempts = 0;
2407                 spin_unlock_bh(&txq->axq_lock);
2408                 ath_tx_flush_tid(sc, txtid);
2409         }
2410 }
2411
2412 /*
2413  * Tx scheduling logic
2414  * NB: must be called with txq lock held
2415  */
2416
2417 void ath_txq_schedule(struct ath_softc *sc, struct ath_txq *txq)
2418 {
2419         struct ath_atx_ac *ac;
2420         struct ath_atx_tid *tid;
2421
2422         /* nothing to schedule */
2423         if (list_empty(&txq->axq_acq))
2424                 return;
2425         /*
2426          * get the first node/ac pair on the queue
2427          */
2428         ac = list_first_entry(&txq->axq_acq, struct ath_atx_ac, list);
2429         list_del(&ac->list);
2430         ac->sched = false;
2431
2432         /*
2433          * process a single tid per destination
2434          */
2435         do {
2436                 /* nothing to schedule */
2437                 if (list_empty(&ac->tid_q))
2438                         return;
2439
2440                 tid = list_first_entry(&ac->tid_q, struct ath_atx_tid, list);
2441                 list_del(&tid->list);
2442                 tid->sched = false;
2443
2444                 if (tid->paused)    /* check next tid to keep h/w busy */
2445                         continue;
2446
2447                 if ((txq->axq_depth % 2) == 0)
2448                         ath_tx_sched_aggr(sc, txq, tid);
2449
2450                 /*
2451                  * add tid to round-robin queue if more frames
2452                  * are pending for the tid
2453                  */
2454                 if (!list_empty(&tid->buf_q))
2455                         ath_tx_queue_tid(txq, tid);
2456
2457                 /* only schedule one TID at a time */
2458                 break;
2459         } while (!list_empty(&ac->tid_q));
2460
2461         /*
2462          * schedule AC if more TIDs need processing
2463          */
2464         if (!list_empty(&ac->tid_q)) {
2465                 /*
2466                  * add dest ac to txq if not already added
2467                  */
2468                 if (!ac->sched) {
2469                         ac->sched = true;
2470                         list_add_tail(&ac->list, &txq->axq_acq);
2471                 }
2472         }
2473 }
2474
2475 /* Initialize per-node transmit state */
2476
2477 void ath_tx_node_init(struct ath_softc *sc, struct ath_node *an)
2478 {
2479         struct ath_atx_tid *tid;
2480         struct ath_atx_ac *ac;
2481         int tidno, acno;
2482
2483         /*
2484          * Init per tid tx state
2485          */
2486         for (tidno = 0, tid = &an->an_aggr.tx.tid[tidno];
2487              tidno < WME_NUM_TID;
2488              tidno++, tid++) {
2489                 tid->an        = an;
2490                 tid->tidno     = tidno;
2491                 tid->seq_start = tid->seq_next = 0;
2492                 tid->baw_size  = WME_MAX_BA;
2493                 tid->baw_head  = tid->baw_tail = 0;
2494                 tid->sched     = false;
2495                 tid->paused = false;
2496                 tid->state &= ~AGGR_CLEANUP;
2497                 INIT_LIST_HEAD(&tid->buf_q);
2498
2499                 acno = TID_TO_WME_AC(tidno);
2500                 tid->ac = &an->an_aggr.tx.ac[acno];
2501
2502                 /* ADDBA state */
2503                 tid->state &= ~AGGR_ADDBA_COMPLETE;
2504                 tid->state &= ~AGGR_ADDBA_PROGRESS;
2505                 tid->addba_exchangeattempts = 0;
2506         }
2507
2508         /*
2509          * Init per ac tx state
2510          */
2511         for (acno = 0, ac = &an->an_aggr.tx.ac[acno];
2512              acno < WME_NUM_AC; acno++, ac++) {
2513                 ac->sched    = false;
2514                 INIT_LIST_HEAD(&ac->tid_q);
2515
2516                 switch (acno) {
2517                 case WME_AC_BE:
2518                         ac->qnum = ath_tx_get_qnum(sc,
2519                                    ATH9K_TX_QUEUE_DATA, ATH9K_WME_AC_BE);
2520                         break;
2521                 case WME_AC_BK:
2522                         ac->qnum = ath_tx_get_qnum(sc,
2523                                    ATH9K_TX_QUEUE_DATA, ATH9K_WME_AC_BK);
2524                         break;
2525                 case WME_AC_VI:
2526                         ac->qnum = ath_tx_get_qnum(sc,
2527                                    ATH9K_TX_QUEUE_DATA, ATH9K_WME_AC_VI);
2528                         break;
2529                 case WME_AC_VO:
2530                         ac->qnum = ath_tx_get_qnum(sc,
2531                                    ATH9K_TX_QUEUE_DATA, ATH9K_WME_AC_VO);
2532                         break;
2533                 }
2534         }
2535 }
2536
2537 /* Cleanupthe pending buffers for the node. */
2538
2539 void ath_tx_node_cleanup(struct ath_softc *sc, struct ath_node *an)
2540 {
2541         int i;
2542         struct ath_atx_ac *ac, *ac_tmp;
2543         struct ath_atx_tid *tid, *tid_tmp;
2544         struct ath_txq *txq;
2545         for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
2546                 if (ATH_TXQ_SETUP(sc, i)) {
2547                         txq = &sc->sc_txq[i];
2548
2549                         spin_lock(&txq->axq_lock);
2550
2551                         list_for_each_entry_safe(ac,
2552                                         ac_tmp, &txq->axq_acq, list) {
2553                                 tid = list_first_entry(&ac->tid_q,
2554                                                 struct ath_atx_tid, list);
2555                                 if (tid && tid->an != an)
2556                                         continue;
2557                                 list_del(&ac->list);
2558                                 ac->sched = false;
2559
2560                                 list_for_each_entry_safe(tid,
2561                                                 tid_tmp, &ac->tid_q, list) {
2562                                         list_del(&tid->list);
2563                                         tid->sched = false;
2564                                         ath_tid_drain(sc, txq, tid);
2565                                         tid->state &= ~AGGR_ADDBA_COMPLETE;
2566                                         tid->addba_exchangeattempts = 0;
2567                                         tid->state &= ~AGGR_CLEANUP;
2568                                 }
2569                         }
2570
2571                         spin_unlock(&txq->axq_lock);
2572                 }
2573         }
2574 }
2575
2576 void ath_tx_cabq(struct ath_softc *sc, struct sk_buff *skb)
2577 {
2578         int hdrlen, padsize;
2579         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
2580         struct ath_tx_control txctl;
2581
2582         memset(&txctl, 0, sizeof(struct ath_tx_control));
2583
2584         /*
2585          * As a temporary workaround, assign seq# here; this will likely need
2586          * to be cleaned up to work better with Beacon transmission and virtual
2587          * BSSes.
2588          */
2589         if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
2590                 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
2591                 if (info->flags & IEEE80211_TX_CTL_FIRST_FRAGMENT)
2592                         sc->seq_no += 0x10;
2593                 hdr->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG);
2594                 hdr->seq_ctrl |= cpu_to_le16(sc->seq_no);
2595         }
2596
2597         /* Add the padding after the header if this is not already done */
2598         hdrlen = ieee80211_get_hdrlen_from_skb(skb);
2599         if (hdrlen & 3) {
2600                 padsize = hdrlen % 4;
2601                 if (skb_headroom(skb) < padsize) {
2602                         DPRINTF(sc, ATH_DBG_XMIT, "%s: TX CABQ padding "
2603                                 "failed\n", __func__);
2604                         dev_kfree_skb_any(skb);
2605                         return;
2606                 }
2607                 skb_push(skb, padsize);
2608                 memmove(skb->data, skb->data + padsize, hdrlen);
2609         }
2610
2611         txctl.txq = sc->sc_cabq;
2612
2613         DPRINTF(sc, ATH_DBG_XMIT, "%s: transmitting CABQ packet, skb: %p\n",
2614                 __func__,
2615                 skb);
2616
2617         if (ath_tx_start(sc, skb, &txctl) != 0) {
2618                 DPRINTF(sc, ATH_DBG_XMIT, "%s: TX failed\n", __func__);
2619                 goto exit;
2620         }
2621
2622         return;
2623 exit:
2624         dev_kfree_skb_any(skb);
2625 }