Update compat-wireless to 2.6.36-5-spn

chromeos/compat-wireless/drivers/net/wireless/ath/ath9k/xmit.c

 /*
  * Copyright (c) 2008-2009 Atheros Communications Inc.
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
  *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
@@ skipping 106 matching lines @@
 
         if (ac->sched)
                 return;
 
         ac->sched = true;
         list_add_tail(&ac->list, &txq->axq_acq);
 }
 
 static void ath_tx_resume_tid(struct ath_softc *sc, struct ath_atx_tid *tid)
 {
-        struct ath_txq *txq = &sc->tx.txq[tid->ac->qnum];
+        struct ath_txq *txq = tid->ac->txq;
 
         WARN_ON(!tid->paused);
 
         spin_lock_bh(&txq->axq_lock);
         tid->paused = false;
 
         if (list_empty(&tid->buf_q))
                 goto unlock;
 
         ath_tx_queue_tid(txq, tid);
         ath_txq_schedule(sc, txq);
 unlock:
         spin_unlock_bh(&txq->axq_lock);
 }
 
 static void ath_tx_flush_tid(struct ath_softc *sc, struct ath_atx_tid *tid)
 {
-        struct ath_txq *txq = &sc->tx.txq[tid->ac->qnum];
+        struct ath_txq *txq = tid->ac->txq;
         struct ath_buf *bf;
         struct list_head bf_head;
         struct ath_tx_status ts;
 
         INIT_LIST_HEAD(&bf_head);
 
         memset(&ts, 0, sizeof(ts));
         spin_lock_bh(&txq->axq_lock);
 
         while (!list_empty(&tid->buf_q)) {
@@ skipping 12 matching lines @@
 }
 
 static void ath_tx_update_baw(struct ath_softc *sc, struct ath_atx_tid *tid,
                               int seqno)
 {
         int index, cindex;
 
         index  = ATH_BA_INDEX(tid->seq_start, seqno);
         cindex = (tid->baw_head + index) & (ATH_TID_MAX_BUFS - 1);
 
-        __clear_bit(cindex, tid->tx_buf);
+        tid->tx_buf[cindex] = NULL;
 
-        while (tid->baw_head != tid->baw_tail && !test_bit(tid->baw_head, tid->tx_buf)) {
+        while (tid->baw_head != tid->baw_tail && !tid->tx_buf[tid->baw_head]) {
                 INCR(tid->seq_start, IEEE80211_SEQ_MAX);
                 INCR(tid->baw_head, ATH_TID_MAX_BUFS);
         }
 }
 
 static void ath_tx_addto_baw(struct ath_softc *sc, struct ath_atx_tid *tid,
                              struct ath_buf *bf)
 {
         int index, cindex;
 
         if (bf_isretried(bf))
                 return;
 
         index  = ATH_BA_INDEX(tid->seq_start, bf->bf_seqno);
         cindex = (tid->baw_head + index) & (ATH_TID_MAX_BUFS - 1);
-        __set_bit(cindex, tid->tx_buf);
+
+        BUG_ON(tid->tx_buf[cindex] != NULL);
+        tid->tx_buf[cindex] = bf;
 
         if (index >= ((tid->baw_tail - tid->baw_head) &
                 (ATH_TID_MAX_BUFS - 1))) {
                 tid->baw_tail = cindex;
                 INCR(tid->baw_tail, ATH_TID_MAX_BUFS);
         }
 }
 
 /*
  * TODO: For frame(s) that are in the retry state, we will reuse the
@@ skipping 103 matching lines @@
         struct ieee80211_hdr *hdr;
         struct ieee80211_tx_info *tx_info;
         struct ath_atx_tid *tid = NULL;
         struct ath_buf *bf_next, *bf_last = bf->bf_lastbf;
         struct list_head bf_head, bf_pending;
         u16 seq_st = 0, acked_cnt = 0, txfail_cnt = 0;
         u32 ba[WME_BA_BMP_SIZE >> 5];
         int isaggr, txfail, txpending, sendbar = 0, needreset = 0, nbad = 0;
         bool rc_update = true;
         struct ieee80211_tx_rate rates[4];
+        int nframes;
 
         skb = bf->bf_mpdu;
         hdr = (struct ieee80211_hdr *)skb->data;
 
         tx_info = IEEE80211_SKB_CB(skb);
         hw = bf->aphy->hw;
 
         memcpy(rates, tx_info->control.rates, sizeof(rates));
+        nframes = bf->bf_nframes;
 
         rcu_read_lock();
 
         /* XXX: use ieee80211_find_sta! */
         sta = ieee80211_find_sta_by_hw(hw, hdr->addr1);
         if (!sta) {
                 rcu_read_unlock();
 
                 INIT_LIST_HEAD(&bf_head);
                 while (bf) {
                         bf_next = bf->bf_next;
 
                         bf->bf_state.bf_type |= BUF_XRETRY;
                         if ((sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) ||
                             !bf->bf_stale || bf_next != NULL)
                                 list_move_tail(&bf->list, &bf_head);
 
-                        ath_tx_rc_status(bf, ts, 0, 0, false);
+                        ath_tx_rc_status(bf, ts, 1, 0, false);
                         ath_tx_complete_buf(sc, bf, txq, &bf_head, ts,
                                 0, 0);
 
                         bf = bf_next;
                 }
                 return;
         }
 
         an = (struct ath_node *)sta->drv_priv;
         tid = ATH_AN_2_TID(an, bf->bf_tidno);
@@ skipping 84 matching lines @@
                         /*
                          * complete the acked-ones/xretried ones; update
                          * block-ack window
                          */
                         spin_lock_bh(&txq->axq_lock);
                         ath_tx_update_baw(sc, tid, bf->bf_seqno);
                         spin_unlock_bh(&txq->axq_lock);
 
                         if (rc_update && (acked_cnt == 1 || txfail_cnt == 1)) {
                                 memcpy(tx_info->control.rates, rates, sizeof(rates));
+                                bf->bf_nframes = nframes;
                                 ath_tx_rc_status(bf, ts, nbad, txok, true);
                                 rc_update = false;
                         } else {
                                 ath_tx_rc_status(bf, ts, nbad, txok, false);
                         }
 
                         ath_tx_complete_buf(sc, bf, txq, &bf_head, ts,
                                 !txfail, sendbar);
                 } else {
                         /* retry the un-acked ones */
@@ skipping 343 matching lines @@
         txtid->paused = true;
         *ssn = txtid->seq_start;
 
         return 0;
 }
 
 void ath_tx_aggr_stop(struct ath_softc *sc, struct ieee80211_sta *sta, u16 tid)
 {
         struct ath_node *an = (struct ath_node *)sta->drv_priv;
         struct ath_atx_tid *txtid = ATH_AN_2_TID(an, tid);
-        struct ath_txq *txq = &sc->tx.txq[txtid->ac->qnum];
+        struct ath_txq *txq = txtid->ac->txq;
 
         if (txtid->state & AGGR_CLEANUP)
                 return;
 
         if (!(txtid->state & AGGR_ADDBA_COMPLETE)) {
                 txtid->state &= ~AGGR_ADDBA_PROGRESS;
                 return;
         }
 
         spin_lock_bh(&txq->axq_lock);
@@ skipping 24 matching lines @@
         if (sc->sc_flags & SC_OP_TXAGGR) {
                 txtid = ATH_AN_2_TID(an, tid);
                 txtid->baw_size =
                         IEEE80211_MIN_AMPDU_BUF << sta->ht_cap.ampdu_factor;
                 txtid->state |= AGGR_ADDBA_COMPLETE;
                 txtid->state &= ~AGGR_ADDBA_PROGRESS;
                 ath_tx_resume_tid(sc, txtid);
         }
 }
 
+bool ath_tx_aggr_check(struct ath_softc *sc, struct ath_node *an, u8 tidno)
+{
+        struct ath_atx_tid *txtid;
+
+        if (!(sc->sc_flags & SC_OP_TXAGGR))
+                return false;
+
+        txtid = ATH_AN_2_TID(an, tidno);
+
+        if (!(txtid->state & (AGGR_ADDBA_COMPLETE | AGGR_ADDBA_PROGRESS)))
+                        return true;
+        return false;
+}
+
 /********************/
 /* Queue Management */
 /********************/
 
 static void ath_txq_drain_pending_buffers(struct ath_softc *sc,
                                           struct ath_txq *txq)
 {
         struct ath_atx_ac *ac, *ac_tmp;
         struct ath_atx_tid *tid, *tid_tmp;
 
         list_for_each_entry_safe(ac, ac_tmp, &txq->axq_acq, list) {
                 list_del(&ac->list);
                 ac->sched = false;
                 list_for_each_entry_safe(tid, tid_tmp, &ac->tid_q, list) {
                         list_del(&tid->list);
                         tid->sched = false;
                         ath_tid_drain(sc, txq, tid);
                 }
         }
 }
 
 struct ath_txq *ath_txq_setup(struct ath_softc *sc, int qtype, int subtype)
 {
         struct ath_hw *ah = sc->sc_ah;
         struct ath_common *common = ath9k_hw_common(ah);
         struct ath9k_tx_queue_info qi;
+        static const int subtype_txq_to_hwq[] = {
+                [WME_AC_BE] = ATH_TXQ_AC_BE,
+                [WME_AC_BK] = ATH_TXQ_AC_BK,
+                [WME_AC_VI] = ATH_TXQ_AC_VI,
+                [WME_AC_VO] = ATH_TXQ_AC_VO,
+        };
         int qnum, i;
 
         memset(&qi, 0, sizeof(qi));
-        qi.tqi_subtype = subtype;
+        qi.tqi_subtype = subtype_txq_to_hwq[subtype];
         qi.tqi_aifs = ATH9K_TXQ_USEDEFAULT;
         qi.tqi_cwmin = ATH9K_TXQ_USEDEFAULT;
         qi.tqi_cwmax = ATH9K_TXQ_USEDEFAULT;
         qi.tqi_physCompBuf = 0;
 
         /*
          * Enable interrupts only for EOL and DESC conditions.
          * We mark tx descriptors to receive a DESC interrupt
          * when a tx queue gets deep; otherwise waiting for the
          * EOL to reap descriptors.  Note that this is done to
@@ skipping 28 matching lines @@
         if (qnum >= ARRAY_SIZE(sc->tx.txq)) {
                 ath_print(common, ATH_DBG_FATAL,
                           "qnum %u out of range, max %u!\n",
                           qnum, (unsigned int)ARRAY_SIZE(sc->tx.txq));
                 ath9k_hw_releasetxqueue(ah, qnum);
                 return NULL;
         }
         if (!ATH_TXQ_SETUP(sc, qnum)) {
                 struct ath_txq *txq = &sc->tx.txq[qnum];
 
-                txq->axq_class = subtype;
                 txq->axq_qnum = qnum;
                 txq->axq_link = NULL;
                 INIT_LIST_HEAD(&txq->axq_q);
                 INIT_LIST_HEAD(&txq->axq_acq);
                 spin_lock_init(&txq->axq_lock);
                 txq->axq_depth = 0;
                 txq->axq_tx_inprogress = false;
                 sc->tx.txqsetup |= 1<<qnum;
 
                 txq->txq_headidx = txq->txq_tailidx = 0;
@@ skipping 128 matching lines @@
                 if (bf_isampdu(bf))
                         ath_tx_complete_aggr(sc, txq, bf, &bf_head, &ts, 0);
                 else
                         ath_tx_complete_buf(sc, bf, txq, &bf_head, &ts, 0, 0);
         }
 
         spin_lock_bh(&txq->axq_lock);
         txq->axq_tx_inprogress = false;
         spin_unlock_bh(&txq->axq_lock);
 
-        /* flush any pending frames if aggregation is enabled */
-        if (sc->sc_flags & SC_OP_TXAGGR) {
-                if (!retry_tx) {
-                        spin_lock_bh(&txq->axq_lock);
-                        ath_txq_drain_pending_buffers(sc, txq);
-                        spin_unlock_bh(&txq->axq_lock);
-                }
-        }
-
         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) {
                 spin_lock_bh(&txq->axq_lock);
                 while (!list_empty(&txq->txq_fifo_pending)) {
                         bf = list_first_entry(&txq->txq_fifo_pending,
                                               struct ath_buf, list);
                         list_cut_position(&bf_head,
                                           &txq->txq_fifo_pending,
                                           &bf->bf_lastbf->list);
                         spin_unlock_bh(&txq->axq_lock);
 
                         if (bf_isampdu(bf))
                                 ath_tx_complete_aggr(sc, txq, bf, &bf_head,
                                                      &ts, 0);
                         else
                                 ath_tx_complete_buf(sc, bf, txq, &bf_head,
                                                     &ts, 0, 0);
                         spin_lock_bh(&txq->axq_lock);
                 }
                 spin_unlock_bh(&txq->axq_lock);
         }
+
+        /* flush any pending frames if aggregation is enabled */
+        if (sc->sc_flags & SC_OP_TXAGGR) {
+                if (!retry_tx) {
+                        spin_lock_bh(&txq->axq_lock);
+                        ath_txq_drain_pending_buffers(sc, txq);
+                        spin_unlock_bh(&txq->axq_lock);
+                }
+        }
 }
 
 void ath_drain_all_txq(struct ath_softc *sc, bool retry_tx)
 {
         struct ath_hw *ah = sc->sc_ah;
         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
         struct ath_txq *txq;
         int i, npend = 0;
 
         if (sc->sc_flags & SC_OP_INVALID)
@@ skipping 72 matching lines @@
         } while (!list_empty(&ac->tid_q));
 
         if (!list_empty(&ac->tid_q)) {
                 if (!ac->sched) {
                         ac->sched = true;
                         list_add_tail(&ac->list, &txq->axq_acq);
                 }
         }
 }
 
-int ath_tx_setup(struct ath_softc *sc, int haltype)
-{
-        struct ath_txq *txq;
-
-        if (haltype >= ARRAY_SIZE(sc->tx.hwq_map)) {
-                ath_print(ath9k_hw_common(sc->sc_ah), ATH_DBG_FATAL,
-                          "HAL AC %u out of range, max %zu!\n",
-                         haltype, ARRAY_SIZE(sc->tx.hwq_map));
-                return 0;
-        }
-        txq = ath_txq_setup(sc, ATH9K_TX_QUEUE_DATA, haltype);
-        if (txq != NULL) {
-                sc->tx.hwq_map[haltype] = txq->axq_qnum;
-                return 1;
-        } else
-                return 0;
-}
-
 /***********/
 /* TX, DMA */
 /***********/
 
 /*
  * Insert a chain of ath_buf (descriptors) on a txq and
  * assume the descriptors are already chained together by caller.
  */
 static void ath_tx_txqaddbuf(struct ath_softc *sc, struct ath_txq *txq,
                              struct list_head *head)
@@ skipping 484 matching lines @@
         if (bf_isht(bf) && (sc->sc_flags & SC_OP_TXAGGR) &&
             tx_info->control.sta) {
                 an = (struct ath_node *)tx_info->control.sta->drv_priv;
                 tid = ATH_AN_2_TID(an, bf->bf_tidno);
 
                 if (!ieee80211_is_data_qos(fc)) {
                         ath_tx_send_normal(sc, txctl->txq, &bf_head);
                         goto tx_done;
                 }
 
+                WARN_ON(tid->ac->txq != txctl->txq);
                 if (tx_info->flags & IEEE80211_TX_CTL_AMPDU) {
                         /*
                          * Try aggregation if it's a unicast data frame
                          * and the destination is HT capable.
                          */
                         ath_tx_send_ampdu(sc, tid, &bf_head, txctl);
                 } else {
                         /*
                          * Send this frame as regular when ADDBA
                          * exchange is neither complete nor pending.
@@ skipping 19 matching lines @@
         struct ath_txq *txq = txctl->txq;
         struct ath_buf *bf;
         int q, r;
 
         bf = ath_tx_get_buffer(sc);
         if (!bf) {
                 ath_print(common, ATH_DBG_XMIT, "TX buffers are full\n");
                 return -1;
         }
 
+        q = skb_get_queue_mapping(skb);
         r = ath_tx_setup_buffer(hw, bf, skb, txctl);
         if (unlikely(r)) {
                 ath_print(common, ATH_DBG_FATAL, "TX mem alloc failure\n");
 
                 /* upon ath_tx_processq() this TX queue will be resumed, we
                  * guarantee this will happen by knowing beforehand that
                  * we will at least have to run TX completionon one buffer
                  * on the queue */
                 spin_lock_bh(&txq->axq_lock);
-                if (!txq->stopped && txq->axq_depth > 1) {
-                        ath_mac80211_stop_queue(sc, skb_get_queue_mapping(skb));
+                if (txq == sc->tx.txq_map[q] && !txq->stopped &&
+                    txq->axq_depth > 1) {
+                        ath_mac80211_stop_queue(sc, q);
                         txq->stopped = 1;
                 }
                 spin_unlock_bh(&txq->axq_lock);
 
                 ath_tx_return_buffer(sc, bf);
 
                 return r;
         }
 
-        q = skb_get_queue_mapping(skb);
-        if (q >= 4)
-                q = 0;
-
         spin_lock_bh(&txq->axq_lock);
-        if (++sc->tx.pending_frames[q] > ATH_MAX_QDEPTH && !txq->stopped) {
-                ath_mac80211_stop_queue(sc, skb_get_queue_mapping(skb));
+        if (txq == sc->tx.txq_map[q] &&
+            ++txq->pending_frames > ATH_MAX_QDEPTH && !txq->stopped) {
+                ath_mac80211_stop_queue(sc, q);
                 txq->stopped = 1;
         }
         spin_unlock_bh(&txq->axq_lock);
 
         ath_tx_start_dma(sc, bf, txctl);
 
         return 0;
 }
 
 void ath_tx_cabq(struct ieee80211_hw *hw, struct sk_buff *skb)
@@ skipping 47 matching lines @@
         return;
 exit:
         dev_kfree_skb_any(skb);
 }
 
 /*****************/
 /* TX Completion */
 /*****************/
 
 static void ath_tx_complete(struct ath_softc *sc, struct sk_buff *skb,
-                            struct ath_wiphy *aphy, int tx_flags)
+                            struct ath_wiphy *aphy, int tx_flags,
+                            struct ath_txq *txq)
 {
         struct ieee80211_hw *hw = sc->hw;
         struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
         struct ieee80211_hdr * hdr = (struct ieee80211_hdr *)skb->data;
         int q, padpos, padsize;
 
         ath_print(common, ATH_DBG_XMIT, "TX complete: skb: %p\n", skb);
 
         if (aphy)
@@ skipping 26 matching lines @@
                         sc->ps_flags & (PS_WAIT_FOR_BEACON |
                                         PS_WAIT_FOR_CAB |
                                         PS_WAIT_FOR_PSPOLL_DATA |
                                         PS_WAIT_FOR_TX_ACK));
         }
 
         if (unlikely(tx_info->pad[0] & ATH_TX_INFO_FRAME_TYPE_INTERNAL))
                 ath9k_tx_status(hw, skb);
         else {
                 q = skb_get_queue_mapping(skb);
-                if (q >= 4)
-                        q = 0;
-
-                if (--sc->tx.pending_frames[q] < 0)
-                        sc->tx.pending_frames[q] = 0;
+                if (txq == sc->tx.txq_map[q]) {
+                        spin_lock_bh(&txq->axq_lock);
+                        if (WARN_ON(--txq->pending_frames < 0))
+                                txq->pending_frames = 0;
+                        spin_unlock_bh(&txq->axq_lock);
+                }
 
                 ieee80211_tx_status(hw, skb);
         }
 }
 
 static void ath_tx_complete_buf(struct ath_softc *sc, struct ath_buf *bf,
                                 struct ath_txq *txq, struct list_head *bf_q,
                                 struct ath_tx_status *ts, int txok, int sendbar)
 {
         struct sk_buff *skb = bf->bf_mpdu;
@@ skipping 13 matching lines @@
         dma_unmap_single(sc->dev, bf->bf_dmacontext, skb->len, DMA_TO_DEVICE);
 
         if (bf->bf_state.bfs_paprd) {
                 if (time_after(jiffies,
                                bf->bf_state.bfs_paprd_timestamp +
                                msecs_to_jiffies(ATH_PAPRD_TIMEOUT)))
                         dev_kfree_skb_any(skb);
                 else
                         complete(&sc->paprd_complete);
         } else {
-                ath_tx_complete(sc, skb, bf->aphy, tx_flags);
-                ath_debug_stat_tx(sc, txq, bf, ts);
+                ath_debug_stat_tx(sc, bf, ts);
+                ath_tx_complete(sc, skb, bf->aphy, tx_flags, txq);
+
         }
 
         /*
          * Return the list of ath_buf of this mpdu to free queue
          */
         spin_lock_irqsave(&sc->tx.txbuflock, flags);
         list_splice_tail_init(bf_q, &sc->tx.txbuf);
         spin_unlock_irqrestore(&sc->tx.txbuflock, flags);
 }
 
@@ skipping 36 matching lines @@
         u8 i, tx_rateindex;
 
         if (txok)
                 tx_info->status.ack_signal = ts->ts_rssi;
 
         tx_rateindex = ts->ts_rateindex;
         WARN_ON(tx_rateindex >= hw->max_rates);
 
         if (ts->ts_status & ATH9K_TXERR_FILT)
                 tx_info->flags |= IEEE80211_TX_STAT_TX_FILTERED;
-        if ((tx_info->flags & IEEE80211_TX_CTL_AMPDU) && update_rc)
+        if ((tx_info->flags & IEEE80211_TX_CTL_AMPDU) && update_rc) {
                 tx_info->flags |= IEEE80211_TX_STAT_AMPDU;
 
+                BUG_ON(nbad > bf->bf_nframes);
+
+                tx_info->status.ampdu_len = bf->bf_nframes;
+                tx_info->status.ampdu_ack_len = bf->bf_nframes - nbad;
+        }
+
         if ((ts->ts_status & ATH9K_TXERR_FILT) == 0 &&
             (bf->bf_flags & ATH9K_TXDESC_NOACK) == 0 && update_rc) {
                 if (ieee80211_is_data(hdr->frame_control)) {
                         if (ts->ts_flags &
                             (ATH9K_TX_DATA_UNDERRUN | ATH9K_TX_DELIM_UNDERRUN))
                                 tx_info->pad[0] |= ATH_TX_INFO_UNDERRUN;
                         if ((ts->ts_status & ATH9K_TXERR_XRETRY) ||
                             (ts->ts_status & ATH9K_TXERR_FIFO))
                                 tx_info->pad[0] |= ATH_TX_INFO_XRETRY;
-                        tx_info->status.ampdu_len = bf->bf_nframes;
-                        tx_info->status.ampdu_ack_len = bf->bf_nframes - nbad;
                 }
         }
 
         for (i = tx_rateindex + 1; i < hw->max_rates; i++) {
                 tx_info->status.rates[i].count = 0;
                 tx_info->status.rates[i].idx = -1;
         }
 
         tx_info->status.rates[tx_rateindex].count = ts->ts_longretry + 1;
 }
 
-static void ath_wake_mac80211_queue(struct ath_softc *sc, struct ath_txq *txq)
+static void ath_wake_mac80211_queue(struct ath_softc *sc, int qnum)
 {
-        int qnum;
+        struct ath_txq *txq;
 
-        qnum = ath_get_mac80211_qnum(txq->axq_class, sc);
-        if (qnum == -1)
-                return;
-
+        txq = sc->tx.txq_map[qnum];
         spin_lock_bh(&txq->axq_lock);
-        if (txq->stopped && sc->tx.pending_frames[qnum] < ATH_MAX_QDEPTH) {
+        if (txq->stopped && txq->pending_frames < ATH_MAX_QDEPTH) {
                 if (ath_mac80211_start_queue(sc, qnum))
                         txq->stopped = 0;
         }
         spin_unlock_bh(&txq->axq_lock);
 }
 
 static void ath_tx_processq(struct ath_softc *sc, struct ath_txq *txq)
 {
         struct ath_hw *ah = sc->sc_ah;
         struct ath_common *common = ath9k_hw_common(ah);
         struct ath_buf *bf, *lastbf, *bf_held = NULL;
         struct list_head bf_head;
         struct ath_desc *ds;
         struct ath_tx_status ts;
         int txok;
         int status;
+        int qnum;
 
         ath_print(common, ATH_DBG_QUEUE, "tx queue %d (%x), link %p\n",
                   txq->axq_qnum, ath9k_hw_gettxbuf(sc->sc_ah, txq->axq_qnum),
                   txq->axq_link);
 
         for (;;) {
                 spin_lock_bh(&txq->axq_lock);
                 if (list_empty(&txq->axq_q)) {
                         txq->axq_link = NULL;
                         spin_unlock_bh(&txq->axq_lock);
@@ skipping 64 matching lines @@
                 if (bf_held)
                         ath_tx_return_buffer(sc, bf_held);
 
                 if (!bf_isampdu(bf)) {
                         /*
                          * This frame is sent out as a single frame.
                          * Use hardware retry status for this frame.
                          */
                         if (ts.ts_status & ATH9K_TXERR_XRETRY)
                                 bf->bf_state.bf_type |= BUF_XRETRY;
-                        ath_tx_rc_status(bf, &ts, 0, txok, true);
+                        ath_tx_rc_status(bf, &ts, txok ? 0 : 1, txok, true);
                 }
 
+                qnum = skb_get_queue_mapping(bf->bf_mpdu);
+
                 if (bf_isampdu(bf))
                         ath_tx_complete_aggr(sc, txq, bf, &bf_head, &ts, txok);
                 else
                         ath_tx_complete_buf(sc, bf, txq, &bf_head, &ts, txok, 0);
 
-                ath_wake_mac80211_queue(sc, txq);
+                if (txq == sc->tx.txq_map[qnum])
+                        ath_wake_mac80211_queue(sc, qnum);
 
                 spin_lock_bh(&txq->axq_lock);
                 if (sc->sc_flags & SC_OP_TXAGGR)
                         ath_txq_schedule(sc, txq);
                 spin_unlock_bh(&txq->axq_lock);
         }
 }
 
 static void ath_tx_complete_poll_work(struct work_struct *work)
 {
@@ skipping 16 matching lines @@
                                         txq->axq_tx_inprogress = true;
                                 }
                         }
                         spin_unlock_bh(&txq->axq_lock);
                 }
 
         if (needreset) {
                 ath_print(ath9k_hw_common(sc->sc_ah), ATH_DBG_RESET,
                           "tx hung, resetting the chip\n");
                 ath9k_ps_wakeup(sc);
-                ath_reset(sc, false);
+                ath_reset(sc, true);
                 ath9k_ps_restore(sc);
         }
 
         ieee80211_queue_delayed_work(sc->hw, &sc->tx_complete_work,
                         msecs_to_jiffies(ATH_TX_COMPLETE_POLL_INT));
 }
 
 
 
 void ath_tx_tasklet(struct ath_softc *sc)
@@ skipping 12 matching lines @@
 void ath_tx_edma_tasklet(struct ath_softc *sc)
 {
         struct ath_tx_status txs;
         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
         struct ath_hw *ah = sc->sc_ah;
         struct ath_txq *txq;
         struct ath_buf *bf, *lastbf;
         struct list_head bf_head;
         int status;
         int txok;
+        int qnum;
 
         for (;;) {
                 status = ath9k_hw_txprocdesc(ah, NULL, (void *)&txs);
                 if (status == -EINPROGRESS)
                         break;
                 if (status == -EIO) {
                         ath_print(common, ATH_DBG_XMIT,
                                   "Error processing tx status\n");
                         break;
                 }
@@ skipping 31 matching lines @@
                 if (bf->bf_isnullfunc && txok) {
                         if ((sc->ps_flags & PS_ENABLED))
                                 ath9k_enable_ps(sc);
                         else
                                 sc->ps_flags |= PS_NULLFUNC_COMPLETED;
                 }
 
                 if (!bf_isampdu(bf)) {
                         if (txs.ts_status & ATH9K_TXERR_XRETRY)
                                 bf->bf_state.bf_type |= BUF_XRETRY;
-                        ath_tx_rc_status(bf, &txs, 0, txok, true);
+                        ath_tx_rc_status(bf, &txs, txok ? 0 : 1, txok, true);
                 }
 
+                qnum = skb_get_queue_mapping(bf->bf_mpdu);
+
                 if (bf_isampdu(bf))
                         ath_tx_complete_aggr(sc, txq, bf, &bf_head, &txs, txok);
                 else
                         ath_tx_complete_buf(sc, bf, txq, &bf_head,
                                             &txs, txok, 0);
 
-                ath_wake_mac80211_queue(sc, txq);
+                if (txq == sc->tx.txq_map[qnum])
+                        ath_wake_mac80211_queue(sc, qnum);
 
                 spin_lock_bh(&txq->axq_lock);
                 if (!list_empty(&txq->txq_fifo_pending)) {
                         INIT_LIST_HEAD(&bf_head);
                         bf = list_first_entry(&txq->txq_fifo_pending,
                                 struct ath_buf, list);
                         list_cut_position(&bf_head, &txq->txq_fifo_pending,
                                 &bf->bf_lastbf->list);
                         ath_tx_txqaddbuf(sc, txq, &bf_head);
                 } else if (sc->sc_flags & SC_OP_TXAGGR)
@@ skipping 111 matching lines @@
                 INIT_LIST_HEAD(&tid->buf_q);
                 acno = TID_TO_WME_AC(tidno);
                 tid->ac = &an->ac[acno];
                 tid->state &= ~AGGR_ADDBA_COMPLETE;
                 tid->state &= ~AGGR_ADDBA_PROGRESS;
         }
 
         for (acno = 0, ac = &an->ac[acno];
              acno < WME_NUM_AC; acno++, ac++) {
                 ac->sched    = false;
-                ac->qnum = sc->tx.hwq_map[acno];
+                ac->txq = sc->tx.txq_map[acno];
                 INIT_LIST_HEAD(&ac->tid_q);
         }
 }
 
 void ath_tx_node_cleanup(struct ath_softc *sc, struct ath_node *an)
 {
         struct ath_atx_ac *ac;
         struct ath_atx_tid *tid;
         struct ath_txq *txq;
-        int i, tidno;
+        int tidno;
 
         for (tidno = 0, tid = &an->tid[tidno];
              tidno < WME_NUM_TID; tidno++, tid++) {
-                i = tid->ac->qnum;
 
-                if (!ATH_TXQ_SETUP(sc, i))
-                        continue;
-
-                txq = &sc->tx.txq[i];
                 ac = tid->ac;
+                txq = ac->txq;
 
                 spin_lock_bh(&txq->axq_lock);
 
                 if (tid->sched) {
                         list_del(&tid->list);
                         tid->sched = false;
                 }
 
                 if (ac->sched) {
                         list_del(&ac->list);
                         tid->ac->sched = false;
                 }
 
                 ath_tid_drain(sc, txq, tid);
                 tid->state &= ~AGGR_ADDBA_COMPLETE;
                 tid->state &= ~AGGR_CLEANUP;
 
                 spin_unlock_bh(&txq->axq_lock);
         }
 }