From 0b00ddfee9d49ee08279735c58c7be3e8f0e7e42 Mon Sep 17 00:00:00 2001 From: nbd Date: Wed, 4 Aug 2010 17:29:05 +0000 Subject: [PATCH] mac80211: merge changes from latest trunk into backfire git-svn-id: svn://svn.openwrt.org/openwrt/branches/backfire@22494 3c298f89-4303-0410-b956-a3cf2f4a3e73 --- package/mac80211/Makefile | 4 +- .../patches/100-disable_pcmcia_compat.patch | 6 +- package/mac80211/patches/120-pm_qos_params.patch | 2 +- .../mac80211/patches/130-printk_debug_revert.patch | 69 ++ package/mac80211/patches/520-ath9k_leak_fix.patch | 32 - package/mac80211/patches/520-pending_work.patch | 993 +++++++++++++++++++++ .../patches/530-ath9k_aggr_state_fix.patch | 72 ++ package/mac80211/patches/530-ath9k_nf_fix.patch | 46 - .../mac80211/patches/531-ath9k_nf_cleanup.patch | 30 - .../mac80211/patches/540-ath9k_bstuck_debug.patch | 43 + .../mac80211/patches/541-ath9k_nf_validate.patch | 101 +++ .../patches/542-ath9k_bstuck_nf_calibrate.patch | 129 +++ .../patches/543-ath9k_interference_nf_cal.patch | 35 + package/mac80211/patches/550-ath9k_tsf_fix.patch | 44 + .../700-mwl8k-missing-pci-id-for-WNR854T.patch | 2 +- .../mac80211/patches/800-mac80211_aggr_fix.patch | 20 - 16 files changed, 1492 insertions(+), 136 deletions(-) create mode 100644 package/mac80211/patches/130-printk_debug_revert.patch delete mode 100644 package/mac80211/patches/520-ath9k_leak_fix.patch create mode 100644 package/mac80211/patches/520-pending_work.patch create mode 100644 package/mac80211/patches/530-ath9k_aggr_state_fix.patch delete mode 100644 package/mac80211/patches/530-ath9k_nf_fix.patch delete mode 100644 package/mac80211/patches/531-ath9k_nf_cleanup.patch create mode 100644 package/mac80211/patches/540-ath9k_bstuck_debug.patch create mode 100644 package/mac80211/patches/541-ath9k_nf_validate.patch create mode 100644 package/mac80211/patches/542-ath9k_bstuck_nf_calibrate.patch create mode 100644 package/mac80211/patches/543-ath9k_interference_nf_cal.patch create mode 100644 package/mac80211/patches/550-ath9k_tsf_fix.patch delete mode 100644 package/mac80211/patches/800-mac80211_aggr_fix.patch diff --git a/package/mac80211/Makefile b/package/mac80211/Makefile index 7dd953882..e2451b395 100644 --- a/package/mac80211/Makefile +++ b/package/mac80211/Makefile @@ -10,12 +10,12 @@ include $(INCLUDE_DIR)/kernel.mk PKG_NAME:=mac80211 -PKG_VERSION:=2010-07-16 +PKG_VERSION:=2010-07-29 PKG_RELEASE:=1 PKG_SOURCE_URL:=http://mirror2.openwrt.org/sources # http://www.orbit-lab.org/kernel/compat-wireless-2.6/2010/11 \ # http://wireless.kernel.org/download/compat-wireless-2.6 -PKG_MD5SUM:=f0eb07a207d1f3675787a466c838b777 +PKG_MD5SUM:=fcfb757939c4718efbf9c87ca59c6932 PKG_SOURCE:=compat-wireless-$(PKG_VERSION).tar.bz2 PKG_BUILD_DIR:=$(KERNEL_BUILD_DIR)/compat-wireless-$(PKG_VERSION) diff --git a/package/mac80211/patches/100-disable_pcmcia_compat.patch b/package/mac80211/patches/100-disable_pcmcia_compat.patch index 8b366ff93..ebfe5ce65 100644 --- a/package/mac80211/patches/100-disable_pcmcia_compat.patch +++ b/package/mac80211/patches/100-disable_pcmcia_compat.patch @@ -42,18 +42,16 @@ #include --- a/include/linux/compat-2.6.33.h +++ b/include/linux/compat-2.6.33.h -@@ -6,8 +6,8 @@ +@@ -6,7 +6,7 @@ #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,33)) #include -#if defined(CONFIG_PCCARD) || defined(CONFIG_PCCARD_MODULE) --#if defined(CONFIG_PCMCIA) || defined(CONFIG_PCMCIA_MODULE) -+#if 0 +#if 0 #include #include #include -@@ -67,9 +67,9 @@ static inline struct sk_buff *netdev_all +@@ -65,9 +65,9 @@ static inline struct sk_buff *netdev_all return skb; } diff --git a/package/mac80211/patches/120-pm_qos_params.patch b/package/mac80211/patches/120-pm_qos_params.patch index 8562992a5..ca4b7bfe3 100644 --- a/package/mac80211/patches/120-pm_qos_params.patch +++ b/package/mac80211/patches/120-pm_qos_params.patch @@ -5,7 +5,7 @@ #define DRV_COPYRIGHT "Copyright(c) 2003-2006 Intel Corporation" +#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35)) - struct pm_qos_request_list *ipw2100_pm_qos_req; + static struct pm_qos_request_list *ipw2100_pm_qos_req; +#endif /* Debugging stuff */ diff --git a/package/mac80211/patches/130-printk_debug_revert.patch b/package/mac80211/patches/130-printk_debug_revert.patch new file mode 100644 index 000000000..232902e8c --- /dev/null +++ b/package/mac80211/patches/130-printk_debug_revert.patch @@ -0,0 +1,69 @@ +--- a/include/net/cfg80211.h ++++ b/include/net/cfg80211.h +@@ -2443,9 +2443,8 @@ void cfg80211_cqm_rssi_notify(struct net + wiphy_printk(KERN_NOTICE, wiphy, format, ##args) + #define wiphy_info(wiphy, format, args...) \ + wiphy_printk(KERN_INFO, wiphy, format, ##args) +- +-int wiphy_debug(const struct wiphy *wiphy, const char *format, ...) +- __attribute__ ((format (printf, 2, 3))); ++#define wiphy_debug(wiphy, format, args...) \ ++ wiphy_printk(KERN_DEBUG, wiphy, format, ##args) + + #if defined(DEBUG) + #define wiphy_dbg(wiphy, format, args...) \ +--- a/net/wireless/core.c ++++ b/net/wireless/core.c +@@ -921,52 +921,3 @@ static void __exit cfg80211_exit(void) + destroy_workqueue(cfg80211_wq); + } + module_exit(cfg80211_exit); +- +-static int ___wiphy_printk(const char *level, const struct wiphy *wiphy, +- struct va_format *vaf) +-{ +- if (!wiphy) +- return printk("%s(NULL wiphy *): %pV", level, vaf); +- +- return printk("%s%s: %pV", level, wiphy_name(wiphy), vaf); +-} +- +-int __wiphy_printk(const char *level, const struct wiphy *wiphy, +- const char *fmt, ...) +-{ +- struct va_format vaf; +- va_list args; +- int r; +- +- va_start(args, fmt); +- +- vaf.fmt = fmt; +- vaf.va = &args; +- +- r = ___wiphy_printk(level, wiphy, &vaf); +- va_end(args); +- +- return r; +-} +-EXPORT_SYMBOL(__wiphy_printk); +- +-#define define_wiphy_printk_level(func, kern_level) \ +-int func(const struct wiphy *wiphy, const char *fmt, ...) \ +-{ \ +- struct va_format vaf; \ +- va_list args; \ +- int r; \ +- \ +- va_start(args, fmt); \ +- \ +- vaf.fmt = fmt; \ +- vaf.va = &args; \ +- \ +- r = ___wiphy_printk(kern_level, wiphy, &vaf); \ +- va_end(args); \ +- \ +- return r; \ +-} \ +-EXPORT_SYMBOL(func); +- +-define_wiphy_printk_level(wiphy_debug, KERN_DEBUG); diff --git a/package/mac80211/patches/520-ath9k_leak_fix.patch b/package/mac80211/patches/520-ath9k_leak_fix.patch deleted file mode 100644 index acf7efd87..000000000 --- a/package/mac80211/patches/520-ath9k_leak_fix.patch +++ /dev/null @@ -1,32 +0,0 @@ ---- a/drivers/net/wireless/ath/ath9k/xmit.c -+++ b/drivers/net/wireless/ath/ath9k/xmit.c -@@ -518,6 +518,14 @@ static void ath_tx_complete_aggr(struct - bf = bf_next; - } - -+ /* prepend un-acked frames to the beginning of the pending frame queue */ -+ if (!list_empty(&bf_pending)) { -+ spin_lock_bh(&txq->axq_lock); -+ list_splice(&bf_pending, &tid->buf_q); -+ ath_tx_queue_tid(txq, tid); -+ spin_unlock_bh(&txq->axq_lock); -+ } -+ - if (tid->state & AGGR_CLEANUP) { - if (tid->baw_head == tid->baw_tail) { - tid->state &= ~AGGR_ADDBA_COMPLETE; -@@ -530,14 +538,6 @@ static void ath_tx_complete_aggr(struct - return; - } - -- /* prepend un-acked frames to the beginning of the pending frame queue */ -- if (!list_empty(&bf_pending)) { -- spin_lock_bh(&txq->axq_lock); -- list_splice(&bf_pending, &tid->buf_q); -- ath_tx_queue_tid(txq, tid); -- spin_unlock_bh(&txq->axq_lock); -- } -- - rcu_read_unlock(); - - if (needreset) diff --git a/package/mac80211/patches/520-pending_work.patch b/package/mac80211/patches/520-pending_work.patch new file mode 100644 index 000000000..bcbbaf66b --- /dev/null +++ b/package/mac80211/patches/520-pending_work.patch @@ -0,0 +1,993 @@ +--- a/net/mac80211/main.c ++++ b/net/mac80211/main.c +@@ -103,11 +103,13 @@ int ieee80211_hw_config(struct ieee80211 + int ret = 0; + int power; + enum nl80211_channel_type channel_type; ++ u32 offchannel_flag; + + might_sleep(); + + scan_chan = local->scan_channel; + ++ offchannel_flag = local->hw.conf.flags & IEEE80211_CONF_OFFCHANNEL; + if (scan_chan) { + chan = scan_chan; + channel_type = NL80211_CHAN_NO_HT; +@@ -121,8 +123,9 @@ int ieee80211_hw_config(struct ieee80211 + channel_type = local->_oper_channel_type; + local->hw.conf.flags &= ~IEEE80211_CONF_OFFCHANNEL; + } ++ offchannel_flag ^= local->hw.conf.flags & IEEE80211_CONF_OFFCHANNEL; + +- if (chan != local->hw.conf.channel || ++ if (offchannel_flag || chan != local->hw.conf.channel || + channel_type != local->hw.conf.channel_type) { + local->hw.conf.channel = chan; + local->hw.conf.channel_type = channel_type; +--- a/drivers/net/wireless/ath/ath9k/ar9002_calib.c ++++ b/drivers/net/wireless/ath/ath9k/ar9002_calib.c +@@ -63,6 +63,7 @@ static bool ar9002_hw_per_calibration(st + u8 rxchainmask, + struct ath9k_cal_list *currCal) + { ++ struct ath9k_hw_cal_data *caldata = ah->caldata; + bool iscaldone = false; + + if (currCal->calState == CAL_RUNNING) { +@@ -81,14 +82,14 @@ static bool ar9002_hw_per_calibration(st + } + + currCal->calData->calPostProc(ah, numChains); +- ichan->CalValid |= currCal->calData->calType; ++ caldata->CalValid |= currCal->calData->calType; + currCal->calState = CAL_DONE; + iscaldone = true; + } else { + ar9002_hw_setup_calibration(ah, currCal); + } + } +- } else if (!(ichan->CalValid & currCal->calData->calType)) { ++ } else if (!(caldata->CalValid & currCal->calData->calType)) { + ath9k_hw_reset_calibration(ah, currCal); + } + +@@ -686,8 +687,13 @@ static bool ar9002_hw_calibrate(struct a + { + bool iscaldone = true; + struct ath9k_cal_list *currCal = ah->cal_list_curr; ++ bool nfcal, nfcal_pending = false; + +- if (currCal && ++ nfcal = !!(REG_READ(ah, AR_PHY_AGC_CONTROL) & AR_PHY_AGC_CONTROL_NF); ++ if (ah->caldata) ++ nfcal_pending = ah->caldata->nfcal_pending; ++ ++ if (currCal && !nfcal && + (currCal->calState == CAL_RUNNING || + currCal->calState == CAL_WAITING)) { + iscaldone = ar9002_hw_per_calibration(ah, chan, +@@ -703,7 +709,7 @@ static bool ar9002_hw_calibrate(struct a + } + + /* Do NF cal only at longer intervals */ +- if (longcal) { ++ if (longcal || nfcal_pending) { + /* Do periodic PAOffset Cal */ + ar9002_hw_pa_cal(ah, false); + ar9002_hw_olc_temp_compensation(ah); +@@ -712,16 +718,18 @@ static bool ar9002_hw_calibrate(struct a + * Get the value from the previous NF cal and update + * history buffer. + */ +- ath9k_hw_getnf(ah, chan); +- +- /* +- * Load the NF from history buffer of the current channel. +- * NF is slow time-variant, so it is OK to use a historical +- * value. +- */ +- ath9k_hw_loadnf(ah, ah->curchan); ++ if (ath9k_hw_getnf(ah, chan)) { ++ /* ++ * Load the NF from history buffer of the current ++ * channel. ++ * NF is slow time-variant, so it is OK to use a ++ * historical value. ++ */ ++ ath9k_hw_loadnf(ah, ah->curchan); ++ } + +- ath9k_hw_start_nfcal(ah); ++ if (longcal) ++ ath9k_hw_start_nfcal(ah, false); + } + + return iscaldone; +@@ -869,8 +877,10 @@ static bool ar9002_hw_init_cal(struct at + ar9002_hw_pa_cal(ah, true); + + /* Do NF Calibration after DC offset and other calibrations */ +- REG_WRITE(ah, AR_PHY_AGC_CONTROL, +- REG_READ(ah, AR_PHY_AGC_CONTROL) | AR_PHY_AGC_CONTROL_NF); ++ ath9k_hw_start_nfcal(ah, true); ++ ++ if (ah->caldata) ++ ah->caldata->nfcal_pending = true; + + ah->cal_list = ah->cal_list_last = ah->cal_list_curr = NULL; + +@@ -901,7 +911,8 @@ static bool ar9002_hw_init_cal(struct at + ath9k_hw_reset_calibration(ah, ah->cal_list_curr); + } + +- chan->CalValid = 0; ++ if (ah->caldata) ++ ah->caldata->CalValid = 0; + + return true; + } +--- a/drivers/net/wireless/ath/ath9k/ar9003_calib.c ++++ b/drivers/net/wireless/ath/ath9k/ar9003_calib.c +@@ -68,6 +68,7 @@ static bool ar9003_hw_per_calibration(st + u8 rxchainmask, + struct ath9k_cal_list *currCal) + { ++ struct ath9k_hw_cal_data *caldata = ah->caldata; + /* Cal is assumed not done until explicitly set below */ + bool iscaldone = false; + +@@ -95,7 +96,7 @@ static bool ar9003_hw_per_calibration(st + currCal->calData->calPostProc(ah, numChains); + + /* Calibration has finished. */ +- ichan->CalValid |= currCal->calData->calType; ++ caldata->CalValid |= currCal->calData->calType; + currCal->calState = CAL_DONE; + iscaldone = true; + } else { +@@ -106,7 +107,7 @@ static bool ar9003_hw_per_calibration(st + ar9003_hw_setup_calibration(ah, currCal); + } + } +- } else if (!(ichan->CalValid & currCal->calData->calType)) { ++ } else if (!(caldata->CalValid & currCal->calData->calType)) { + /* If current cal is marked invalid in channel, kick it off */ + ath9k_hw_reset_calibration(ah, currCal); + } +@@ -149,6 +150,12 @@ static bool ar9003_hw_calibrate(struct a + /* Do NF cal only at longer intervals */ + if (longcal) { + /* ++ * Get the value from the previous NF cal and update ++ * history buffer. ++ */ ++ ath9k_hw_getnf(ah, chan); ++ ++ /* + * Load the NF from history buffer of the current channel. + * NF is slow time-variant, so it is OK to use a historical + * value. +@@ -156,7 +163,7 @@ static bool ar9003_hw_calibrate(struct a + ath9k_hw_loadnf(ah, ah->curchan); + + /* start NF calibration, without updating BB NF register */ +- ath9k_hw_start_nfcal(ah); ++ ath9k_hw_start_nfcal(ah, false); + } + + return iscaldone; +@@ -762,6 +769,8 @@ static bool ar9003_hw_init_cal(struct at + /* Revert chainmasks to their original values before NF cal */ + ar9003_hw_set_chain_masks(ah, ah->rxchainmask, ah->txchainmask); + ++ ath9k_hw_start_nfcal(ah, true); ++ + /* Initialize list pointers */ + ah->cal_list = ah->cal_list_last = ah->cal_list_curr = NULL; + +@@ -785,7 +794,8 @@ static bool ar9003_hw_init_cal(struct at + if (ah->cal_list_curr) + ath9k_hw_reset_calibration(ah, ah->cal_list_curr); + +- chan->CalValid = 0; ++ if (ah->caldata) ++ ah->caldata->CalValid = 0; + + return true; + } +--- a/drivers/net/wireless/ath/ath9k/ar9003_phy.c ++++ b/drivers/net/wireless/ath/ath9k/ar9003_phy.c +@@ -542,7 +542,11 @@ static void ar9003_hw_prog_ini(struct at + u32 reg = INI_RA(iniArr, i, 0); + u32 val = INI_RA(iniArr, i, column); + +- REG_WRITE(ah, reg, val); ++ if (reg >= 0x16000 && reg < 0x17000) ++ ath9k_hw_analog_shift_regwrite(ah, reg, val); ++ else ++ REG_WRITE(ah, reg, val); ++ + DO_DELAY(regWrites); + } + } +--- a/drivers/net/wireless/ath/ath9k/calib.c ++++ b/drivers/net/wireless/ath/ath9k/calib.c +@@ -22,23 +22,6 @@ + /* We can tune this as we go by monitoring really low values */ + #define ATH9K_NF_TOO_LOW -60 + +-/* AR5416 may return very high value (like -31 dBm), in those cases the nf +- * is incorrect and we should use the static NF value. Later we can try to +- * find out why they are reporting these values */ +- +-static bool ath9k_hw_nf_in_range(struct ath_hw *ah, s16 nf) +-{ +- if (nf > ATH9K_NF_TOO_LOW) { +- ath_print(ath9k_hw_common(ah), ATH_DBG_CALIBRATE, +- "noise floor value detected (%d) is " +- "lower than what we think is a " +- "reasonable value (%d)\n", +- nf, ATH9K_NF_TOO_LOW); +- return false; +- } +- return true; +-} +- + static int16_t ath9k_hw_get_nf_hist_mid(int16_t *nfCalBuffer) + { + int16_t nfval; +@@ -121,6 +104,19 @@ void ath9k_hw_reset_calibration(struct a + ah->cal_samples = 0; + } + ++static s16 ath9k_hw_get_default_nf(struct ath_hw *ah, ++ struct ath9k_channel *chan) ++{ ++ struct ath_nf_limits *limit; ++ ++ if (!chan || IS_CHAN_2GHZ(chan)) ++ limit = &ah->nf_2g; ++ else ++ limit = &ah->nf_5g; ++ ++ return limit->nominal; ++} ++ + /* This is done for the currently configured channel */ + bool ath9k_hw_reset_calvalid(struct ath_hw *ah) + { +@@ -128,7 +124,7 @@ bool ath9k_hw_reset_calvalid(struct ath_ + struct ieee80211_conf *conf = &common->hw->conf; + struct ath9k_cal_list *currCal = ah->cal_list_curr; + +- if (!ah->curchan) ++ if (!ah->caldata) + return true; + + if (!AR_SREV_9100(ah) && !AR_SREV_9160_10_OR_LATER(ah)) +@@ -151,37 +147,55 @@ bool ath9k_hw_reset_calvalid(struct ath_ + "Resetting Cal %d state for channel %u\n", + currCal->calData->calType, conf->channel->center_freq); + +- ah->curchan->CalValid &= ~currCal->calData->calType; ++ ah->caldata->CalValid &= ~currCal->calData->calType; + currCal->calState = CAL_WAITING; + + return false; + } + EXPORT_SYMBOL(ath9k_hw_reset_calvalid); + +-void ath9k_hw_start_nfcal(struct ath_hw *ah) ++void ath9k_hw_start_nfcal(struct ath_hw *ah, bool update) + { ++ if (ah->caldata) ++ ah->caldata->nfcal_pending = true; ++ + REG_SET_BIT(ah, AR_PHY_AGC_CONTROL, + AR_PHY_AGC_CONTROL_ENABLE_NF); +- REG_SET_BIT(ah, AR_PHY_AGC_CONTROL, ++ ++ if (update) ++ REG_CLR_BIT(ah, AR_PHY_AGC_CONTROL, ++ AR_PHY_AGC_CONTROL_NO_UPDATE_NF); ++ else ++ REG_SET_BIT(ah, AR_PHY_AGC_CONTROL, + AR_PHY_AGC_CONTROL_NO_UPDATE_NF); ++ + REG_SET_BIT(ah, AR_PHY_AGC_CONTROL, AR_PHY_AGC_CONTROL_NF); + } + + void ath9k_hw_loadnf(struct ath_hw *ah, struct ath9k_channel *chan) + { +- struct ath9k_nfcal_hist *h; ++ struct ath9k_nfcal_hist *h = NULL; + unsigned i, j; + int32_t val; + u8 chainmask = (ah->rxchainmask << 3) | ah->rxchainmask; + struct ath_common *common = ath9k_hw_common(ah); ++ s16 default_nf = ath9k_hw_get_default_nf(ah, chan); + +- h = ah->nfCalHist; ++ if (ah->caldata) ++ h = ah->caldata->nfCalHist; + + for (i = 0; i < NUM_NF_READINGS; i++) { + if (chainmask & (1 << i)) { ++ s16 nfval; ++ ++ if (h) ++ nfval = h[i].privNF; ++ else ++ nfval = default_nf; ++ + val = REG_READ(ah, ah->nf_regs[i]); + val &= 0xFFFFFE00; +- val |= (((u32) (h[i].privNF) << 1) & 0x1ff); ++ val |= (((u32) nfval << 1) & 0x1ff); + REG_WRITE(ah, ah->nf_regs[i], val); + } + } +@@ -277,22 +291,25 @@ static void ath9k_hw_nf_sanitize(struct + } + } + +-int16_t ath9k_hw_getnf(struct ath_hw *ah, +- struct ath9k_channel *chan) ++bool ath9k_hw_getnf(struct ath_hw *ah, struct ath9k_channel *chan) + { + struct ath_common *common = ath9k_hw_common(ah); + int16_t nf, nfThresh; + int16_t nfarray[NUM_NF_READINGS] = { 0 }; + struct ath9k_nfcal_hist *h; + struct ieee80211_channel *c = chan->chan; ++ struct ath9k_hw_cal_data *caldata = ah->caldata; ++ ++ if (!caldata) ++ return false; + + chan->channelFlags &= (~CHANNEL_CW_INT); + if (REG_READ(ah, AR_PHY_AGC_CONTROL) & AR_PHY_AGC_CONTROL_NF) { + ath_print(common, ATH_DBG_CALIBRATE, + "NF did not complete in calibration window\n"); + nf = 0; +- chan->rawNoiseFloor = nf; +- return chan->rawNoiseFloor; ++ caldata->rawNoiseFloor = nf; ++ return false; + } else { + ath9k_hw_do_getnf(ah, nfarray); + ath9k_hw_nf_sanitize(ah, nfarray); +@@ -307,47 +324,40 @@ int16_t ath9k_hw_getnf(struct ath_hw *ah + } + } + +- h = ah->nfCalHist; +- ++ h = caldata->nfCalHist; ++ caldata->nfcal_pending = false; + ath9k_hw_update_nfcal_hist_buffer(h, nfarray); +- chan->rawNoiseFloor = h[0].privNF; +- +- return chan->rawNoiseFloor; ++ caldata->rawNoiseFloor = h[0].privNF; ++ return true; + } + +-void ath9k_init_nfcal_hist_buffer(struct ath_hw *ah) ++void ath9k_init_nfcal_hist_buffer(struct ath_hw *ah, ++ struct ath9k_channel *chan) + { +- struct ath_nf_limits *limit; ++ struct ath9k_nfcal_hist *h; ++ s16 default_nf; + int i, j; + +- if (!ah->curchan || IS_CHAN_2GHZ(ah->curchan)) +- limit = &ah->nf_2g; +- else +- limit = &ah->nf_5g; ++ if (!ah->caldata) ++ return; + ++ h = ah->caldata->nfCalHist; ++ default_nf = ath9k_hw_get_default_nf(ah, chan); + for (i = 0; i < NUM_NF_READINGS; i++) { +- ah->nfCalHist[i].currIndex = 0; +- ah->nfCalHist[i].privNF = limit->nominal; +- ah->nfCalHist[i].invalidNFcount = +- AR_PHY_CCA_FILTERWINDOW_LENGTH; ++ h[i].currIndex = 0; ++ h[i].privNF = default_nf; ++ h[i].invalidNFcount = AR_PHY_CCA_FILTERWINDOW_LENGTH; + for (j = 0; j < ATH9K_NF_CAL_HIST_MAX; j++) { +- ah->nfCalHist[i].nfCalBuffer[j] = limit->nominal; ++ h[i].nfCalBuffer[j] = default_nf; + } + } + } + + s16 ath9k_hw_getchan_noise(struct ath_hw *ah, struct ath9k_channel *chan) + { +- s16 nf; +- +- if (chan->rawNoiseFloor == 0) +- nf = -96; +- else +- nf = chan->rawNoiseFloor; +- +- if (!ath9k_hw_nf_in_range(ah, nf)) +- nf = ATH_DEFAULT_NOISE_FLOOR; ++ if (!ah->caldata || !ah->caldata->rawNoiseFloor) ++ return ath9k_hw_get_default_nf(ah, chan); + +- return nf; ++ return ah->caldata->rawNoiseFloor; + } + EXPORT_SYMBOL(ath9k_hw_getchan_noise); +--- a/drivers/net/wireless/ath/ath9k/calib.h ++++ b/drivers/net/wireless/ath/ath9k/calib.h +@@ -108,11 +108,11 @@ struct ath9k_pacal_info{ + }; + + bool ath9k_hw_reset_calvalid(struct ath_hw *ah); +-void ath9k_hw_start_nfcal(struct ath_hw *ah); ++void ath9k_hw_start_nfcal(struct ath_hw *ah, bool update); + void ath9k_hw_loadnf(struct ath_hw *ah, struct ath9k_channel *chan); +-int16_t ath9k_hw_getnf(struct ath_hw *ah, +- struct ath9k_channel *chan); +-void ath9k_init_nfcal_hist_buffer(struct ath_hw *ah); ++bool ath9k_hw_getnf(struct ath_hw *ah, struct ath9k_channel *chan); ++void ath9k_init_nfcal_hist_buffer(struct ath_hw *ah, ++ struct ath9k_channel *chan); + s16 ath9k_hw_getchan_noise(struct ath_hw *ah, struct ath9k_channel *chan); + void ath9k_hw_reset_calibration(struct ath_hw *ah, + struct ath9k_cal_list *currCal); +--- a/drivers/net/wireless/ath/ath9k/hw.c ++++ b/drivers/net/wireless/ath/ath9k/hw.c +@@ -622,7 +622,6 @@ static int __ath9k_hw_init(struct ath_hw + else + ah->tx_trig_level = (AR_FTRIG_512B >> AR_FTRIG_S); + +- ath9k_init_nfcal_hist_buffer(ah); + ah->bb_watchdog_timeout_ms = 25; + + common->state = ATH_HW_INITIALIZED; +@@ -1195,9 +1194,6 @@ static bool ath9k_hw_channel_change(stru + + ath9k_hw_spur_mitigate_freq(ah, chan); + +- if (!chan->oneTimeCalsDone) +- chan->oneTimeCalsDone = true; +- + return true; + } + +@@ -1230,7 +1226,7 @@ bool ath9k_hw_check_alive(struct ath_hw + EXPORT_SYMBOL(ath9k_hw_check_alive); + + int ath9k_hw_reset(struct ath_hw *ah, struct ath9k_channel *chan, +- bool bChannelChange) ++ struct ath9k_hw_cal_data *caldata, bool bChannelChange) + { + struct ath_common *common = ath9k_hw_common(ah); + u32 saveLedState; +@@ -1255,9 +1251,19 @@ int ath9k_hw_reset(struct ath_hw *ah, st + if (!ath9k_hw_setpower(ah, ATH9K_PM_AWAKE)) + return -EIO; + +- if (curchan && !ah->chip_fullsleep) ++ if (curchan && !ah->chip_fullsleep && ah->caldata) + ath9k_hw_getnf(ah, curchan); + ++ ah->caldata = caldata; ++ if (caldata && ++ (chan->channel != caldata->channel || ++ (chan->channelFlags & ~CHANNEL_CW_INT) != ++ (caldata->channelFlags & ~CHANNEL_CW_INT))) { ++ /* Operating channel changed, reset channel calibration data */ ++ memset(caldata, 0, sizeof(*caldata)); ++ ath9k_init_nfcal_hist_buffer(ah, chan); ++ } ++ + if (bChannelChange && + (ah->chip_fullsleep != true) && + (ah->curchan != NULL) && +@@ -1268,7 +1274,7 @@ int ath9k_hw_reset(struct ath_hw *ah, st + + if (ath9k_hw_channel_change(ah, chan)) { + ath9k_hw_loadnf(ah, ah->curchan); +- ath9k_hw_start_nfcal(ah); ++ ath9k_hw_start_nfcal(ah, true); + return 0; + } + } +@@ -1473,11 +1479,8 @@ int ath9k_hw_reset(struct ath_hw *ah, st + if (ah->btcoex_hw.enabled) + ath9k_hw_btcoex_enable(ah); + +- if (AR_SREV_9300_20_OR_LATER(ah)) { +- ath9k_hw_loadnf(ah, curchan); +- ath9k_hw_start_nfcal(ah); ++ if (AR_SREV_9300_20_OR_LATER(ah)) + ar9003_hw_bb_watchdog_config(ah); +- } + + return 0; + } +--- a/drivers/net/wireless/ath/ath9k/main.c ++++ b/drivers/net/wireless/ath/ath9k/main.c +@@ -155,6 +155,27 @@ void ath9k_ps_restore(struct ath_softc * + spin_unlock_irqrestore(&sc->sc_pm_lock, flags); + } + ++static void ath_start_ani(struct ath_common *common) ++{ ++ struct ath_hw *ah = common->ah; ++ unsigned long timestamp = jiffies_to_msecs(jiffies); ++ struct ath_softc *sc = (struct ath_softc *) common->priv; ++ ++ if (!(sc->sc_flags & SC_OP_ANI_RUN)) ++ return; ++ ++ if (sc->sc_flags & SC_OP_OFFCHANNEL) ++ return; ++ ++ common->ani.longcal_timer = timestamp; ++ common->ani.shortcal_timer = timestamp; ++ common->ani.checkani_timer = timestamp; ++ ++ mod_timer(&common->ani.timer, ++ jiffies + ++ msecs_to_jiffies((u32)ah->config.ani_poll_interval)); ++} ++ + /* + * Set/change channels. If the channel is really being changed, it's done + * by reseting the chip. To accomplish this we must first cleanup any pending +@@ -163,16 +184,23 @@ void ath9k_ps_restore(struct ath_softc * + int ath_set_channel(struct ath_softc *sc, struct ieee80211_hw *hw, + struct ath9k_channel *hchan) + { ++ struct ath_wiphy *aphy = hw->priv; + struct ath_hw *ah = sc->sc_ah; + struct ath_common *common = ath9k_hw_common(ah); + struct ieee80211_conf *conf = &common->hw->conf; + bool fastcc = true, stopped; + struct ieee80211_channel *channel = hw->conf.channel; ++ struct ath9k_hw_cal_data *caldata = NULL; + int r; + + if (sc->sc_flags & SC_OP_INVALID) + return -EIO; + ++ del_timer_sync(&common->ani.timer); ++ cancel_work_sync(&sc->paprd_work); ++ cancel_work_sync(&sc->hw_check_work); ++ cancel_delayed_work_sync(&sc->tx_complete_work); ++ + ath9k_ps_wakeup(sc); + + /* +@@ -192,9 +220,12 @@ int ath_set_channel(struct ath_softc *sc + * to flush data frames already in queue because of + * changing channel. */ + +- if (!stopped || (sc->sc_flags & SC_OP_FULL_RESET)) ++ if (!stopped || !(sc->sc_flags & SC_OP_OFFCHANNEL)) + fastcc = false; + ++ if (!(sc->sc_flags & SC_OP_OFFCHANNEL)) ++ caldata = &aphy->caldata; ++ + ath_print(common, ATH_DBG_CONFIG, + "(%u MHz) -> (%u MHz), conf_is_ht40: %d\n", + sc->sc_ah->curchan->channel, +@@ -202,7 +233,7 @@ int ath_set_channel(struct ath_softc *sc + + spin_lock_bh(&sc->sc_resetlock); + +- r = ath9k_hw_reset(ah, hchan, fastcc); ++ r = ath9k_hw_reset(ah, hchan, caldata, fastcc); + if (r) { + ath_print(common, ATH_DBG_FATAL, + "Unable to reset channel (%u MHz), " +@@ -213,8 +244,6 @@ int ath_set_channel(struct ath_softc *sc + } + spin_unlock_bh(&sc->sc_resetlock); + +- sc->sc_flags &= ~SC_OP_FULL_RESET; +- + if (ath_startrecv(sc) != 0) { + ath_print(common, ATH_DBG_FATAL, + "Unable to restart recv logic\n"); +@@ -226,6 +255,12 @@ int ath_set_channel(struct ath_softc *sc + ath_update_txpow(sc); + ath9k_hw_set_interrupts(ah, ah->imask); + ++ if (!(sc->sc_flags & (SC_OP_OFFCHANNEL | SC_OP_SCANNING))) { ++ ath_start_ani(common); ++ ieee80211_queue_delayed_work(sc->hw, &sc->tx_complete_work, 0); ++ ath_beacon_config(sc, NULL); ++ } ++ + ps_restore: + ath9k_ps_restore(sc); + return r; +@@ -234,17 +269,19 @@ int ath_set_channel(struct ath_softc *sc + static void ath_paprd_activate(struct ath_softc *sc) + { + struct ath_hw *ah = sc->sc_ah; ++ struct ath9k_hw_cal_data *caldata = ah->caldata; + int chain; + +- if (!ah->curchan->paprd_done) ++ if (!caldata || !caldata->paprd_done) + return; + + ath9k_ps_wakeup(sc); ++ ar9003_paprd_enable(ah, false); + for (chain = 0; chain < AR9300_MAX_CHAINS; chain++) { + if (!(ah->caps.tx_chainmask & BIT(chain))) + continue; + +- ar9003_paprd_populate_single_table(ah, ah->curchan, chain); ++ ar9003_paprd_populate_single_table(ah, caldata, chain); + } + + ar9003_paprd_enable(ah, true); +@@ -262,6 +299,7 @@ void ath_paprd_calibrate(struct work_str + int band = hw->conf.channel->band; + struct ieee80211_supported_band *sband = &sc->sbands[band]; + struct ath_tx_control txctl; ++ struct ath9k_hw_cal_data *caldata = ah->caldata; + int qnum, ftype; + int chain_ok = 0; + int chain; +@@ -269,6 +307,9 @@ void ath_paprd_calibrate(struct work_str + int time_left; + int i; + ++ if (!caldata) ++ return; ++ + skb = alloc_skb(len, GFP_KERNEL); + if (!skb) + return; +@@ -323,7 +364,7 @@ void ath_paprd_calibrate(struct work_str + if (!ar9003_paprd_is_done(ah)) + break; + +- if (ar9003_paprd_create_curve(ah, ah->curchan, chain) != 0) ++ if (ar9003_paprd_create_curve(ah, caldata, chain) != 0) + break; + + chain_ok = 1; +@@ -331,7 +372,7 @@ void ath_paprd_calibrate(struct work_str + kfree_skb(skb); + + if (chain_ok) { +- ah->curchan->paprd_done = true; ++ caldata->paprd_done = true; + ath_paprd_activate(sc); + } + +@@ -440,33 +481,14 @@ set_timer: + cal_interval = min(cal_interval, (u32)short_cal_interval); + + mod_timer(&common->ani.timer, jiffies + msecs_to_jiffies(cal_interval)); +- if ((sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_PAPRD) && +- !(sc->sc_flags & SC_OP_SCANNING)) { +- if (!sc->sc_ah->curchan->paprd_done) ++ if ((sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_PAPRD) && ah->caldata) { ++ if (!ah->caldata->paprd_done) + ieee80211_queue_work(sc->hw, &sc->paprd_work); + else + ath_paprd_activate(sc); + } + } + +-static void ath_start_ani(struct ath_common *common) +-{ +- struct ath_hw *ah = common->ah; +- unsigned long timestamp = jiffies_to_msecs(jiffies); +- struct ath_softc *sc = (struct ath_softc *) common->priv; +- +- if (!(sc->sc_flags & SC_OP_ANI_RUN)) +- return; +- +- common->ani.longcal_timer = timestamp; +- common->ani.shortcal_timer = timestamp; +- common->ani.checkani_timer = timestamp; +- +- mod_timer(&common->ani.timer, +- jiffies + +- msecs_to_jiffies((u32)ah->config.ani_poll_interval)); +-} +- + /* + * Update tx/rx chainmask. For legacy association, + * hard code chainmask to 1x1, for 11n association, use +@@ -478,7 +500,7 @@ void ath_update_chainmask(struct ath_sof + struct ath_hw *ah = sc->sc_ah; + struct ath_common *common = ath9k_hw_common(ah); + +- if ((sc->sc_flags & SC_OP_SCANNING) || is_ht || ++ if ((sc->sc_flags & SC_OP_OFFCHANNEL) || is_ht || + (ah->btcoex_hw.scheme != ATH_BTCOEX_CFG_NONE)) { + common->tx_chainmask = ah->caps.tx_chainmask; + common->rx_chainmask = ah->caps.rx_chainmask; +@@ -818,7 +840,7 @@ void ath_radio_enable(struct ath_softc * + ah->curchan = ath_get_curchannel(sc, sc->hw); + + spin_lock_bh(&sc->sc_resetlock); +- r = ath9k_hw_reset(ah, ah->curchan, false); ++ r = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false); + if (r) { + ath_print(common, ATH_DBG_FATAL, + "Unable to reset channel (%u MHz), " +@@ -878,7 +900,7 @@ void ath_radio_disable(struct ath_softc + ah->curchan = ath_get_curchannel(sc, hw); + + spin_lock_bh(&sc->sc_resetlock); +- r = ath9k_hw_reset(ah, ah->curchan, false); ++ r = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false); + if (r) { + ath_print(ath9k_hw_common(sc->sc_ah), ATH_DBG_FATAL, + "Unable to reset channel (%u MHz), " +@@ -911,7 +933,7 @@ int ath_reset(struct ath_softc *sc, bool + ath_flushrecv(sc); + + spin_lock_bh(&sc->sc_resetlock); +- r = ath9k_hw_reset(ah, sc->sc_ah->curchan, false); ++ r = ath9k_hw_reset(ah, sc->sc_ah->curchan, ah->caldata, false); + if (r) + ath_print(common, ATH_DBG_FATAL, + "Unable to reset hardware; reset status %d\n", r); +@@ -1086,7 +1108,7 @@ static int ath9k_start(struct ieee80211_ + * and then setup of the interrupt mask. + */ + spin_lock_bh(&sc->sc_resetlock); +- r = ath9k_hw_reset(ah, init_channel, false); ++ r = ath9k_hw_reset(ah, init_channel, ah->caldata, false); + if (r) { + ath_print(common, ATH_DBG_FATAL, + "Unable to reset hardware; reset status %d " +@@ -1580,6 +1602,10 @@ static int ath9k_config(struct ieee80211 + + aphy->chan_idx = pos; + aphy->chan_is_ht = conf_is_ht(conf); ++ if (hw->conf.flags & IEEE80211_CONF_OFFCHANNEL) ++ sc->sc_flags |= SC_OP_OFFCHANNEL; ++ else ++ sc->sc_flags &= ~SC_OP_OFFCHANNEL; + + if (aphy->state == ATH_WIPHY_SCAN || + aphy->state == ATH_WIPHY_ACTIVE) +@@ -1991,7 +2017,6 @@ static void ath9k_sw_scan_start(struct i + { + struct ath_wiphy *aphy = hw->priv; + struct ath_softc *sc = aphy->sc; +- struct ath_common *common = ath9k_hw_common(sc->sc_ah); + + mutex_lock(&sc->mutex); + if (ath9k_wiphy_scanning(sc)) { +@@ -2009,10 +2034,6 @@ static void ath9k_sw_scan_start(struct i + aphy->state = ATH_WIPHY_SCAN; + ath9k_wiphy_pause_all_forced(sc, aphy); + sc->sc_flags |= SC_OP_SCANNING; +- del_timer_sync(&common->ani.timer); +- cancel_work_sync(&sc->paprd_work); +- cancel_work_sync(&sc->hw_check_work); +- cancel_delayed_work_sync(&sc->tx_complete_work); + mutex_unlock(&sc->mutex); + } + +@@ -2024,15 +2045,10 @@ static void ath9k_sw_scan_complete(struc + { + struct ath_wiphy *aphy = hw->priv; + struct ath_softc *sc = aphy->sc; +- struct ath_common *common = ath9k_hw_common(sc->sc_ah); + + mutex_lock(&sc->mutex); + aphy->state = ATH_WIPHY_ACTIVE; + sc->sc_flags &= ~SC_OP_SCANNING; +- sc->sc_flags |= SC_OP_FULL_RESET; +- ath_start_ani(common); +- ieee80211_queue_delayed_work(sc->hw, &sc->tx_complete_work, 0); +- ath_beacon_config(sc, NULL); + mutex_unlock(&sc->mutex); + } + +--- a/drivers/net/wireless/ath/ath9k/ar9003_paprd.c ++++ b/drivers/net/wireless/ath/ath9k/ar9003_paprd.c +@@ -577,10 +577,11 @@ static bool create_pa_curve(u32 *data_L, + } + + void ar9003_paprd_populate_single_table(struct ath_hw *ah, +- struct ath9k_channel *chan, int chain) ++ struct ath9k_hw_cal_data *caldata, ++ int chain) + { +- u32 *paprd_table_val = chan->pa_table[chain]; +- u32 small_signal_gain = chan->small_signal_gain[chain]; ++ u32 *paprd_table_val = caldata->pa_table[chain]; ++ u32 small_signal_gain = caldata->small_signal_gain[chain]; + u32 training_power; + u32 reg = 0; + int i; +@@ -654,17 +655,17 @@ int ar9003_paprd_setup_gain_table(struct + } + EXPORT_SYMBOL(ar9003_paprd_setup_gain_table); + +-int ar9003_paprd_create_curve(struct ath_hw *ah, struct ath9k_channel *chan, +- int chain) ++int ar9003_paprd_create_curve(struct ath_hw *ah, ++ struct ath9k_hw_cal_data *caldata, int chain) + { +- u16 *small_signal_gain = &chan->small_signal_gain[chain]; +- u32 *pa_table = chan->pa_table[chain]; ++ u16 *small_signal_gain = &caldata->small_signal_gain[chain]; ++ u32 *pa_table = caldata->pa_table[chain]; + u32 *data_L, *data_U; + int i, status = 0; + u32 *buf; + u32 reg; + +- memset(chan->pa_table[chain], 0, sizeof(chan->pa_table[chain])); ++ memset(caldata->pa_table[chain], 0, sizeof(caldata->pa_table[chain])); + + buf = kmalloc(2 * 48 * sizeof(u32), GFP_ATOMIC); + if (!buf) +--- a/drivers/net/wireless/ath/ath9k/ath9k.h ++++ b/drivers/net/wireless/ath/ath9k/ath9k.h +@@ -511,7 +511,7 @@ void ath_deinit_leds(struct ath_softc *s + #define SC_OP_BEACONS BIT(1) + #define SC_OP_RXAGGR BIT(2) + #define SC_OP_TXAGGR BIT(3) +-#define SC_OP_FULL_RESET BIT(4) ++#define SC_OP_OFFCHANNEL BIT(4) + #define SC_OP_PREAMBLE_SHORT BIT(5) + #define SC_OP_PROTECT_ENABLE BIT(6) + #define SC_OP_RXFLUSH BIT(7) +@@ -612,6 +612,7 @@ struct ath_softc { + struct ath_wiphy { + struct ath_softc *sc; /* shared for all virtual wiphys */ + struct ieee80211_hw *hw; ++ struct ath9k_hw_cal_data caldata; + enum ath_wiphy_state { + ATH_WIPHY_INACTIVE, + ATH_WIPHY_ACTIVE, +--- a/drivers/net/wireless/ath/ath9k/htc.h ++++ b/drivers/net/wireless/ath/ath9k/htc.h +@@ -353,6 +353,8 @@ struct ath9k_htc_priv { + u16 seq_no; + u32 bmiss_cnt; + ++ struct ath9k_hw_cal_data caldata[38]; ++ + spinlock_t beacon_lock; + + bool tx_queues_stop; +--- a/drivers/net/wireless/ath/ath9k/htc_drv_main.c ++++ b/drivers/net/wireless/ath/ath9k/htc_drv_main.c +@@ -125,6 +125,7 @@ static int ath9k_htc_set_channel(struct + struct ieee80211_conf *conf = &common->hw->conf; + bool fastcc = true; + struct ieee80211_channel *channel = hw->conf.channel; ++ struct ath9k_hw_cal_data *caldata; + enum htc_phymode mode; + __be16 htc_mode; + u8 cmd_rsp; +@@ -149,7 +150,8 @@ static int ath9k_htc_set_channel(struct + priv->ah->curchan->channel, + channel->center_freq, conf_is_ht(conf), conf_is_ht40(conf)); + +- ret = ath9k_hw_reset(ah, hchan, fastcc); ++ caldata = &priv->caldata[channel->hw_value]; ++ ret = ath9k_hw_reset(ah, hchan, caldata, fastcc); + if (ret) { + ath_print(common, ATH_DBG_FATAL, + "Unable to reset channel (%u Mhz) " +@@ -1028,7 +1030,7 @@ static void ath9k_htc_radio_enable(struc + ah->curchan = ath9k_cmn_get_curchannel(hw, ah); + + /* Reset the HW */ +- ret = ath9k_hw_reset(ah, ah->curchan, false); ++ ret = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false); + if (ret) { + ath_print(common, ATH_DBG_FATAL, + "Unable to reset hardware; reset status %d " +@@ -1091,7 +1093,7 @@ static void ath9k_htc_radio_disable(stru + ah->curchan = ath9k_cmn_get_curchannel(hw, ah); + + /* Reset the HW */ +- ret = ath9k_hw_reset(ah, ah->curchan, false); ++ ret = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false); + if (ret) { + ath_print(common, ATH_DBG_FATAL, + "Unable to reset hardware; reset status %d " +@@ -1179,7 +1181,7 @@ static int ath9k_htc_start(struct ieee80 + ath9k_hw_configpcipowersave(ah, 0, 0); + + ath9k_hw_htc_resetinit(ah); +- ret = ath9k_hw_reset(ah, init_channel, false); ++ ret = ath9k_hw_reset(ah, init_channel, ah->caldata, false); + if (ret) { + ath_print(common, ATH_DBG_FATAL, + "Unable to reset hardware; reset status %d " +--- a/drivers/net/wireless/ath/ath9k/hw.h ++++ b/drivers/net/wireless/ath/ath9k/hw.h +@@ -346,19 +346,25 @@ enum ath9k_int { + CHANNEL_HT40PLUS | \ + CHANNEL_HT40MINUS) + +-struct ath9k_channel { +- struct ieee80211_channel *chan; ++struct ath9k_hw_cal_data { + u16 channel; + u32 channelFlags; +- u32 chanmode; + int32_t CalValid; +- bool oneTimeCalsDone; + int8_t iCoff; + int8_t qCoff; + int16_t rawNoiseFloor; + bool paprd_done; ++ bool nfcal_pending; + u16 small_signal_gain[AR9300_MAX_CHAINS]; + u32 pa_table[AR9300_MAX_CHAINS][PAPRD_TABLE_SZ]; ++ struct ath9k_nfcal_hist nfCalHist[NUM_NF_READINGS]; ++}; ++ ++struct ath9k_channel { ++ struct ieee80211_channel *chan; ++ u16 channel; ++ u32 channelFlags; ++ u32 chanmode; + }; + + #define IS_CHAN_G(_c) ((((_c)->channelFlags & (CHANNEL_G)) == CHANNEL_G) || \ +@@ -669,7 +675,7 @@ struct ath_hw { + enum nl80211_iftype opmode; + enum ath9k_power_mode power_mode; + +- struct ath9k_nfcal_hist nfCalHist[NUM_NF_READINGS]; ++ struct ath9k_hw_cal_data *caldata; + struct ath9k_pacal_info pacal_info; + struct ar5416Stats stats; + struct ath9k_tx_queue_info txq[ATH9K_NUM_TX_QUEUES]; +@@ -863,7 +869,7 @@ const char *ath9k_hw_probe(u16 vendorid, + void ath9k_hw_deinit(struct ath_hw *ah); + int ath9k_hw_init(struct ath_hw *ah); + int ath9k_hw_reset(struct ath_hw *ah, struct ath9k_channel *chan, +- bool bChannelChange); ++ struct ath9k_hw_cal_data *caldata, bool bChannelChange); + int ath9k_hw_fill_cap_info(struct ath_hw *ah); + u32 ath9k_regd_get_ctl(struct ath_regulatory *reg, struct ath9k_channel *chan); + +@@ -958,9 +964,10 @@ void ar9003_hw_bb_watchdog_read(struct a + void ar9003_hw_bb_watchdog_dbg_info(struct ath_hw *ah); + void ar9003_paprd_enable(struct ath_hw *ah, bool val); + void ar9003_paprd_populate_single_table(struct ath_hw *ah, +- struct ath9k_channel *chan, int chain); +-int ar9003_paprd_create_curve(struct ath_hw *ah, struct ath9k_channel *chan, +- int chain); ++ struct ath9k_hw_cal_data *caldata, ++ int chain); ++int ar9003_paprd_create_curve(struct ath_hw *ah, ++ struct ath9k_hw_cal_data *caldata, int chain); + int ar9003_paprd_setup_gain_table(struct ath_hw *ah, int chain); + int ar9003_paprd_init_table(struct ath_hw *ah); + bool ar9003_paprd_is_done(struct ath_hw *ah); +--- a/drivers/net/wireless/ath/ath9k/xmit.c ++++ b/drivers/net/wireless/ath/ath9k/xmit.c +@@ -1181,7 +1181,7 @@ void ath_drain_all_txq(struct ath_softc + "Failed to stop TX DMA. Resetting hardware!\n"); + + spin_lock_bh(&sc->sc_resetlock); +- r = ath9k_hw_reset(ah, sc->sc_ah->curchan, false); ++ r = ath9k_hw_reset(ah, sc->sc_ah->curchan, ah->caldata, false); + if (r) + ath_print(common, ATH_DBG_FATAL, + "Unable to reset hardware; reset status %d\n", diff --git a/package/mac80211/patches/530-ath9k_aggr_state_fix.patch b/package/mac80211/patches/530-ath9k_aggr_state_fix.patch new file mode 100644 index 000000000..d3a784948 --- /dev/null +++ b/package/mac80211/patches/530-ath9k_aggr_state_fix.patch @@ -0,0 +1,72 @@ +--- a/drivers/net/wireless/ath/ath9k/xmit.c ++++ b/drivers/net/wireless/ath/ath9k/xmit.c +@@ -120,26 +120,14 @@ static void ath_tx_queue_tid(struct ath_ + list_add_tail(&ac->list, &txq->axq_acq); + } + +-static void ath_tx_pause_tid(struct ath_softc *sc, struct ath_atx_tid *tid) +-{ +- struct ath_txq *txq = &sc->tx.txq[tid->ac->qnum]; +- +- spin_lock_bh(&txq->axq_lock); +- tid->paused++; +- spin_unlock_bh(&txq->axq_lock); +-} +- + static void ath_tx_resume_tid(struct ath_softc *sc, struct ath_atx_tid *tid) + { + struct ath_txq *txq = &sc->tx.txq[tid->ac->qnum]; + +- BUG_ON(tid->paused <= 0); +- spin_lock_bh(&txq->axq_lock); +- +- tid->paused--; ++ WARN_ON(!tid->paused); + +- if (tid->paused > 0) +- goto unlock; ++ spin_lock_bh(&txq->axq_lock); ++ tid->paused = false; + + if (list_empty(&tid->buf_q)) + goto unlock; +@@ -157,15 +145,10 @@ static void ath_tx_flush_tid(struct ath_ + struct list_head bf_head; + INIT_LIST_HEAD(&bf_head); + +- BUG_ON(tid->paused <= 0); +- spin_lock_bh(&txq->axq_lock); ++ WARN_ON(!tid->paused); + +- tid->paused--; +- +- if (tid->paused > 0) { +- spin_unlock_bh(&txq->axq_lock); +- return; +- } ++ spin_lock_bh(&txq->axq_lock); ++ tid->paused = false; + + while (!list_empty(&tid->buf_q)) { + bf = list_first_entry(&tid->buf_q, struct ath_buf, list); +@@ -811,7 +794,7 @@ void ath_tx_aggr_start(struct ath_softc + an = (struct ath_node *)sta->drv_priv; + txtid = ATH_AN_2_TID(an, tid); + txtid->state |= AGGR_ADDBA_PROGRESS; +- ath_tx_pause_tid(sc, txtid); ++ txtid->paused = true; + *ssn = txtid->seq_start; + } + +@@ -835,10 +818,9 @@ void ath_tx_aggr_stop(struct ath_softc * + return; + } + +- ath_tx_pause_tid(sc, txtid); +- + /* drop all software retried frames and mark this TID */ + spin_lock_bh(&txq->axq_lock); ++ txtid->paused = true; + while (!list_empty(&txtid->buf_q)) { + bf = list_first_entry(&txtid->buf_q, struct ath_buf, list); + if (!bf_isretried(bf)) { diff --git a/package/mac80211/patches/530-ath9k_nf_fix.patch b/package/mac80211/patches/530-ath9k_nf_fix.patch deleted file mode 100644 index 081c2ab74..000000000 --- a/package/mac80211/patches/530-ath9k_nf_fix.patch +++ /dev/null @@ -1,46 +0,0 @@ ---- a/drivers/net/wireless/ath/ath9k/ar5008_phy.c -+++ b/drivers/net/wireless/ath/ath9k/ar5008_phy.c -@@ -1508,6 +1508,9 @@ static void ar5008_hw_do_getnf(struct at - nf = MS(REG_READ(ah, AR_PHY_CH2_CCA), AR_PHY_CH2_MINCCA_PWR); - nfarray[2] = sign_extend(nf, 9); - -+ if (!IS_CHAN_HT40(ah->curchan)) -+ return; -+ - nf = MS(REG_READ(ah, AR_PHY_EXT_CCA), AR_PHY_EXT_MINCCA_PWR); - nfarray[3] = sign_extend(nf, 9); - ---- a/drivers/net/wireless/ath/ath9k/ar9002_phy.c -+++ b/drivers/net/wireless/ath/ath9k/ar9002_phy.c -@@ -477,7 +477,8 @@ static void ar9002_hw_do_getnf(struct at - nfarray[0] = sign_extend(nf, 9); - - nf = MS(REG_READ(ah, AR_PHY_EXT_CCA), AR9280_PHY_EXT_MINCCA_PWR); -- nfarray[3] = sign_extend(nf, 9); -+ if (IS_CHAN_HT40(ah->curchan)) -+ nfarray[3] = sign_extend(nf, 9); - - if (AR_SREV_9285(ah) || AR_SREV_9271(ah)) - return; -@@ -486,7 +487,8 @@ static void ar9002_hw_do_getnf(struct at - nfarray[1] = sign_extend(nf, 9); - - nf = MS(REG_READ(ah, AR_PHY_CH1_EXT_CCA), AR9280_PHY_CH1_EXT_MINCCA_PWR); -- nfarray[4] = sign_extend(nf, 9); -+ if (IS_CHAN_HT40(ah->curchan)) -+ nfarray[4] = sign_extend(nf, 9); - } - - static void ar9002_hw_set_nf_limits(struct ath_hw *ah) ---- a/drivers/net/wireless/ath/ath9k/ar9003_phy.c -+++ b/drivers/net/wireless/ath/ath9k/ar9003_phy.c -@@ -1029,6 +1029,9 @@ static void ar9003_hw_do_getnf(struct at - nf = MS(REG_READ(ah, AR_PHY_CCA_2), AR_PHY_CH2_MINCCA_PWR); - nfarray[2] = sign_extend(nf, 9); - -+ if (!IS_CHAN_HT40(ah->curchan)) -+ return; -+ - nf = MS(REG_READ(ah, AR_PHY_EXT_CCA), AR_PHY_EXT_MINCCA_PWR); - nfarray[3] = sign_extend(nf, 9); - diff --git a/package/mac80211/patches/531-ath9k_nf_cleanup.patch b/package/mac80211/patches/531-ath9k_nf_cleanup.patch deleted file mode 100644 index f038559a4..000000000 --- a/package/mac80211/patches/531-ath9k_nf_cleanup.patch +++ /dev/null @@ -1,30 +0,0 @@ ---- a/drivers/net/wireless/ath/ath9k/calib.c -+++ b/drivers/net/wireless/ath/ath9k/calib.c -@@ -172,26 +172,9 @@ void ath9k_hw_loadnf(struct ath_hw *ah, - struct ath9k_nfcal_hist *h; - unsigned i, j; - int32_t val; -- u8 chainmask; -+ u8 chainmask = (ah->rxchainmask << 3) | ah->rxchainmask; - struct ath_common *common = ath9k_hw_common(ah); - -- if (AR_SREV_9300_20_OR_LATER(ah)) -- chainmask = 0x3F; -- else if (AR_SREV_9285(ah) || AR_SREV_9271(ah)) -- chainmask = 0x9; -- else if (AR_SREV_9280(ah) || AR_SREV_9287(ah)) { -- if ((ah->rxchainmask & 0x2) || (ah->rxchainmask & 0x4)) -- chainmask = 0x1B; -- else -- chainmask = 0x09; -- } else { -- if (ah->rxchainmask & 0x4) -- chainmask = 0x3F; -- else if (ah->rxchainmask & 0x2) -- chainmask = 0x1B; -- else -- chainmask = 0x09; -- } - h = ah->nfCalHist; - - for (i = 0; i < NUM_NF_READINGS; i++) { diff --git a/package/mac80211/patches/540-ath9k_bstuck_debug.patch b/package/mac80211/patches/540-ath9k_bstuck_debug.patch new file mode 100644 index 000000000..b2d44c5bb --- /dev/null +++ b/package/mac80211/patches/540-ath9k_bstuck_debug.patch @@ -0,0 +1,43 @@ +--- a/drivers/net/wireless/ath/debug.h ++++ b/drivers/net/wireless/ath/debug.h +@@ -36,6 +36,7 @@ + * @ATH_DBG_PS: power save processing + * @ATH_DBG_HWTIMER: hardware timer handling + * @ATH_DBG_BTCOEX: bluetooth coexistance ++ * @ATH_DBG_BSTUCK: stuck beacons + * @ATH_DBG_ANY: enable all debugging + * + * The debug level is used to control the amount and type of debugging output +@@ -60,6 +61,7 @@ enum ATH_DEBUG { + ATH_DBG_HWTIMER = 0x00001000, + ATH_DBG_BTCOEX = 0x00002000, + ATH_DBG_WMI = 0x00004000, ++ ATH_DBG_BSTUCK = 0x00008000, + ATH_DBG_ANY = 0xffffffff + }; + +--- a/drivers/net/wireless/ath/ath9k/beacon.c ++++ b/drivers/net/wireless/ath/ath9k/beacon.c +@@ -359,11 +359,11 @@ void ath_beacon_tasklet(unsigned long da + sc->beacon.bmisscnt++; + + if (sc->beacon.bmisscnt < BSTUCK_THRESH) { +- ath_print(common, ATH_DBG_BEACON, ++ ath_print(common, ATH_DBG_BSTUCK, + "missed %u consecutive beacons\n", + sc->beacon.bmisscnt); + } else if (sc->beacon.bmisscnt >= BSTUCK_THRESH) { +- ath_print(common, ATH_DBG_BEACON, ++ ath_print(common, ATH_DBG_BSTUCK, + "beacon is officially stuck\n"); + sc->sc_flags |= SC_OP_TSF_RESET; + ath_reset(sc, false); +@@ -373,7 +373,7 @@ void ath_beacon_tasklet(unsigned long da + } + + if (sc->beacon.bmisscnt != 0) { +- ath_print(common, ATH_DBG_BEACON, ++ ath_print(common, ATH_DBG_BSTUCK, + "resume beacon xmit after %u misses\n", + sc->beacon.bmisscnt); + sc->beacon.bmisscnt = 0; diff --git a/package/mac80211/patches/541-ath9k_nf_validate.patch b/package/mac80211/patches/541-ath9k_nf_validate.patch new file mode 100644 index 000000000..7e3cb350f --- /dev/null +++ b/package/mac80211/patches/541-ath9k_nf_validate.patch @@ -0,0 +1,101 @@ +--- a/drivers/net/wireless/ath/ath9k/calib.c ++++ b/drivers/net/wireless/ath/ath9k/calib.c +@@ -19,8 +19,7 @@ + + /* Common calibration code */ + +-/* We can tune this as we go by monitoring really low values */ +-#define ATH9K_NF_TOO_LOW -60 ++#define ATH9K_NF_TOO_HIGH -60 + + static int16_t ath9k_hw_get_nf_hist_mid(int16_t *nfCalBuffer) + { +@@ -45,11 +44,35 @@ static int16_t ath9k_hw_get_nf_hist_mid( + return nfval; + } + +-static void ath9k_hw_update_nfcal_hist_buffer(struct ath9k_nfcal_hist *h, ++static struct ath_nf_limits *ath9k_hw_get_nf_limits(struct ath_hw *ah, ++ struct ath9k_channel *chan) ++{ ++ struct ath_nf_limits *limit; ++ ++ if (!chan || IS_CHAN_2GHZ(chan)) ++ limit = &ah->nf_2g; ++ else ++ limit = &ah->nf_5g; ++ ++ return limit; ++} ++ ++static s16 ath9k_hw_get_default_nf(struct ath_hw *ah, ++ struct ath9k_channel *chan) ++{ ++ return ath9k_hw_get_nf_limits(ah, chan)->nominal; ++} ++ ++ ++static void ath9k_hw_update_nfcal_hist_buffer(struct ath_hw *ah, ++ struct ath9k_nfcal_hist *h, + int16_t *nfarray) + { ++ struct ath_nf_limits *limit; + int i; + ++ limit = ath9k_hw_get_nf_limits(ah, ah->curchan); ++ + for (i = 0; i < NUM_NF_READINGS; i++) { + h[i].nfCalBuffer[h[i].currIndex] = nfarray[i]; + +@@ -63,6 +86,9 @@ static void ath9k_hw_update_nfcal_hist_b + h[i].privNF = + ath9k_hw_get_nf_hist_mid(h[i].nfCalBuffer); + } ++ ++ if (h[i].privNF > limit->max) ++ h[i].privNF = limit->max; + } + } + +@@ -104,19 +130,6 @@ void ath9k_hw_reset_calibration(struct a + ah->cal_samples = 0; + } + +-static s16 ath9k_hw_get_default_nf(struct ath_hw *ah, +- struct ath9k_channel *chan) +-{ +- struct ath_nf_limits *limit; +- +- if (!chan || IS_CHAN_2GHZ(chan)) +- limit = &ah->nf_2g; +- else +- limit = &ah->nf_5g; +- +- return limit->nominal; +-} +- + /* This is done for the currently configured channel */ + bool ath9k_hw_reset_calvalid(struct ath_hw *ah) + { +@@ -277,10 +290,10 @@ static void ath9k_hw_nf_sanitize(struct + "NF calibrated [%s] [chain %d] is %d\n", + (i >= 3 ? "ext" : "ctl"), i % 3, nf[i]); + +- if (nf[i] > limit->max) { ++ if (nf[i] > ATH9K_NF_TOO_HIGH) { + ath_print(common, ATH_DBG_CALIBRATE, + "NF[%d] (%d) > MAX (%d), correcting to MAX", +- i, nf[i], limit->max); ++ i, nf[i], ATH9K_NF_TOO_HIGH); + nf[i] = limit->max; + } else if (nf[i] < limit->min) { + ath_print(common, ATH_DBG_CALIBRATE, +@@ -326,7 +339,7 @@ bool ath9k_hw_getnf(struct ath_hw *ah, s + + h = caldata->nfCalHist; + caldata->nfcal_pending = false; +- ath9k_hw_update_nfcal_hist_buffer(h, nfarray); ++ ath9k_hw_update_nfcal_hist_buffer(ah, h, nfarray); + caldata->rawNoiseFloor = h[0].privNF; + return true; + } diff --git a/package/mac80211/patches/542-ath9k_bstuck_nf_calibrate.patch b/package/mac80211/patches/542-ath9k_bstuck_nf_calibrate.patch new file mode 100644 index 000000000..4ac4ab210 --- /dev/null +++ b/package/mac80211/patches/542-ath9k_bstuck_nf_calibrate.patch @@ -0,0 +1,129 @@ +--- a/drivers/net/wireless/ath/ath9k/beacon.c ++++ b/drivers/net/wireless/ath/ath9k/beacon.c +@@ -362,6 +362,7 @@ void ath_beacon_tasklet(unsigned long da + ath_print(common, ATH_DBG_BSTUCK, + "missed %u consecutive beacons\n", + sc->beacon.bmisscnt); ++ ath9k_hw_bstuck_nfcal(ah); + } else if (sc->beacon.bmisscnt >= BSTUCK_THRESH) { + ath_print(common, ATH_DBG_BSTUCK, + "beacon is officially stuck\n"); +--- a/drivers/net/wireless/ath/ath9k/calib.c ++++ b/drivers/net/wireless/ath/ath9k/calib.c +@@ -65,12 +65,16 @@ static s16 ath9k_hw_get_default_nf(struc + + + static void ath9k_hw_update_nfcal_hist_buffer(struct ath_hw *ah, +- struct ath9k_nfcal_hist *h, ++ struct ath9k_hw_cal_data *cal, + int16_t *nfarray) + { ++ struct ath_common *common = ath9k_hw_common(ah); + struct ath_nf_limits *limit; ++ struct ath9k_nfcal_hist *h; ++ bool high_nf_mid = false; + int i; + ++ h = cal->nfCalHist; + limit = ath9k_hw_get_nf_limits(ah, ah->curchan); + + for (i = 0; i < NUM_NF_READINGS; i++) { +@@ -87,9 +91,38 @@ static void ath9k_hw_update_nfcal_hist_b + ath9k_hw_get_nf_hist_mid(h[i].nfCalBuffer); + } + +- if (h[i].privNF > limit->max) +- h[i].privNF = limit->max; ++ if (!h[i].privNF) ++ continue; ++ ++ if (h[i].privNF > limit->max) { ++ high_nf_mid = true; ++ ++ ath_print(common, ATH_DBG_CALIBRATE, ++ "NFmid[%d] (%d) > MAX (%d), %s\n", ++ i, h[i].privNF, limit->max, ++ (cal->nfcal_interference ? ++ "not corrected (due to interference)" : ++ "correcting to MAX")); ++ ++ /* ++ * Normally we limit the average noise floor by the ++ * hardware specific maximum here. However if we have ++ * encountered stuck beacons because of interference, ++ * we bypass this limit here in order to better deal ++ * with our environment. ++ */ ++ if (!cal->nfcal_interference) ++ h[i].privNF = limit->max; ++ } + } ++ ++ /* ++ * If the noise floor seems normal for all chains, assume that ++ * there is no significant interference in the environment anymore. ++ * Re-enable the enforcement of the NF maximum again. ++ */ ++ if (!high_nf_mid) ++ cal->nfcal_interference = false; + } + + static bool ath9k_hw_get_nf_thresh(struct ath_hw *ah, +@@ -339,7 +372,7 @@ bool ath9k_hw_getnf(struct ath_hw *ah, s + + h = caldata->nfCalHist; + caldata->nfcal_pending = false; +- ath9k_hw_update_nfcal_hist_buffer(ah, h, nfarray); ++ ath9k_hw_update_nfcal_hist_buffer(ah, caldata, nfarray); + caldata->rawNoiseFloor = h[0].privNF; + return true; + } +@@ -374,3 +407,28 @@ s16 ath9k_hw_getchan_noise(struct ath_hw + return ah->caldata->rawNoiseFloor; + } + EXPORT_SYMBOL(ath9k_hw_getchan_noise); ++ ++void ath9k_hw_bstuck_nfcal(struct ath_hw *ah) ++{ ++ struct ath9k_hw_cal_data *caldata = ah->caldata; ++ ++ if (unlikely(!caldata)) ++ return; ++ ++ /* ++ * If beacons are stuck, the most likely cause is interference. ++ * Triggering a noise floor calibration at this point helps the ++ * hardware adapt to a noisy environment much faster. ++ * To ensure that we recover from stuck beacons quickly, let ++ * the baseband update the internal NF value itself, similar to ++ * what is being done after a full reset. ++ */ ++ if (!caldata->nfcal_pending) ++ ath9k_hw_start_nfcal(ah, true); ++ else if (!(REG_READ(ah, AR_PHY_AGC_CONTROL) & AR_PHY_AGC_CONTROL_NF)) ++ ath9k_hw_getnf(ah, ah->curchan); ++ ++ caldata->nfcal_interference = true; ++} ++EXPORT_SYMBOL(ath9k_hw_bstuck_nfcal); ++ +--- a/drivers/net/wireless/ath/ath9k/calib.h ++++ b/drivers/net/wireless/ath/ath9k/calib.h +@@ -113,6 +113,7 @@ void ath9k_hw_loadnf(struct ath_hw *ah, + bool ath9k_hw_getnf(struct ath_hw *ah, struct ath9k_channel *chan); + void ath9k_init_nfcal_hist_buffer(struct ath_hw *ah, + struct ath9k_channel *chan); ++void ath9k_hw_bstuck_nfcal(struct ath_hw *ah); + s16 ath9k_hw_getchan_noise(struct ath_hw *ah, struct ath9k_channel *chan); + void ath9k_hw_reset_calibration(struct ath_hw *ah, + struct ath9k_cal_list *currCal); +--- a/drivers/net/wireless/ath/ath9k/hw.h ++++ b/drivers/net/wireless/ath/ath9k/hw.h +@@ -355,6 +355,7 @@ struct ath9k_hw_cal_data { + int16_t rawNoiseFloor; + bool paprd_done; + bool nfcal_pending; ++ bool nfcal_interference; + u16 small_signal_gain[AR9300_MAX_CHAINS]; + u32 pa_table[AR9300_MAX_CHAINS][PAPRD_TABLE_SZ]; + struct ath9k_nfcal_hist nfCalHist[NUM_NF_READINGS]; diff --git a/package/mac80211/patches/543-ath9k_interference_nf_cal.patch b/package/mac80211/patches/543-ath9k_interference_nf_cal.patch new file mode 100644 index 000000000..74bee3e14 --- /dev/null +++ b/package/mac80211/patches/543-ath9k_interference_nf_cal.patch @@ -0,0 +1,35 @@ +--- a/drivers/net/wireless/ath/ath9k/ath9k.h ++++ b/drivers/net/wireless/ath/ath9k/ath9k.h +@@ -423,6 +423,7 @@ int ath_beaconq_config(struct ath_softc + #define ATH_AP_SHORT_CALINTERVAL 100 /* 100 ms */ + #define ATH_ANI_POLLINTERVAL_OLD 100 /* 100 ms */ + #define ATH_ANI_POLLINTERVAL_NEW 1000 /* 1000 ms */ ++#define ATH_LONG_CALINTERVAL_INT 1000 /* 1000 ms */ + #define ATH_LONG_CALINTERVAL 30000 /* 30 seconds */ + #define ATH_RESTART_CALINTERVAL 1200000 /* 20 minutes */ + +--- a/drivers/net/wireless/ath/ath9k/main.c ++++ b/drivers/net/wireless/ath/ath9k/main.c +@@ -396,7 +396,12 @@ void ath_ani_calibrate(unsigned long dat + bool shortcal = false; + bool aniflag = false; + unsigned int timestamp = jiffies_to_msecs(jiffies); +- u32 cal_interval, short_cal_interval; ++ u32 cal_interval, short_cal_interval, long_cal_interval; ++ ++ if (ah->caldata && ah->caldata->nfcal_interference) ++ long_cal_interval = ATH_LONG_CALINTERVAL_INT; ++ else ++ long_cal_interval = ATH_LONG_CALINTERVAL; + + short_cal_interval = (ah->opmode == NL80211_IFTYPE_AP) ? + ATH_AP_SHORT_CALINTERVAL : ATH_STA_SHORT_CALINTERVAL; +@@ -408,7 +413,7 @@ void ath_ani_calibrate(unsigned long dat + ath9k_ps_wakeup(sc); + + /* Long calibration runs independently of short calibration. */ +- if ((timestamp - common->ani.longcal_timer) >= ATH_LONG_CALINTERVAL) { ++ if ((timestamp - common->ani.longcal_timer) >= long_cal_interval) { + longcal = true; + ath_print(common, ATH_DBG_ANI, "longcal @%lu\n", jiffies); + common->ani.longcal_timer = timestamp; diff --git a/package/mac80211/patches/550-ath9k_tsf_fix.patch b/package/mac80211/patches/550-ath9k_tsf_fix.patch new file mode 100644 index 000000000..8a99ed7a2 --- /dev/null +++ b/package/mac80211/patches/550-ath9k_tsf_fix.patch @@ -0,0 +1,44 @@ +ath9k_rx_skb_preprocess nulls rxs and the mactime is never set again - +mactime is always 0. This causes problems in IBSS mode. + +ieee80211_rx_bss_info uses mactime to decide if an IBSS merge is needed. +Without this patch the merge is triggered by each beacon received. + +This can be recognized by the "beacon TSF higher than local TSF - IBSS +merge with BSSID" log message accompanying each beacon. + +This problem was not completely fixed in commit +a6d2055b02dde1067075795274672720baadd3ca and is not a stable kernel fix. +It is solely intended for wireless-testing. + +Signed-off-by: Jan Friedrich +--- + drivers/net/wireless/ath/ath9k/recv.c | 10 +++++----- + 1 files changed, 5 insertions(+), 5 deletions(-) + +--- a/drivers/net/wireless/ath/ath9k/recv.c ++++ b/drivers/net/wireless/ath/ath9k/recv.c +@@ -1140,6 +1140,11 @@ int ath_rx_tasklet(struct ath_softc *sc, + if (flush) + goto requeue; + ++ retval = ath9k_rx_skb_preprocess(common, hw, hdr, &rs, ++ rxs, &decrypt_error); ++ if (retval) ++ goto requeue; ++ + rxs->mactime = (tsf & ~0xffffffffULL) | rs.rs_tstamp; + if (rs.rs_tstamp > tsf_lower && + unlikely(rs.rs_tstamp - tsf_lower > 0x10000000)) +@@ -1149,11 +1154,6 @@ int ath_rx_tasklet(struct ath_softc *sc, + unlikely(tsf_lower - rs.rs_tstamp > 0x10000000)) + rxs->mactime += 0x100000000ULL; + +- retval = ath9k_rx_skb_preprocess(common, hw, hdr, &rs, +- rxs, &decrypt_error); +- if (retval) +- goto requeue; +- + /* Ensure we always have an skb to requeue once we are done + * processing the current buffer's skb */ + requeue_skb = ath_rxbuf_alloc(common, common->rx_bufsize, GFP_ATOMIC); diff --git a/package/mac80211/patches/700-mwl8k-missing-pci-id-for-WNR854T.patch b/package/mac80211/patches/700-mwl8k-missing-pci-id-for-WNR854T.patch index cf8a4d510..b90539e5e 100644 --- a/package/mac80211/patches/700-mwl8k-missing-pci-id-for-WNR854T.patch +++ b/package/mac80211/patches/700-mwl8k-missing-pci-id-for-WNR854T.patch @@ -1,6 +1,6 @@ --- a/drivers/net/wireless/mwl8k.c +++ b/drivers/net/wireless/mwl8k.c -@@ -3882,6 +3882,7 @@ MODULE_FIRMWARE("mwl8k/helper_8366.fw"); +@@ -3884,6 +3884,7 @@ MODULE_FIRMWARE("mwl8k/helper_8366.fw"); MODULE_FIRMWARE("mwl8k/fmimage_8366.fw"); static DEFINE_PCI_DEVICE_TABLE(mwl8k_pci_id_table) = { diff --git a/package/mac80211/patches/800-mac80211_aggr_fix.patch b/package/mac80211/patches/800-mac80211_aggr_fix.patch deleted file mode 100644 index 564bfac06..000000000 --- a/package/mac80211/patches/800-mac80211_aggr_fix.patch +++ /dev/null @@ -1,20 +0,0 @@ ---- a/net/mac80211/iface.c -+++ b/net/mac80211/iface.c -@@ -756,7 +756,7 @@ static void ieee80211_iface_work(struct - int len = skb->len; - - mutex_lock(&local->sta_mtx); -- sta = sta_info_get(sdata, mgmt->sa); -+ sta = sta_info_get_bss(sdata, mgmt->sa); - if (sta) { - switch (mgmt->u.action.u.addba_req.action_code) { - case WLAN_ACTION_ADDBA_REQ: -@@ -797,7 +797,7 @@ static void ieee80211_iface_work(struct - * right, so terminate the session. - */ - mutex_lock(&local->sta_mtx); -- sta = sta_info_get(sdata, mgmt->sa); -+ sta = sta_info_get_bss(sdata, mgmt->sa); - if (sta) { - u16 tid = *ieee80211_get_qos_ctl(hdr) & - IEEE80211_QOS_CTL_TID_MASK; -- 2.11.0