ath9k: fix various calibration related bugs and clean up the code

SVN-Revision: 22408

5 files changed, 1017 insertions, 20 deletions

diff --git a/package/mac80211/patches/520-mac80211_offchannel_conf.patch b/package/mac80211/patches/520-mac80211_offchannel_conf.patch
new file mode 100644
index 0000000000..deb0d06cb5
--- /dev/null
+++ b/package/mac80211/patches/520-mac80211_offchannel_conf.patch
@@ -0,0 +1,35 @@
+--- a/include/net/mac80211.h
++++ b/include/net/mac80211.h
+@@ -625,11 +625,14 @@ struct ieee80211_rx_status {
+  *	may turn the device off as much as possible. Typically, this flag will
+  *	be set when an interface is set UP but not associated or scanning, but
+  *	it can also be unset in that case when monitor interfaces are active.
++ * @IEEE80211_CONF_OFFCHANNEL: The device is currently not on its main
++ *	operating channel.
+  */
+ enum ieee80211_conf_flags {
+ 	IEEE80211_CONF_MONITOR		= (1<<0),
+ 	IEEE80211_CONF_PS		= (1<<1),
+ 	IEEE80211_CONF_IDLE		= (1<<2),
++	IEEE80211_CONF_OFFCHANNEL	= (1<<3),
+ };
+ 
+ 
+--- a/net/mac80211/main.c
++++ b/net/mac80211/main.c
+@@ -111,12 +111,15 @@ int ieee80211_hw_config(struct ieee80211
+ 	if (scan_chan) {
+ 		chan = scan_chan;
+ 		channel_type = NL80211_CHAN_NO_HT;
++		local->hw.conf.flags |= IEEE80211_CONF_OFFCHANNEL;
+ 	} else if (local->tmp_channel) {
+ 		chan = scan_chan = local->tmp_channel;
+ 		channel_type = local->tmp_channel_type;
++		local->hw.conf.flags |= IEEE80211_CONF_OFFCHANNEL;
+ 	} else {
+ 		chan = local->oper_channel;
+ 		channel_type = local->_oper_channel_type;
++		local->hw.conf.flags &= ~IEEE80211_CONF_OFFCHANNEL;
+ 	}
+ 
+ 	if (chan != local->hw.conf.channel ||
diff --git a/package/mac80211/patches/521-ath9k_no_offchannel_cal.patch b/package/mac80211/patches/521-ath9k_no_offchannel_cal.patch
new file mode 100644
index 0000000000..5f5d6087d0
--- /dev/null
+++ b/package/mac80211/patches/521-ath9k_no_offchannel_cal.patch
@@ -0,0 +1,201 @@
+--- a/drivers/net/wireless/ath/ath9k/ath9k.h
++++ b/drivers/net/wireless/ath/ath9k/ath9k.h
+@@ -511,13 +511,12 @@ 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_PREAMBLE_SHORT         BIT(5)
+ #define SC_OP_PROTECT_ENABLE         BIT(6)
+ #define SC_OP_RXFLUSH                BIT(7)
+ #define SC_OP_LED_ASSOCIATED         BIT(8)
+ #define SC_OP_LED_ON                 BIT(9)
+-#define SC_OP_SCANNING               BIT(10)
++#define SC_OP_OFFCHANNEL             BIT(10)
+ #define SC_OP_TSF_RESET              BIT(11)
+ #define SC_OP_BT_PRIORITY_DETECTED   BIT(12)
+ #define SC_OP_BT_SCAN		     BIT(13)
+--- 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
+@@ -173,6 +194,11 @@ int ath_set_channel(struct ath_softc *sc
+ 	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,7 +218,7 @@ 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;
+ 
+ 	ath_print(common, ATH_DBG_CONFIG,
+@@ -213,8 +239,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 +250,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)) {
++		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;
+@@ -440,8 +470,7 @@ 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->caps.hw_caps & ATH9K_HW_CAP_PAPRD) {
+ 		if (!sc->sc_ah->curchan->paprd_done)
+ 			ieee80211_queue_work(sc->hw, &sc->paprd_work);
+ 		else
+@@ -449,24 +478,6 @@ set_timer:
+ 	}
+ }
+ 
+-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 +489,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;
+@@ -1580,6 +1591,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 +2006,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)) {
+@@ -2007,11 +2021,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);
+ }
+ 
+@@ -2019,15 +2028,9 @@ 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/recv.c
++++ b/drivers/net/wireless/ath/ath9k/recv.c
+@@ -292,7 +292,7 @@ static void ath_edma_start_recv(struct a
+ 
+ 	ath_opmode_init(sc);
+ 
+-	ath9k_hw_startpcureceive(sc->sc_ah, (sc->sc_flags & SC_OP_SCANNING));
++	ath9k_hw_startpcureceive(sc->sc_ah, (sc->sc_flags & SC_OP_OFFCHANNEL));
+ }
+ 
+ static void ath_edma_stop_recv(struct ath_softc *sc)
+@@ -498,7 +498,7 @@ int ath_startrecv(struct ath_softc *sc)
+ start_recv:
+ 	spin_unlock_bh(&sc->rx.rxbuflock);
+ 	ath_opmode_init(sc);
+-	ath9k_hw_startpcureceive(ah, (sc->sc_flags & SC_OP_SCANNING));
++	ath9k_hw_startpcureceive(ah, (sc->sc_flags & SC_OP_OFFCHANNEL));
+ 
+ 	return 0;
+ }
diff --git a/package/mac80211/patches/522-ath9k_cleanup_cal_data.patch b/package/mac80211/patches/522-ath9k_cleanup_cal_data.patch
new file mode 100644
index 0000000000..a4b6e456b8
--- /dev/null
+++ b/package/mac80211/patches/522-ath9k_cleanup_cal_data.patch
@@ -0,0 +1,641 @@
+--- a/drivers/net/wireless/ath/ath9k/hw.h
++++ b/drivers/net/wireless/ath/ath9k/hw.h
+@@ -346,19 +346,24 @@ 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;
+ 	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 +674,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 +868,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 +963,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/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,7 +147,7 @@ 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;
+@@ -169,19 +165,28 @@ void ath9k_hw_start_nfcal(struct ath_hw 
+ 
+ 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);
+ 		}
+ 	}
+@@ -285,14 +290,18 @@ int16_t ath9k_hw_getnf(struct ath_hw *ah
+ 	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 ath9k_hw_get_default_nf(ah, chan);
+ 
+ 	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 caldata->rawNoiseFloor;
+ 	} else {
+ 		ath9k_hw_do_getnf(ah, nfarray);
+ 		ath9k_hw_nf_sanitize(ah, nfarray);
+@@ -307,47 +316,41 @@ int16_t ath9k_hw_getnf(struct ath_hw *ah
+ 		}
+ 	}
+ 
+-	h = ah->nfCalHist;
++	h = caldata->nfCalHist;
+ 
+ 	ath9k_hw_update_nfcal_hist_buffer(h, nfarray);
+-	chan->rawNoiseFloor = h[0].privNF;
++	caldata->rawNoiseFloor = h[0].privNF;
+ 
+-	return chan->rawNoiseFloor;
++	return ah->caldata->rawNoiseFloor;
+ }
+ 
+-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/main.c
++++ b/drivers/net/wireless/ath/ath9k/main.c
+@@ -184,11 +184,13 @@ static void ath_start_ani(struct ath_com
+ 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)
+@@ -221,6 +223,9 @@ int ath_set_channel(struct ath_softc *sc
+ 	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,
+@@ -228,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), "
+@@ -264,9 +269,10 @@ 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);
+@@ -274,7 +280,7 @@ static void ath_paprd_activate(struct at
+ 		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);
+@@ -292,6 +298,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;
+@@ -299,6 +306,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;
+@@ -353,7 +363,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;
+@@ -361,7 +371,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);
+ 	}
+ 
+@@ -470,8 +480,8 @@ 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) {
+-		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);
+@@ -829,7 +839,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), "
+@@ -889,7 +899,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), "
+@@ -922,7 +932,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);
+@@ -1097,7 +1107,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 "
+--- 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/hw.c
++++ b/drivers/net/wireless/ath/ath9k/hw.c
+@@ -621,7 +621,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;
+@@ -1194,9 +1193,6 @@ static bool ath9k_hw_channel_change(stru
+ 
+ 	ath9k_hw_spur_mitigate_freq(ah, chan);
+ 
+-	if (!chan->oneTimeCalsDone)
+-		chan->oneTimeCalsDone = true;
+-
+ 	return true;
+ }
+ 
+@@ -1229,7 +1225,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;
+@@ -1254,9 +1250,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) &&
+--- 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);
+ 	}
+ 
+@@ -901,7 +902,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);
+ 	}
+@@ -785,7 +786,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/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/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",
+--- a/drivers/net/wireless/ath/ath9k/ath9k.h
++++ b/drivers/net/wireless/ath/ath9k/ath9k.h
+@@ -611,6 +611,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/calib.h
++++ b/drivers/net/wireless/ath/ath9k/calib.h
+@@ -112,7 +112,8 @@ void ath9k_hw_start_nfcal(struct ath_hw 
+ 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);
++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/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;
diff --git a/package/mac80211/patches/523-ath9k_nfcal_timeout_handling.patch b/package/mac80211/patches/523-ath9k_nfcal_timeout_handling.patch
new file mode 100644
index 0000000000..90363605eb
--- /dev/null
+++ b/package/mac80211/patches/523-ath9k_nfcal_timeout_handling.patch
@@ -0,0 +1,140 @@
+--- a/drivers/net/wireless/ath/ath9k/hw.h
++++ b/drivers/net/wireless/ath/ath9k/hw.h
+@@ -354,6 +354,7 @@ struct ath9k_hw_cal_data {
+ 	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];
+--- a/drivers/net/wireless/ath/ath9k/calib.c
++++ b/drivers/net/wireless/ath/ath9k/calib.c
+@@ -156,6 +156,9 @@ EXPORT_SYMBOL(ath9k_hw_reset_calvalid);
+ 
+ void ath9k_hw_start_nfcal(struct ath_hw *ah)
+ {
++	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,
+@@ -282,8 +285,7 @@ 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;
+@@ -293,7 +295,7 @@ int16_t ath9k_hw_getnf(struct ath_hw *ah
+ 	struct ath9k_hw_cal_data *caldata = ah->caldata;
+ 
+ 	if (!caldata)
+-		return ath9k_hw_get_default_nf(ah, chan);
++		return false;
+ 
+ 	chan->channelFlags &= (~CHANNEL_CW_INT);
+ 	if (REG_READ(ah, AR_PHY_AGC_CONTROL) & AR_PHY_AGC_CONTROL_NF) {
+@@ -301,7 +303,7 @@ int16_t ath9k_hw_getnf(struct ath_hw *ah
+ 			  "NF did not complete in calibration window\n");
+ 		nf = 0;
+ 		caldata->rawNoiseFloor = nf;
+-		return caldata->rawNoiseFloor;
++		return false;
+ 	} else {
+ 		ath9k_hw_do_getnf(ah, nfarray);
+ 		ath9k_hw_nf_sanitize(ah, nfarray);
+@@ -317,11 +319,10 @@ int16_t ath9k_hw_getnf(struct ath_hw *ah
+ 	}
+ 
+ 	h = caldata->nfCalHist;
+-
++	caldata->nfcal_pending = false;
+ 	ath9k_hw_update_nfcal_hist_buffer(h, nfarray);
+ 	caldata->rawNoiseFloor = h[0].privNF;
+-
+-	return ah->caldata->rawNoiseFloor;
++	return true;
+ }
+ 
+ void ath9k_init_nfcal_hist_buffer(struct ath_hw *ah,
+--- a/drivers/net/wireless/ath/ath9k/ar9002_calib.c
++++ b/drivers/net/wireless/ath/ath9k/ar9002_calib.c
+@@ -687,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,
+@@ -704,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);
+@@ -713,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);
+ 	}
+ 
+ 	return iscaldone;
+@@ -873,6 +880,9 @@ static bool ar9002_hw_init_cal(struct at
+ 	REG_WRITE(ah, AR_PHY_AGC_CONTROL,
+ 		  REG_READ(ah, AR_PHY_AGC_CONTROL) | AR_PHY_AGC_CONTROL_NF);
+ 
++	if (ah->caldata)
++		ah->caldata->nfcal_pending = true;
++
+ 	ah->cal_list = ah->cal_list_last = ah->cal_list_curr = NULL;
+ 
+ 	/* Enable IQ, ADC Gain and ADC DC offset CALs */
+--- a/drivers/net/wireless/ath/ath9k/calib.h
++++ b/drivers/net/wireless/ath/ath9k/calib.h
+@@ -110,8 +110,7 @@ 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_loadnf(struct ath_hw *ah, struct ath9k_channel *chan);
+-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);
+ 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);
diff --git a/package/mac80211/patches/800-mac80211_scan_callback_revert.patch b/package/mac80211/patches/800-mac80211_scan_callback_revert.patch
deleted file mode 100644
index 904dd3c03b..0000000000
--- a/package/mac80211/patches/800-mac80211_scan_callback_revert.patch
+++ /dev/null
@@ -1,20 +0,0 @@
---- a/net/mac80211/scan.c
-+++ b/net/mac80211/scan.c
-@@ -287,8 +287,6 @@ void ieee80211_scan_completed(struct iee
- 	local->scanning = 0;
- 	local->scan_channel = NULL;
- 
--	drv_sw_scan_complete(local);
--
- 	/* we only have to protect scan_req and hw/sw scan */
- 	mutex_unlock(&local->scan_mtx);
- 
-@@ -298,6 +296,8 @@ void ieee80211_scan_completed(struct iee
- 
- 	ieee80211_configure_filter(local);
- 
-+	drv_sw_scan_complete(local);
-+
- 	ieee80211_offchannel_return(local, true);
- 
-  done: