source: trunk/package/mac80211/patches/300-pending_work.patch @ 26665

Last change on this file since 26665 was 26665, checked in by nbd, 6 years ago

ath9k: fix resetting the hw during channel change when the MAC fails to go idle

File size: 10.2 KB
  • drivers/net/wireless/ath/ath9k/main.c

    a b static void ath_paprd_activate(struct at 
    324324        if (!caldata || !caldata->paprd_done) 
    325325                return; 
    326326 
    327         ath9k_ps_wakeup(sc); 
    328327        ar9003_paprd_enable(ah, false); 
    329328        for (chain = 0; chain < AR9300_MAX_CHAINS; chain++) { 
    330329                if (!(common->tx_chainmask & BIT(chain))) 
    static void ath_paprd_activate(struct at 
    334333        } 
    335334 
    336335        ar9003_paprd_enable(ah, true); 
    337         ath9k_ps_restore(sc); 
    338336} 
    339337 
    340338static bool ath_paprd_send_frame(struct ath_softc *sc, struct sk_buff *skb, int chain) 
    set_timer: 
    554552        if ((sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_PAPRD) && ah->caldata) { 
    555553                if (!ah->caldata->paprd_done) 
    556554                        ieee80211_queue_work(sc->hw, &sc->paprd_work); 
    557                 else if (!ah->paprd_table_write_done) 
     555                else if (!ah->paprd_table_write_done) { 
     556                        ath9k_ps_wakeup(sc); 
    558557                        ath_paprd_activate(sc); 
     558                        ath9k_ps_restore(sc); 
     559                } 
    559560        } 
    560561} 
    561562 
    static void ath9k_calculate_summary_stat 
    13761377 
    13771378        ath9k_calculate_iter_data(hw, vif, &iter_data); 
    13781379 
    1379         ath9k_ps_wakeup(sc); 
    13801380        /* Set BSSID mask. */ 
    13811381        memcpy(common->bssidmask, iter_data.mask, ETH_ALEN); 
    13821382        ath_hw_setbssidmask(common); 
    static void ath9k_calculate_summary_stat 
    14111411        } 
    14121412 
    14131413        ath9k_hw_set_interrupts(ah, ah->imask); 
    1414         ath9k_ps_restore(sc); 
    14151414 
    14161415        /* Set up ANI */ 
    14171416        if ((iter_data.naps + iter_data.nadhocs) > 0) { 
    static int ath9k_add_interface(struct ie 
    14571456        struct ath_vif *avp = (void *)vif->drv_priv; 
    14581457        int ret = 0; 
    14591458 
     1459        ath9k_ps_wakeup(sc); 
    14601460        mutex_lock(&sc->mutex); 
    14611461 
    14621462        switch (vif->type) { 
    static int ath9k_add_interface(struct ie 
    15031503        ath9k_do_vif_add_setup(hw, vif); 
    15041504out: 
    15051505        mutex_unlock(&sc->mutex); 
     1506        ath9k_ps_restore(sc); 
    15061507        return ret; 
    15071508} 
    15081509 
    static int ath9k_change_interface(struct 
    15171518 
    15181519        ath_dbg(common, ATH_DBG_CONFIG, "Change Interface\n"); 
    15191520        mutex_lock(&sc->mutex); 
     1521        ath9k_ps_wakeup(sc); 
    15201522 
    15211523        /* See if new interface type is valid. */ 
    15221524        if ((new_type == NL80211_IFTYPE_ADHOC) && 
    static int ath9k_change_interface(struct 
    15461548 
    15471549        ath9k_do_vif_add_setup(hw, vif); 
    15481550out: 
     1551        ath9k_ps_restore(sc); 
    15491552        mutex_unlock(&sc->mutex); 
    15501553        return ret; 
    15511554} 
    static void ath9k_remove_interface(struc 
    15581561 
    15591562        ath_dbg(common, ATH_DBG_CONFIG, "Detach Interface\n"); 
    15601563 
     1564        ath9k_ps_wakeup(sc); 
    15611565        mutex_lock(&sc->mutex); 
    15621566 
    15631567        sc->nvifs--; 
    static void ath9k_remove_interface(struc 
    15691573        ath9k_calculate_summary_state(hw, NULL); 
    15701574 
    15711575        mutex_unlock(&sc->mutex); 
     1576        ath9k_ps_restore(sc); 
    15721577} 
    15731578 
    15741579static void ath9k_enable_ps(struct ath_softc *sc) 
    static int ath9k_conf_tx(struct ieee8021 
    18091814 
    18101815        txq = sc->tx.txq_map[queue]; 
    18111816 
     1817        ath9k_ps_wakeup(sc); 
    18121818        mutex_lock(&sc->mutex); 
    18131819 
    18141820        memset(&qi, 0, sizeof(struct ath9k_tx_queue_info)); 
    static int ath9k_conf_tx(struct ieee8021 
    18321838                        ath_beaconq_config(sc); 
    18331839 
    18341840        mutex_unlock(&sc->mutex); 
     1841        ath9k_ps_restore(sc); 
    18351842 
    18361843        return ret; 
    18371844} 
    static void ath9k_bss_info_changed(struc 
    19081915        int slottime; 
    19091916        int error; 
    19101917 
     1918        ath9k_ps_wakeup(sc); 
    19111919        mutex_lock(&sc->mutex); 
    19121920 
    19131921        if (changed & BSS_CHANGED_BSSID) { 
    static void ath9k_bss_info_changed(struc 
    20082016        } 
    20092017 
    20102018        mutex_unlock(&sc->mutex); 
     2019        ath9k_ps_restore(sc); 
    20112020} 
    20122021 
    20132022static u64 ath9k_get_tsf(struct ieee80211_hw *hw) 
  • drivers/net/wireless/ath/ath9k/beacon.c

    a b void ath_beacon_tasklet(unsigned long da 
    392392        tsf += TU_TO_USEC(ah->config.sw_beacon_response_time); 
    393393        tsftu = TSF_TO_TU((tsf * ATH_BCBUF) >>32, tsf * ATH_BCBUF); 
    394394        slot = (tsftu % (intval * ATH_BCBUF)) / intval; 
    395         /* 
    396          * Reverse the slot order to get slot 0 on the TBTT offset that does 
    397          * not require TSF adjustment and other slots adding 
    398          * slot/ATH_BCBUF * beacon_int to timestamp. For example, with 
    399          * ATH_BCBUF = 4, we process beacon slots as follows: 3 2 1 0 3 2 1 .. 
    400          * and slot 0 is at correct offset to TBTT. 
    401          */ 
    402         slot = ATH_BCBUF - slot - 1; 
    403395        vif = sc->beacon.bslot[slot]; 
    404396 
    405397        ath_dbg(common, ATH_DBG_BEACON, 
    void ath_beacon_config(struct ath_softc  
    708700        if (cur_conf->dtim_period == 0) 
    709701                cur_conf->dtim_period = 1; 
    710702 
    711         switch (iftype) { 
     703        switch (sc->sc_ah->opmode) { 
    712704        case NL80211_IFTYPE_AP: 
    713705                ath_beacon_config_ap(sc, cur_conf); 
    714706                break; 
  • net/mac80211/rx.c

    a b ieee80211_drop_unencrypted_mgmt(struct i 
    15851585} 
    15861586 
    15871587static int 
    1588 __ieee80211_data_to_8023(struct ieee80211_rx_data *rx) 
     1588__ieee80211_data_to_8023(struct ieee80211_rx_data *rx, bool *port_control) 
    15891589{ 
    15901590        struct ieee80211_sub_if_data *sdata = rx->sdata; 
    15911591        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data; 
    __ieee80211_data_to_8023(struct ieee8021 
    15931593        struct ethhdr *ehdr; 
    15941594        int ret; 
    15951595 
     1596        *port_control = false; 
    15961597        if (ieee80211_has_a4(hdr->frame_control) && 
    15971598            sdata->vif.type == NL80211_IFTYPE_AP_VLAN && !sdata->u.vlan.sta) 
    15981599                return -1; 
    __ieee80211_data_to_8023(struct ieee8021 
    16111612                return -1; 
    16121613 
    16131614        ret = ieee80211_data_to_8023(rx->skb, sdata->vif.addr, sdata->vif.type); 
    1614         if (ret < 0 || !check_port_control) 
     1615        if (ret < 0) 
    16151616                return ret; 
    16161617 
    16171618        ehdr = (struct ethhdr *) rx->skb->data; 
    1618         if (ehdr->h_proto != rx->sdata->control_port_protocol) 
     1619        if (ehdr->h_proto == rx->sdata->control_port_protocol) 
     1620                *port_control = true; 
     1621        else if (check_port_control) 
    16191622                return -1; 
    16201623 
    16211624        return 0; 
    ieee80211_rx_h_data(struct ieee80211_rx_ 
    19161919        struct net_device *dev = sdata->dev; 
    19171920        struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)rx->skb->data; 
    19181921        __le16 fc = hdr->frame_control; 
     1922        bool port_control; 
    19191923        int err; 
    19201924 
    19211925        if (unlikely(!ieee80211_is_data(hdr->frame_control))) 
    ieee80211_rx_h_data(struct ieee80211_rx_ 
    19321936            sdata->vif.type == NL80211_IFTYPE_AP) 
    19331937                return RX_DROP_MONITOR; 
    19341938 
    1935         err = __ieee80211_data_to_8023(rx); 
     1939        err = __ieee80211_data_to_8023(rx, &port_control); 
    19361940        if (unlikely(err)) 
    19371941                return RX_DROP_UNUSABLE; 
    19381942 
    19391943        if (!ieee80211_frame_allowed(rx, fc)) 
    19401944                return RX_DROP_MONITOR; 
    19411945 
     1946        if (rx->sdata->vif.type == NL80211_IFTYPE_AP_VLAN && 
     1947            unlikely(port_control) && sdata->bss) { 
     1948                sdata = container_of(sdata->bss, struct ieee80211_sub_if_data, 
     1949                                     u.ap); 
     1950                dev = sdata->dev; 
     1951                rx->sdata = sdata; 
     1952        } 
     1953 
    19421954        rx->skb->dev = dev; 
    19431955 
    19441956        dev->stats.rx_packets++; 
  • drivers/net/wireless/ath/ath9k/recv.c

    a b static void ath_rx_buf_link(struct ath_s 
    7575                *sc->rx.rxlink = bf->bf_daddr; 
    7676 
    7777        sc->rx.rxlink = &ds->ds_link; 
    78         ath9k_hw_rxena(ah); 
    7978} 
    8079 
    8180static void ath_setdefantenna(struct ath_softc *sc, u32 antenna) 
    u32 ath_calcrxfilter(struct ath_softc *s 
    426425        else 
    427426                rfilt |= ATH9K_RX_FILTER_BEACON; 
    428427 
    429         if ((AR_SREV_9280_20_OR_LATER(sc->sc_ah) || 
    430             AR_SREV_9285_12_OR_LATER(sc->sc_ah)) && 
    431             (sc->sc_ah->opmode == NL80211_IFTYPE_AP) && 
     428        if ((sc->sc_ah->opmode == NL80211_IFTYPE_AP) || 
    432429            (sc->rx.rxfilter & FIF_PSPOLL)) 
    433430                rfilt |= ATH9K_RX_FILTER_PSPOLL; 
    434431 
    start_recv: 
    486483bool ath_stoprecv(struct ath_softc *sc) 
    487484{ 
    488485        struct ath_hw *ah = sc->sc_ah; 
    489         bool stopped; 
     486        bool stopped, reset = false; 
    490487 
    491488        spin_lock_bh(&sc->rx.rxbuflock); 
    492489        ath9k_hw_abortpcurecv(ah); 
    493490        ath9k_hw_setrxfilter(ah, 0); 
    494         stopped = ath9k_hw_stopdmarecv(ah); 
     491        stopped = ath9k_hw_stopdmarecv(ah, &reset); 
    495492 
    496493        if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) 
    497494                ath_edma_stop_recv(sc); 
    bool ath_stoprecv(struct ath_softc *sc) 
    506503                        "confusing the DMA engine when we start RX up\n"); 
    507504                ATH_DBG_WARN_ON_ONCE(!stopped); 
    508505        } 
    509         return stopped; 
     506        return stopped && !reset; 
    510507} 
    511508 
    512509void ath_flushrecv(struct ath_softc *sc) 
    requeue: 
    17671764                } else { 
    17681765                        list_move_tail(&bf->list, &sc->rx.rxbuf); 
    17691766                        ath_rx_buf_link(sc, bf); 
     1767                        ath9k_hw_rxena(ah); 
    17701768                } 
    17711769        } while (1); 
    17721770 
  • drivers/net/wireless/ath/ath9k/hw.c

    a b int ath9k_hw_reset(struct ath_hw *ah, st 
    12491249        ah->txchainmask = common->tx_chainmask; 
    12501250        ah->rxchainmask = common->rx_chainmask; 
    12511251 
    1252         if ((common->bus_ops->ath_bus_type != ATH_USB) && !ah->chip_fullsleep) { 
    1253                 ath9k_hw_abortpcurecv(ah); 
    1254                 if (!ath9k_hw_stopdmarecv(ah)) { 
    1255                         ath_dbg(common, ATH_DBG_XMIT, 
    1256                                 "Failed to stop receive dma\n"); 
    1257                         bChannelChange = false; 
    1258                 } 
    1259         } 
    1260  
    12611252        if (!ath9k_hw_setpower(ah, ATH9K_PM_AWAKE)) 
    12621253                return -EIO; 
    12631254 
  • drivers/net/wireless/ath/ath9k/mac.c

    a b void ath9k_hw_abortpcurecv(struct ath_hw 
    710710} 
    711711EXPORT_SYMBOL(ath9k_hw_abortpcurecv); 
    712712 
    713 bool ath9k_hw_stopdmarecv(struct ath_hw *ah) 
     713bool ath9k_hw_stopdmarecv(struct ath_hw *ah, bool *reset) 
    714714{ 
    715715#define AH_RX_STOP_DMA_TIMEOUT 10000   /* usec */ 
    716716        struct ath_common *common = ath9k_hw_common(ah); 
     717        u32 mac_status, last_mac_status = 0; 
    717718        int i; 
    718719 
     720        /* Enable access to the DMA observation bus */ 
     721        REG_WRITE(ah, AR_MACMISC, 
     722                  ((AR_MACMISC_DMA_OBS_LINE_8 << AR_MACMISC_DMA_OBS_S) | 
     723                   (AR_MACMISC_MISC_OBS_BUS_1 << 
     724                    AR_MACMISC_MISC_OBS_BUS_MSB_S))); 
     725 
    719726        REG_WRITE(ah, AR_CR, AR_CR_RXD); 
    720727 
    721728        /* Wait for rx enable bit to go low */ 
    722729        for (i = AH_RX_STOP_DMA_TIMEOUT / AH_TIME_QUANTUM; i != 0; i--) { 
    723730                if ((REG_READ(ah, AR_CR) & AR_CR_RXE) == 0) 
    724731                        break; 
     732 
     733                if (!AR_SREV_9300_20_OR_LATER(ah)) { 
     734                        mac_status = REG_READ(ah, AR_DMADBG_7) & 0x7f0; 
     735                        if (mac_status == 0x1c0 && mac_status == last_mac_status) { 
     736                                *reset = true; 
     737                                break; 
     738                        } 
     739 
     740                        last_mac_status = mac_status; 
     741                } 
     742 
    725743                udelay(AH_TIME_QUANTUM); 
    726744        } 
    727745 
    728746        if (i == 0) { 
    729747                ath_err(common, 
    730                         "DMA failed to stop in %d ms AR_CR=0x%08x AR_DIAG_SW=0x%08x\n", 
     748                        "DMA failed to stop in %d ms AR_CR=0x%08x AR_DIAG_SW=0x%08x DMADBG_7=0x%08x\n", 
    731749                        AH_RX_STOP_DMA_TIMEOUT / 1000, 
    732750                        REG_READ(ah, AR_CR), 
    733                         REG_READ(ah, AR_DIAG_SW)); 
     751                        REG_READ(ah, AR_DIAG_SW), 
     752                        REG_READ(ah, AR_DMADBG_7)); 
    734753                return false; 
    735754        } else { 
    736755                return true; 
  • drivers/net/wireless/ath/ath9k/mac.h

    a b bool ath9k_hw_setrxabort(struct ath_hw * 
    695695void ath9k_hw_putrxbuf(struct ath_hw *ah, u32 rxdp); 
    696696void ath9k_hw_startpcureceive(struct ath_hw *ah, bool is_scanning); 
    697697void ath9k_hw_abortpcurecv(struct ath_hw *ah); 
    698 bool ath9k_hw_stopdmarecv(struct ath_hw *ah); 
     698bool ath9k_hw_stopdmarecv(struct ath_hw *ah, bool *reset); 
    699699int ath9k_hw_beaconq_setup(struct ath_hw *ah); 
    700700 
    701701/* Interrupt Handling */ 
Note: See TracBrowser for help on using the repository browser.