package/mac80211/patches/522-ath9k_cleanup_cal_data.patch

   1 --- a/drivers/net/wireless/ath/ath9k/hw.h
   2 +++ b/drivers/net/wireless/ath/ath9k/hw.h
   3 @@ -346,19 +346,24 @@ enum ath9k_int {
   4          CHANNEL_HT40PLUS |                     \
   5          CHANNEL_HT40MINUS)
   6
   7 -struct ath9k_channel {
   8 -       struct ieee80211_channel *chan;
   9 +struct ath9k_hw_cal_data {
  10         u16 channel;
  11         u32 channelFlags;
  12 -       u32 chanmode;
  13         int32_t CalValid;
  14 -       bool oneTimeCalsDone;
  15         int8_t iCoff;
  16         int8_t qCoff;
  17         int16_t rawNoiseFloor;
  18         bool paprd_done;
  19         u16 small_signal_gain[AR9300_MAX_CHAINS];
  20         u32 pa_table[AR9300_MAX_CHAINS][PAPRD_TABLE_SZ];
  21 +       struct ath9k_nfcal_hist nfCalHist[NUM_NF_READINGS];
  22 +};
  23 +
  24 +struct ath9k_channel {
  25 +       struct ieee80211_channel *chan;
  26 +       u16 channel;
  27 +       u32 channelFlags;
  28 +       u32 chanmode;
  29  };
  30
  31  #define IS_CHAN_G(_c) ((((_c)->channelFlags & (CHANNEL_G)) == CHANNEL_G) || \
  32 @@ -669,7 +674,7 @@ struct ath_hw {
  33         enum nl80211_iftype opmode;
  34         enum ath9k_power_mode power_mode;
  35
  36 -       struct ath9k_nfcal_hist nfCalHist[NUM_NF_READINGS];
  37 +       struct ath9k_hw_cal_data *caldata;
  38         struct ath9k_pacal_info pacal_info;
  39         struct ar5416Stats stats;
  40         struct ath9k_tx_queue_info txq[ATH9K_NUM_TX_QUEUES];
  41 @@ -863,7 +868,7 @@ const char *ath9k_hw_probe(u16 vendorid,
  42  void ath9k_hw_deinit(struct ath_hw *ah);
  43  int ath9k_hw_init(struct ath_hw *ah);
  44  int ath9k_hw_reset(struct ath_hw *ah, struct ath9k_channel *chan,
  45 -                  bool bChannelChange);
  46 +                  struct ath9k_hw_cal_data *caldata, bool bChannelChange);
  47  int ath9k_hw_fill_cap_info(struct ath_hw *ah);
  48  u32 ath9k_regd_get_ctl(struct ath_regulatory *reg, struct ath9k_channel *chan);
  49
  50 @@ -958,9 +963,10 @@ void ar9003_hw_bb_watchdog_read(struct a
  51  void ar9003_hw_bb_watchdog_dbg_info(struct ath_hw *ah);
  52  void ar9003_paprd_enable(struct ath_hw *ah, bool val);
  53  void ar9003_paprd_populate_single_table(struct ath_hw *ah,
  54 -                                       struct ath9k_channel *chan, int chain);
  55 -int ar9003_paprd_create_curve(struct ath_hw *ah, struct ath9k_channel *chan,
  56 -                             int chain);
  57 +                                       struct ath9k_hw_cal_data *caldata,
  58 +                                       int chain);
  59 +int ar9003_paprd_create_curve(struct ath_hw *ah,
  60 +                             struct ath9k_hw_cal_data *caldata, int chain);
  61  int ar9003_paprd_setup_gain_table(struct ath_hw *ah, int chain);
  62  int ar9003_paprd_init_table(struct ath_hw *ah);
  63  bool ar9003_paprd_is_done(struct ath_hw *ah);
  64 --- a/drivers/net/wireless/ath/ath9k/calib.c
  65 +++ b/drivers/net/wireless/ath/ath9k/calib.c
  66 @@ -22,23 +22,6 @@
  67  /* We can tune this as we go by monitoring really low values */
  68  #define ATH9K_NF_TOO_LOW       -60
  69
  70 -/* AR5416 may return very high value (like -31 dBm), in those cases the nf
  71 - * is incorrect and we should use the static NF value. Later we can try to
  72 - * find out why they are reporting these values */
  73 -
  74 -static bool ath9k_hw_nf_in_range(struct ath_hw *ah, s16 nf)
  75 -{
  76 -       if (nf > ATH9K_NF_TOO_LOW) {
  77 -               ath_print(ath9k_hw_common(ah), ATH_DBG_CALIBRATE,
  78 -                         "noise floor value detected (%d) is "
  79 -                         "lower than what we think is a "
  80 -                         "reasonable value (%d)\n",
  81 -                         nf, ATH9K_NF_TOO_LOW);
  82 -               return false;
  83 -       }
  84 -       return true;
  85 -}
  86 -
  87  static int16_t ath9k_hw_get_nf_hist_mid(int16_t *nfCalBuffer)
  88  {
  89         int16_t nfval;
  90 @@ -121,6 +104,19 @@ void ath9k_hw_reset_calibration(struct a
  91         ah->cal_samples = 0;
  92  }
  93
  94 +static s16 ath9k_hw_get_default_nf(struct ath_hw *ah,
  95 +                                  struct ath9k_channel *chan)
  96 +{
  97 +       struct ath_nf_limits *limit;
  98 +
  99 +       if (!chan || IS_CHAN_2GHZ(chan))
 100 +               limit = &ah->nf_2g;
 101 +       else
 102 +               limit = &ah->nf_5g;
 103 +
 104 +       return limit->nominal;
 105 +}
 106 +
 107  /* This is done for the currently configured channel */
 108  bool ath9k_hw_reset_calvalid(struct ath_hw *ah)
 109  {
 110 @@ -128,7 +124,7 @@ bool ath9k_hw_reset_calvalid(struct ath_
 111         struct ieee80211_conf *conf = &common->hw->conf;
 112         struct ath9k_cal_list *currCal = ah->cal_list_curr;
 113
 114 -       if (!ah->curchan)
 115 +       if (!ah->caldata)
 116                 return true;
 117
 118         if (!AR_SREV_9100(ah) && !AR_SREV_9160_10_OR_LATER(ah))
 119 @@ -151,7 +147,7 @@ bool ath9k_hw_reset_calvalid(struct ath_
 120                   "Resetting Cal %d state for channel %u\n",
 121                   currCal->calData->calType, conf->channel->center_freq);
 122
 123 -       ah->curchan->CalValid &= ~currCal->calData->calType;
 124 +       ah->caldata->CalValid &= ~currCal->calData->calType;
 125         currCal->calState = CAL_WAITING;
 126
 127         return false;
 128 @@ -169,19 +165,28 @@ void ath9k_hw_start_nfcal(struct ath_hw
 129
 130  void ath9k_hw_loadnf(struct ath_hw *ah, struct ath9k_channel *chan)
 131  {
 132 -       struct ath9k_nfcal_hist *h;
 133 +       struct ath9k_nfcal_hist *h = NULL;
 134         unsigned i, j;
 135         int32_t val;
 136         u8 chainmask = (ah->rxchainmask << 3) | ah->rxchainmask;
 137         struct ath_common *common = ath9k_hw_common(ah);
 138 +       s16 default_nf = ath9k_hw_get_default_nf(ah, chan);
 139
 140 -       h = ah->nfCalHist;
 141 +       if (ah->caldata)
 142 +               h = ah->caldata->nfCalHist;
 143
 144         for (i = 0; i < NUM_NF_READINGS; i++) {
 145                 if (chainmask & (1 << i)) {
 146 +                       s16 nfval;
 147 +
 148 +                       if (h)
 149 +                               nfval = h[i].privNF;
 150 +                       else
 151 +                               nfval = default_nf;
 152 +
 153                         val = REG_READ(ah, ah->nf_regs[i]);
 154                         val &= 0xFFFFFE00;
 155 -                       val |= (((u32) (h[i].privNF) << 1) & 0x1ff);
 156 +                       val |= (((u32) nfval << 1) & 0x1ff);
 157                         REG_WRITE(ah, ah->nf_regs[i], val);
 158                 }
 159         }
 160 @@ -285,14 +290,18 @@ int16_t ath9k_hw_getnf(struct ath_hw *ah
 161         int16_t nfarray[NUM_NF_READINGS] = { 0 };
 162         struct ath9k_nfcal_hist *h;
 163         struct ieee80211_channel *c = chan->chan;
 164 +       struct ath9k_hw_cal_data *caldata = ah->caldata;
 165 +
 166 +       if (!caldata)
 167 +               return ath9k_hw_get_default_nf(ah, chan);
 168
 169         chan->channelFlags &= (~CHANNEL_CW_INT);
 170         if (REG_READ(ah, AR_PHY_AGC_CONTROL) & AR_PHY_AGC_CONTROL_NF) {
 171                 ath_print(common, ATH_DBG_CALIBRATE,
 172                           "NF did not complete in calibration window\n");
 173                 nf = 0;
 174 -               chan->rawNoiseFloor = nf;
 175 -               return chan->rawNoiseFloor;
 176 +               caldata->rawNoiseFloor = nf;
 177 +               return caldata->rawNoiseFloor;
 178         } else {
 179                 ath9k_hw_do_getnf(ah, nfarray);
 180                 ath9k_hw_nf_sanitize(ah, nfarray);
 181 @@ -307,47 +316,41 @@ int16_t ath9k_hw_getnf(struct ath_hw *ah
 182                 }
 183         }
 184
 185 -       h = ah->nfCalHist;
 186 +       h = caldata->nfCalHist;
 187
 188         ath9k_hw_update_nfcal_hist_buffer(h, nfarray);
 189 -       chan->rawNoiseFloor = h[0].privNF;
 190 +       caldata->rawNoiseFloor = h[0].privNF;
 191
 192 -       return chan->rawNoiseFloor;
 193 +       return ah->caldata->rawNoiseFloor;
 194  }
 195
 196 -void ath9k_init_nfcal_hist_buffer(struct ath_hw *ah)
 197 +void ath9k_init_nfcal_hist_buffer(struct ath_hw *ah,
 198 +                                 struct ath9k_channel *chan)
 199  {
 200 -       struct ath_nf_limits *limit;
 201 +       struct ath9k_nfcal_hist *h;
 202 +       s16 default_nf;
 203         int i, j;
 204
 205 -       if (!ah->curchan || IS_CHAN_2GHZ(ah->curchan))
 206 -               limit = &ah->nf_2g;
 207 -       else
 208 -               limit = &ah->nf_5g;
 209 +       if (!ah->caldata)
 210 +               return;
 211
 212 +       h = ah->caldata->nfCalHist;
 213 +       default_nf = ath9k_hw_get_default_nf(ah, chan);
 214         for (i = 0; i < NUM_NF_READINGS; i++) {
 215 -               ah->nfCalHist[i].currIndex = 0;
 216 -               ah->nfCalHist[i].privNF = limit->nominal;
 217 -               ah->nfCalHist[i].invalidNFcount =
 218 -                       AR_PHY_CCA_FILTERWINDOW_LENGTH;
 219 +               h[i].currIndex = 0;
 220 +               h[i].privNF = default_nf;
 221 +               h[i].invalidNFcount = AR_PHY_CCA_FILTERWINDOW_LENGTH;
 222                 for (j = 0; j < ATH9K_NF_CAL_HIST_MAX; j++) {
 223 -                       ah->nfCalHist[i].nfCalBuffer[j] = limit->nominal;
 224 +                       h[i].nfCalBuffer[j] = default_nf;
 225                 }
 226         }
 227  }
 228
 229  s16 ath9k_hw_getchan_noise(struct ath_hw *ah, struct ath9k_channel *chan)
 230  {
 231 -       s16 nf;
 232 -
 233 -       if (chan->rawNoiseFloor == 0)
 234 -               nf = -96;
 235 -       else
 236 -               nf = chan->rawNoiseFloor;
 237 -
 238 -       if (!ath9k_hw_nf_in_range(ah, nf))
 239 -               nf = ATH_DEFAULT_NOISE_FLOOR;
 240 +       if (!ah->caldata || !ah->caldata->rawNoiseFloor)
 241 +               return ath9k_hw_get_default_nf(ah, chan);
 242
 243 -       return nf;
 244 +       return ah->caldata->rawNoiseFloor;
 245  }
 246  EXPORT_SYMBOL(ath9k_hw_getchan_noise);
 247 --- a/drivers/net/wireless/ath/ath9k/main.c
 248 +++ b/drivers/net/wireless/ath/ath9k/main.c
 249 @@ -184,11 +184,13 @@ static void ath_start_ani(struct ath_com
 250  int ath_set_channel(struct ath_softc *sc, struct ieee80211_hw *hw,
 251                     struct ath9k_channel *hchan)
 252  {
 253 +       struct ath_wiphy *aphy = hw->priv;
 254         struct ath_hw *ah = sc->sc_ah;
 255         struct ath_common *common = ath9k_hw_common(ah);
 256         struct ieee80211_conf *conf = &common->hw->conf;
 257         bool fastcc = true, stopped;
 258         struct ieee80211_channel *channel = hw->conf.channel;
 259 +       struct ath9k_hw_cal_data *caldata = NULL;
 260         int r;
 261
 262         if (sc->sc_flags & SC_OP_INVALID)
 263 @@ -221,6 +223,9 @@ int ath_set_channel(struct ath_softc *sc
 264         if (!stopped || !(sc->sc_flags & SC_OP_OFFCHANNEL))
 265                 fastcc = false;
 266
 267 +       if (!(sc->sc_flags & SC_OP_OFFCHANNEL))
 268 +               caldata = &aphy->caldata;
 269 +
 270         ath_print(common, ATH_DBG_CONFIG,
 271                   "(%u MHz) -> (%u MHz), conf_is_ht40: %d\n",
 272                   sc->sc_ah->curchan->channel,
 273 @@ -228,7 +233,7 @@ int ath_set_channel(struct ath_softc *sc
 274
 275         spin_lock_bh(&sc->sc_resetlock);
 276
 277 -       r = ath9k_hw_reset(ah, hchan, fastcc);
 278 +       r = ath9k_hw_reset(ah, hchan, caldata, fastcc);
 279         if (r) {
 280                 ath_print(common, ATH_DBG_FATAL,
 281                           "Unable to reset channel (%u MHz), "
 282 @@ -264,9 +269,10 @@ int ath_set_channel(struct ath_softc *sc
 283  static void ath_paprd_activate(struct ath_softc *sc)
 284  {
 285         struct ath_hw *ah = sc->sc_ah;
 286 +       struct ath9k_hw_cal_data *caldata = ah->caldata;
 287         int chain;
 288
 289 -       if (!ah->curchan->paprd_done)
 290 +       if (!caldata || !caldata->paprd_done)
 291                 return;
 292
 293         ath9k_ps_wakeup(sc);
 294 @@ -274,7 +280,7 @@ static void ath_paprd_activate(struct at
 295                 if (!(ah->caps.tx_chainmask & BIT(chain)))
 296                         continue;
 297
 298 -               ar9003_paprd_populate_single_table(ah, ah->curchan, chain);
 299 +               ar9003_paprd_populate_single_table(ah, caldata, chain);
 300         }
 301
 302         ar9003_paprd_enable(ah, true);
 303 @@ -292,6 +298,7 @@ void ath_paprd_calibrate(struct work_str
 304         int band = hw->conf.channel->band;
 305         struct ieee80211_supported_band *sband = &sc->sbands[band];
 306         struct ath_tx_control txctl;
 307 +       struct ath9k_hw_cal_data *caldata = ah->caldata;
 308         int qnum, ftype;
 309         int chain_ok = 0;
 310         int chain;
 311 @@ -299,6 +306,9 @@ void ath_paprd_calibrate(struct work_str
 312         int time_left;
 313         int i;
 314
 315 +       if (!caldata)
 316 +               return;
 317 +
 318         skb = alloc_skb(len, GFP_KERNEL);
 319         if (!skb)
 320                 return;
 321 @@ -353,7 +363,7 @@ void ath_paprd_calibrate(struct work_str
 322                 if (!ar9003_paprd_is_done(ah))
 323                         break;
 324
 325 -               if (ar9003_paprd_create_curve(ah, ah->curchan, chain) != 0)
 326 +               if (ar9003_paprd_create_curve(ah, caldata, chain) != 0)
 327                         break;
 328
 329                 chain_ok = 1;
 330 @@ -361,7 +371,7 @@ void ath_paprd_calibrate(struct work_str
 331         kfree_skb(skb);
 332
 333         if (chain_ok) {
 334 -               ah->curchan->paprd_done = true;
 335 +               caldata->paprd_done = true;
 336                 ath_paprd_activate(sc);
 337         }
 338
 339 @@ -470,8 +480,8 @@ set_timer:
 340                 cal_interval = min(cal_interval, (u32)short_cal_interval);
 341
 342         mod_timer(&common->ani.timer, jiffies + msecs_to_jiffies(cal_interval));
 343 -       if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_PAPRD) {
 344 -               if (!sc->sc_ah->curchan->paprd_done)
 345 +       if ((sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_PAPRD) && ah->caldata) {
 346 +               if (!ah->caldata->paprd_done)
 347                         ieee80211_queue_work(sc->hw, &sc->paprd_work);
 348                 else
 349                         ath_paprd_activate(sc);
 350 @@ -829,7 +839,7 @@ void ath_radio_enable(struct ath_softc *
 351                 ah->curchan = ath_get_curchannel(sc, sc->hw);
 352
 353         spin_lock_bh(&sc->sc_resetlock);
 354 -       r = ath9k_hw_reset(ah, ah->curchan, false);
 355 +       r = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
 356         if (r) {
 357                 ath_print(common, ATH_DBG_FATAL,
 358                           "Unable to reset channel (%u MHz), "
 359 @@ -889,7 +899,7 @@ void ath_radio_disable(struct ath_softc
 360                 ah->curchan = ath_get_curchannel(sc, hw);
 361
 362         spin_lock_bh(&sc->sc_resetlock);
 363 -       r = ath9k_hw_reset(ah, ah->curchan, false);
 364 +       r = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
 365         if (r) {
 366                 ath_print(ath9k_hw_common(sc->sc_ah), ATH_DBG_FATAL,
 367                           "Unable to reset channel (%u MHz), "
 368 @@ -922,7 +932,7 @@ int ath_reset(struct ath_softc *sc, bool
 369         ath_flushrecv(sc);
 370
 371         spin_lock_bh(&sc->sc_resetlock);
 372 -       r = ath9k_hw_reset(ah, sc->sc_ah->curchan, false);
 373 +       r = ath9k_hw_reset(ah, sc->sc_ah->curchan, ah->caldata, false);
 374         if (r)
 375                 ath_print(common, ATH_DBG_FATAL,
 376                           "Unable to reset hardware; reset status %d\n", r);
 377 @@ -1097,7 +1107,7 @@ static int ath9k_start(struct ieee80211_
 378          * and then setup of the interrupt mask.
 379          */
 380         spin_lock_bh(&sc->sc_resetlock);
 381 -       r = ath9k_hw_reset(ah, init_channel, false);
 382 +       r = ath9k_hw_reset(ah, init_channel, ah->caldata, false);
 383         if (r) {
 384                 ath_print(common, ATH_DBG_FATAL,
 385                           "Unable to reset hardware; reset status %d "
 386 --- a/drivers/net/wireless/ath/ath9k/ar9003_paprd.c
 387 +++ b/drivers/net/wireless/ath/ath9k/ar9003_paprd.c
 388 @@ -577,10 +577,11 @@ static bool create_pa_curve(u32 *data_L,
 389  }
 390
 391  void ar9003_paprd_populate_single_table(struct ath_hw *ah,
 392 -                                       struct ath9k_channel *chan, int chain)
 393 +                                       struct ath9k_hw_cal_data *caldata,
 394 +                                       int chain)
 395  {
 396 -       u32 *paprd_table_val = chan->pa_table[chain];
 397 -       u32 small_signal_gain = chan->small_signal_gain[chain];
 398 +       u32 *paprd_table_val = caldata->pa_table[chain];
 399 +       u32 small_signal_gain = caldata->small_signal_gain[chain];
 400         u32 training_power;
 401         u32 reg = 0;
 402         int i;
 403 @@ -654,17 +655,17 @@ int ar9003_paprd_setup_gain_table(struct
 404  }
 405  EXPORT_SYMBOL(ar9003_paprd_setup_gain_table);
 406
 407 -int ar9003_paprd_create_curve(struct ath_hw *ah, struct ath9k_channel *chan,
 408 -                             int chain)
 409 +int ar9003_paprd_create_curve(struct ath_hw *ah,
 410 +                             struct ath9k_hw_cal_data *caldata, int chain)
 411  {
 412 -       u16 *small_signal_gain = &chan->small_signal_gain[chain];
 413 -       u32 *pa_table = chan->pa_table[chain];
 414 +       u16 *small_signal_gain = &caldata->small_signal_gain[chain];
 415 +       u32 *pa_table = caldata->pa_table[chain];
 416         u32 *data_L, *data_U;
 417         int i, status = 0;
 418         u32 *buf;
 419         u32 reg;
 420
 421 -       memset(chan->pa_table[chain], 0, sizeof(chan->pa_table[chain]));
 422 +       memset(caldata->pa_table[chain], 0, sizeof(caldata->pa_table[chain]));
 423
 424         buf = kmalloc(2 * 48 * sizeof(u32), GFP_ATOMIC);
 425         if (!buf)
 426 --- a/drivers/net/wireless/ath/ath9k/hw.c
 427 +++ b/drivers/net/wireless/ath/ath9k/hw.c
 428 @@ -621,7 +621,6 @@ static int __ath9k_hw_init(struct ath_hw
 429         else
 430                 ah->tx_trig_level = (AR_FTRIG_512B >> AR_FTRIG_S);
 431
 432 -       ath9k_init_nfcal_hist_buffer(ah);
 433         ah->bb_watchdog_timeout_ms = 25;
 434
 435         common->state = ATH_HW_INITIALIZED;
 436 @@ -1194,9 +1193,6 @@ static bool ath9k_hw_channel_change(stru
 437
 438         ath9k_hw_spur_mitigate_freq(ah, chan);
 439
 440 -       if (!chan->oneTimeCalsDone)
 441 -               chan->oneTimeCalsDone = true;
 442 -
 443         return true;
 444  }
 445
 446 @@ -1229,7 +1225,7 @@ bool ath9k_hw_check_alive(struct ath_hw
 447  EXPORT_SYMBOL(ath9k_hw_check_alive);
 448
 449  int ath9k_hw_reset(struct ath_hw *ah, struct ath9k_channel *chan,
 450 -                   bool bChannelChange)
 451 +                  struct ath9k_hw_cal_data *caldata, bool bChannelChange)
 452  {
 453         struct ath_common *common = ath9k_hw_common(ah);
 454         u32 saveLedState;
 455 @@ -1254,9 +1250,19 @@ int ath9k_hw_reset(struct ath_hw *ah, st
 456         if (!ath9k_hw_setpower(ah, ATH9K_PM_AWAKE))
 457                 return -EIO;
 458
 459 -       if (curchan && !ah->chip_fullsleep)
 460 +       if (curchan && !ah->chip_fullsleep && ah->caldata)
 461                 ath9k_hw_getnf(ah, curchan);
 462
 463 +       ah->caldata = caldata;
 464 +       if (caldata &&
 465 +           (chan->channel != caldata->channel ||
 466 +            (chan->channelFlags & ~CHANNEL_CW_INT) !=
 467 +            (caldata->channelFlags & ~CHANNEL_CW_INT))) {
 468 +               /* Operating channel changed, reset channel calibration data */
 469 +               memset(caldata, 0, sizeof(*caldata));
 470 +               ath9k_init_nfcal_hist_buffer(ah, chan);
 471 +       }
 472 +
 473         if (bChannelChange &&
 474             (ah->chip_fullsleep != true) &&
 475             (ah->curchan != NULL) &&
 476 --- a/drivers/net/wireless/ath/ath9k/ar9002_calib.c
 477 +++ b/drivers/net/wireless/ath/ath9k/ar9002_calib.c
 478 @@ -63,6 +63,7 @@ static bool ar9002_hw_per_calibration(st
 479                                       u8 rxchainmask,
 480                                       struct ath9k_cal_list *currCal)
 481  {
 482 +       struct ath9k_hw_cal_data *caldata = ah->caldata;
 483         bool iscaldone = false;
 484
 485         if (currCal->calState == CAL_RUNNING) {
 486 @@ -81,14 +82,14 @@ static bool ar9002_hw_per_calibration(st
 487                                 }
 488
 489                                 currCal->calData->calPostProc(ah, numChains);
 490 -                               ichan->CalValid |= currCal->calData->calType;
 491 +                               caldata->CalValid |= currCal->calData->calType;
 492                                 currCal->calState = CAL_DONE;
 493                                 iscaldone = true;
 494                         } else {
 495                                 ar9002_hw_setup_calibration(ah, currCal);
 496                         }
 497                 }
 498 -       } else if (!(ichan->CalValid & currCal->calData->calType)) {
 499 +       } else if (!(caldata->CalValid & currCal->calData->calType)) {
 500                 ath9k_hw_reset_calibration(ah, currCal);
 501         }
 502
 503 @@ -901,7 +902,8 @@ static bool ar9002_hw_init_cal(struct at
 504                         ath9k_hw_reset_calibration(ah, ah->cal_list_curr);
 505         }
 506
 507 -       chan->CalValid = 0;
 508 +       if (ah->caldata)
 509 +               ah->caldata->CalValid = 0;
 510
 511         return true;
 512  }
 513 --- a/drivers/net/wireless/ath/ath9k/ar9003_calib.c
 514 +++ b/drivers/net/wireless/ath/ath9k/ar9003_calib.c
 515 @@ -68,6 +68,7 @@ static bool ar9003_hw_per_calibration(st
 516                                       u8 rxchainmask,
 517                                       struct ath9k_cal_list *currCal)
 518  {
 519 +       struct ath9k_hw_cal_data *caldata = ah->caldata;
 520         /* Cal is assumed not done until explicitly set below */
 521         bool iscaldone = false;
 522
 523 @@ -95,7 +96,7 @@ static bool ar9003_hw_per_calibration(st
 524                                 currCal->calData->calPostProc(ah, numChains);
 525
 526                                 /* Calibration has finished. */
 527 -                               ichan->CalValid |= currCal->calData->calType;
 528 +                               caldata->CalValid |= currCal->calData->calType;
 529                                 currCal->calState = CAL_DONE;
 530                                 iscaldone = true;
 531                         } else {
 532 @@ -106,7 +107,7 @@ static bool ar9003_hw_per_calibration(st
 533                         ar9003_hw_setup_calibration(ah, currCal);
 534                         }
 535                 }
 536 -       } else if (!(ichan->CalValid & currCal->calData->calType)) {
 537 +       } else if (!(caldata->CalValid & currCal->calData->calType)) {
 538                 /* If current cal is marked invalid in channel, kick it off */
 539                 ath9k_hw_reset_calibration(ah, currCal);
 540         }
 541 @@ -785,7 +786,8 @@ static bool ar9003_hw_init_cal(struct at
 542         if (ah->cal_list_curr)
 543                 ath9k_hw_reset_calibration(ah, ah->cal_list_curr);
 544
 545 -       chan->CalValid = 0;
 546 +       if (ah->caldata)
 547 +               ah->caldata->CalValid = 0;
 548
 549         return true;
 550  }
 551 --- a/drivers/net/wireless/ath/ath9k/htc_drv_main.c
 552 +++ b/drivers/net/wireless/ath/ath9k/htc_drv_main.c
 553 @@ -125,6 +125,7 @@ static int ath9k_htc_set_channel(struct
 554         struct ieee80211_conf *conf = &common->hw->conf;
 555         bool fastcc = true;
 556         struct ieee80211_channel *channel = hw->conf.channel;
 557 +       struct ath9k_hw_cal_data *caldata;
 558         enum htc_phymode mode;
 559         __be16 htc_mode;
 560         u8 cmd_rsp;
 561 @@ -149,7 +150,8 @@ static int ath9k_htc_set_channel(struct
 562                   priv->ah->curchan->channel,
 563                   channel->center_freq, conf_is_ht(conf), conf_is_ht40(conf));
 564
 565 -       ret = ath9k_hw_reset(ah, hchan, fastcc);
 566 +       caldata = &priv->caldata[channel->hw_value];
 567 +       ret = ath9k_hw_reset(ah, hchan, caldata, fastcc);
 568         if (ret) {
 569                 ath_print(common, ATH_DBG_FATAL,
 570                           "Unable to reset channel (%u Mhz) "
 571 @@ -1028,7 +1030,7 @@ static void ath9k_htc_radio_enable(struc
 572                 ah->curchan = ath9k_cmn_get_curchannel(hw, ah);
 573
 574         /* Reset the HW */
 575 -       ret = ath9k_hw_reset(ah, ah->curchan, false);
 576 +       ret = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
 577         if (ret) {
 578                 ath_print(common, ATH_DBG_FATAL,
 579                           "Unable to reset hardware; reset status %d "
 580 @@ -1091,7 +1093,7 @@ static void ath9k_htc_radio_disable(stru
 581                 ah->curchan = ath9k_cmn_get_curchannel(hw, ah);
 582
 583         /* Reset the HW */
 584 -       ret = ath9k_hw_reset(ah, ah->curchan, false);
 585 +       ret = ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
 586         if (ret) {
 587                 ath_print(common, ATH_DBG_FATAL,
 588                           "Unable to reset hardware; reset status %d "
 589 @@ -1179,7 +1181,7 @@ static int ath9k_htc_start(struct ieee80
 590         ath9k_hw_configpcipowersave(ah, 0, 0);
 591
 592         ath9k_hw_htc_resetinit(ah);
 593 -       ret = ath9k_hw_reset(ah, init_channel, false);
 594 +       ret = ath9k_hw_reset(ah, init_channel, ah->caldata, false);
 595         if (ret) {
 596                 ath_print(common, ATH_DBG_FATAL,
 597                           "Unable to reset hardware; reset status %d "
 598 --- a/drivers/net/wireless/ath/ath9k/xmit.c
 599 +++ b/drivers/net/wireless/ath/ath9k/xmit.c
 600 @@ -1181,7 +1181,7 @@ void ath_drain_all_txq(struct ath_softc
 601                           "Failed to stop TX DMA. Resetting hardware!\n");
 602
 603                 spin_lock_bh(&sc->sc_resetlock);
 604 -               r = ath9k_hw_reset(ah, sc->sc_ah->curchan, false);
 605 +               r = ath9k_hw_reset(ah, sc->sc_ah->curchan, ah->caldata, false);
 606                 if (r)
 607                         ath_print(common, ATH_DBG_FATAL,
 608                                   "Unable to reset hardware; reset status %d\n",
 609 --- a/drivers/net/wireless/ath/ath9k/ath9k.h
 610 +++ b/drivers/net/wireless/ath/ath9k/ath9k.h
 611 @@ -611,6 +611,7 @@ struct ath_softc {
 612  struct ath_wiphy {
 613         struct ath_softc *sc; /* shared for all virtual wiphys */
 614         struct ieee80211_hw *hw;
 615 +       struct ath9k_hw_cal_data caldata;
 616         enum ath_wiphy_state {
 617                 ATH_WIPHY_INACTIVE,
 618                 ATH_WIPHY_ACTIVE,
 619 --- a/drivers/net/wireless/ath/ath9k/calib.h
 620 +++ b/drivers/net/wireless/ath/ath9k/calib.h
 621 @@ -112,7 +112,8 @@ void ath9k_hw_start_nfcal(struct ath_hw
 622  void ath9k_hw_loadnf(struct ath_hw *ah, struct ath9k_channel *chan);
 623  int16_t ath9k_hw_getnf(struct ath_hw *ah,
 624                        struct ath9k_channel *chan);
 625 -void ath9k_init_nfcal_hist_buffer(struct ath_hw *ah);
 626 +void ath9k_init_nfcal_hist_buffer(struct ath_hw *ah,
 627 +                                 struct ath9k_channel *chan);
 628  s16 ath9k_hw_getchan_noise(struct ath_hw *ah, struct ath9k_channel *chan);
 629  void ath9k_hw_reset_calibration(struct ath_hw *ah,
 630                                 struct ath9k_cal_list *currCal);
 631 --- a/drivers/net/wireless/ath/ath9k/htc.h
 632 +++ b/drivers/net/wireless/ath/ath9k/htc.h
 633 @@ -353,6 +353,8 @@ struct ath9k_htc_priv {
 634         u16 seq_no;
 635         u32 bmiss_cnt;
 636
 637 +       struct ath9k_hw_cal_data caldata[38];
 638 +
 639         spinlock_t beacon_lock;
 640
 641         bool tx_queues_stop;