source: trunk/package/mac80211/patches/541-ath9k_aggr_queue_cleanup.patch @ 27958

Last change on this file since 27958 was 27958, checked in by nbd, 5 years ago

mac80211: update to 2011-08-10

File size: 8.4 KB
  • drivers/net/wireless/ath/ath9k/ath9k.h

    a b struct ath_atx_ac { 
    206206}; 
    207207 
    208208struct ath_frame_info { 
     209        struct ath_buf *bf; 
    209210        int framelen; 
    210211        u32 keyix; 
    211212        enum ath9k_key_type keytype; 
    struct ath_buf { 
    235236 
    236237struct ath_atx_tid { 
    237238        struct list_head list; 
    238         struct list_head buf_q; 
     239        struct sk_buff_head buf_q; 
    239240        struct ath_node *an; 
    240241        struct ath_atx_ac *ac; 
    241242        unsigned long tx_buf[BITS_TO_LONGS(ATH_TID_MAX_BUFS)]; 
  • drivers/net/wireless/ath/ath9k/debug.c

    a b static ssize_t read_file_stations(struct 
    711711                                        " tid: %p %s %s %i %p %p\n", 
    712712                                        tid, tid->sched ? "sched" : "idle", 
    713713                                        tid->paused ? "paused" : "running", 
    714                                         list_empty(&tid->buf_q), 
     714                                        skb_queue_empty(&tid->buf_q), 
    715715                                        tid->an, tid->ac); 
    716716                        if (len >= size) 
    717717                                goto done; 
  • drivers/net/wireless/ath/ath9k/xmit.c

    a b static void ath_tx_resume_tid(struct ath 
    129129        spin_lock_bh(&txq->axq_lock); 
    130130        tid->paused = false; 
    131131 
    132         if (list_empty(&tid->buf_q)) 
     132        if (skb_queue_empty(&tid->buf_q)) 
    133133                goto unlock; 
    134134 
    135135        ath_tx_queue_tid(txq, tid); 
    static struct ath_frame_info *get_frame_ 
    149149static void ath_tx_flush_tid(struct ath_softc *sc, struct ath_atx_tid *tid) 
    150150{ 
    151151        struct ath_txq *txq = tid->ac->txq; 
     152        struct sk_buff *skb; 
    152153        struct ath_buf *bf; 
    153154        struct list_head bf_head; 
    154155        struct ath_tx_status ts; 
    static void ath_tx_flush_tid(struct ath_ 
    159160        memset(&ts, 0, sizeof(ts)); 
    160161        spin_lock_bh(&txq->axq_lock); 
    161162 
    162         while (!list_empty(&tid->buf_q)) { 
    163                 bf = list_first_entry(&tid->buf_q, struct ath_buf, list); 
    164                 list_move_tail(&bf->list, &bf_head); 
     163        while ((skb = __skb_dequeue(&tid->buf_q))) { 
     164                fi = get_frame_info(skb); 
     165                bf = fi->bf; 
     166 
     167                list_add_tail(&bf->list, &bf_head); 
    165168 
    166169                spin_unlock_bh(&txq->axq_lock); 
    167                 fi = get_frame_info(bf->bf_mpdu); 
    168170                if (fi->retries) { 
    169171                        ath_tx_update_baw(sc, tid, fi->seqno); 
    170172                        ath_tx_complete_buf(sc, bf, txq, &bf_head, &ts, 0, 1); 
    static void ath_tid_drain(struct ath_sof 
    219221                          struct ath_atx_tid *tid) 
    220222 
    221223{ 
     224        struct sk_buff *skb; 
    222225        struct ath_buf *bf; 
    223226        struct list_head bf_head; 
    224227        struct ath_tx_status ts; 
    static void ath_tid_drain(struct ath_sof 
    227230        memset(&ts, 0, sizeof(ts)); 
    228231        INIT_LIST_HEAD(&bf_head); 
    229232 
    230         for (;;) { 
    231                 if (list_empty(&tid->buf_q)) 
    232                         break; 
     233        while ((skb = __skb_dequeue(&tid->buf_q))) { 
     234                fi = get_frame_info(skb); 
     235                bf = fi->bf; 
    233236 
    234                 bf = list_first_entry(&tid->buf_q, struct ath_buf, list); 
    235                 list_move_tail(&bf->list, &bf_head); 
     237                list_add_tail(&bf->list, &bf_head); 
    236238 
    237                 fi = get_frame_info(bf->bf_mpdu); 
    238239                if (fi->retries) 
    239240                        ath_tx_update_baw(sc, tid, fi->seqno); 
    240241 
    static void ath_tx_complete_aggr(struct  
    352353        struct ieee80211_tx_info *tx_info; 
    353354        struct ath_atx_tid *tid = NULL; 
    354355        struct ath_buf *bf_next, *bf_last = bf->bf_lastbf; 
    355         struct list_head bf_head, bf_pending; 
     356        struct list_head bf_head; 
     357        struct sk_buff_head bf_pending; 
    356358        u16 seq_st = 0, acked_cnt = 0, txfail_cnt = 0; 
    357359        u32 ba[WME_BA_BMP_SIZE >> 5]; 
    358360        int isaggr, txfail, txpending, sendbar = 0, needreset = 0, nbad = 0; 
    static void ath_tx_complete_aggr(struct  
    430432                } 
    431433        } 
    432434 
    433         INIT_LIST_HEAD(&bf_pending); 
    434         INIT_LIST_HEAD(&bf_head); 
     435        __skb_queue_head_init(&bf_pending); 
    435436 
    436437        ath_tx_count_frames(sc, bf, ts, txok, &nframes, &nbad); 
    437438        while (bf) { 
    static void ath_tx_complete_aggr(struct  
    476477                 * Make sure the last desc is reclaimed if it 
    477478                 * not a holding desc. 
    478479                 */ 
    479                 if (!bf_last->bf_stale || bf_next != NULL) 
     480                INIT_LIST_HEAD(&bf_head); 
     481                if ((sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) || 
     482                    bf_next != NULL || !bf_last->bf_stale) 
    480483                        list_move_tail(&bf->list, &bf_head); 
    481                 else 
    482                         INIT_LIST_HEAD(&bf_head); 
    483484 
    484485                if (!txpending || (tid->state & AGGR_CLEANUP)) { 
    485486                        /* 
    static void ath_tx_complete_aggr(struct  
    530531 
    531532                                        ath9k_hw_cleartxdesc(sc->sc_ah, 
    532533                                                             tbf->bf_desc); 
    533                                         list_add_tail(&tbf->list, &bf_head); 
     534                                        fi->bf = tbf; 
    534535                                } else { 
    535536                                        /* 
    536537                                         * Clear descriptor status words for 
    static void ath_tx_complete_aggr(struct  
    545546                         * Put this buffer to the temporary pending 
    546547                         * queue to retain ordering 
    547548                         */ 
    548                         list_splice_tail_init(&bf_head, &bf_pending); 
     549                        __skb_queue_tail(&bf_pending, skb); 
    549550                } 
    550551 
    551552                bf = bf_next; 
    552553        } 
    553554 
    554555        /* prepend un-acked frames to the beginning of the pending frame queue */ 
    555         if (!list_empty(&bf_pending)) { 
     556        if (!skb_queue_empty(&bf_pending)) { 
    556557                if (an->sleeping) 
    557558                        ieee80211_sta_set_tim(sta); 
    558559 
    559560                spin_lock_bh(&txq->axq_lock); 
    560561                if (clear_filter) 
    561562                        tid->ac->clear_ps_filter = true; 
    562                 list_splice(&bf_pending, &tid->buf_q); 
     563                skb_queue_splice(&bf_pending, &tid->buf_q); 
    563564                if (!an->sleeping) 
    564565                        ath_tx_queue_tid(txq, tid); 
    565566                spin_unlock_bh(&txq->axq_lock); 
    static enum ATH_AGGR_STATUS ath_tx_form_ 
    721722                                             int *aggr_len) 
    722723{ 
    723724#define PADBYTES(_len) ((4 - ((_len) % 4)) % 4) 
    724         struct ath_buf *bf, *bf_first, *bf_prev = NULL; 
     725        struct ath_buf *bf, *bf_first = NULL, *bf_prev = NULL; 
    725726        int rl = 0, nframes = 0, ndelim, prev_al = 0; 
    726727        u16 aggr_limit = 0, al = 0, bpad = 0, 
    727728                al_delta, h_baw = tid->baw_size / 2; 
    728729        enum ATH_AGGR_STATUS status = ATH_AGGR_DONE; 
    729730        struct ieee80211_tx_info *tx_info; 
    730731        struct ath_frame_info *fi; 
    731  
    732         bf_first = list_first_entry(&tid->buf_q, struct ath_buf, list); 
     732        struct sk_buff *skb; 
    733733 
    734734        do { 
    735                 bf = list_first_entry(&tid->buf_q, struct ath_buf, list); 
    736                 fi = get_frame_info(bf->bf_mpdu); 
     735                skb = skb_peek(&tid->buf_q); 
     736                fi = get_frame_info(skb); 
     737                bf = fi->bf; 
     738 
     739                if (!bf_first) 
     740                        bf_first = bf; 
    737741 
    738742                /* do not step over block-ack window */ 
    739743                if (!BAW_WITHIN(tid->seq_start, tid->baw_size, fi->seqno)) { 
    static enum ATH_AGGR_STATUS ath_tx_form_ 
    784788                if (!fi->retries) 
    785789                        ath_tx_addto_baw(sc, tid, fi->seqno); 
    786790                ath9k_hw_set11n_aggr_middle(sc->sc_ah, bf->bf_desc, ndelim); 
    787                 list_move_tail(&bf->list, bf_q); 
     791 
     792                __skb_unlink(skb, &tid->buf_q); 
     793                list_add_tail(&bf->list, bf_q); 
    788794                if (bf_prev) { 
    789795                        bf_prev->bf_next = bf; 
    790796                        ath9k_hw_set_desc_link(sc->sc_ah, bf_prev->bf_desc, 
    static enum ATH_AGGR_STATUS ath_tx_form_ 
    792798                } 
    793799                bf_prev = bf; 
    794800 
    795         } while (!list_empty(&tid->buf_q)); 
     801        } while (!skb_queue_empty(&tid->buf_q)); 
    796802 
    797803        *aggr_len = al; 
    798804 
    static void ath_tx_sched_aggr(struct ath 
    810816        int aggr_len; 
    811817 
    812818        do { 
    813                 if (list_empty(&tid->buf_q)) 
     819                if (skb_queue_empty(&tid->buf_q)) 
    814820                        return; 
    815821 
    816822                INIT_LIST_HEAD(&bf_q); 
    bool ath_tx_aggr_sleep(struct ath_softc  
    931937 
    932938                spin_lock_bh(&txq->axq_lock); 
    933939 
    934                 if (!list_empty(&tid->buf_q)) 
     940                if (!skb_queue_empty(&tid->buf_q)) 
    935941                        buffered = true; 
    936942 
    937943                tid->sched = false; 
    void ath_tx_aggr_wakeup(struct ath_softc 
    964970                spin_lock_bh(&txq->axq_lock); 
    965971                ac->clear_ps_filter = true; 
    966972 
    967                 if (!list_empty(&tid->buf_q) && !tid->paused) { 
     973                if (!skb_queue_empty(&tid->buf_q) && !tid->paused) { 
    968974                        ath_tx_queue_tid(txq, tid); 
    969975                        ath_txq_schedule(sc, txq); 
    970976                } 
    void ath_txq_schedule(struct ath_softc * 
    13081314                         * add tid to round-robin queue if more frames 
    13091315                         * are pending for the tid 
    13101316                         */ 
    1311                         if (!list_empty(&tid->buf_q)) 
     1317                        if (!skb_queue_empty(&tid->buf_q)) 
    13121318                                ath_tx_queue_tid(txq, tid); 
    13131319 
    13141320                        if (tid == last_tid || 
    static void ath_tx_send_ampdu(struct ath 
    14141420         * - seqno is not within block-ack window 
    14151421         * - h/w queue depth exceeds low water mark 
    14161422         */ 
    1417         if (!list_empty(&tid->buf_q) || tid->paused || 
     1423        if (!skb_queue_empty(&tid->buf_q) || tid->paused || 
    14181424            !BAW_WITHIN(tid->seq_start, tid->baw_size, fi->seqno) || 
    14191425            txctl->txq->axq_ampdu_depth >= ATH_AGGR_MIN_QDEPTH) { 
    14201426                /* 
    static void ath_tx_send_ampdu(struct ath 
    14221428                 * for aggregation. 
    14231429                 */ 
    14241430                TX_STAT_INC(txctl->txq->axq_qnum, a_queued_sw); 
    1425                 list_add_tail(&bf->list, &tid->buf_q); 
     1431                __skb_queue_tail(&tid->buf_q, bf->bf_mpdu); 
    14261432                if (!txctl->an || !txctl->an->sleeping) 
    14271433                        ath_tx_queue_tid(txctl->txq, tid); 
    14281434                return; 
    static struct ath_buf *ath_tx_setup_buff 
    17531759                            bf->bf_buf_addr, 
    17541760                            txq->axq_qnum); 
    17551761 
     1762        fi->bf = bf; 
    17561763 
    17571764        return bf; 
    17581765} 
    void ath_tx_node_init(struct ath_softc * 
    23702377                tid->sched     = false; 
    23712378                tid->paused    = false; 
    23722379                tid->state &= ~AGGR_CLEANUP; 
    2373                 INIT_LIST_HEAD(&tid->buf_q); 
     2380                __skb_queue_head_init(&tid->buf_q); 
    23742381                acno = TID_TO_WME_AC(tidno); 
    23752382                tid->ac = &an->ac[acno]; 
    23762383                tid->state &= ~AGGR_ADDBA_COMPLETE; 
Note: See TracBrowser for help on using the repository browser.