source: branches/backfire/package/mac80211/patches/531-ath9k_fix_ap_ps_buffering.patch @ 25966

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

mac80211: sync with trunk (as of r25965)

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

    a b struct ath_atx_ac { 
    203203        int sched; 
    204204        struct list_head list; 
    205205        struct list_head tid_q; 
     206        bool clear_ps_filter; 
    206207}; 
    207208 
    208209struct ath_frame_info { 
    struct ath_node { 
    260261        struct ath_atx_ac ac[WME_NUM_AC]; 
    261262        u16 maxampdu; 
    262263        u8 mpdudensity; 
     264 
     265        bool sleeping; 
    263266}; 
    264267 
    265268#define AGGR_CLEANUP         BIT(1) 
    int ath_tx_aggr_start(struct ath_softc * 
    341344void ath_tx_aggr_stop(struct ath_softc *sc, struct ieee80211_sta *sta, u16 tid); 
    342345void ath_tx_aggr_resume(struct ath_softc *sc, struct ieee80211_sta *sta, u16 tid); 
    343346 
     347void ath_tx_aggr_wakeup(struct ath_softc *sc, struct ath_node *an); 
     348bool ath_tx_aggr_sleep(struct ath_softc *sc, struct ath_node *an); 
     349 
    344350/********/ 
    345351/* VIFs */ 
    346352/********/ 
  • drivers/net/wireless/ath/ath9k/main.c

    a b static int ath9k_sta_remove(struct ieee8 
    17911791        return 0; 
    17921792} 
    17931793 
     1794static void ath9k_sta_notify(struct ieee80211_hw *hw, 
     1795                         struct ieee80211_vif *vif, 
     1796                         enum sta_notify_cmd cmd, 
     1797                         struct ieee80211_sta *sta) 
     1798{ 
     1799        struct ath_softc *sc = hw->priv; 
     1800        struct ath_node *an = (struct ath_node *) sta->drv_priv; 
     1801 
     1802        switch (cmd) { 
     1803        case STA_NOTIFY_SLEEP: 
     1804                an->sleeping = true; 
     1805                if (ath_tx_aggr_sleep(sc, an)) 
     1806                        ieee80211_sta_set_tim(sta); 
     1807                break; 
     1808        case STA_NOTIFY_AWAKE: 
     1809                an->sleeping = false; 
     1810                ath_tx_aggr_wakeup(sc, an); 
     1811                break; 
     1812        } 
     1813} 
     1814 
    17941815static int ath9k_conf_tx(struct ieee80211_hw *hw, u16 queue, 
    17951816                         const struct ieee80211_tx_queue_params *params) 
    17961817{ 
    struct ieee80211_ops ath9k_ops = { 
    21912212        .configure_filter   = ath9k_configure_filter, 
    21922213        .sta_add            = ath9k_sta_add, 
    21932214        .sta_remove         = ath9k_sta_remove, 
     2215        .sta_notify         = ath9k_sta_notify, 
    21942216        .conf_tx            = ath9k_conf_tx, 
    21952217        .bss_info_changed   = ath9k_bss_info_changed, 
    21962218        .set_key            = ath9k_set_key, 
  • drivers/net/wireless/ath/ath9k/xmit.c

    a b static void ath_tx_complete_aggr(struct  
    357357        struct ath_frame_info *fi; 
    358358        int nframes; 
    359359        u8 tidno; 
     360        bool clear_filter; 
    360361 
    361362        skb = bf->bf_mpdu; 
    362363        hdr = (struct ieee80211_hdr *)skb->data; 
    static void ath_tx_complete_aggr(struct  
    442443                        acked_cnt++; 
    443444                } else { 
    444445                        if (!(tid->state & AGGR_CLEANUP) && retry) { 
    445                                 if (fi->retries < ATH_MAX_SW_RETRIES) { 
     446                                if (ts->ts_status & ATH9K_TXERR_FILT) { 
     447                                        if (!an->sleeping) 
     448                                                clear_filter = true; 
     449                                        txpending = 1; 
     450                                } else if (fi->retries < ATH_MAX_SW_RETRIES) { 
    446451                                        ath_tx_set_retry(sc, txq, bf->bf_mpdu); 
    447452                                        txpending = 1; 
    448453                                } else { 
    static void ath_tx_complete_aggr(struct  
    496501                                !txfail, sendbar); 
    497502                } else { 
    498503                        /* retry the un-acked ones */ 
     504                        ath9k_hw_set_clrdmask(sc->sc_ah, bf->bf_desc, false); 
    499505                        if (!(sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)) { 
    500506                                if (bf->bf_next == NULL && bf_last->bf_stale) { 
    501507                                        struct ath_buf *tbf; 
    static void ath_tx_complete_aggr(struct  
    546552 
    547553        /* prepend un-acked frames to the beginning of the pending frame queue */ 
    548554        if (!list_empty(&bf_pending)) { 
     555                if (an->sleeping) 
     556                        ieee80211_sta_set_tim(sta); 
     557 
    549558                spin_lock_bh(&txq->axq_lock); 
     559                if (clear_filter) 
     560                        tid->ac->clear_ps_filter = true; 
    550561                list_splice(&bf_pending, &tid->buf_q); 
    551562                ath_tx_queue_tid(txq, tid); 
    552563                spin_unlock_bh(&txq->axq_lock); 
    static void ath_tx_sched_aggr(struct ath 
    816827                bf = list_first_entry(&bf_q, struct ath_buf, list); 
    817828                bf->bf_lastbf = list_entry(bf_q.prev, struct ath_buf, list); 
    818829 
     830                if (tid->ac->clear_ps_filter) { 
     831                        tid->ac->clear_ps_filter = false; 
     832                        ath9k_hw_set_clrdmask(sc->sc_ah, bf->bf_desc, true); 
     833                } 
     834 
    819835                /* if only one frame, send as non-aggregate */ 
    820836                if (bf == bf->bf_lastbf) { 
    821837                        fi = get_frame_info(bf->bf_mpdu); 
    void ath_tx_aggr_stop(struct ath_softc * 
    896912        ath_tx_flush_tid(sc, txtid); 
    897913} 
    898914 
     915bool ath_tx_aggr_sleep(struct ath_softc *sc, struct ath_node *an) 
     916{ 
     917        struct ath_atx_tid *tid; 
     918        struct ath_atx_ac *ac; 
     919        struct ath_txq *txq; 
     920        bool buffered = false; 
     921        int tidno; 
     922 
     923        for (tidno = 0, tid = &an->tid[tidno]; 
     924             tidno < WME_NUM_TID; tidno++, tid++) { 
     925 
     926                if (!tid->sched) 
     927                        continue; 
     928 
     929                ac = tid->ac; 
     930                txq = ac->txq; 
     931 
     932                spin_lock_bh(&txq->axq_lock); 
     933 
     934                if (!list_empty(&tid->buf_q)) 
     935                        buffered = true; 
     936 
     937                tid->sched = false; 
     938                list_del(&tid->list); 
     939 
     940                if (ac->sched) { 
     941                        ac->sched = false; 
     942                        list_del(&ac->list); 
     943                } 
     944 
     945                spin_unlock_bh(&txq->axq_lock); 
     946        } 
     947 
     948        return buffered; 
     949} 
     950 
     951void ath_tx_aggr_wakeup(struct ath_softc *sc, struct ath_node *an) 
     952{ 
     953        struct ath_atx_tid *tid; 
     954        struct ath_atx_ac *ac; 
     955        struct ath_txq *txq; 
     956        int tidno; 
     957 
     958        for (tidno = 0, tid = &an->tid[tidno]; 
     959             tidno < WME_NUM_TID; tidno++, tid++) { 
     960 
     961                ac = tid->ac; 
     962                txq = ac->txq; 
     963 
     964                spin_lock_bh(&txq->axq_lock); 
     965                ac->clear_ps_filter = true; 
     966 
     967                if (!list_empty(&tid->buf_q) && !tid->paused) { 
     968                        ath_tx_queue_tid(txq, tid); 
     969                        ath_txq_schedule(sc, txq); 
     970                } 
     971 
     972                spin_unlock_bh(&txq->axq_lock); 
     973        } 
     974} 
     975 
    899976void ath_tx_aggr_resume(struct ath_softc *sc, struct ieee80211_sta *sta, u16 tid) 
    900977{ 
    901978        struct ath_atx_tid *txtid; 
    static int setup_tx_flags(struct sk_buff 
    14931570        struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb); 
    14941571        int flags = 0; 
    14951572 
    1496         flags |= ATH9K_TXDESC_CLRDMASK; /* needed for crypto errors */ 
    14971573        flags |= ATH9K_TXDESC_INTREQ; 
    14981574 
    14991575        if (tx_info->flags & IEEE80211_TX_CTL_NO_ACK) 
    static void ath_tx_start_dma(struct ath_ 
    17561832                if (txctl->paprd) 
    17571833                        bf->bf_state.bfs_paprd_timestamp = jiffies; 
    17581834 
     1835                if (tx_info->flags & IEEE80211_TX_CTL_CLEAR_PS_FILT) 
     1836                        ath9k_hw_set_clrdmask(sc->sc_ah, bf->bf_desc, true); 
     1837 
    17591838                ath_tx_send_normal(sc, txctl->txq, tid, &bf_head); 
    17601839        } 
    17611840 
  • drivers/net/wireless/ath/ath9k/hw-ops.h

    a b static inline void ath9k_hw_set11n_virtu 
    128128        ath9k_hw_ops(ah)->set11n_virtualmorefrag(ah, ds, vmf); 
    129129} 
    130130 
     131static inline void ath9k_hw_set_clrdmask(struct ath_hw *ah, void *ds, bool val) 
     132{ 
     133        ath9k_hw_ops(ah)->set_clrdmask(ah, ds, val); 
     134} 
     135 
    131136/* Private hardware call ops */ 
    132137 
    133138/* PHY ops */ 
  • drivers/net/wireless/ath/ath9k/hw.h

    a b struct ath_hw_ops { 
    642642                                     u32 burstDuration); 
    643643        void (*set11n_virtualmorefrag)(struct ath_hw *ah, void *ds, 
    644644                                       u32 vmf); 
     645        void (*set_clrdmask)(struct ath_hw *ah, void *ds, bool val); 
    645646}; 
    646647 
    647648struct ath_nf_limits { 
  • drivers/net/wireless/ath/ath9k/ar9002_mac.c

    a b static void ar9002_hw_set11n_txdesc(stru 
    290290                | (flags & ATH9K_TXDESC_VMF ? AR_VirtMoreFrag : 0) 
    291291                | SM(txPower, AR_XmitPower) 
    292292                | (flags & ATH9K_TXDESC_VEOL ? AR_VEOL : 0) 
    293                 | (flags & ATH9K_TXDESC_CLRDMASK ? AR_ClrDestMask : 0) 
    294293                | (flags & ATH9K_TXDESC_INTREQ ? AR_TxIntrReq : 0) 
    295294                | (keyIx != ATH9K_TXKEYIX_INVALID ? AR_DestIdxValid : 0); 
    296295 
    static void ar9002_hw_set11n_txdesc(stru 
    311310        } 
    312311} 
    313312 
     313static void ar9002_hw_set_clrdmask(struct ath_hw *ah, void *ds, bool val) 
     314{ 
     315        struct ar5416_desc *ads = AR5416DESC(ds); 
     316 
     317        if (val) 
     318                ads->ds_ctl0 |= AR_ClrDestMask; 
     319        else 
     320                ads->ds_ctl0 &= ~AR_ClrDestMask; 
     321} 
     322 
    314323static void ar9002_hw_set11n_ratescenario(struct ath_hw *ah, void *ds, 
    315324                                          void *lastds, 
    316325                                          u32 durUpdateEn, u32 rtsctsRate, 
    void ar9002_hw_attach_mac_ops(struct ath 
    460469        ops->clr11n_aggr = ar9002_hw_clr11n_aggr; 
    461470        ops->set11n_burstduration = ar9002_hw_set11n_burstduration; 
    462471        ops->set11n_virtualmorefrag = ar9002_hw_set11n_virtualmorefrag; 
     472        ops->set_clrdmask = ar9002_hw_set_clrdmask; 
    463473} 
  • drivers/net/wireless/ath/ath9k/ar9003_mac.c

    a b static void ar9003_hw_set11n_txdesc(stru 
    329329                | (flags & ATH9K_TXDESC_VMF ? AR_VirtMoreFrag : 0) 
    330330                | SM(txpower, AR_XmitPower) 
    331331                | (flags & ATH9K_TXDESC_VEOL ? AR_VEOL : 0) 
    332                 | (flags & ATH9K_TXDESC_CLRDMASK ? AR_ClrDestMask : 0) 
    333332                | (keyIx != ATH9K_TXKEYIX_INVALID ? AR_DestIdxValid : 0) 
    334333                | (flags & ATH9K_TXDESC_LOWRXCHAIN ? AR_LowRxChain : 0); 
    335334 
    static void ar9003_hw_set11n_txdesc(stru 
    350349        ads->ctl22 = 0; 
    351350} 
    352351 
     352static void ar9003_hw_set_clrdmask(struct ath_hw *ah, void *ds, bool val) 
     353{ 
     354        struct ar9003_txc *ads = (struct ar9003_txc *) ds; 
     355 
     356        if (val) 
     357                ads->ctl11 |= AR_ClrDestMask; 
     358        else 
     359                ads->ctl11 &= ~AR_ClrDestMask; 
     360} 
     361 
    353362static void ar9003_hw_set11n_ratescenario(struct ath_hw *ah, void *ds, 
    354363                                          void *lastds, 
    355364                                          u32 durUpdateEn, u32 rtsctsRate, 
    void ar9003_hw_attach_mac_ops(struct ath 
    522531        ops->clr11n_aggr = ar9003_hw_clr11n_aggr; 
    523532        ops->set11n_burstduration = ar9003_hw_set11n_burstduration; 
    524533        ops->set11n_virtualmorefrag = ar9003_hw_set11n_virtualmorefrag; 
     534        ops->set_clrdmask = ar9003_hw_set_clrdmask; 
    525535} 
    526536 
    527537void ath9k_hw_set_rx_bufsize(struct ath_hw *ah, u16 buf_size) 
  • drivers/net/wireless/ath/ath9k/mac.h

    a b struct ath_desc { 
    239239        void *ds_vdata; 
    240240} __packed __aligned(4); 
    241241 
    242 #define ATH9K_TXDESC_CLRDMASK           0x0001 
    243242#define ATH9K_TXDESC_NOACK              0x0002 
    244243#define ATH9K_TXDESC_RTSENA             0x0004 
    245244#define ATH9K_TXDESC_CTSENA             0x0008 
Note: See TracBrowser for help on using the repository browser.