diff options
Diffstat (limited to 'package/mac80211/patches/300-pending_work.patch')
| -rw-r--r-- | package/mac80211/patches/300-pending_work.patch | 3029 |
1 files changed, 1645 insertions, 1384 deletions
diff --git a/package/mac80211/patches/300-pending_work.patch b/package/mac80211/patches/300-pending_work.patch index 6062e9da26..c8dce038e3 100644 --- a/package/mac80211/patches/300-pending_work.patch +++ b/package/mac80211/patches/300-pending_work.patch @@ -1,1248 +1,1613 @@ ---- a/drivers/net/wireless/ath/ath9k/ani.c -+++ b/drivers/net/wireless/ath/ath9k/ani.c -@@ -104,11 +104,6 @@ static const struct ani_cck_level_entry - #define ATH9K_ANI_CCK_DEF_LEVEL \ - 2 /* default level - matches the INI settings */ +--- a/drivers/net/wireless/ath/ath9k/ath9k.h ++++ b/drivers/net/wireless/ath/ath9k/ath9k.h +@@ -360,7 +360,7 @@ void ath_tx_aggr_sleep(struct ieee80211_ + + struct ath_vif { + int av_bslot; +- bool is_bslot_active, primary_sta_vif; ++ bool primary_sta_vif; + __le64 tsf_adjust; /* TSF adjustment for staggered beacons */ + struct ath_buf *av_bcbuf; + }; +@@ -386,6 +386,7 @@ struct ath_beacon_config { + u16 dtim_period; + u16 bmiss_timeout; + u8 dtim_count; ++ bool enable_beacon; + }; --static bool use_new_ani(struct ath_hw *ah) --{ -- return AR_SREV_9300_20_OR_LATER(ah) || modparam_force_new_ani; --} -- - static void ath9k_hw_update_mibstats(struct ath_hw *ah, - struct ath9k_mib_stats *stats) + struct ath_beacon { +@@ -397,7 +398,6 @@ struct ath_beacon { + + u32 beaconq; + u32 bmisscnt; +- u32 ast_be_xmit; + u32 bc_tstamp; + struct ieee80211_vif *bslot[ATH_BCBUF]; + int slottime; +@@ -411,12 +411,14 @@ struct ath_beacon { + bool tx_last; + }; + +-void ath_beacon_tasklet(unsigned long data); +-void ath_beacon_config(struct ath_softc *sc, struct ieee80211_vif *vif); +-int ath_beacon_alloc(struct ath_softc *sc, struct ieee80211_vif *vif); +-void ath_beacon_return(struct ath_softc *sc, struct ath_vif *avp); +-int ath_beaconq_config(struct ath_softc *sc); +-void ath_set_beacon(struct ath_softc *sc); ++void ath9k_beacon_tasklet(unsigned long data); ++bool ath9k_allow_beacon_config(struct ath_softc *sc, struct ieee80211_vif *vif); ++void ath9k_beacon_config(struct ath_softc *sc, struct ieee80211_vif *vif, ++ u32 changed); ++void ath9k_beacon_assign_slot(struct ath_softc *sc, struct ieee80211_vif *vif); ++void ath9k_beacon_remove_slot(struct ath_softc *sc, struct ieee80211_vif *vif); ++void ath9k_set_tsfadjust(struct ath_softc *sc, struct ieee80211_vif *vif); ++void ath9k_set_beacon(struct ath_softc *sc); + void ath9k_set_beaconing_status(struct ath_softc *sc, bool status); + + /*******************/ +@@ -442,9 +444,12 @@ void ath_rx_poll(unsigned long data); + void ath_start_rx_poll(struct ath_softc *sc, u8 nbeacon); + void ath_paprd_calibrate(struct work_struct *work); + void ath_ani_calibrate(unsigned long data); +-void ath_start_ani(struct ath_common *common); ++void ath_start_ani(struct ath_softc *sc); ++void ath_stop_ani(struct ath_softc *sc); ++void ath_check_ani(struct ath_softc *sc); + int ath_update_survey_stats(struct ath_softc *sc); + void ath_update_survey_nf(struct ath_softc *sc, int channel); ++void ath9k_queue_reset(struct ath_softc *sc, enum ath_reset_type type); + + /**********/ + /* BTCOEX */ +@@ -613,7 +618,6 @@ enum sc_op_flags { + SC_OP_INVALID, + SC_OP_BEACONS, + SC_OP_RXFLUSH, +- SC_OP_TSF_RESET, + SC_OP_ANI_RUN, + SC_OP_PRIM_STA_VIF, + SC_OP_HW_RESET, +--- a/drivers/net/wireless/ath/ath9k/beacon.c ++++ b/drivers/net/wireless/ath/ath9k/beacon.c +@@ -30,7 +30,7 @@ static void ath9k_reset_beacon_status(st + * the operating mode of the station (AP or AdHoc). Parameters are AIFS + * settings and channel width min/max + */ +-int ath_beaconq_config(struct ath_softc *sc) ++static void ath9k_beaconq_config(struct ath_softc *sc) { -@@ -122,8 +117,6 @@ static void ath9k_hw_update_mibstats(str - static void ath9k_ani_restart(struct ath_hw *ah) + struct ath_hw *ah = sc->sc_ah; + struct ath_common *common = ath9k_hw_common(ah); +@@ -38,6 +38,7 @@ int ath_beaconq_config(struct ath_softc + struct ath_txq *txq; + + ath9k_hw_get_txq_props(ah, sc->beacon.beaconq, &qi); ++ + if (sc->sc_ah->opmode == NL80211_IFTYPE_AP) { + /* Always burst out beacon and CAB traffic. */ + qi.tqi_aifs = 1; +@@ -56,12 +57,9 @@ int ath_beaconq_config(struct ath_softc + } + + if (!ath9k_hw_set_txq_props(ah, sc->beacon.beaconq, &qi)) { +- ath_err(common, +- "Unable to update h/w beacon queue parameters\n"); +- return 0; ++ ath_err(common, "Unable to update h/w beacon queue parameters\n"); + } else { + ath9k_hw_resettxqueue(ah, sc->beacon.beaconq); +- return 1; + } + } + +@@ -70,7 +68,7 @@ int ath_beaconq_config(struct ath_softc + * up rate codes, and channel flags. Beacons are always sent out at the + * lowest rate, and are not retried. + */ +-static void ath_beacon_setup(struct ath_softc *sc, struct ieee80211_vif *vif, ++static void ath9k_beacon_setup(struct ath_softc *sc, struct ieee80211_vif *vif, + struct ath_buf *bf, int rateidx) { - struct ar5416AniState *aniState; -- struct ath_common *common = ath9k_hw_common(ah); -- u32 ofdm_base = 0, cck_base = 0; + struct sk_buff *skb = bf->bf_mpdu; +@@ -81,8 +79,6 @@ static void ath_beacon_setup(struct ath_ + u8 chainmask = ah->txchainmask; + u8 rate = 0; - if (!DO_ANI(ah)) - return; -@@ -131,18 +124,10 @@ static void ath9k_ani_restart(struct ath - aniState = &ah->curchan->ani; - aniState->listenTime = 0; +- ath9k_reset_beacon_status(sc); +- + sband = &sc->sbands[common->hw->conf.channel->band]; + rate = sband->bitrates[rateidx].hw_value; + if (vif->bss_conf.use_short_preamble) +@@ -111,7 +107,7 @@ static void ath_beacon_setup(struct ath_ + ath9k_hw_set_txdesc(ah, bf->bf_desc, &info); + } -- if (!use_new_ani(ah)) { -- ofdm_base = AR_PHY_COUNTMAX - ah->config.ofdm_trig_high; -- cck_base = AR_PHY_COUNTMAX - ah->config.cck_trig_high; -- } +-static void ath_tx_cabq(struct ieee80211_hw *hw, struct sk_buff *skb) ++static void ath9k_tx_cabq(struct ieee80211_hw *hw, struct sk_buff *skb) + { + struct ath_softc *sc = hw->priv; + struct ath_common *common = ath9k_hw_common(sc->sc_ah); +@@ -128,28 +124,22 @@ static void ath_tx_cabq(struct ieee80211 + } + } + +-static struct ath_buf *ath_beacon_generate(struct ieee80211_hw *hw, +- struct ieee80211_vif *vif) ++static struct ath_buf *ath9k_beacon_generate(struct ieee80211_hw *hw, ++ struct ieee80211_vif *vif) + { + struct ath_softc *sc = hw->priv; + struct ath_common *common = ath9k_hw_common(sc->sc_ah); + struct ath_buf *bf; +- struct ath_vif *avp; ++ struct ath_vif *avp = (void *)vif->drv_priv; + struct sk_buff *skb; +- struct ath_txq *cabq; ++ struct ath_txq *cabq = sc->beacon.cabq; + struct ieee80211_tx_info *info; ++ struct ieee80211_mgmt *mgmt_hdr; + int cabq_depth; + +- ath9k_reset_beacon_status(sc); - -- ath_dbg(common, ANI, "Writing ofdmbase=%u cckbase=%u\n", -- ofdm_base, cck_base); +- avp = (void *)vif->drv_priv; +- cabq = sc->beacon.cabq; - - ENABLE_REGWRITE_BUFFER(ah); +- if ((avp->av_bcbuf == NULL) || !avp->is_bslot_active) ++ if (avp->av_bcbuf == NULL) + return NULL; -- REG_WRITE(ah, AR_PHY_ERR_1, ofdm_base); -- REG_WRITE(ah, AR_PHY_ERR_2, cck_base); -+ REG_WRITE(ah, AR_PHY_ERR_1, 0); -+ REG_WRITE(ah, AR_PHY_ERR_2, 0); - REG_WRITE(ah, AR_PHY_ERR_MASK_1, AR_PHY_ERR_OFDM_TIMING); - REG_WRITE(ah, AR_PHY_ERR_MASK_2, AR_PHY_ERR_CCK_TIMING); +- /* Release the old beacon first */ +- + bf = avp->av_bcbuf; + skb = bf->bf_mpdu; + if (skb) { +@@ -159,14 +149,14 @@ static struct ath_buf *ath_beacon_genera + bf->bf_buf_addr = 0; + } + +- /* Get a new beacon from mac80211 */ +- + skb = ieee80211_beacon_get(hw, vif); +- bf->bf_mpdu = skb; + if (skb == NULL) + return NULL; +- ((struct ieee80211_mgmt *)skb->data)->u.beacon.timestamp = +- avp->tsf_adjust; ++ ++ bf->bf_mpdu = skb; ++ ++ mgmt_hdr = (struct ieee80211_mgmt *)skb->data; ++ mgmt_hdr->u.beacon.timestamp = avp->tsf_adjust; + + info = IEEE80211_SKB_CB(skb); + if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) { +@@ -212,61 +202,52 @@ static struct ath_buf *ath_beacon_genera + } + } -@@ -154,110 +139,6 @@ static void ath9k_ani_restart(struct ath - aniState->cckPhyErrCount = 0; +- ath_beacon_setup(sc, vif, bf, info->control.rates[0].idx); ++ ath9k_beacon_setup(sc, vif, bf, info->control.rates[0].idx); + + while (skb) { +- ath_tx_cabq(hw, skb); ++ ath9k_tx_cabq(hw, skb); + skb = ieee80211_get_buffered_bc(hw, vif); + } + + return bf; } --static void ath9k_hw_ani_ofdm_err_trigger_old(struct ath_hw *ah) --{ -- struct ieee80211_conf *conf = &ath9k_hw_common(ah)->hw->conf; -- struct ar5416AniState *aniState; -- int32_t rssi; -- -- aniState = &ah->curchan->ani; +-int ath_beacon_alloc(struct ath_softc *sc, struct ieee80211_vif *vif) ++void ath9k_beacon_assign_slot(struct ath_softc *sc, struct ieee80211_vif *vif) + { + struct ath_common *common = ath9k_hw_common(sc->sc_ah); +- struct ath_vif *avp; +- struct ath_buf *bf; +- struct sk_buff *skb; +- struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf; +- __le64 tstamp; ++ struct ath_vif *avp = (void *)vif->drv_priv; ++ int slot; + +- avp = (void *)vif->drv_priv; ++ avp->av_bcbuf = list_first_entry(&sc->beacon.bbuf, struct ath_buf, list); ++ list_del(&avp->av_bcbuf->list); + +- /* Allocate a beacon descriptor if we haven't done so. */ +- if (!avp->av_bcbuf) { +- /* Allocate beacon state for hostap/ibss. We know +- * a buffer is available. */ +- avp->av_bcbuf = list_first_entry(&sc->beacon.bbuf, +- struct ath_buf, list); +- list_del(&avp->av_bcbuf->list); - -- if (aniState->noiseImmunityLevel < HAL_NOISE_IMMUNE_MAX) { -- if (ath9k_hw_ani_control(ah, ATH9K_ANI_NOISE_IMMUNITY_LEVEL, -- aniState->noiseImmunityLevel + 1)) { -- return; -- } -- } +- if (ath9k_uses_beacons(vif->type)) { +- int slot; +- /* +- * Assign the vif to a beacon xmit slot. As +- * above, this cannot fail to find one. +- */ +- avp->av_bslot = 0; +- for (slot = 0; slot < ATH_BCBUF; slot++) +- if (sc->beacon.bslot[slot] == NULL) { +- avp->av_bslot = slot; +- avp->is_bslot_active = false; - -- if (aniState->spurImmunityLevel < HAL_SPUR_IMMUNE_MAX) { -- if (ath9k_hw_ani_control(ah, ATH9K_ANI_SPUR_IMMUNITY_LEVEL, -- aniState->spurImmunityLevel + 1)) { -- return; -- } -- } +- /* NB: keep looking for a double slot */ +- if (slot == 0 || !sc->beacon.bslot[slot-1]) +- break; +- } +- BUG_ON(sc->beacon.bslot[avp->av_bslot] != NULL); +- sc->beacon.bslot[avp->av_bslot] = vif; +- sc->nbcnvifs++; ++ for (slot = 0; slot < ATH_BCBUF; slot++) { ++ if (sc->beacon.bslot[slot] == NULL) { ++ avp->av_bslot = slot; ++ break; + } + } + +- /* release the previous beacon frame, if it already exists. */ +- bf = avp->av_bcbuf; +- if (bf->bf_mpdu != NULL) { +- skb = bf->bf_mpdu; ++ sc->beacon.bslot[avp->av_bslot] = vif; ++ sc->nbcnvifs++; ++ ++ ath_dbg(common, CONFIG, "Added interface at beacon slot: %d\n", ++ avp->av_bslot); ++} ++ ++void ath9k_beacon_remove_slot(struct ath_softc *sc, struct ieee80211_vif *vif) ++{ ++ struct ath_common *common = ath9k_hw_common(sc->sc_ah); ++ struct ath_vif *avp = (void *)vif->drv_priv; ++ struct ath_buf *bf = avp->av_bcbuf; ++ ++ ath_dbg(common, CONFIG, "Removing interface at beacon slot: %d\n", ++ avp->av_bslot); ++ ++ tasklet_disable(&sc->bcon_tasklet); ++ ++ if (bf && bf->bf_mpdu) { ++ struct sk_buff *skb = bf->bf_mpdu; + dma_unmap_single(sc->dev, bf->bf_buf_addr, + skb->len, DMA_TO_DEVICE); + dev_kfree_skb_any(skb); +@@ -274,99 +255,74 @@ int ath_beacon_alloc(struct ath_softc *s + bf->bf_buf_addr = 0; + } + +- /* NB: the beacon data buffer must be 32-bit aligned. */ +- skb = ieee80211_beacon_get(sc->hw, vif); +- if (skb == NULL) +- return -ENOMEM; - -- if (ah->opmode == NL80211_IFTYPE_AP) { -- if (aniState->firstepLevel < HAL_FIRST_STEP_MAX) { -- ath9k_hw_ani_control(ah, ATH9K_ANI_FIRSTEP_LEVEL, -- aniState->firstepLevel + 1); -- } -- return; +- tstamp = ((struct ieee80211_mgmt *)skb->data)->u.beacon.timestamp; +- sc->beacon.bc_tstamp = (u32) le64_to_cpu(tstamp); +- /* Calculate a TSF adjustment factor required for staggered beacons. */ +- if (avp->av_bslot > 0) { +- u64 tsfadjust; +- int intval; ++ avp->av_bcbuf = NULL; ++ sc->beacon.bslot[avp->av_bslot] = NULL; ++ sc->nbcnvifs--; ++ list_add_tail(&bf->list, &sc->beacon.bbuf); + +- intval = cur_conf->beacon_interval ? : ATH_DEFAULT_BINTVAL; ++ tasklet_enable(&sc->bcon_tasklet); ++} + +- /* +- * Calculate the TSF offset for this beacon slot, i.e., the +- * number of usecs that need to be added to the timestamp field +- * in Beacon and Probe Response frames. Beacon slot 0 is +- * processed at the correct offset, so it does not require TSF +- * adjustment. Other slots are adjusted to get the timestamp +- * close to the TBTT for the BSS. +- */ +- tsfadjust = TU_TO_USEC(intval * avp->av_bslot) / ATH_BCBUF; +- avp->tsf_adjust = cpu_to_le64(tsfadjust); ++static int ath9k_beacon_choose_slot(struct ath_softc *sc) ++{ ++ struct ath_common *common = ath9k_hw_common(sc->sc_ah); ++ struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf; ++ u16 intval; ++ u32 tsftu; ++ u64 tsf; ++ int slot; + +- ath_dbg(common, BEACON, +- "stagger beacons, bslot %d intval %u tsfadjust %llu\n", +- avp->av_bslot, intval, (unsigned long long)tsfadjust); ++ if (sc->sc_ah->opmode != NL80211_IFTYPE_AP) { ++ ath_dbg(common, BEACON, "slot 0, tsf: %llu\n", ++ ath9k_hw_gettsf64(sc->sc_ah)); ++ return 0; ++ } + +- ((struct ieee80211_mgmt *)skb->data)->u.beacon.timestamp = +- avp->tsf_adjust; +- } else +- avp->tsf_adjust = cpu_to_le64(0); ++ intval = cur_conf->beacon_interval ? : ATH_DEFAULT_BINTVAL; ++ tsf = ath9k_hw_gettsf64(sc->sc_ah); ++ tsf += TU_TO_USEC(sc->sc_ah->config.sw_beacon_response_time); ++ tsftu = TSF_TO_TU((tsf * ATH_BCBUF) >>32, tsf * ATH_BCBUF); ++ slot = (tsftu % (intval * ATH_BCBUF)) / intval; + +- bf->bf_mpdu = skb; +- bf->bf_buf_addr = dma_map_single(sc->dev, skb->data, +- skb->len, DMA_TO_DEVICE); +- if (unlikely(dma_mapping_error(sc->dev, bf->bf_buf_addr))) { +- dev_kfree_skb_any(skb); +- bf->bf_mpdu = NULL; +- bf->bf_buf_addr = 0; +- ath_err(common, "dma_mapping_error on beacon alloc\n"); +- return -ENOMEM; - } -- rssi = BEACON_RSSI(ah); -- if (rssi > aniState->rssiThrHigh) { -- if (!aniState->ofdmWeakSigDetectOff) { -- if (ath9k_hw_ani_control(ah, -- ATH9K_ANI_OFDM_WEAK_SIGNAL_DETECTION, -- false)) { -- ath9k_hw_ani_control(ah, -- ATH9K_ANI_SPUR_IMMUNITY_LEVEL, 0); -- return; -- } -- } -- if (aniState->firstepLevel < HAL_FIRST_STEP_MAX) { -- ath9k_hw_ani_control(ah, ATH9K_ANI_FIRSTEP_LEVEL, -- aniState->firstepLevel + 1); -- return; +- avp->is_bslot_active = true; ++ ath_dbg(common, BEACON, "slot: %d tsf: %llu tsftu: %u\n", ++ slot, tsf, tsftu / ATH_BCBUF); + +- return 0; ++ return slot; + } + +-void ath_beacon_return(struct ath_softc *sc, struct ath_vif *avp) ++void ath9k_set_tsfadjust(struct ath_softc *sc, struct ieee80211_vif *vif) + { +- if (avp->av_bcbuf != NULL) { +- struct ath_buf *bf; ++ struct ath_common *common = ath9k_hw_common(sc->sc_ah); ++ struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf; ++ struct ath_vif *avp = (void *)vif->drv_priv; ++ u64 tsfadjust; + +- avp->is_bslot_active = false; +- if (avp->av_bslot != -1) { +- sc->beacon.bslot[avp->av_bslot] = NULL; +- sc->nbcnvifs--; +- avp->av_bslot = -1; - } -- } else if (rssi > aniState->rssiThrLow) { -- if (aniState->ofdmWeakSigDetectOff) -- ath9k_hw_ani_control(ah, -- ATH9K_ANI_OFDM_WEAK_SIGNAL_DETECTION, -- true); -- if (aniState->firstepLevel < HAL_FIRST_STEP_MAX) -- ath9k_hw_ani_control(ah, ATH9K_ANI_FIRSTEP_LEVEL, -- aniState->firstepLevel + 1); -- return; -- } else { -- if ((conf->channel->band == IEEE80211_BAND_2GHZ) && -- !conf_is_ht(conf)) { -- if (!aniState->ofdmWeakSigDetectOff) -- ath9k_hw_ani_control(ah, -- ATH9K_ANI_OFDM_WEAK_SIGNAL_DETECTION, -- false); -- if (aniState->firstepLevel > 0) -- ath9k_hw_ani_control(ah, -- ATH9K_ANI_FIRSTEP_LEVEL, 0); -- return; ++ if (avp->av_bslot == 0) ++ return; + +- bf = avp->av_bcbuf; +- if (bf->bf_mpdu != NULL) { +- struct sk_buff *skb = bf->bf_mpdu; +- dma_unmap_single(sc->dev, bf->bf_buf_addr, +- skb->len, DMA_TO_DEVICE); +- dev_kfree_skb_any(skb); +- bf->bf_mpdu = NULL; +- bf->bf_buf_addr = 0; - } +- list_add_tail(&bf->list, &sc->beacon.bbuf); ++ tsfadjust = cur_conf->beacon_interval * avp->av_bslot / ATH_BCBUF; ++ avp->tsf_adjust = cpu_to_le64(TU_TO_USEC(tsfadjust)); + +- avp->av_bcbuf = NULL; - } --} ++ ath_dbg(common, CONFIG, "tsfadjust is: %llu for bslot: %d\n", ++ (unsigned long long)tsfadjust, avp->av_bslot); + } + +-void ath_beacon_tasklet(unsigned long data) ++void ath9k_beacon_tasklet(unsigned long data) + { + struct ath_softc *sc = (struct ath_softc *)data; +- struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf; + struct ath_hw *ah = sc->sc_ah; + struct ath_common *common = ath9k_hw_common(ah); + struct ath_buf *bf = NULL; + struct ieee80211_vif *vif; + bool edma = !!(ah->caps.hw_caps & ATH9K_HW_CAP_EDMA); + int slot; +- u32 bfaddr, bc = 0; + +- if (work_pending(&sc->hw_reset_work)) { ++ if (test_bit(SC_OP_HW_RESET, &sc->sc_flags)) { + ath_dbg(common, RESET, + "reset work is pending, skip beaconing now\n"); + return; + } ++ + /* + * Check if the previous beacon has gone out. If + * not don't try to post another, skip this period +@@ -390,55 +346,25 @@ void ath_beacon_tasklet(unsigned long da + } else if (sc->beacon.bmisscnt >= BSTUCK_THRESH) { + ath_dbg(common, BSTUCK, "beacon is officially stuck\n"); + sc->beacon.bmisscnt = 0; +- set_bit(SC_OP_TSF_RESET, &sc->sc_flags); +- ieee80211_queue_work(sc->hw, &sc->hw_reset_work); ++ ath9k_queue_reset(sc, RESET_TYPE_BEACON_STUCK); + } + + return; + } + +- /* +- * Generate beacon frames. we are sending frames +- * staggered so calculate the slot for this frame based +- * on the tsf to safeguard against missing an swba. +- */ - --static void ath9k_hw_ani_cck_err_trigger_old(struct ath_hw *ah) --{ -- struct ieee80211_conf *conf = &ath9k_hw_common(ah)->hw->conf; -- struct ar5416AniState *aniState; -- int32_t rssi; - -- aniState = &ah->curchan->ani; -- if (aniState->noiseImmunityLevel < HAL_NOISE_IMMUNE_MAX) { -- if (ath9k_hw_ani_control(ah, ATH9K_ANI_NOISE_IMMUNITY_LEVEL, -- aniState->noiseImmunityLevel + 1)) { -- return; -- } -- } - if (ah->opmode == NL80211_IFTYPE_AP) { -- if (aniState->firstepLevel < HAL_FIRST_STEP_MAX) { -- ath9k_hw_ani_control(ah, ATH9K_ANI_FIRSTEP_LEVEL, -- aniState->firstepLevel + 1); -- } -- return; -- } -- rssi = BEACON_RSSI(ah); -- if (rssi > aniState->rssiThrLow) { -- if (aniState->firstepLevel < HAL_FIRST_STEP_MAX) -- ath9k_hw_ani_control(ah, ATH9K_ANI_FIRSTEP_LEVEL, -- aniState->firstepLevel + 1); -- } else { -- if ((conf->channel->band == IEEE80211_BAND_2GHZ) && -- !conf_is_ht(conf)) { -- if (aniState->firstepLevel > 0) -- ath9k_hw_ani_control(ah, -- ATH9K_ANI_FIRSTEP_LEVEL, 0); -- } -- } --} +- u16 intval; +- u32 tsftu; +- u64 tsf; - - /* Adjust the OFDM Noise Immunity Level */ - static void ath9k_hw_set_ofdm_nil(struct ath_hw *ah, u8 immunityLevel) - { -@@ -265,18 +146,15 @@ static void ath9k_hw_set_ofdm_nil(struct - struct ath_common *common = ath9k_hw_common(ah); - const struct ani_ofdm_level_entry *entry_ofdm; - const struct ani_cck_level_entry *entry_cck; +- intval = cur_conf->beacon_interval ? : ATH_DEFAULT_BINTVAL; +- tsf = ath9k_hw_gettsf64(ah); +- tsf += TU_TO_USEC(ah->config.sw_beacon_response_time); +- tsftu = TSF_TO_TU((tsf * ATH_BCBUF) >>32, tsf * ATH_BCBUF); +- slot = (tsftu % (intval * ATH_BCBUF)) / intval; +- vif = sc->beacon.bslot[slot]; - -- aniState->noiseFloor = BEACON_RSSI(ah); -+ bool weak_sig; - - ath_dbg(common, ANI, "**** ofdmlevel %d=>%d, rssi=%d[lo=%d hi=%d]\n", - aniState->ofdmNoiseImmunityLevel, -- immunityLevel, aniState->noiseFloor, -+ immunityLevel, BEACON_RSSI(ah), - aniState->rssiThrLow, aniState->rssiThrHigh); - - if (aniState->update_ani) -- aniState->ofdmNoiseImmunityLevel = -- (immunityLevel > ATH9K_ANI_OFDM_DEF_LEVEL) ? -- immunityLevel : ATH9K_ANI_OFDM_DEF_LEVEL; -+ aniState->ofdmNoiseImmunityLevel = immunityLevel; - - entry_ofdm = &ofdm_level_table[aniState->ofdmNoiseImmunityLevel]; - entry_cck = &cck_level_table[aniState->cckNoiseImmunityLevel]; -@@ -292,12 +170,22 @@ static void ath9k_hw_set_ofdm_nil(struct - ATH9K_ANI_FIRSTEP_LEVEL, - entry_ofdm->fir_step_level); - -- if ((aniState->noiseFloor >= aniState->rssiThrHigh) && -- (!aniState->ofdmWeakSigDetectOff != -- entry_ofdm->ofdm_weak_signal_on)) { -+ weak_sig = entry_ofdm->ofdm_weak_signal_on; -+ if (ah->opmode == NL80211_IFTYPE_STATION && -+ BEACON_RSSI(ah) <= aniState->rssiThrHigh) -+ weak_sig = true; +- ath_dbg(common, BEACON, +- "slot %d [tsf %llu tsftu %u intval %u] vif %p\n", +- slot, tsf, tsftu / ATH_BCBUF, intval, vif); +- } else { +- slot = 0; +- vif = sc->beacon.bslot[slot]; +- } ++ slot = ath9k_beacon_choose_slot(sc); ++ vif = sc->beacon.bslot[slot]; + ++ if (!vif || !vif->bss_conf.enable_beacon) ++ return; + +- bfaddr = 0; +- if (vif) { +- bf = ath_beacon_generate(sc->hw, vif); +- if (bf != NULL) { +- bfaddr = bf->bf_daddr; +- bc = 1; +- } ++ bf = ath9k_beacon_generate(sc->hw, vif); ++ WARN_ON(!bf); + +- if (sc->beacon.bmisscnt != 0) { +- ath_dbg(common, BSTUCK, +- "resume beacon xmit after %u misses\n", +- sc->beacon.bmisscnt); +- sc->beacon.bmisscnt = 0; +- } ++ if (sc->beacon.bmisscnt != 0) { ++ ath_dbg(common, BSTUCK, "resume beacon xmit after %u misses\n", ++ sc->beacon.bmisscnt); ++ sc->beacon.bmisscnt = 0; + } + + /* +@@ -458,39 +384,37 @@ void ath_beacon_tasklet(unsigned long da + * set to ATH_BCBUF so this check is a noop. + */ + if (sc->beacon.updateslot == UPDATE) { +- sc->beacon.updateslot = COMMIT; /* commit next beacon */ ++ sc->beacon.updateslot = COMMIT; + sc->beacon.slotupdate = slot; +- } else if (sc->beacon.updateslot == COMMIT && sc->beacon.slotupdate == slot) { ++ } else if (sc->beacon.updateslot == COMMIT && ++ sc->beacon.slotupdate == slot) { + ah->slottime = sc->beacon.slottime; + ath9k_hw_init_global_settings(ah); + sc->beacon.updateslot = OK; + } +- if (bfaddr != 0) { + -+ if (aniState->ofdmWeakSigDetect != weak_sig) - ath9k_hw_ani_control(ah, - ATH9K_ANI_OFDM_WEAK_SIGNAL_DETECTION, - entry_ofdm->ofdm_weak_signal_on); ++ if (bf) { ++ ath9k_reset_beacon_status(sc); + -+ if (aniState->ofdmNoiseImmunityLevel >= ATH9K_ANI_OFDM_DEF_LEVEL) { -+ ah->config.ofdm_trig_high = ATH9K_ANI_OFDM_TRIG_HIGH; -+ ah->config.ofdm_trig_low = ATH9K_ANI_OFDM_TRIG_LOW_ABOVE_INI; -+ } else { -+ ah->config.ofdm_trig_high = ATH9K_ANI_OFDM_TRIG_HIGH_BELOW_INI; -+ ah->config.ofdm_trig_low = ATH9K_ANI_OFDM_TRIG_LOW; + /* NB: cabq traffic should already be queued and primed */ +- ath9k_hw_puttxbuf(ah, sc->beacon.beaconq, bfaddr); ++ ath9k_hw_puttxbuf(ah, sc->beacon.beaconq, bf->bf_daddr); + + if (!edma) + ath9k_hw_txstart(ah, sc->beacon.beaconq); +- +- sc->beacon.ast_be_xmit += bc; /* XXX per-vif? */ } } -@@ -308,11 +196,6 @@ static void ath9k_hw_ani_ofdm_err_trigge - if (!DO_ANI(ah)) - return; - -- if (!use_new_ani(ah)) { -- ath9k_hw_ani_ofdm_err_trigger_old(ah); -- return; +-static void ath9k_beacon_init(struct ath_softc *sc, +- u32 next_beacon, +- u32 beacon_period) ++static void ath9k_beacon_init(struct ath_softc *sc, u32 nexttbtt, u32 intval) + { +- if (test_bit(SC_OP_TSF_RESET, &sc->sc_flags)) { +- ath9k_ps_wakeup(sc); +- ath9k_hw_reset_tsf(sc->sc_ah); - } - - aniState = &ah->curchan->ani; - - if (aniState->ofdmNoiseImmunityLevel < ATH9K_ANI_OFDM_MAX_LEVEL) -@@ -329,22 +212,18 @@ static void ath9k_hw_set_cck_nil(struct - const struct ani_ofdm_level_entry *entry_ofdm; - const struct ani_cck_level_entry *entry_cck; - -- aniState->noiseFloor = BEACON_RSSI(ah); - ath_dbg(common, ANI, "**** ccklevel %d=>%d, rssi=%d[lo=%d hi=%d]\n", - aniState->cckNoiseImmunityLevel, immunityLevel, -- aniState->noiseFloor, aniState->rssiThrLow, -+ BEACON_RSSI(ah), aniState->rssiThrLow, - aniState->rssiThrHigh); - -- if ((ah->opmode == NL80211_IFTYPE_STATION || -- ah->opmode == NL80211_IFTYPE_ADHOC) && -- aniState->noiseFloor <= aniState->rssiThrLow && -+ if (ah->opmode == NL80211_IFTYPE_STATION && -+ BEACON_RSSI(ah) <= aniState->rssiThrLow && - immunityLevel > ATH9K_ANI_CCK_MAX_LEVEL_LOW_RSSI) - immunityLevel = ATH9K_ANI_CCK_MAX_LEVEL_LOW_RSSI; - - if (aniState->update_ani) -- aniState->cckNoiseImmunityLevel = -- (immunityLevel > ATH9K_ANI_CCK_DEF_LEVEL) ? -- immunityLevel : ATH9K_ANI_CCK_DEF_LEVEL; -+ aniState->cckNoiseImmunityLevel = immunityLevel; - - entry_ofdm = &ofdm_level_table[aniState->ofdmNoiseImmunityLevel]; - entry_cck = &cck_level_table[aniState->cckNoiseImmunityLevel]; -@@ -372,70 +251,12 @@ static void ath9k_hw_ani_cck_err_trigger - if (!DO_ANI(ah)) - return; +- ath9k_hw_beaconinit(sc->sc_ah, next_beacon, beacon_period); ++ struct ath_hw *ah = sc->sc_ah; -- if (!use_new_ani(ah)) { -- ath9k_hw_ani_cck_err_trigger_old(ah); -- return; +- if (test_bit(SC_OP_TSF_RESET, &sc->sc_flags)) { +- ath9k_ps_restore(sc); +- clear_bit(SC_OP_TSF_RESET, &sc->sc_flags); - } -- - aniState = &ah->curchan->ani; ++ ath9k_hw_disable_interrupts(ah); ++ ath9k_hw_reset_tsf(ah); ++ ath9k_beaconq_config(sc); ++ ath9k_hw_beaconinit(ah, nexttbtt, intval); ++ sc->beacon.bmisscnt = 0; ++ ath9k_hw_set_interrupts(ah); ++ ath9k_hw_enable_interrupts(ah); + } + + /* +@@ -498,32 +422,27 @@ static void ath9k_beacon_init(struct ath + * burst together. For the former arrange for the SWBA to be delivered for each + * slot. Slots that are not occupied will generate nothing. + */ +-static void ath_beacon_config_ap(struct ath_softc *sc, +- struct ath_beacon_config *conf) ++static void ath9k_beacon_config_ap(struct ath_softc *sc, ++ struct ath_beacon_config *conf) + { + struct ath_hw *ah = sc->sc_ah; ++ struct ath_common *common = ath9k_hw_common(ah); + u32 nexttbtt, intval; + + /* NB: the beacon interval is kept internally in TU's */ + intval = TU_TO_USEC(conf->beacon_interval); +- intval /= ATH_BCBUF; /* for staggered beacons */ ++ intval /= ATH_BCBUF; + nexttbtt = intval; - if (aniState->cckNoiseImmunityLevel < ATH9K_ANI_CCK_MAX_LEVEL) - ath9k_hw_set_cck_nil(ah, aniState->cckNoiseImmunityLevel + 1); +- /* +- * In AP mode we enable the beacon timers and SWBA interrupts to +- * prepare beacon frames. +- */ +- ah->imask |= ATH9K_INT_SWBA; +- ath_beaconq_config(sc); ++ if (conf->enable_beacon) ++ ah->imask |= ATH9K_INT_SWBA; ++ else ++ ah->imask &= ~ATH9K_INT_SWBA; + +- /* Set the computed AP beacon timers */ ++ ath_dbg(common, BEACON, "AP nexttbtt: %u intval: %u conf_intval: %u\n", ++ nexttbtt, intval, conf->beacon_interval); + +- ath9k_hw_disable_interrupts(ah); +- set_bit(SC_OP_TSF_RESET, &sc->sc_flags); + ath9k_beacon_init(sc, nexttbtt, intval); +- sc->beacon.bmisscnt = 0; +- ath9k_hw_set_interrupts(ah); +- ath9k_hw_enable_interrupts(ah); } --static void ath9k_hw_ani_lower_immunity_old(struct ath_hw *ah) --{ -- struct ar5416AniState *aniState; -- int32_t rssi; -- -- aniState = &ah->curchan->ani; -- -- if (ah->opmode == NL80211_IFTYPE_AP) { -- if (aniState->firstepLevel > 0) { -- if (ath9k_hw_ani_control(ah, ATH9K_ANI_FIRSTEP_LEVEL, -- aniState->firstepLevel - 1)) -- return; -- } -- } else { -- rssi = BEACON_RSSI(ah); -- if (rssi > aniState->rssiThrHigh) { -- /* XXX: Handle me */ -- } else if (rssi > aniState->rssiThrLow) { -- if (aniState->ofdmWeakSigDetectOff) { -- if (ath9k_hw_ani_control(ah, -- ATH9K_ANI_OFDM_WEAK_SIGNAL_DETECTION, -- true)) -- return; -- } -- if (aniState->firstepLevel > 0) { -- if (ath9k_hw_ani_control(ah, -- ATH9K_ANI_FIRSTEP_LEVEL, -- aniState->firstepLevel - 1)) -- return; -- } -- } else { -- if (aniState->firstepLevel > 0) { -- if (ath9k_hw_ani_control(ah, -- ATH9K_ANI_FIRSTEP_LEVEL, -- aniState->firstepLevel - 1)) -- return; -- } -- } -- } + /* +@@ -534,8 +453,8 @@ static void ath_beacon_config_ap(struct + * we'll receive a BMISS interrupt when we stop seeing beacons from the AP + * we've associated with. + */ +-static void ath_beacon_config_sta(struct ath_softc *sc, +- struct ath_beacon_config *conf) ++static void ath9k_beacon_config_sta(struct ath_softc *sc, ++ struct ath_beacon_config *conf) + { + struct ath_hw *ah = sc->sc_ah; + struct ath_common *common = ath9k_hw_common(ah); +@@ -654,8 +573,8 @@ static void ath_beacon_config_sta(struct + ath9k_hw_enable_interrupts(ah); + } + +-static void ath_beacon_config_adhoc(struct ath_softc *sc, +- struct ath_beacon_config *conf) ++static void ath9k_beacon_config_adhoc(struct ath_softc *sc, ++ struct ath_beacon_config *conf) + { + struct ath_hw *ah = sc->sc_ah; + struct ath_common *common = ath9k_hw_common(ah); +@@ -669,82 +588,53 @@ static void ath_beacon_config_adhoc(stru + tsf = roundup(ath9k_hw_gettsf32(ah) + TU_TO_USEC(FUDGE), intval); + nexttbtt = tsf + intval; + +- ath_dbg(common, BEACON, "IBSS nexttbtt %u intval %u (%u)\n", +- nexttbtt, intval, conf->beacon_interval); - -- if (aniState->spurImmunityLevel > 0) { -- if (ath9k_hw_ani_control(ah, ATH9K_ANI_SPUR_IMMUNITY_LEVEL, -- aniState->spurImmunityLevel - 1)) -- return; -- } +- /* +- * In IBSS mode enable the beacon timers but only enable SWBA interrupts +- * if we need to manually prepare beacon frames. Otherwise we use a +- * self-linked tx descriptor and let the hardware deal with things. +- */ +- ah->imask |= ATH9K_INT_SWBA; - -- if (aniState->noiseImmunityLevel > 0) { -- ath9k_hw_ani_control(ah, ATH9K_ANI_NOISE_IMMUNITY_LEVEL, -- aniState->noiseImmunityLevel - 1); -- return; -- } --} +- ath_beaconq_config(sc); ++ if (conf->enable_beacon) ++ ah->imask |= ATH9K_INT_SWBA; ++ else ++ ah->imask &= ~ATH9K_INT_SWBA; + +- /* Set the computed ADHOC beacon timers */ ++ ath_dbg(common, BEACON, "IBSS nexttbtt: %u intval: %u conf_intval: %u\n", ++ nexttbtt, intval, conf->beacon_interval); + +- ath9k_hw_disable_interrupts(ah); + ath9k_beacon_init(sc, nexttbtt, intval); +- sc->beacon.bmisscnt = 0; - - /* - * only lower either OFDM or CCK errors per turn - * we lower the other one next time -@@ -446,11 +267,6 @@ static void ath9k_hw_ani_lower_immunity( +- ath9k_hw_set_interrupts(ah); +- ath9k_hw_enable_interrupts(ah); + } - aniState = &ah->curchan->ani; +-static bool ath9k_allow_beacon_config(struct ath_softc *sc, +- struct ieee80211_vif *vif) ++bool ath9k_allow_beacon_config(struct ath_softc *sc, struct ieee80211_vif *vif) + { +- struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf; + struct ath_common *common = ath9k_hw_common(sc->sc_ah); +- struct ieee80211_bss_conf *bss_conf = &vif->bss_conf; + struct ath_vif *avp = (void *)vif->drv_priv; -- if (!use_new_ani(ah)) { -- ath9k_hw_ani_lower_immunity_old(ah); -- return; +- /* +- * Can not have different beacon interval on multiple +- * AP interface case +- */ +- if ((sc->sc_ah->opmode == NL80211_IFTYPE_AP) && +- (sc->nbcnvifs > 1) && +- (vif->type == NL80211_IFTYPE_AP) && +- (cur_conf->beacon_interval != bss_conf->beacon_int)) { +- ath_dbg(common, CONFIG, +- "Changing beacon interval of multiple AP interfaces !\n"); +- return false; - } -- - /* lower OFDM noise immunity */ - if (aniState->ofdmNoiseImmunityLevel > 0 && - (aniState->ofdmsTurn || aniState->cckNoiseImmunityLevel == 0)) { -@@ -463,72 +279,6 @@ static void ath9k_hw_ani_lower_immunity( - ath9k_hw_set_cck_nil(ah, aniState->cckNoiseImmunityLevel - 1); +- /* +- * Can not configure station vif's beacon config +- * while on AP opmode +- */ +- if ((sc->sc_ah->opmode == NL80211_IFTYPE_AP) && +- (vif->type != NL80211_IFTYPE_AP)) { +- ath_dbg(common, CONFIG, +- "STA vif's beacon not allowed on AP mode\n"); +- return false; ++ if (sc->sc_ah->opmode == NL80211_IFTYPE_AP) { ++ if ((vif->type != NL80211_IFTYPE_AP) || ++ (sc->nbcnvifs > 1)) { ++ ath_dbg(common, CONFIG, ++ "An AP interface is already present !\n"); ++ return false; ++ } + } +- /* +- * Do not allow beacon config if HW was already configured +- * with another STA vif +- */ +- if ((sc->sc_ah->opmode == NL80211_IFTYPE_STATION) && +- (vif->type == NL80211_IFTYPE_STATION) && +- test_bit(SC_OP_BEACONS, &sc->sc_flags) && +- !avp->primary_sta_vif) { +- ath_dbg(common, CONFIG, +- "Beacon already configured for a station interface\n"); +- return false; ++ ++ if (sc->sc_ah->opmode == NL80211_IFTYPE_STATION) { ++ if ((vif->type == NL80211_IFTYPE_STATION) && ++ test_bit(SC_OP_BEACONS, &sc->sc_flags) && ++ !avp->primary_sta_vif) { ++ ath_dbg(common, CONFIG, ++ "Beacon already configured for a station interface\n"); ++ return false; ++ } + } ++ + return true; } --static void ath9k_ani_reset_old(struct ath_hw *ah, bool is_scanning) --{ -- struct ar5416AniState *aniState; -- struct ath9k_channel *chan = ah->curchan; -- struct ath_common *common = ath9k_hw_common(ah); -- -- if (!DO_ANI(ah)) +-void ath_beacon_config(struct ath_softc *sc, struct ieee80211_vif *vif) ++static void ath9k_cache_beacon_config(struct ath_softc *sc, ++ struct ieee80211_bss_conf *bss_conf) + { ++ struct ath_common *common = ath9k_hw_common(sc->sc_ah); + struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf; +- struct ieee80211_bss_conf *bss_conf = &vif->bss_conf; + +- if (!ath9k_allow_beacon_config(sc, vif)) - return; ++ ath_dbg(common, BEACON, ++ "Caching beacon data for BSS: %pM\n", bss_conf->bssid); + +- /* Setup the beacon configuration parameters */ + cur_conf->beacon_interval = bss_conf->beacon_int; + cur_conf->dtim_period = bss_conf->dtim_period; + cur_conf->listen_interval = 1; +@@ -769,73 +659,59 @@ void ath_beacon_config(struct ath_softc + if (cur_conf->dtim_period == 0) + cur_conf->dtim_period = 1; + +- ath_set_beacon(sc); + } + +-static bool ath_has_valid_bslot(struct ath_softc *sc) ++void ath9k_beacon_config(struct ath_softc *sc, struct ieee80211_vif *vif, ++ u32 changed) + { +- struct ath_vif *avp; +- int slot; +- bool found = false; ++ struct ieee80211_bss_conf *bss_conf = &vif->bss_conf; ++ struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf; + +- for (slot = 0; slot < ATH_BCBUF; slot++) { +- if (sc->beacon.bslot[slot]) { +- avp = (void *)sc->beacon.bslot[slot]->drv_priv; +- if (avp->is_bslot_active) { +- found = true; +- break; +- } ++ ath9k_cache_beacon_config(sc, bss_conf); ++ ++ if (sc->sc_ah->opmode == NL80211_IFTYPE_STATION) { ++ ath9k_set_beacon(sc); ++ set_bit(SC_OP_BEACONS, &sc->sc_flags); ++ } else { ++ /* ++ * Take care of multiple interfaces when ++ * enabling/disabling SWBA. ++ */ ++ if (changed & BSS_CHANGED_BEACON_ENABLED) { ++ if (!bss_conf->enable_beacon && ++ (sc->nbcnvifs <= 1)) ++ cur_conf->enable_beacon = false; ++ else if (bss_conf->enable_beacon) ++ cur_conf->enable_beacon = true; + } ++ ++ ath9k_set_beacon(sc); ++ ++ if (cur_conf->enable_beacon) ++ set_bit(SC_OP_BEACONS, &sc->sc_flags); ++ else ++ clear_bit(SC_OP_BEACONS, &sc->sc_flags); + } +- return found; + } + - -- aniState = &ah->curchan->ani; -- -- if (ah->opmode != NL80211_IFTYPE_STATION -- && ah->opmode != NL80211_IFTYPE_ADHOC) { -- ath_dbg(common, ANI, "Reset ANI state opmode %u\n", ah->opmode); -- ah->stats.ast_ani_reset++; +-void ath_set_beacon(struct ath_softc *sc) ++void ath9k_set_beacon(struct ath_softc *sc) + { + struct ath_common *common = ath9k_hw_common(sc->sc_ah); + struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf; + + switch (sc->sc_ah->opmode) { + case NL80211_IFTYPE_AP: +- if (ath_has_valid_bslot(sc)) +- ath_beacon_config_ap(sc, cur_conf); ++ ath9k_beacon_config_ap(sc, cur_conf); + break; + case NL80211_IFTYPE_ADHOC: + case NL80211_IFTYPE_MESH_POINT: +- ath_beacon_config_adhoc(sc, cur_conf); ++ ath9k_beacon_config_adhoc(sc, cur_conf); + break; + case NL80211_IFTYPE_STATION: +- ath_beacon_config_sta(sc, cur_conf); ++ ath9k_beacon_config_sta(sc, cur_conf); + break; + default: + ath_dbg(common, CONFIG, "Unsupported beaconing mode\n"); + return; + } - -- if (ah->opmode == NL80211_IFTYPE_AP) { -- /* -- * ath9k_hw_ani_control() will only process items set on -- * ah->ani_function -- */ -- if (IS_CHAN_2GHZ(chan)) -- ah->ani_function = (ATH9K_ANI_SPUR_IMMUNITY_LEVEL | -- ATH9K_ANI_FIRSTEP_LEVEL); -- else -- ah->ani_function = 0; -- } +- set_bit(SC_OP_BEACONS, &sc->sc_flags); +-} - -- ath9k_hw_ani_control(ah, ATH9K_ANI_NOISE_IMMUNITY_LEVEL, 0); -- ath9k_hw_ani_control(ah, ATH9K_ANI_SPUR_IMMUNITY_LEVEL, 0); -- ath9k_hw_ani_control(ah, ATH9K_ANI_FIRSTEP_LEVEL, 0); -- ath9k_hw_ani_control(ah, ATH9K_ANI_OFDM_WEAK_SIGNAL_DETECTION, -- !ATH9K_ANI_USE_OFDM_WEAK_SIG); -- ath9k_hw_ani_control(ah, ATH9K_ANI_CCK_WEAK_SIGNAL_THR, -- ATH9K_ANI_CCK_WEAK_SIG_THR); +-void ath9k_set_beaconing_status(struct ath_softc *sc, bool status) +-{ +- struct ath_hw *ah = sc->sc_ah; - -- ath9k_ani_restart(ah); +- if (!ath_has_valid_bslot(sc)) { +- clear_bit(SC_OP_BEACONS, &sc->sc_flags); - return; - } - -- if (aniState->noiseImmunityLevel != 0) -- ath9k_hw_ani_control(ah, ATH9K_ANI_NOISE_IMMUNITY_LEVEL, -- aniState->noiseImmunityLevel); -- if (aniState->spurImmunityLevel != 0) -- ath9k_hw_ani_control(ah, ATH9K_ANI_SPUR_IMMUNITY_LEVEL, -- aniState->spurImmunityLevel); -- if (aniState->ofdmWeakSigDetectOff) -- ath9k_hw_ani_control(ah, ATH9K_ANI_OFDM_WEAK_SIGNAL_DETECTION, -- !aniState->ofdmWeakSigDetectOff); -- if (aniState->cckWeakSigThreshold) -- ath9k_hw_ani_control(ah, ATH9K_ANI_CCK_WEAK_SIGNAL_THR, -- aniState->cckWeakSigThreshold); -- if (aniState->firstepLevel != 0) -- ath9k_hw_ani_control(ah, ATH9K_ANI_FIRSTEP_LEVEL, -- aniState->firstepLevel); -- -- ath9k_ani_restart(ah); -- -- ENABLE_REGWRITE_BUFFER(ah); -- -- REG_WRITE(ah, AR_PHY_ERR_MASK_1, AR_PHY_ERR_OFDM_TIMING); -- REG_WRITE(ah, AR_PHY_ERR_MASK_2, AR_PHY_ERR_CCK_TIMING); -- -- REGWRITE_BUFFER_FLUSH(ah); --} -- - /* - * Restore the ANI parameters in the HAL and reset the statistics. - * This routine should be called for every hardware reset and for -@@ -539,13 +289,11 @@ void ath9k_ani_reset(struct ath_hw *ah, - struct ar5416AniState *aniState = &ah->curchan->ani; - struct ath9k_channel *chan = ah->curchan; - struct ath_common *common = ath9k_hw_common(ah); -+ int ofdm_nil, cck_nil; +- ath9k_ps_wakeup(sc); +- if (status) { +- /* Re-enable beaconing */ +- ah->imask |= ATH9K_INT_SWBA; +- ath9k_hw_set_interrupts(ah); +- } else { +- /* Disable SWBA interrupt */ +- ah->imask &= ~ATH9K_INT_SWBA; +- ath9k_hw_set_interrupts(ah); +- tasklet_kill(&sc->bcon_tasklet); +- ath9k_hw_stop_dma_queue(ah, sc->beacon.beaconq); +- } +- ath9k_ps_restore(sc); + } +--- a/drivers/net/wireless/ath/ath9k/debug.c ++++ b/drivers/net/wireless/ath/ath9k/debug.c +@@ -206,10 +206,9 @@ static ssize_t write_file_disable_ani(st - if (!DO_ANI(ah)) - return; + if (disable_ani) { + clear_bit(SC_OP_ANI_RUN, &sc->sc_flags); +- del_timer_sync(&common->ani.timer); ++ ath_stop_ani(sc); + } else { +- set_bit(SC_OP_ANI_RUN, &sc->sc_flags); +- ath_start_ani(common); ++ ath_check_ani(sc); + } + + return count; +--- a/drivers/net/wireless/ath/ath9k/debug.h ++++ b/drivers/net/wireless/ath/ath9k/debug.h +@@ -32,6 +32,19 @@ struct ath_buf; + #define RESET_STAT_INC(sc, type) do { } while (0) + #endif + ++enum ath_reset_type { ++ RESET_TYPE_BB_HANG, ++ RESET_TYPE_BB_WATCHDOG, ++ RESET_TYPE_FATAL_INT, ++ RESET_TYPE_TX_ERROR, ++ RESET_TYPE_TX_HANG, ++ RESET_TYPE_PLL_HANG, ++ RESET_TYPE_MAC_HANG, ++ RESET_TYPE_BEACON_STUCK, ++ RESET_TYPE_MCI, ++ __RESET_TYPE_MAX ++}; ++ + #ifdef CONFIG_ATH9K_DEBUGFS -- if (!use_new_ani(ah)) -- return ath9k_ani_reset_old(ah, is_scanning); + /** +@@ -209,17 +222,6 @@ struct ath_rx_stats { + u32 rx_frags; + }; + +-enum ath_reset_type { +- RESET_TYPE_BB_HANG, +- RESET_TYPE_BB_WATCHDOG, +- RESET_TYPE_FATAL_INT, +- RESET_TYPE_TX_ERROR, +- RESET_TYPE_TX_HANG, +- RESET_TYPE_PLL_HANG, +- RESET_TYPE_MAC_HANG, +- __RESET_TYPE_MAX +-}; - - BUG_ON(aniState == NULL); - ah->stats.ast_ani_reset++; + struct ath_stats { + struct ath_interrupt_stats istats; + struct ath_tx_stats txstats[ATH9K_NUM_TX_QUEUES]; +--- a/drivers/net/wireless/ath/ath9k/htc_drv_main.c ++++ b/drivers/net/wireless/ath/ath9k/htc_drv_main.c +@@ -1111,7 +1111,7 @@ static int ath9k_htc_add_interface(struc + + if ((priv->ah->opmode == NL80211_IFTYPE_AP) && + !test_bit(OP_ANI_RUNNING, &priv->op_flags)) { +- ath9k_hw_set_tsfadjust(priv->ah, 1); ++ ath9k_hw_set_tsfadjust(priv->ah, true); + ath9k_htc_start_ani(priv); + } + +--- a/drivers/net/wireless/ath/ath9k/hw.c ++++ b/drivers/net/wireless/ath/ath9k/hw.c +@@ -2908,9 +2908,9 @@ void ath9k_hw_reset_tsf(struct ath_hw *a + } + EXPORT_SYMBOL(ath9k_hw_reset_tsf); -@@ -563,6 +311,11 @@ void ath9k_ani_reset(struct ath_hw *ah, - /* always allow mode (on/off) to be controlled */ - ah->ani_function |= ATH9K_ANI_MODE; +-void ath9k_hw_set_tsfadjust(struct ath_hw *ah, u32 setting) ++void ath9k_hw_set_tsfadjust(struct ath_hw *ah, bool set) + { +- if (setting) ++ if (set) + ah->misc_mode |= AR_PCU_TX_ADD_TSF; + else + ah->misc_mode &= ~AR_PCU_TX_ADD_TSF; +--- a/drivers/net/wireless/ath/ath9k/hw.h ++++ b/drivers/net/wireless/ath/ath9k/hw.h +@@ -943,7 +943,7 @@ u32 ath9k_hw_gettsf32(struct ath_hw *ah) + u64 ath9k_hw_gettsf64(struct ath_hw *ah); + void ath9k_hw_settsf64(struct ath_hw *ah, u64 tsf64); + void ath9k_hw_reset_tsf(struct ath_hw *ah); +-void ath9k_hw_set_tsfadjust(struct ath_hw *ah, u32 setting); ++void ath9k_hw_set_tsfadjust(struct ath_hw *ah, bool set); + void ath9k_hw_init_global_settings(struct ath_hw *ah); + u32 ar9003_get_pll_sqsum_dvc(struct ath_hw *ah); + void ath9k_hw_set11nmac2040(struct ath_hw *ah); +--- a/drivers/net/wireless/ath/ath9k/init.c ++++ b/drivers/net/wireless/ath/ath9k/init.c +@@ -560,7 +560,7 @@ static int ath9k_init_softc(u16 devid, s + spin_lock_init(&sc->debug.samp_lock); + #endif + tasklet_init(&sc->intr_tq, ath9k_tasklet, (unsigned long)sc); +- tasklet_init(&sc->bcon_tasklet, ath_beacon_tasklet, ++ tasklet_init(&sc->bcon_tasklet, ath9k_beacon_tasklet, + (unsigned long)sc); + + INIT_WORK(&sc->hw_reset_work, ath_reset_work); +--- a/drivers/net/wireless/ath/ath9k/link.c ++++ b/drivers/net/wireless/ath/ath9k/link.c +@@ -50,8 +50,7 @@ void ath_tx_complete_poll_work(struct wo + if (needreset) { + ath_dbg(ath9k_hw_common(sc->sc_ah), RESET, + "tx hung, resetting the chip\n"); +- RESET_STAT_INC(sc, RESET_TYPE_TX_HANG); +- ieee80211_queue_work(sc->hw, &sc->hw_reset_work); ++ ath9k_queue_reset(sc, RESET_TYPE_TX_HANG); + return; + } -+ ofdm_nil = max_t(int, ATH9K_ANI_OFDM_DEF_LEVEL, -+ aniState->ofdmNoiseImmunityLevel); -+ cck_nil = max_t(int, ATH9K_ANI_CCK_DEF_LEVEL, -+ aniState->cckNoiseImmunityLevel); -+ - if (is_scanning || - (ah->opmode != NL80211_IFTYPE_STATION && - ah->opmode != NL80211_IFTYPE_ADHOC)) { -@@ -586,8 +339,8 @@ void ath9k_ani_reset(struct ath_hw *ah, - aniState->cckNoiseImmunityLevel); - - aniState->update_ani = false; -- ath9k_hw_set_ofdm_nil(ah, ATH9K_ANI_OFDM_DEF_LEVEL); -- ath9k_hw_set_cck_nil(ah, ATH9K_ANI_CCK_DEF_LEVEL); -+ ofdm_nil = ATH9K_ANI_OFDM_DEF_LEVEL; -+ cck_nil = ATH9K_ANI_CCK_DEF_LEVEL; +@@ -69,6 +68,7 @@ void ath_hw_check(struct work_struct *wo + unsigned long flags; + int busy; + u8 is_alive, nbeacon = 1; ++ enum ath_reset_type type; + + ath9k_ps_wakeup(sc); + is_alive = ath9k_hw_check_alive(sc->sc_ah); +@@ -78,7 +78,7 @@ void ath_hw_check(struct work_struct *wo + else if (!is_alive && AR_SREV_9300(sc->sc_ah)) { + ath_dbg(common, RESET, + "DCU stuck is detected. Schedule chip reset\n"); +- RESET_STAT_INC(sc, RESET_TYPE_MAC_HANG); ++ type = RESET_TYPE_MAC_HANG; + goto sched_reset; + } + +@@ -90,7 +90,7 @@ void ath_hw_check(struct work_struct *wo + busy, sc->hw_busy_count + 1); + if (busy >= 99) { + if (++sc->hw_busy_count >= 3) { +- RESET_STAT_INC(sc, RESET_TYPE_BB_HANG); ++ type = RESET_TYPE_BB_HANG; + goto sched_reset; } - } else { - /* -@@ -603,11 +356,9 @@ void ath9k_ani_reset(struct ath_hw *ah, - aniState->cckNoiseImmunityLevel); - - aniState->update_ani = true; -- ath9k_hw_set_ofdm_nil(ah, -- aniState->ofdmNoiseImmunityLevel); -- ath9k_hw_set_cck_nil(ah, -- aniState->cckNoiseImmunityLevel); + } else if (busy >= 0) { +@@ -102,7 +102,7 @@ void ath_hw_check(struct work_struct *wo + goto out; + + sched_reset: +- ieee80211_queue_work(sc->hw, &sc->hw_reset_work); ++ ath9k_queue_reset(sc, type); + out: + ath9k_ps_restore(sc); + } +@@ -119,8 +119,7 @@ static bool ath_hw_pll_rx_hang_check(str + count++; + if (count == 3) { + ath_dbg(common, RESET, "PLL WAR, resetting the chip\n"); +- RESET_STAT_INC(sc, RESET_TYPE_PLL_HANG); +- ieee80211_queue_work(sc->hw, &sc->hw_reset_work); ++ ath9k_queue_reset(sc, RESET_TYPE_PLL_HANG); + count = 0; + return true; + } +@@ -432,26 +431,69 @@ set_timer: } -+ ath9k_hw_set_ofdm_nil(ah, ofdm_nil); -+ ath9k_hw_set_cck_nil(ah, cck_nil); + } - /* - * enable phy counters if hw supports or if not, enable phy -@@ -627,9 +378,6 @@ static bool ath9k_hw_ani_read_counters(s +-void ath_start_ani(struct ath_common *common) ++void ath_start_ani(struct ath_softc *sc) { - struct ath_common *common = ath9k_hw_common(ah); - struct ar5416AniState *aniState = &ah->curchan->ani; -- u32 ofdm_base = 0; -- u32 cck_base = 0; -- u32 ofdmPhyErrCnt, cckPhyErrCnt; - u32 phyCnt1, phyCnt2; - int32_t listenTime; - -@@ -642,11 +390,6 @@ static bool ath9k_hw_ani_read_counters(s - return false; - } +- struct ath_hw *ah = common->ah; ++ struct ath_hw *ah = sc->sc_ah; ++ struct ath_common *common = ath9k_hw_common(ah); + unsigned long timestamp = jiffies_to_msecs(jiffies); +- struct ath_softc *sc = (struct ath_softc *) common->priv; -- if (!use_new_ani(ah)) { -- ofdm_base = AR_PHY_COUNTMAX - ah->config.ofdm_trig_high; -- cck_base = AR_PHY_COUNTMAX - ah->config.cck_trig_high; -- } +- if (!test_bit(SC_OP_ANI_RUN, &sc->sc_flags)) +- return; - - aniState->listenTime += listenTime; - - ath9k_hw_update_mibstats(ah, &ah->ah_mibStats); -@@ -654,35 +397,12 @@ static bool ath9k_hw_ani_read_counters(s - phyCnt1 = REG_READ(ah, AR_PHY_ERR_1); - phyCnt2 = REG_READ(ah, AR_PHY_ERR_2); - -- if (!use_new_ani(ah) && (phyCnt1 < ofdm_base || phyCnt2 < cck_base)) { -- if (phyCnt1 < ofdm_base) { -- ath_dbg(common, ANI, -- "phyCnt1 0x%x, resetting counter value to 0x%x\n", -- phyCnt1, ofdm_base); -- REG_WRITE(ah, AR_PHY_ERR_1, ofdm_base); -- REG_WRITE(ah, AR_PHY_ERR_MASK_1, -- AR_PHY_ERR_OFDM_TIMING); -- } -- if (phyCnt2 < cck_base) { -- ath_dbg(common, ANI, -- "phyCnt2 0x%x, resetting counter value to 0x%x\n", -- phyCnt2, cck_base); -- REG_WRITE(ah, AR_PHY_ERR_2, cck_base); -- REG_WRITE(ah, AR_PHY_ERR_MASK_2, -- AR_PHY_ERR_CCK_TIMING); -- } -- return false; -- } -+ ah->stats.ast_ani_ofdmerrs += phyCnt1 - aniState->ofdmPhyErrCount; -+ aniState->ofdmPhyErrCount = phyCnt1; +- if (sc->hw->conf.flags & IEEE80211_CONF_OFFCHANNEL) ++ if (common->disable_ani || ++ !test_bit(SC_OP_ANI_RUN, &sc->sc_flags) || ++ (sc->hw->conf.flags & IEEE80211_CONF_OFFCHANNEL)) + return; + + common->ani.longcal_timer = timestamp; + common->ani.shortcal_timer = timestamp; + common->ani.checkani_timer = timestamp; + ++ ath_dbg(common, ANI, "Starting ANI\n"); + mod_timer(&common->ani.timer, + jiffies + msecs_to_jiffies((u32)ah->config.ani_poll_interval)); + } + ++void ath_stop_ani(struct ath_softc *sc) ++{ ++ struct ath_common *common = ath9k_hw_common(sc->sc_ah); ++ ++ ath_dbg(common, ANI, "Stopping ANI\n"); ++ del_timer_sync(&common->ani.timer); ++} ++ ++void ath_check_ani(struct ath_softc *sc) ++{ ++ struct ath_hw *ah = sc->sc_ah; ++ struct ath_beacon_config *cur_conf = &sc->cur_beacon_conf; ++ ++ /* ++ * Check for the various conditions in which ANI has to ++ * be stopped. ++ */ ++ if (ah->opmode == NL80211_IFTYPE_ADHOC) { ++ if (!cur_conf->enable_beacon) ++ goto stop_ani; ++ } else if (ah->opmode == NL80211_IFTYPE_AP) { ++ if (!cur_conf->enable_beacon) { ++ /* ++ * Disable ANI only when there are no ++ * associated stations. ++ */ ++ if (!test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags)) ++ goto stop_ani; ++ } ++ } else if (ah->opmode == NL80211_IFTYPE_STATION) { ++ if (!test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags)) ++ goto stop_ani; ++ } + -+ ah->stats.ast_ani_cckerrs += phyCnt2 - aniState->cckPhyErrCount; -+ aniState->cckPhyErrCount = phyCnt2; ++ set_bit(SC_OP_ANI_RUN, &sc->sc_flags); ++ ath_start_ani(sc); ++ return; ++ ++stop_ani: ++ clear_bit(SC_OP_ANI_RUN, &sc->sc_flags); ++ ath_stop_ani(sc); ++} ++ + void ath_update_survey_nf(struct ath_softc *sc, int channel) + { + struct ath_hw *ah = sc->sc_ah; +--- a/drivers/net/wireless/ath/ath9k/main.c ++++ b/drivers/net/wireless/ath/ath9k/main.c +@@ -167,8 +167,6 @@ static void ath_cancel_work(struct ath_s -- ofdmPhyErrCnt = phyCnt1 - ofdm_base; -- ah->stats.ast_ani_ofdmerrs += -- ofdmPhyErrCnt - aniState->ofdmPhyErrCount; -- aniState->ofdmPhyErrCount = ofdmPhyErrCnt; + static void ath_restart_work(struct ath_softc *sc) + { +- struct ath_common *common = ath9k_hw_common(sc->sc_ah); - -- cckPhyErrCnt = phyCnt2 - cck_base; -- ah->stats.ast_ani_cckerrs += -- cckPhyErrCnt - aniState->cckPhyErrCount; -- aniState->cckPhyErrCount = cckPhyErrCnt; - return true; + ieee80211_queue_delayed_work(sc->hw, &sc->tx_complete_work, 0); + + if (AR_SREV_9340(sc->sc_ah) || AR_SREV_9485(sc->sc_ah) || +@@ -177,21 +175,18 @@ static void ath_restart_work(struct ath_ + msecs_to_jiffies(ATH_PLL_WORK_INTERVAL)); + + ath_start_rx_poll(sc, 3); +- +- if (!common->disable_ani) +- ath_start_ani(common); ++ ath_start_ani(sc); } -@@ -716,21 +436,10 @@ void ath9k_hw_ani_monitor(struct ath_hw - - if (aniState->listenTime > ah->aniperiod) { - if (cckPhyErrRate < ah->config.cck_trig_low && -- ((ofdmPhyErrRate < ah->config.ofdm_trig_low && -- aniState->ofdmNoiseImmunityLevel < -- ATH9K_ANI_OFDM_DEF_LEVEL) || -- (ofdmPhyErrRate < ATH9K_ANI_OFDM_TRIG_LOW_ABOVE_INI && -- aniState->ofdmNoiseImmunityLevel >= -- ATH9K_ANI_OFDM_DEF_LEVEL))) { -+ ofdmPhyErrRate < ah->config.ofdm_trig_low) { - ath9k_hw_ani_lower_immunity(ah); - aniState->ofdmsTurn = !aniState->ofdmsTurn; -- } else if ((ofdmPhyErrRate > ah->config.ofdm_trig_high && -- aniState->ofdmNoiseImmunityLevel >= -- ATH9K_ANI_OFDM_DEF_LEVEL) || -- (ofdmPhyErrRate > -- ATH9K_ANI_OFDM_TRIG_HIGH_BELOW_INI && -- aniState->ofdmNoiseImmunityLevel < -- ATH9K_ANI_OFDM_DEF_LEVEL)) { -+ } else if (ofdmPhyErrRate > ah->config.ofdm_trig_high) { - ath9k_hw_ani_ofdm_err_trigger(ah); - aniState->ofdmsTurn = false; - } else if (cckPhyErrRate > ah->config.cck_trig_high) { -@@ -778,49 +487,6 @@ void ath9k_hw_disable_mib_counters(struc + static bool ath_prepare_reset(struct ath_softc *sc, bool retry_tx, bool flush) + { + struct ath_hw *ah = sc->sc_ah; +- struct ath_common *common = ath9k_hw_common(ah); + bool ret = true; + + ieee80211_stop_queues(sc->hw); + + sc->hw_busy_count = 0; +- del_timer_sync(&common->ani.timer); ++ ath_stop_ani(sc); + del_timer_sync(&sc->rx_poll_timer); + + ath9k_debug_samp_bb_mac(sc); +@@ -236,7 +231,7 @@ static bool ath_complete_reset(struct at + if (!test_bit(SC_OP_BEACONS, &sc->sc_flags)) + goto work; + +- ath_set_beacon(sc); ++ ath9k_set_beacon(sc); + + if (ah->opmode == NL80211_IFTYPE_STATION && + test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags)) { +@@ -365,6 +360,7 @@ void ath9k_tasklet(unsigned long data) + struct ath_softc *sc = (struct ath_softc *)data; + struct ath_hw *ah = sc->sc_ah; + struct ath_common *common = ath9k_hw_common(ah); ++ enum ath_reset_type type; + unsigned long flags; + u32 status = sc->intrstatus; + u32 rxmask; +@@ -374,18 +370,13 @@ void ath9k_tasklet(unsigned long data) + + if ((status & ATH9K_INT_FATAL) || + (status & ATH9K_INT_BB_WATCHDOG)) { +-#ifdef CONFIG_ATH9K_DEBUGFS +- enum ath_reset_type type; + + if (status & ATH9K_INT_FATAL) + type = RESET_TYPE_FATAL_INT; + else + type = RESET_TYPE_BB_WATCHDOG; + +- RESET_STAT_INC(sc, type); +-#endif +- set_bit(SC_OP_HW_RESET, &sc->sc_flags); +- ieee80211_queue_work(sc->hw, &sc->hw_reset_work); ++ ath9k_queue_reset(sc, type); + goto out; + } + +@@ -575,6 +566,15 @@ static int ath_reset(struct ath_softc *s + return r; } - EXPORT_SYMBOL(ath9k_hw_disable_mib_counters); --/* -- * Process a MIB interrupt. We may potentially be invoked because -- * any of the MIB counters overflow/trigger so don't assume we're -- * here because a PHY error counter triggered. -- */ --void ath9k_hw_proc_mib_event(struct ath_hw *ah) ++void ath9k_queue_reset(struct ath_softc *sc, enum ath_reset_type type) ++{ ++#ifdef CONFIG_ATH9K_DEBUGFS ++ RESET_STAT_INC(sc, type); ++#endif ++ set_bit(SC_OP_HW_RESET, &sc->sc_flags); ++ ieee80211_queue_work(sc->hw, &sc->hw_reset_work); ++} ++ + void ath_reset_work(struct work_struct *work) + { + struct ath_softc *sc = container_of(work, struct ath_softc, hw_reset_work); +@@ -841,16 +841,6 @@ bool ath9k_uses_beacons(int type) + } + } + +-static void ath9k_reclaim_beacon(struct ath_softc *sc, +- struct ieee80211_vif *vif) -{ -- u32 phyCnt1, phyCnt2; -- -- /* Reset these counters regardless */ -- REG_WRITE(ah, AR_FILT_OFDM, 0); -- REG_WRITE(ah, AR_FILT_CCK, 0); -- if (!(REG_READ(ah, AR_SLP_MIB_CTRL) & AR_SLP_MIB_PENDING)) -- REG_WRITE(ah, AR_SLP_MIB_CTRL, AR_SLP_MIB_CLEAR); -- -- /* Clear the mib counters and save them in the stats */ -- ath9k_hw_update_mibstats(ah, &ah->ah_mibStats); -- -- if (!DO_ANI(ah)) { -- /* -- * We must always clear the interrupt cause by -- * resetting the phy error regs. -- */ -- REG_WRITE(ah, AR_PHY_ERR_1, 0); -- REG_WRITE(ah, AR_PHY_ERR_2, 0); -- return; -- } -- -- /* NB: these are not reset-on-read */ -- phyCnt1 = REG_READ(ah, AR_PHY_ERR_1); -- phyCnt2 = REG_READ(ah, AR_PHY_ERR_2); -- if (((phyCnt1 & AR_MIBCNT_INTRMASK) == AR_MIBCNT_INTRMASK) || -- ((phyCnt2 & AR_MIBCNT_INTRMASK) == AR_MIBCNT_INTRMASK)) { +- struct ath_vif *avp = (void *)vif->drv_priv; - -- if (!use_new_ani(ah)) -- ath9k_hw_ani_read_counters(ah); -- -- /* NB: always restart to insure the h/w counters are reset */ -- ath9k_ani_restart(ah); -- } +- ath9k_set_beaconing_status(sc, false); +- ath_beacon_return(sc, avp); +- ath9k_set_beaconing_status(sc, true); -} --EXPORT_SYMBOL(ath9k_hw_proc_mib_event); - - void ath9k_hw_ani_setup(struct ath_hw *ah) + static void ath9k_vif_iter(void *data, u8 *mac, struct ieee80211_vif *vif) { - int i; -@@ -845,50 +511,31 @@ void ath9k_hw_ani_init(struct ath_hw *ah + struct ath9k_vif_iter_data *iter_data = data; +@@ -918,18 +908,14 @@ static void ath9k_calculate_summary_stat - ath_dbg(common, ANI, "Initialize ANI\n"); + ath9k_calculate_iter_data(hw, vif, &iter_data); -- if (use_new_ani(ah)) { -- ah->config.ofdm_trig_high = ATH9K_ANI_OFDM_TRIG_HIGH_NEW; -- ah->config.ofdm_trig_low = ATH9K_ANI_OFDM_TRIG_LOW_NEW; -+ ah->config.ofdm_trig_high = ATH9K_ANI_OFDM_TRIG_HIGH; -+ ah->config.ofdm_trig_low = ATH9K_ANI_OFDM_TRIG_LOW; +- /* Set BSSID mask. */ + memcpy(common->bssidmask, iter_data.mask, ETH_ALEN); + ath_hw_setbssidmask(common); -- ah->config.cck_trig_high = ATH9K_ANI_CCK_TRIG_HIGH_NEW; -- ah->config.cck_trig_low = ATH9K_ANI_CCK_TRIG_LOW_NEW; -- } else { -- ah->config.ofdm_trig_high = ATH9K_ANI_OFDM_TRIG_HIGH_OLD; -- ah->config.ofdm_trig_low = ATH9K_ANI_OFDM_TRIG_LOW_OLD; +- /* Set op-mode & TSF */ + if (iter_data.naps > 0) { +- ath9k_hw_set_tsfadjust(ah, 1); +- set_bit(SC_OP_TSF_RESET, &sc->sc_flags); ++ ath9k_hw_set_tsfadjust(ah, true); + ah->opmode = NL80211_IFTYPE_AP; + } else { +- ath9k_hw_set_tsfadjust(ah, 0); +- clear_bit(SC_OP_TSF_RESET, &sc->sc_flags); ++ ath9k_hw_set_tsfadjust(ah, false); + + if (iter_data.nmeshes) + ah->opmode = NL80211_IFTYPE_MESH_POINT; +@@ -941,45 +927,14 @@ static void ath9k_calculate_summary_stat + ah->opmode = NL80211_IFTYPE_STATION; + } + +- /* +- * Enable MIB interrupts when there are hardware phy counters. +- */ ++ ath9k_hw_setopmode(ah); ++ + if ((iter_data.nstations + iter_data.nadhocs + iter_data.nmeshes) > 0) + ah->imask |= ATH9K_INT_TSFOOR; + else + ah->imask &= ~ATH9K_INT_TSFOOR; + + ath9k_hw_set_interrupts(ah); - -- ah->config.cck_trig_high = ATH9K_ANI_CCK_TRIG_HIGH_OLD; -- ah->config.cck_trig_low = ATH9K_ANI_CCK_TRIG_LOW_OLD; -- } -+ ah->config.cck_trig_high = ATH9K_ANI_CCK_TRIG_HIGH; -+ ah->config.cck_trig_low = ATH9K_ANI_CCK_TRIG_LOW; - - for (i = 0; i < ARRAY_SIZE(ah->channels); i++) { - struct ath9k_channel *chan = &ah->channels[i]; - struct ar5416AniState *ani = &chan->ani; - -- if (use_new_ani(ah)) { -- ani->spurImmunityLevel = -- ATH9K_ANI_SPUR_IMMUNE_LVL_NEW; -+ ani->spurImmunityLevel = ATH9K_ANI_SPUR_IMMUNE_LVL; - -- ani->firstepLevel = ATH9K_ANI_FIRSTEP_LVL_NEW; -+ ani->firstepLevel = ATH9K_ANI_FIRSTEP_LVL; - -- if (AR_SREV_9300_20_OR_LATER(ah)) -- ani->mrcCCKOff = -- !ATH9K_ANI_ENABLE_MRC_CCK; -- else -- ani->mrcCCKOff = true; +- /* Set up ANI */ +- if (iter_data.naps > 0) { +- sc->sc_ah->stats.avgbrssi = ATH_RSSI_DUMMY_MARKER; - -- ani->ofdmsTurn = true; -- } else { -- ani->spurImmunityLevel = -- ATH9K_ANI_SPUR_IMMUNE_LVL_OLD; -- ani->firstepLevel = ATH9K_ANI_FIRSTEP_LVL_OLD; -+ if (AR_SREV_9300_20_OR_LATER(ah)) -+ ani->mrcCCKOff = -+ !ATH9K_ANI_ENABLE_MRC_CCK; -+ else -+ ani->mrcCCKOff = true; - -- ani->cckWeakSigThreshold = -- ATH9K_ANI_CCK_WEAK_SIG_THR; +- if (!common->disable_ani) { +- set_bit(SC_OP_ANI_RUN, &sc->sc_flags); +- ath_start_ani(common); - } -+ ani->ofdmsTurn = true; - - ani->rssiThrHigh = ATH9K_ANI_RSSI_THR_HIGH; - ani->rssiThrLow = ATH9K_ANI_RSSI_THR_LOW; -- ani->ofdmWeakSigDetectOff = -- !ATH9K_ANI_USE_OFDM_WEAK_SIG; -+ ani->ofdmWeakSigDetect = ATH9K_ANI_USE_OFDM_WEAK_SIG; - ani->cckNoiseImmunityLevel = ATH9K_ANI_CCK_DEF_LEVEL; - ani->ofdmNoiseImmunityLevel = ATH9K_ANI_OFDM_DEF_LEVEL; - ani->update_ani = false; -@@ -898,13 +545,8 @@ void ath9k_hw_ani_init(struct ath_hw *ah - * since we expect some ongoing maintenance on the tables, let's sanity - * check here default level should not modify INI setting. - */ -- if (use_new_ani(ah)) { -- ah->aniperiod = ATH9K_ANI_PERIOD_NEW; -- ah->config.ani_poll_interval = ATH9K_ANI_POLLINTERVAL_NEW; +- - } else { -- ah->aniperiod = ATH9K_ANI_PERIOD_OLD; -- ah->config.ani_poll_interval = ATH9K_ANI_POLLINTERVAL_OLD; +- clear_bit(SC_OP_ANI_RUN, &sc->sc_flags); +- del_timer_sync(&common->ani.timer); +- } +-} +- +-/* Called with sc->mutex held, vif counts set up properly. */ +-static void ath9k_do_vif_add_setup(struct ieee80211_hw *hw, +- struct ieee80211_vif *vif) +-{ +- struct ath_softc *sc = hw->priv; +- +- ath9k_calculate_summary_state(hw, vif); +- +- if (ath9k_uses_beacons(vif->type)) { +- /* Reserve a beacon slot for the vif */ +- ath9k_set_beaconing_status(sc, false); +- ath_beacon_alloc(sc, vif); +- ath9k_set_beaconing_status(sc, true); - } -+ ah->aniperiod = ATH9K_ANI_PERIOD; -+ ah->config.ani_poll_interval = ATH9K_ANI_POLLINTERVAL; - - if (ah->config.enable_ani) - ah->proc_phyerr |= HAL_PROCESS_ANI; ---- a/drivers/net/wireless/ath/ath9k/ani.h -+++ b/drivers/net/wireless/ath/ath9k/ani.h -@@ -24,42 +24,34 @@ - #define BEACON_RSSI(ahp) (ahp->stats.avgbrssi) - - /* units are errors per second */ --#define ATH9K_ANI_OFDM_TRIG_HIGH_OLD 500 --#define ATH9K_ANI_OFDM_TRIG_HIGH_NEW 3500 -+#define ATH9K_ANI_OFDM_TRIG_HIGH 3500 - #define ATH9K_ANI_OFDM_TRIG_HIGH_BELOW_INI 1000 - - /* units are errors per second */ --#define ATH9K_ANI_OFDM_TRIG_LOW_OLD 200 --#define ATH9K_ANI_OFDM_TRIG_LOW_NEW 400 -+#define ATH9K_ANI_OFDM_TRIG_LOW 400 - #define ATH9K_ANI_OFDM_TRIG_LOW_ABOVE_INI 900 - - /* units are errors per second */ --#define ATH9K_ANI_CCK_TRIG_HIGH_OLD 200 --#define ATH9K_ANI_CCK_TRIG_HIGH_NEW 600 -+#define ATH9K_ANI_CCK_TRIG_HIGH 600 - - /* units are errors per second */ --#define ATH9K_ANI_CCK_TRIG_LOW_OLD 100 --#define ATH9K_ANI_CCK_TRIG_LOW_NEW 300 -+#define ATH9K_ANI_CCK_TRIG_LOW 300 - - #define ATH9K_ANI_NOISE_IMMUNE_LVL 4 - #define ATH9K_ANI_USE_OFDM_WEAK_SIG true - #define ATH9K_ANI_CCK_WEAK_SIG_THR false - --#define ATH9K_ANI_SPUR_IMMUNE_LVL_OLD 7 --#define ATH9K_ANI_SPUR_IMMUNE_LVL_NEW 3 -+#define ATH9K_ANI_SPUR_IMMUNE_LVL 3 - --#define ATH9K_ANI_FIRSTEP_LVL_OLD 0 --#define ATH9K_ANI_FIRSTEP_LVL_NEW 2 -+#define ATH9K_ANI_FIRSTEP_LVL 2 - - #define ATH9K_ANI_RSSI_THR_HIGH 40 - #define ATH9K_ANI_RSSI_THR_LOW 7 - --#define ATH9K_ANI_PERIOD_OLD 100 --#define ATH9K_ANI_PERIOD_NEW 300 -+#define ATH9K_ANI_PERIOD 300 - - /* in ms */ --#define ATH9K_ANI_POLLINTERVAL_OLD 100 --#define ATH9K_ANI_POLLINTERVAL_NEW 1000 -+#define ATH9K_ANI_POLLINTERVAL 1000 - - #define HAL_NOISE_IMMUNE_MAX 4 - #define HAL_SPUR_IMMUNE_MAX 7 -@@ -122,13 +114,12 @@ struct ar5416AniState { - u8 mrcCCKOff; - u8 spurImmunityLevel; - u8 firstepLevel; -- u8 ofdmWeakSigDetectOff; -+ u8 ofdmWeakSigDetect; - u8 cckWeakSigThreshold; - bool update_ani; - u32 listenTime; - int32_t rssiThrLow; - int32_t rssiThrHigh; -- u32 noiseFloor; - u32 ofdmPhyErrCount; - u32 cckPhyErrCount; - int16_t pktRssi[2]; ---- a/drivers/net/wireless/ath/ath9k/ar5008_phy.c -+++ b/drivers/net/wireless/ath/ath9k/ar5008_phy.c -@@ -995,141 +995,6 @@ static u32 ar5008_hw_compute_pll_control - return pll; } --static bool ar5008_hw_ani_control_old(struct ath_hw *ah, -- enum ath9k_ani_cmd cmd, -- int param) --{ -- struct ar5416AniState *aniState = &ah->curchan->ani; -- struct ath_common *common = ath9k_hw_common(ah); + static int ath9k_add_interface(struct ieee80211_hw *hw, +@@ -1021,7 +976,10 @@ static int ath9k_add_interface(struct ie + + sc->nvifs++; + +- ath9k_do_vif_add_setup(hw, vif); ++ ath9k_calculate_summary_state(hw, vif); ++ if (ath9k_uses_beacons(vif->type)) ++ ath9k_beacon_assign_slot(sc, vif); ++ + out: + mutex_unlock(&sc->mutex); + ath9k_ps_restore(sc); +@@ -1038,6 +996,7 @@ static int ath9k_change_interface(struct + int ret = 0; + + ath_dbg(common, CONFIG, "Change Interface\n"); ++ + mutex_lock(&sc->mutex); + ath9k_ps_wakeup(sc); + +@@ -1050,15 +1009,16 @@ static int ath9k_change_interface(struct + } + } + +- /* Clean up old vif stuff */ + if (ath9k_uses_beacons(vif->type)) +- ath9k_reclaim_beacon(sc, vif); ++ ath9k_beacon_remove_slot(sc, vif); + +- /* Add new settings */ + vif->type = new_type; + vif->p2p = p2p; + +- ath9k_do_vif_add_setup(hw, vif); ++ ath9k_calculate_summary_state(hw, vif); ++ if (ath9k_uses_beacons(vif->type)) ++ ath9k_beacon_assign_slot(sc, vif); ++ + out: + ath9k_ps_restore(sc); + mutex_unlock(&sc->mutex); +@@ -1078,9 +1038,8 @@ static void ath9k_remove_interface(struc + + sc->nvifs--; + +- /* Reclaim beacon resources */ + if (ath9k_uses_beacons(vif->type)) +- ath9k_reclaim_beacon(sc, vif); ++ ath9k_beacon_remove_slot(sc, vif); + + ath9k_calculate_summary_state(hw, NULL); + +@@ -1388,10 +1347,6 @@ static int ath9k_conf_tx(struct ieee8021 + if (ret) + ath_err(common, "TXQ Update failed\n"); + +- if (sc->sc_ah->opmode == NL80211_IFTYPE_ADHOC) +- if (queue == WME_AC_BE && !ret) +- ath_beaconq_config(sc); - -- switch (cmd & ah->ani_function) { -- case ATH9K_ANI_NOISE_IMMUNITY_LEVEL:{ -- u32 level = param; + mutex_unlock(&sc->mutex); + ath9k_ps_restore(sc); + +@@ -1460,85 +1415,36 @@ static int ath9k_set_key(struct ieee8021 + + return ret; + } +-static void ath9k_bss_iter(void *data, u8 *mac, struct ieee80211_vif *vif) ++ ++static void ath9k_bss_assoc_iter(void *data, u8 *mac, struct ieee80211_vif *vif) + { + struct ath_softc *sc = data; + struct ath_common *common = ath9k_hw_common(sc->sc_ah); +- struct ieee80211_bss_conf *bss_conf = &vif->bss_conf; + struct ath_vif *avp = (void *)vif->drv_priv; ++ struct ieee80211_bss_conf *bss_conf = &vif->bss_conf; + unsigned long flags; +- /* +- * Skip iteration if primary station vif's bss info +- * was not changed +- */ ++ + if (test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags)) + return; + + if (bss_conf->assoc) { + set_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags); + avp->primary_sta_vif = true; ++ + memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN); + common->curaid = bss_conf->aid; + ath9k_hw_write_associd(sc->sc_ah); +- ath_dbg(common, CONFIG, "Bss Info ASSOC %d, bssid: %pM\n", +- bss_conf->aid, common->curbssid); +- ath_beacon_config(sc, vif); +- /* +- * Request a re-configuration of Beacon related timers +- * on the receipt of the first Beacon frame (i.e., +- * after time sync with the AP). +- */ +- spin_lock_irqsave(&sc->sc_pm_lock, flags); +- sc->ps_flags |= PS_BEACON_SYNC | PS_WAIT_FOR_BEACON; +- spin_unlock_irqrestore(&sc->sc_pm_lock, flags); + +- /* Reset rssi stats */ + sc->last_rssi = ATH_RSSI_DUMMY_MARKER; + sc->sc_ah->stats.avgbrssi = ATH_RSSI_DUMMY_MARKER; + +- ath_start_rx_poll(sc, 3); - -- if (level >= ARRAY_SIZE(ah->totalSizeDesired)) { -- ath_dbg(common, ANI, "level out of range (%u > %zu)\n", -- level, ARRAY_SIZE(ah->totalSizeDesired)); -- return false; +- if (!common->disable_ani) { +- set_bit(SC_OP_ANI_RUN, &sc->sc_flags); +- ath_start_ani(common); - } - -- REG_RMW_FIELD(ah, AR_PHY_DESIRED_SZ, -- AR_PHY_DESIRED_SZ_TOT_DES, -- ah->totalSizeDesired[level]); -- REG_RMW_FIELD(ah, AR_PHY_AGC_CTL1, -- AR_PHY_AGC_CTL1_COARSE_LOW, -- ah->coarse_low[level]); -- REG_RMW_FIELD(ah, AR_PHY_AGC_CTL1, -- AR_PHY_AGC_CTL1_COARSE_HIGH, -- ah->coarse_high[level]); -- REG_RMW_FIELD(ah, AR_PHY_FIND_SIG, -- AR_PHY_FIND_SIG_FIRPWR, -- ah->firpwr[level]); -- -- if (level > aniState->noiseImmunityLevel) -- ah->stats.ast_ani_niup++; -- else if (level < aniState->noiseImmunityLevel) -- ah->stats.ast_ani_nidown++; -- aniState->noiseImmunityLevel = level; -- break; - } -- case ATH9K_ANI_OFDM_WEAK_SIGNAL_DETECTION:{ -- u32 on = param ? 1 : 0; +-} - -- if (on) -- REG_SET_BIT(ah, AR_PHY_SFCORR_LOW, -- AR_PHY_SFCORR_LOW_USE_SELF_CORR_LOW); -- else -- REG_CLR_BIT(ah, AR_PHY_SFCORR_LOW, -- AR_PHY_SFCORR_LOW_USE_SELF_CORR_LOW); +-static void ath9k_config_bss(struct ath_softc *sc, struct ieee80211_vif *vif) +-{ +- struct ath_common *common = ath9k_hw_common(sc->sc_ah); +- struct ieee80211_bss_conf *bss_conf = &vif->bss_conf; +- struct ath_vif *avp = (void *)vif->drv_priv; - -- if (!on != aniState->ofdmWeakSigDetectOff) { -- if (on) -- ah->stats.ast_ani_ofdmon++; -- else -- ah->stats.ast_ani_ofdmoff++; -- aniState->ofdmWeakSigDetectOff = !on; -- } -- break; -- } -- case ATH9K_ANI_CCK_WEAK_SIGNAL_THR:{ -- static const int weakSigThrCck[] = { 8, 6 }; -- u32 high = param ? 1 : 0; +- if (sc->sc_ah->opmode != NL80211_IFTYPE_STATION) +- return; - -- REG_RMW_FIELD(ah, AR_PHY_CCK_DETECT, -- AR_PHY_CCK_DETECT_WEAK_SIG_THR_CCK, -- weakSigThrCck[high]); -- if (high != aniState->cckWeakSigThreshold) { -- if (high) -- ah->stats.ast_ani_cckhigh++; -- else -- ah->stats.ast_ani_ccklow++; -- aniState->cckWeakSigThreshold = high; -- } -- break; +- /* Reconfigure bss info */ +- if (avp->primary_sta_vif && !bss_conf->assoc) { +- ath_dbg(common, CONFIG, "Bss Info DISASSOC %d, bssid %pM\n", +- common->curaid, common->curbssid); +- clear_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags); +- clear_bit(SC_OP_BEACONS, &sc->sc_flags); +- avp->primary_sta_vif = false; +- memset(common->curbssid, 0, ETH_ALEN); +- common->curaid = 0; - } -- case ATH9K_ANI_FIRSTEP_LEVEL:{ -- static const int firstep[] = { 0, 4, 8 }; -- u32 level = param; - -- if (level >= ARRAY_SIZE(firstep)) { -- ath_dbg(common, ANI, "level out of range (%u > %zu)\n", -- level, ARRAY_SIZE(firstep)); -- return false; -- } -- REG_RMW_FIELD(ah, AR_PHY_FIND_SIG, -- AR_PHY_FIND_SIG_FIRSTEP, -- firstep[level]); -- if (level > aniState->firstepLevel) -- ah->stats.ast_ani_stepup++; -- else if (level < aniState->firstepLevel) -- ah->stats.ast_ani_stepdown++; -- aniState->firstepLevel = level; -- break; -- } -- case ATH9K_ANI_SPUR_IMMUNITY_LEVEL:{ -- static const int cycpwrThr1[] = { 2, 4, 6, 8, 10, 12, 14, 16 }; -- u32 level = param; +- ieee80211_iterate_active_interfaces_atomic( +- sc->hw, ath9k_bss_iter, sc); ++ spin_lock_irqsave(&sc->sc_pm_lock, flags); ++ sc->ps_flags |= PS_BEACON_SYNC | PS_WAIT_FOR_BEACON; ++ spin_unlock_irqrestore(&sc->sc_pm_lock, flags); + +- /* +- * None of station vifs are associated. +- * Clear bssid & aid +- */ +- if (!test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags)) { +- ath9k_hw_write_associd(sc->sc_ah); +- clear_bit(SC_OP_ANI_RUN, &sc->sc_flags); +- del_timer_sync(&common->ani.timer); +- del_timer_sync(&sc->rx_poll_timer); +- memset(&sc->caldata, 0, sizeof(sc->caldata)); ++ ath_dbg(common, CONFIG, ++ "Primary Station interface: %pM, BSSID: %pM\n", ++ vif->addr, common->curbssid); + } + } + +@@ -1547,6 +1453,11 @@ static void ath9k_bss_info_changed(struc + struct ieee80211_bss_conf *bss_conf, + u32 changed) + { ++#define CHECK_ANI \ ++ (BSS_CHANGED_ASSOC | \ ++ BSS_CHANGED_IBSS | \ ++ BSS_CHANGED_BEACON_ENABLED) ++ + struct ath_softc *sc = hw->priv; + struct ath_hw *ah = sc->sc_ah; + struct ath_common *common = ath9k_hw_common(ah); +@@ -1557,53 +1468,43 @@ static void ath9k_bss_info_changed(struc + mutex_lock(&sc->mutex); + + if (changed & BSS_CHANGED_ASSOC) { +- ath9k_config_bss(sc, vif); ++ ath_dbg(common, CONFIG, "BSSID %pM Changed ASSOC %d\n", ++ bss_conf->bssid, bss_conf->assoc); + +- ath_dbg(common, CONFIG, "BSSID: %pM aid: 0x%x\n", +- common->curbssid, common->curaid); ++ /* ++ * Do not do anything when the opmode is not STATION. ++ */ ++ if (ah->opmode == NL80211_IFTYPE_STATION) { ++ if (avp->primary_sta_vif && !bss_conf->assoc) { ++ clear_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags); ++ clear_bit(SC_OP_BEACONS, &sc->sc_flags); ++ avp->primary_sta_vif = false; ++ } ++ ++ ieee80211_iterate_active_interfaces_atomic(sc->hw, ++ ath9k_bss_assoc_iter, sc); ++ ++ if (!test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags)) { ++ memset(common->curbssid, 0, ETH_ALEN); ++ common->curaid = 0; ++ ath9k_hw_write_associd(sc->sc_ah); ++ } ++ } + } + + if (changed & BSS_CHANGED_IBSS) { +- /* There can be only one vif available */ + memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN); + common->curaid = bss_conf->aid; + ath9k_hw_write_associd(sc->sc_ah); - -- if (level >= ARRAY_SIZE(cycpwrThr1)) { -- ath_dbg(common, ANI, "level out of range (%u > %zu)\n", -- level, ARRAY_SIZE(cycpwrThr1)); -- return false; -- } -- REG_RMW_FIELD(ah, AR_PHY_TIMING5, -- AR_PHY_TIMING5_CYCPWR_THR1, -- cycpwrThr1[level]); -- if (level > aniState->spurImmunityLevel) -- ah->stats.ast_ani_spurup++; -- else if (level < aniState->spurImmunityLevel) -- ah->stats.ast_ani_spurdown++; -- aniState->spurImmunityLevel = level; -- break; -- } -- case ATH9K_ANI_PRESENT: -- break; -- default: -- ath_dbg(common, ANI, "invalid cmd %u\n", cmd); -- return false; -- } +- if (bss_conf->ibss_joined) { +- sc->sc_ah->stats.avgbrssi = ATH_RSSI_DUMMY_MARKER; - -- ath_dbg(common, ANI, "ANI parameters:\n"); -- ath_dbg(common, ANI, -- "noiseImmunityLevel=%d, spurImmunityLevel=%d, ofdmWeakSigDetectOff=%d\n", -- aniState->noiseImmunityLevel, -- aniState->spurImmunityLevel, -- !aniState->ofdmWeakSigDetectOff); -- ath_dbg(common, ANI, -- "cckWeakSigThreshold=%d, firstepLevel=%d, listenTime=%d\n", -- aniState->cckWeakSigThreshold, -- aniState->firstepLevel, -- aniState->listenTime); -- ath_dbg(common, ANI, "ofdmPhyErrCount=%d, cckPhyErrCount=%d\n\n", -- aniState->ofdmPhyErrCount, -- aniState->cckPhyErrCount); +- if (!common->disable_ani) { +- set_bit(SC_OP_ANI_RUN, &sc->sc_flags); +- ath_start_ani(common); +- } - -- return true; --} +- } else { +- clear_bit(SC_OP_ANI_RUN, &sc->sc_flags); +- del_timer_sync(&common->ani.timer); +- del_timer_sync(&sc->rx_poll_timer); +- } + } + +- /* +- * In case of AP mode, the HW TSF has to be reset +- * when the beacon interval changes. +- */ +- if ((changed & BSS_CHANGED_BEACON_INT) && +- (vif->type == NL80211_IFTYPE_AP)) +- set_bit(SC_OP_TSF_RESET, &sc->sc_flags); - - static bool ar5008_hw_ani_control_new(struct ath_hw *ah, - enum ath9k_ani_cmd cmd, - int param) -@@ -1206,18 +1071,18 @@ static bool ar5008_hw_ani_control_new(st - REG_CLR_BIT(ah, AR_PHY_SFCORR_LOW, - AR_PHY_SFCORR_LOW_USE_SELF_CORR_LOW); - -- if (!on != aniState->ofdmWeakSigDetectOff) { -+ if (on != aniState->ofdmWeakSigDetect) { - ath_dbg(common, ANI, - "** ch %d: ofdm weak signal: %s=>%s\n", - chan->channel, -- !aniState->ofdmWeakSigDetectOff ? -+ aniState->ofdmWeakSigDetect ? - "on" : "off", - on ? "on" : "off"); - if (on) - ah->stats.ast_ani_ofdmon++; - else - ah->stats.ast_ani_ofdmoff++; -- aniState->ofdmWeakSigDetectOff = !on; -+ aniState->ofdmWeakSigDetect = on; +- /* Configure beaconing (AP, IBSS, MESH) */ +- if (ath9k_uses_beacons(vif->type) && +- ((changed & BSS_CHANGED_BEACON) || +- (changed & BSS_CHANGED_BEACON_ENABLED) || +- (changed & BSS_CHANGED_BEACON_INT))) { +- ath9k_set_beaconing_status(sc, false); +- if (bss_conf->enable_beacon) +- ath_beacon_alloc(sc, vif); +- else +- avp->is_bslot_active = false; +- ath_beacon_config(sc, vif); +- ath9k_set_beaconing_status(sc, true); ++ if ((changed & BSS_CHANGED_BEACON) || ++ (changed & BSS_CHANGED_BEACON_ENABLED) || ++ (changed & BSS_CHANGED_BEACON_INT)) { ++ if (ah->opmode == NL80211_IFTYPE_AP) ++ ath9k_set_tsfadjust(sc, vif); ++ if (ath9k_allow_beacon_config(sc, vif)) ++ ath9k_beacon_config(sc, vif, changed); + } + + if (changed & BSS_CHANGED_ERP_SLOT) { +@@ -1625,8 +1526,13 @@ static void ath9k_bss_info_changed(struc } - break; } -@@ -1236,7 +1101,7 @@ static bool ar5008_hw_ani_control_new(st - * from INI file & cap value - */ - value = firstep_table[level] - -- firstep_table[ATH9K_ANI_FIRSTEP_LVL_NEW] + -+ firstep_table[ATH9K_ANI_FIRSTEP_LVL] + - aniState->iniDef.firstep; - if (value < ATH9K_SIG_FIRSTEP_SETTING_MIN) - value = ATH9K_SIG_FIRSTEP_SETTING_MIN; -@@ -1251,7 +1116,7 @@ static bool ar5008_hw_ani_control_new(st - * from INI file & cap value - */ - value2 = firstep_table[level] - -- firstep_table[ATH9K_ANI_FIRSTEP_LVL_NEW] + -+ firstep_table[ATH9K_ANI_FIRSTEP_LVL] + - aniState->iniDef.firstepLow; - if (value2 < ATH9K_SIG_FIRSTEP_SETTING_MIN) - value2 = ATH9K_SIG_FIRSTEP_SETTING_MIN; -@@ -1267,7 +1132,7 @@ static bool ar5008_hw_ani_control_new(st - chan->channel, - aniState->firstepLevel, - level, -- ATH9K_ANI_FIRSTEP_LVL_NEW, -+ ATH9K_ANI_FIRSTEP_LVL, - value, - aniState->iniDef.firstep); - ath_dbg(common, ANI, -@@ -1275,7 +1140,7 @@ static bool ar5008_hw_ani_control_new(st - chan->channel, - aniState->firstepLevel, - level, -- ATH9K_ANI_FIRSTEP_LVL_NEW, -+ ATH9K_ANI_FIRSTEP_LVL, - value2, - aniState->iniDef.firstepLow); - if (level > aniState->firstepLevel) -@@ -1300,7 +1165,7 @@ static bool ar5008_hw_ani_control_new(st - * from INI file & cap value - */ - value = cycpwrThr1_table[level] - -- cycpwrThr1_table[ATH9K_ANI_SPUR_IMMUNE_LVL_NEW] + -+ cycpwrThr1_table[ATH9K_ANI_SPUR_IMMUNE_LVL] + - aniState->iniDef.cycpwrThr1; - if (value < ATH9K_SIG_SPUR_IMM_SETTING_MIN) - value = ATH9K_SIG_SPUR_IMM_SETTING_MIN; -@@ -1316,7 +1181,7 @@ static bool ar5008_hw_ani_control_new(st - * from INI file & cap value - */ - value2 = cycpwrThr1_table[level] - -- cycpwrThr1_table[ATH9K_ANI_SPUR_IMMUNE_LVL_NEW] + -+ cycpwrThr1_table[ATH9K_ANI_SPUR_IMMUNE_LVL] + - aniState->iniDef.cycpwrThr1Ext; - if (value2 < ATH9K_SIG_SPUR_IMM_SETTING_MIN) - value2 = ATH9K_SIG_SPUR_IMM_SETTING_MIN; -@@ -1331,7 +1196,7 @@ static bool ar5008_hw_ani_control_new(st - chan->channel, - aniState->spurImmunityLevel, - level, -- ATH9K_ANI_SPUR_IMMUNE_LVL_NEW, -+ ATH9K_ANI_SPUR_IMMUNE_LVL, - value, - aniState->iniDef.cycpwrThr1); - ath_dbg(common, ANI, -@@ -1339,7 +1204,7 @@ static bool ar5008_hw_ani_control_new(st - chan->channel, - aniState->spurImmunityLevel, - level, -- ATH9K_ANI_SPUR_IMMUNE_LVL_NEW, -+ ATH9K_ANI_SPUR_IMMUNE_LVL, - value2, - aniState->iniDef.cycpwrThr1Ext); - if (level > aniState->spurImmunityLevel) -@@ -1367,7 +1232,7 @@ static bool ar5008_hw_ani_control_new(st - ath_dbg(common, ANI, - "ANI parameters: SI=%d, ofdmWS=%s FS=%d MRCcck=%s listenTime=%d ofdmErrs=%d cckErrs=%d\n", - aniState->spurImmunityLevel, -- !aniState->ofdmWeakSigDetectOff ? "on" : "off", -+ aniState->ofdmWeakSigDetect ? "on" : "off", - aniState->firstepLevel, - !aniState->mrcCCKOff ? "on" : "off", - aniState->listenTime, -@@ -1454,9 +1319,9 @@ static void ar5008_hw_ani_cache_ini_regs - AR_PHY_EXT_TIMING5_CYCPWR_THR1); - - /* these levels just got reset to defaults by the INI */ -- aniState->spurImmunityLevel = ATH9K_ANI_SPUR_IMMUNE_LVL_NEW; -- aniState->firstepLevel = ATH9K_ANI_FIRSTEP_LVL_NEW; -- aniState->ofdmWeakSigDetectOff = !ATH9K_ANI_USE_OFDM_WEAK_SIG; -+ aniState->spurImmunityLevel = ATH9K_ANI_SPUR_IMMUNE_LVL; -+ aniState->firstepLevel = ATH9K_ANI_FIRSTEP_LVL; -+ aniState->ofdmWeakSigDetect = ATH9K_ANI_USE_OFDM_WEAK_SIG; - aniState->mrcCCKOff = true; /* not available on pre AR9003 */ + ++ if (changed & CHECK_ANI) ++ ath_check_ani(sc); ++ + mutex_unlock(&sc->mutex); + ath9k_ps_restore(sc); ++ ++#undef CHECK_ANI } -@@ -1545,11 +1410,8 @@ void ar5008_hw_attach_phy_ops(struct ath - priv_ops->do_getnf = ar5008_hw_do_getnf; - priv_ops->set_radar_params = ar5008_hw_set_radar_params; + static u64 ath9k_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif) +@@ -1855,10 +1761,11 @@ static int ath9k_tx_last_beacon(struct i + if (!vif) + return 0; -- if (modparam_force_new_ani) { -- priv_ops->ani_control = ar5008_hw_ani_control_new; -- priv_ops->ani_cache_ini_regs = ar5008_hw_ani_cache_ini_regs; -- } else -- priv_ops->ani_control = ar5008_hw_ani_control_old; -+ priv_ops->ani_control = ar5008_hw_ani_control_new; -+ priv_ops->ani_cache_ini_regs = ar5008_hw_ani_cache_ini_regs; - - if (AR_SREV_9100(ah) || AR_SREV_9160_10_OR_LATER(ah)) - priv_ops->compute_pll_control = ar9160_hw_compute_pll_control; ---- a/drivers/net/wireless/ath/ath9k/ar9002_hw.c -+++ b/drivers/net/wireless/ath/ath9k/ar9002_hw.c -@@ -21,10 +21,6 @@ - #include "ar9002_initvals.h" - #include "ar9002_phy.h" - --int modparam_force_new_ani; --module_param_named(force_new_ani, modparam_force_new_ani, int, 0444); --MODULE_PARM_DESC(force_new_ani, "Force new ANI for AR5008, AR9001, AR9002"); -- - /* General hardware code for the A5008/AR9001/AR9002 hadware families */ - - static void ar9002_hw_init_mode_regs(struct ath_hw *ah) ---- a/drivers/net/wireless/ath/ath9k/ar9003_phy.c -+++ b/drivers/net/wireless/ath/ath9k/ar9003_phy.c -@@ -825,18 +825,18 @@ static bool ar9003_hw_ani_control(struct - REG_CLR_BIT(ah, AR_PHY_SFCORR_LOW, - AR_PHY_SFCORR_LOW_USE_SELF_CORR_LOW); - -- if (!on != aniState->ofdmWeakSigDetectOff) { -+ if (on != aniState->ofdmWeakSigDetect) { - ath_dbg(common, ANI, - "** ch %d: ofdm weak signal: %s=>%s\n", - chan->channel, -- !aniState->ofdmWeakSigDetectOff ? -+ aniState->ofdmWeakSigDetect ? - "on" : "off", - on ? "on" : "off"); - if (on) - ah->stats.ast_ani_ofdmon++; - else - ah->stats.ast_ani_ofdmoff++; -- aniState->ofdmWeakSigDetectOff = !on; -+ aniState->ofdmWeakSigDetect = on; +- avp = (void *)vif->drv_priv; +- if (!avp->is_bslot_active) ++ if (!vif->bss_conf.enable_beacon) + return 0; + ++ avp = (void *)vif->drv_priv; ++ + if (!sc->beacon.tx_processed && !edma) { + tasklet_disable(&sc->bcon_tasklet); + +--- a/drivers/net/wireless/ath/ath9k/mci.c ++++ b/drivers/net/wireless/ath/ath9k/mci.c +@@ -202,7 +202,7 @@ static void ath_mci_cal_msg(struct ath_s + case MCI_GPM_BT_CAL_REQ: + if (mci_hw->bt_state == MCI_BT_AWAKE) { + ar9003_mci_state(ah, MCI_STATE_SET_BT_CAL_START); +- ieee80211_queue_work(sc->hw, &sc->hw_reset_work); ++ ath9k_queue_reset(sc, RESET_TYPE_MCI); } + ath_dbg(common, MCI, "MCI State : %d\n", mci_hw->bt_state); break; +--- a/drivers/net/wireless/ath/ath9k/recv.c ++++ b/drivers/net/wireless/ath/ath9k/recv.c +@@ -553,7 +553,7 @@ static void ath_rx_ps_beacon(struct ath_ + sc->ps_flags &= ~PS_BEACON_SYNC; + ath_dbg(common, PS, + "Reconfigure Beacon timers based on timestamp from the AP\n"); +- ath_set_beacon(sc); ++ ath9k_set_beacon(sc); } -@@ -855,7 +855,7 @@ static bool ar9003_hw_ani_control(struct - * from INI file & cap value - */ - value = firstep_table[level] - -- firstep_table[ATH9K_ANI_FIRSTEP_LVL_NEW] + -+ firstep_table[ATH9K_ANI_FIRSTEP_LVL] + - aniState->iniDef.firstep; - if (value < ATH9K_SIG_FIRSTEP_SETTING_MIN) - value = ATH9K_SIG_FIRSTEP_SETTING_MIN; -@@ -870,7 +870,7 @@ static bool ar9003_hw_ani_control(struct - * from INI file & cap value - */ - value2 = firstep_table[level] - -- firstep_table[ATH9K_ANI_FIRSTEP_LVL_NEW] + -+ firstep_table[ATH9K_ANI_FIRSTEP_LVL] + - aniState->iniDef.firstepLow; - if (value2 < ATH9K_SIG_FIRSTEP_SETTING_MIN) - value2 = ATH9K_SIG_FIRSTEP_SETTING_MIN; -@@ -886,7 +886,7 @@ static bool ar9003_hw_ani_control(struct - chan->channel, - aniState->firstepLevel, - level, -- ATH9K_ANI_FIRSTEP_LVL_NEW, -+ ATH9K_ANI_FIRSTEP_LVL, - value, - aniState->iniDef.firstep); - ath_dbg(common, ANI, -@@ -894,7 +894,7 @@ static bool ar9003_hw_ani_control(struct - chan->channel, - aniState->firstepLevel, - level, -- ATH9K_ANI_FIRSTEP_LVL_NEW, -+ ATH9K_ANI_FIRSTEP_LVL, - value2, - aniState->iniDef.firstepLow); - if (level > aniState->firstepLevel) -@@ -919,7 +919,7 @@ static bool ar9003_hw_ani_control(struct - * from INI file & cap value - */ - value = cycpwrThr1_table[level] - -- cycpwrThr1_table[ATH9K_ANI_SPUR_IMMUNE_LVL_NEW] + -+ cycpwrThr1_table[ATH9K_ANI_SPUR_IMMUNE_LVL] + - aniState->iniDef.cycpwrThr1; - if (value < ATH9K_SIG_SPUR_IMM_SETTING_MIN) - value = ATH9K_SIG_SPUR_IMM_SETTING_MIN; -@@ -935,7 +935,7 @@ static bool ar9003_hw_ani_control(struct - * from INI file & cap value - */ - value2 = cycpwrThr1_table[level] - -- cycpwrThr1_table[ATH9K_ANI_SPUR_IMMUNE_LVL_NEW] + -+ cycpwrThr1_table[ATH9K_ANI_SPUR_IMMUNE_LVL] + - aniState->iniDef.cycpwrThr1Ext; - if (value2 < ATH9K_SIG_SPUR_IMM_SETTING_MIN) - value2 = ATH9K_SIG_SPUR_IMM_SETTING_MIN; -@@ -950,7 +950,7 @@ static bool ar9003_hw_ani_control(struct - chan->channel, - aniState->spurImmunityLevel, - level, -- ATH9K_ANI_SPUR_IMMUNE_LVL_NEW, -+ ATH9K_ANI_SPUR_IMMUNE_LVL, - value, - aniState->iniDef.cycpwrThr1); - ath_dbg(common, ANI, -@@ -958,7 +958,7 @@ static bool ar9003_hw_ani_control(struct - chan->channel, - aniState->spurImmunityLevel, - level, -- ATH9K_ANI_SPUR_IMMUNE_LVL_NEW, -+ ATH9K_ANI_SPUR_IMMUNE_LVL, - value2, - aniState->iniDef.cycpwrThr1Ext); - if (level > aniState->spurImmunityLevel) -@@ -1002,7 +1002,7 @@ static bool ar9003_hw_ani_control(struct - ath_dbg(common, ANI, - "ANI parameters: SI=%d, ofdmWS=%s FS=%d MRCcck=%s listenTime=%d ofdmErrs=%d cckErrs=%d\n", - aniState->spurImmunityLevel, -- !aniState->ofdmWeakSigDetectOff ? "on" : "off", -+ aniState->ofdmWeakSigDetect ? "on" : "off", - aniState->firstepLevel, - !aniState->mrcCCKOff ? "on" : "off", - aniState->listenTime, -@@ -1111,9 +1111,9 @@ static void ar9003_hw_ani_cache_ini_regs - AR_PHY_EXT_CYCPWR_THR1); - - /* these levels just got reset to defaults by the INI */ -- aniState->spurImmunityLevel = ATH9K_ANI_SPUR_IMMUNE_LVL_NEW; -- aniState->firstepLevel = ATH9K_ANI_FIRSTEP_LVL_NEW; -- aniState->ofdmWeakSigDetectOff = !ATH9K_ANI_USE_OFDM_WEAK_SIG; -+ aniState->spurImmunityLevel = ATH9K_ANI_SPUR_IMMUNE_LVL; -+ aniState->firstepLevel = ATH9K_ANI_FIRSTEP_LVL; -+ aniState->ofdmWeakSigDetect = ATH9K_ANI_USE_OFDM_WEAK_SIG; - aniState->mrcCCKOff = !ATH9K_ANI_ENABLE_MRC_CCK; - } ---- a/drivers/net/wireless/ath/ath9k/debug.c -+++ b/drivers/net/wireless/ath/ath9k/debug.c -@@ -348,8 +348,6 @@ void ath_debug_stat_interrupt(struct ath - sc->debug.stats.istats.txok++; - if (status & ATH9K_INT_TXURN) - sc->debug.stats.istats.txurn++; -- if (status & ATH9K_INT_MIB) -- sc->debug.stats.istats.mib++; - if (status & ATH9K_INT_RXPHY) - sc->debug.stats.istats.rxphyerr++; - if (status & ATH9K_INT_RXKCM) ---- a/drivers/net/wireless/ath/ath9k/hw.h -+++ b/drivers/net/wireless/ath/ath9k/hw.h -@@ -1019,16 +1019,8 @@ void ar9002_hw_attach_ops(struct ath_hw - void ar9003_hw_attach_ops(struct ath_hw *ah); - - void ar9002_hw_load_ani_reg(struct ath_hw *ah, struct ath9k_channel *chan); --/* -- * ANI work can be shared between all families but a next -- * generation implementation of ANI will be used only for AR9003 only -- * for now as the other families still need to be tested with the same -- * next generation ANI. Feel free to start testing it though for the -- * older families (AR5008, AR9001, AR9002) by using modparam_force_new_ani. -- */ --extern int modparam_force_new_ani; -+ - void ath9k_ani_reset(struct ath_hw *ah, bool is_scanning); --void ath9k_hw_proc_mib_event(struct ath_hw *ah); - void ath9k_hw_ani_monitor(struct ath_hw *ah, struct ath9k_channel *chan); - - #ifdef CONFIG_ATH9K_BTCOEX_SUPPORT ---- a/drivers/net/wireless/ath/ath9k/main.c -+++ b/drivers/net/wireless/ath/ath9k/main.c -@@ -19,7 +19,7 @@ - #include "ath9k.h" - #include "btcoex.h" + if (ath_beacon_dtim_pending_cab(skb)) { +--- a/drivers/net/wireless/ath/ath9k/xmit.c ++++ b/drivers/net/wireless/ath/ath9k/xmit.c +@@ -614,10 +614,8 @@ static void ath_tx_complete_aggr(struct --static u8 parse_mpdudensity(u8 mpdudensity) -+u8 ath9k_parse_mpdudensity(u8 mpdudensity) - { - /* - * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing": -@@ -320,6 +320,7 @@ static void ath_node_attach(struct ath_s - struct ieee80211_vif *vif) - { - struct ath_node *an; -+ u8 density; - an = (struct ath_node *)sta->drv_priv; + rcu_read_unlock(); - #ifdef CONFIG_ATH9K_DEBUGFS -@@ -334,7 +335,8 @@ static void ath_node_attach(struct ath_s - ath_tx_node_init(sc, an); - an->maxampdu = 1 << (IEEE80211_HT_MAX_AMPDU_FACTOR + - sta->ht_cap.ampdu_factor); -- an->mpdudensity = parse_mpdudensity(sta->ht_cap.ampdu_density); -+ density = ath9k_parse_mpdudensity(sta->ht_cap.ampdu_density); -+ an->mpdudensity = density; - } +- if (needreset) { +- RESET_STAT_INC(sc, RESET_TYPE_TX_ERROR); +- ieee80211_queue_work(sc->hw, &sc->hw_reset_work); +- } ++ if (needreset) ++ ath9k_queue_reset(sc, RESET_TYPE_TX_ERROR); } -@@ -516,24 +518,6 @@ irqreturn_t ath_isr(int irq, void *dev) - ath9k_hw_set_interrupts(ah); - } + static bool ath_lookup_legacy(struct ath_buf *bf) +@@ -1586,7 +1584,8 @@ void ath_txq_schedule(struct ath_softc * + struct ath_atx_ac *ac, *ac_tmp, *last_ac; + struct ath_atx_tid *tid, *last_tid; -- if (status & ATH9K_INT_MIB) { -- /* -- * Disable interrupts until we service the MIB -- * interrupt; otherwise it will continue to -- * fire. -- */ -- ath9k_hw_disable_interrupts(ah); -- /* -- * Let the hal handle the event. We assume -- * it will clear whatever condition caused -- * the interrupt. -- */ -- spin_lock(&common->cc_lock); -- ath9k_hw_proc_mib_event(ah); -- spin_unlock(&common->cc_lock); -- ath9k_hw_enable_interrupts(ah); -- } -- - if (!(ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP)) - if (status & ATH9K_INT_TIM_TIMER) { - if (ATH_DBG_WARN_ON_ONCE(sc->ps_idle)) -@@ -959,14 +943,10 @@ static void ath9k_calculate_summary_stat - /* - * Enable MIB interrupts when there are hardware phy counters. - */ -- if ((iter_data.nstations + iter_data.nadhocs + iter_data.nmeshes) > 0) { -- if (ah->config.enable_ani) -- ah->imask |= ATH9K_INT_MIB; -+ if ((iter_data.nstations + iter_data.nadhocs + iter_data.nmeshes) > 0) - ah->imask |= ATH9K_INT_TSFOOR; -- } else { -- ah->imask &= ~ATH9K_INT_MIB; -+ else - ah->imask &= ~ATH9K_INT_TSFOOR; -- } +- if (work_pending(&sc->hw_reset_work) || list_empty(&txq->axq_acq) || ++ if (test_bit(SC_OP_HW_RESET, &sc->sc_flags) || ++ list_empty(&txq->axq_acq) || + txq->axq_ampdu_depth >= ATH_AGGR_MIN_QDEPTH) + return; - ath9k_hw_set_interrupts(ah); +@@ -2191,7 +2190,7 @@ static void ath_tx_processq(struct ath_s + + ath_txq_lock(sc, txq); + for (;;) { +- if (work_pending(&sc->hw_reset_work)) ++ if (test_bit(SC_OP_HW_RESET, &sc->sc_flags)) + break; + + if (list_empty(&txq->axq_q)) { +@@ -2274,7 +2273,7 @@ void ath_tx_edma_tasklet(struct ath_soft + int status; + for (;;) { +- if (work_pending(&sc->hw_reset_work)) ++ if (test_bit(SC_OP_HW_RESET, &sc->sc_flags)) + break; + + status = ath9k_hw_txprocdesc(ah, NULL, (void *)&ts); +--- a/include/net/mac80211.h ++++ b/include/net/mac80211.h +@@ -3596,22 +3596,6 @@ void ieee80211_request_smps(struct ieee8 + enum ieee80211_smps_mode smps_mode); + + /** +- * ieee80211_key_removed - disable hw acceleration for key +- * @key_conf: The key hw acceleration should be disabled for +- * +- * This allows drivers to indicate that the given key has been +- * removed from hardware acceleration, due to a new key that +- * was added. Don't use this if the key can continue to be used +- * for TX, if the key restriction is on RX only it is permitted +- * to keep the key for TX only and not call this function. +- * +- * Due to locking constraints, it may only be called during +- * @set_key. This function must be allowed to sleep, and the +- * key it tries to disable may still be used until it returns. +- */ +-void ieee80211_key_removed(struct ieee80211_key_conf *key_conf); +- +-/** + * ieee80211_ready_on_channel - notification of remain-on-channel start + * @hw: pointer as obtained from ieee80211_alloc_hw() + */ --- a/net/mac80211/agg-rx.c +++ b/net/mac80211/agg-rx.c -@@ -201,6 +201,8 @@ static void ieee80211_send_addba_resp(st +@@ -203,6 +203,8 @@ static void ieee80211_send_addba_resp(st memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN); else if (sdata->vif.type == NL80211_IFTYPE_ADHOC) memcpy(mgmt->bssid, sdata->u.ibss.bssid, ETH_ALEN); @@ -1263,7 +1628,7 @@ memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN); else if (sdata->vif.type == NL80211_IFTYPE_STATION) memcpy(mgmt->bssid, sdata->u.mgd.bssid, ETH_ALEN); -@@ -456,6 +457,7 @@ int ieee80211_start_tx_ba_session(struct +@@ -459,6 +460,7 @@ int ieee80211_start_tx_ba_session(struct sdata->vif.type != NL80211_IFTYPE_MESH_POINT && sdata->vif.type != NL80211_IFTYPE_AP_VLAN && sdata->vif.type != NL80211_IFTYPE_AP && @@ -1271,6 +1636,17 @@ sdata->vif.type != NL80211_IFTYPE_ADHOC) return -EINVAL; +--- a/net/mac80211/cfg.c ++++ b/net/mac80211/cfg.c +@@ -1741,6 +1741,8 @@ static int ieee80211_set_txq_params(stru + return -EINVAL; + } + ++ ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_QOS); ++ + return 0; + } + --- a/net/mac80211/debugfs_sta.c +++ b/net/mac80211/debugfs_sta.c @@ -63,11 +63,11 @@ static ssize_t sta_flags_read(struct fil @@ -1289,7 +1665,7 @@ TEST(TDLS_PEER_AUTH), TEST(4ADDR_EVENT), --- a/net/mac80211/iface.c +++ b/net/mac80211/iface.c -@@ -284,7 +284,6 @@ static int ieee80211_do_open(struct net_ +@@ -400,7 +400,6 @@ static int ieee80211_do_open(struct net_ { struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev); struct ieee80211_local *local = sdata->local; @@ -1297,7 +1673,7 @@ u32 changed = 0; int res; u32 hw_reconf_flags = 0; -@@ -430,28 +429,6 @@ static int ieee80211_do_open(struct net_ +@@ -538,28 +537,6 @@ static int ieee80211_do_open(struct net_ set_bit(SDATA_STATE_RUNNING, &sdata->state); @@ -1326,16 +1702,7 @@ /* * set_multicast_list will be invoked by the networking core * which will check whether any increments here were done in -@@ -639,6 +616,8 @@ static void ieee80211_do_stop(struct iee - ieee80211_configure_filter(local); - break; - default: -+ flush_work(&local->hw_roc_start); -+ flush_work(&local->hw_roc_done); - flush_work(&sdata->work); - /* - * When we get here, the interface is marked down. -@@ -845,6 +824,72 @@ static void ieee80211_if_setup(struct ne +@@ -949,6 +926,72 @@ static void ieee80211_if_setup(struct ne dev->destructor = free_netdev; } @@ -1408,7 +1775,7 @@ static void ieee80211_iface_work(struct work_struct *work) { struct ieee80211_sub_if_data *sdata = -@@ -949,6 +994,9 @@ static void ieee80211_iface_work(struct +@@ -1053,6 +1096,9 @@ static void ieee80211_iface_work(struct break; ieee80211_mesh_rx_queued_mgmt(sdata, skb); break; @@ -1418,9 +1785,132 @@ default: WARN(1, "frame for unexpected interface type"); break; +--- a/net/mac80211/key.c ++++ b/net/mac80211/key.c +@@ -197,26 +197,6 @@ static void ieee80211_key_disable_hw_acc + key->flags &= ~KEY_FLAG_UPLOADED_TO_HARDWARE; + } + +-void ieee80211_key_removed(struct ieee80211_key_conf *key_conf) +-{ +- struct ieee80211_key *key; +- +- key = container_of(key_conf, struct ieee80211_key, conf); +- +- might_sleep(); +- assert_key_lock(key->local); +- +- key->flags &= ~KEY_FLAG_UPLOADED_TO_HARDWARE; +- +- /* +- * Flush TX path to avoid attempts to use this key +- * after this function returns. Until then, drivers +- * must be prepared to handle the key. +- */ +- synchronize_rcu(); +-} +-EXPORT_SYMBOL_GPL(ieee80211_key_removed); +- + static void __ieee80211_set_default_key(struct ieee80211_sub_if_data *sdata, + int idx, bool uni, bool multi) + { +--- a/net/mac80211/mlme.c ++++ b/net/mac80211/mlme.c +@@ -1108,7 +1108,7 @@ void ieee80211_dynamic_ps_timer(unsigned + } + + /* MLME */ +-static void ieee80211_sta_wmm_params(struct ieee80211_local *local, ++static bool ieee80211_sta_wmm_params(struct ieee80211_local *local, + struct ieee80211_sub_if_data *sdata, + u8 *wmm_param, size_t wmm_param_len) + { +@@ -1119,23 +1119,23 @@ static void ieee80211_sta_wmm_params(str + u8 *pos, uapsd_queues = 0; + + if (!local->ops->conf_tx) +- return; ++ return false; + + if (local->hw.queues < IEEE80211_NUM_ACS) +- return; ++ return false; + + if (!wmm_param) +- return; ++ return false; + + if (wmm_param_len < 8 || wmm_param[5] /* version */ != 1) +- return; ++ return false; + + if (ifmgd->flags & IEEE80211_STA_UAPSD_ENABLED) + uapsd_queues = ifmgd->uapsd_queues; + + count = wmm_param[6] & 0x0f; + if (count == ifmgd->wmm_last_param_set) +- return; ++ return false; + ifmgd->wmm_last_param_set = count; + + pos = wmm_param + 8; +@@ -1202,6 +1202,7 @@ static void ieee80211_sta_wmm_params(str + + /* enable WMM or activate new settings */ + sdata->vif.bss_conf.qos = true; ++ return true; + } + + static void __ieee80211_stop_poll(struct ieee80211_sub_if_data *sdata) +@@ -2435,14 +2436,6 @@ static void ieee80211_rx_mgmt_beacon(str + directed_tim = ieee80211_check_tim(elems.tim, elems.tim_len, + ifmgd->aid); + +- if (ncrc != ifmgd->beacon_crc || !ifmgd->beacon_crc_valid) { +- ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems, +- true); +- +- ieee80211_sta_wmm_params(local, sdata, elems.wmm_param, +- elems.wmm_param_len); +- } +- + if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) { + if (directed_tim) { + if (local->hw.conf.dynamic_ps_timeout > 0) { +@@ -2473,6 +2466,13 @@ static void ieee80211_rx_mgmt_beacon(str + ifmgd->beacon_crc = ncrc; + ifmgd->beacon_crc_valid = true; + ++ ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems, ++ true); ++ ++ if (ieee80211_sta_wmm_params(local, sdata, elems.wmm_param, ++ elems.wmm_param_len)) ++ changed |= BSS_CHANGED_QOS; ++ + if (elems.erp_info && elems.erp_info_len >= 1) { + erp_valid = true; + erp_value = elems.erp_info[0]; +--- a/net/mac80211/rc80211_minstrel_ht.c ++++ b/net/mac80211/rc80211_minstrel_ht.c +@@ -626,8 +626,12 @@ minstrel_ht_get_rate(void *priv, struct + + #ifdef CONFIG_MAC80211_DEBUGFS + /* use fixed index if set */ +- if (mp->fixed_rate_idx != -1) +- sample_idx = mp->fixed_rate_idx; ++ if (mp->fixed_rate_idx != -1) { ++ mi->max_tp_rate = mp->fixed_rate_idx; ++ mi->max_tp_rate2 = mp->fixed_rate_idx; ++ mi->max_prob_rate = mp->fixed_rate_idx; ++ sample_idx = -1; ++ } + #endif + + if (sample_idx >= 0) { --- a/net/mac80211/rx.c +++ b/net/mac80211/rx.c -@@ -2281,6 +2281,7 @@ ieee80211_rx_h_action(struct ieee80211_r +@@ -2262,6 +2262,7 @@ ieee80211_rx_h_action(struct ieee80211_r sdata->vif.type != NL80211_IFTYPE_MESH_POINT && sdata->vif.type != NL80211_IFTYPE_AP_VLAN && sdata->vif.type != NL80211_IFTYPE_AP && @@ -1428,7 +1918,7 @@ sdata->vif.type != NL80211_IFTYPE_ADHOC) break; -@@ -2495,14 +2496,15 @@ ieee80211_rx_h_mgmt(struct ieee80211_rx_ +@@ -2479,14 +2480,15 @@ ieee80211_rx_h_mgmt(struct ieee80211_rx_ if (!ieee80211_vif_is_mesh(&sdata->vif) && sdata->vif.type != NL80211_IFTYPE_ADHOC && @@ -1446,7 +1936,7 @@ break; case cpu_to_le16(IEEE80211_STYPE_ASSOC_RESP): case cpu_to_le16(IEEE80211_STYPE_REASSOC_RESP): -@@ -2833,10 +2835,16 @@ static int prepare_for_handlers(struct i +@@ -2817,10 +2819,16 @@ static int prepare_for_handlers(struct i } break; case NL80211_IFTYPE_WDS: @@ -1483,243 +1973,14 @@ WLAN_STA_CLEAR_PS_FILT, WLAN_STA_MFP, WLAN_STA_BLOCK_BA, ---- a/drivers/net/wireless/ath/ath9k/ath9k.h -+++ b/drivers/net/wireless/ath/ath9k/ath9k.h -@@ -214,6 +214,7 @@ struct ath_frame_info { - enum ath9k_key_type keytype; - u8 keyix; - u8 retries; -+ u8 rtscts_rate; - }; - - struct ath_buf_state { -@@ -721,6 +722,7 @@ extern int ath9k_modparam_nohwcrypt; - extern int led_blink; - extern bool is_ath9k_unloaded; - -+u8 ath9k_parse_mpdudensity(u8 mpdudensity); - irqreturn_t ath_isr(int irq, void *dev); - int ath9k_init_device(u16 devid, struct ath_softc *sc, - const struct ath_bus_ops *bus_ops); ---- a/drivers/net/wireless/ath/ath9k/xmit.c -+++ b/drivers/net/wireless/ath/ath9k/xmit.c -@@ -938,6 +938,7 @@ static void ath_buf_set_rate(struct ath_ - struct ieee80211_tx_rate *rates; - const struct ieee80211_rate *rate; - struct ieee80211_hdr *hdr; -+ struct ath_frame_info *fi = get_frame_info(bf->bf_mpdu); - int i; - u8 rix = 0; - -@@ -948,18 +949,7 @@ static void ath_buf_set_rate(struct ath_ - - /* set dur_update_en for l-sig computation except for PS-Poll frames */ - info->dur_update = !ieee80211_is_pspoll(hdr->frame_control); -- -- /* -- * We check if Short Preamble is needed for the CTS rate by -- * checking the BSS's global flag. -- * But for the rate series, IEEE80211_TX_RC_USE_SHORT_PREAMBLE is used. -- */ -- rate = ieee80211_get_rts_cts_rate(sc->hw, tx_info); -- info->rtscts_rate = rate->hw_value; -- -- if (tx_info->control.vif && -- tx_info->control.vif->bss_conf.use_short_preamble) -- info->rtscts_rate |= rate->hw_value_short; -+ info->rtscts_rate = fi->rtscts_rate; - - for (i = 0; i < 4; i++) { - bool is_40, is_sgi, is_sp; -@@ -1001,13 +991,13 @@ static void ath_buf_set_rate(struct ath_ - } - - /* legacy rates */ -+ rate = &sc->sbands[tx_info->band].bitrates[rates[i].idx]; - if ((tx_info->band == IEEE80211_BAND_2GHZ) && - !(rate->flags & IEEE80211_RATE_ERP_G)) - phy = WLAN_RC_PHY_CCK; - else - phy = WLAN_RC_PHY_OFDM; - -- rate = &sc->sbands[tx_info->band].bitrates[rates[i].idx]; - info->rates[i].Rate = rate->hw_value; - if (rate->hw_value_short) { - if (rates[i].flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE) -@@ -1175,6 +1165,7 @@ int ath_tx_aggr_start(struct ath_softc * - { - struct ath_atx_tid *txtid; - struct ath_node *an; -+ u8 density; - - an = (struct ath_node *)sta->drv_priv; - txtid = ATH_AN_2_TID(an, tid); -@@ -1182,6 +1173,17 @@ int ath_tx_aggr_start(struct ath_softc * - if (txtid->state & (AGGR_CLEANUP | AGGR_ADDBA_COMPLETE)) - return -EAGAIN; - -+ /* update ampdu factor/density, they may have changed. This may happen -+ * in HT IBSS when a beacon with HT-info is received after the station -+ * has already been added. -+ */ -+ if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_HT) { -+ an->maxampdu = 1 << (IEEE80211_HT_MAX_AMPDU_FACTOR + -+ sta->ht_cap.ampdu_factor); -+ density = ath9k_parse_mpdudensity(sta->ht_cap.ampdu_density); -+ an->mpdudensity = density; -+ } -+ - txtid->state |= AGGR_ADDBA_PROGRESS; - txtid->paused = true; - *ssn = txtid->seq_start = txtid->seq_next; -@@ -1776,10 +1778,22 @@ static void setup_frame_info(struct ieee - struct ieee80211_sta *sta = tx_info->control.sta; - struct ieee80211_key_conf *hw_key = tx_info->control.hw_key; - struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data; -+ const struct ieee80211_rate *rate; - struct ath_frame_info *fi = get_frame_info(skb); - struct ath_node *an = NULL; - enum ath9k_key_type keytype; -+ bool short_preamble = false; -+ -+ /* -+ * We check if Short Preamble is needed for the CTS rate by -+ * checking the BSS's global flag. -+ * But for the rate series, IEEE80211_TX_RC_USE_SHORT_PREAMBLE is used. -+ */ -+ if (tx_info->control.vif && -+ tx_info->control.vif->bss_conf.use_short_preamble) -+ short_preamble = true; - -+ rate = ieee80211_get_rts_cts_rate(hw, tx_info); - keytype = ath9k_cmn_get_hw_crypto_keytype(skb); - - if (sta) -@@ -1794,6 +1808,9 @@ static void setup_frame_info(struct ieee - fi->keyix = ATH9K_TXKEYIX_INVALID; - fi->keytype = keytype; - fi->framelen = framelen; -+ fi->rtscts_rate = rate->hw_value; -+ if (short_preamble) -+ fi->rtscts_rate |= rate->hw_value_short; - } - - u8 ath_txchainmask_reduction(struct ath_softc *sc, u8 chainmask, u32 rate) ---- a/net/wireless/nl80211.c -+++ b/net/wireless/nl80211.c -@@ -2246,6 +2246,33 @@ static int nl80211_parse_beacon(struct g - return 0; - } - -+static bool nl80211_get_ap_channel(struct cfg80211_registered_device *rdev, -+ struct cfg80211_ap_settings *params) -+{ -+ struct wireless_dev *wdev; -+ bool ret = false; -+ -+ mutex_lock(&rdev->devlist_mtx); -+ -+ list_for_each_entry(wdev, &rdev->netdev_list, list) { -+ if (wdev->iftype != NL80211_IFTYPE_AP && -+ wdev->iftype != NL80211_IFTYPE_P2P_GO) -+ continue; -+ -+ if (!wdev->preset_chan) -+ continue; -+ -+ params->channel = wdev->preset_chan; -+ params->channel_type = wdev->preset_chantype; -+ ret = true; -+ break; -+ } -+ -+ mutex_unlock(&rdev->devlist_mtx); -+ -+ return ret; -+} -+ - static int nl80211_start_ap(struct sk_buff *skb, struct genl_info *info) +--- a/net/mac80211/tx.c ++++ b/net/mac80211/tx.c +@@ -2716,7 +2716,7 @@ EXPORT_SYMBOL(ieee80211_get_buffered_bc) + void ieee80211_tx_skb_tid(struct ieee80211_sub_if_data *sdata, + struct sk_buff *skb, int tid) { - struct cfg80211_registered_device *rdev = info->user_ptr[0]; -@@ -2348,7 +2375,7 @@ static int nl80211_start_ap(struct sk_bu - } else if (wdev->preset_chan) { - params.channel = wdev->preset_chan; - params.channel_type = wdev->preset_chantype; -- } else -+ } else if (!nl80211_get_ap_channel(rdev, ¶ms)) - return -EINVAL; - - if (!cfg80211_can_beacon_sec_chan(&rdev->wiphy, params.channel, -@@ -2356,8 +2383,11 @@ static int nl80211_start_ap(struct sk_bu - return -EINVAL; - - err = rdev->ops->start_ap(&rdev->wiphy, dev, ¶ms); -- if (!err) -+ if (!err) { -+ wdev->preset_chan = params.channel; -+ wdev->preset_chantype = params.channel_type; - wdev->beacon_interval = params.beacon_interval; -+ } - return err; - } - ---- a/drivers/net/wireless/ath/ath9k/link.c -+++ b/drivers/net/wireless/ath/ath9k/link.c -@@ -407,6 +407,7 @@ void ath_ani_calibrate(unsigned long dat - longcal ? "long" : "", shortcal ? "short" : "", - aniflag ? "ani" : "", common->ani.caldone ? "true" : "false"); - -+ ath9k_debug_samp_bb_mac(sc); - ath9k_ps_restore(sc); - - set_timer: -@@ -415,7 +416,6 @@ set_timer: - * The interval must be the shortest necessary to satisfy ANI, - * short calibration and long calibration. - */ -- ath9k_debug_samp_bb_mac(sc); - cal_interval = ATH_LONG_CALINTERVAL; - if (sc->sc_ah->config.enable_ani) - cal_interval = min(cal_interval, ---- a/drivers/net/wireless/ath/ath.h -+++ b/drivers/net/wireless/ath/ath.h -@@ -143,6 +143,7 @@ struct ath_common { - u32 keymax; - DECLARE_BITMAP(keymap, ATH_KEYMAX); - DECLARE_BITMAP(tkip_keymap, ATH_KEYMAX); -+ DECLARE_BITMAP(ccmp_keymap, ATH_KEYMAX); - enum ath_crypt_caps crypt_caps; - - unsigned int clockrate; ---- a/drivers/net/wireless/ath/ath9k/recv.c -+++ b/drivers/net/wireless/ath/ath9k/recv.c -@@ -785,7 +785,8 @@ static bool ath9k_rx_accept(struct ath_c - * descriptor does contain a valid key index. This has been observed - * mostly with CCMP encryption. - */ -- if (rx_stats->rs_keyix == ATH9K_RXKEYIX_INVALID) -+ if (rx_stats->rs_keyix == ATH9K_RXKEYIX_INVALID || -+ !test_bit(rx_stats->rs_keyix, common->ccmp_keymap)) - rx_stats->rs_status &= ~ATH9K_RXERR_KEYMISS; - - if (!rx_stats->rs_datalen) { ---- a/drivers/net/wireless/ath/key.c -+++ b/drivers/net/wireless/ath/key.c -@@ -556,6 +556,9 @@ int ath_key_config(struct ath_common *co - return -EIO; - - set_bit(idx, common->keymap); -+ if (key->cipher == WLAN_CIPHER_SUITE_CCMP) -+ set_bit(idx, common->ccmp_keymap); -+ - if (key->cipher == WLAN_CIPHER_SUITE_TKIP) { - set_bit(idx + 64, common->keymap); - set_bit(idx, common->tkip_keymap); -@@ -582,6 +585,7 @@ void ath_key_delete(struct ath_common *c - return; - - clear_bit(key->hw_key_idx, common->keymap); -+ clear_bit(key->hw_key_idx, common->ccmp_keymap); - if (key->cipher != WLAN_CIPHER_SUITE_TKIP) - return; +- int ac = ieee802_1d_to_ac[tid]; ++ int ac = ieee802_1d_to_ac[tid & 7]; + skb_set_mac_header(skb, 0); + skb_set_network_header(skb, 0); |