drivers/net/wireless/ath/ath9k/channel.c

   1 /*
   2  * Copyright (c) 2014 Qualcomm Atheros, Inc.
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #include "ath9k.h"
  18
  19 /* Set/change channels.  If the channel is really being changed, it's done
  20  * by reseting the chip.  To accomplish this we must first cleanup any pending
  21  * DMA, then restart stuff.
  22  */
  23 static int ath_set_channel(struct ath_softc *sc)
  24 {
  25         struct ath_hw *ah = sc->sc_ah;
  26         struct ath_common *common = ath9k_hw_common(ah);
  27         struct ieee80211_hw *hw = sc->hw;
  28         struct ath9k_channel *hchan;
  29         struct cfg80211_chan_def *chandef = &sc->cur_chan->chandef;
  30         struct ieee80211_channel *chan = chandef->chan;
  31         int pos = chan->hw_value;
  32         int old_pos = -1;
  33         int r;
  34
  35         if (test_bit(ATH_OP_INVALID, &common->op_flags))
  36                 return -EIO;
  37
  38         if (ah->curchan)
  39                 old_pos = ah->curchan - &ah->channels[0];
  40
  41         ath_dbg(common, CONFIG, "Set channel: %d MHz width: %d\n",
  42                 chan->center_freq, chandef->width);
  43
  44         /* update survey stats for the old channel before switching */
  45         spin_lock_bh(&common->cc_lock);
  46         ath_update_survey_stats(sc);
  47         spin_unlock_bh(&common->cc_lock);
  48
  49         ath9k_cmn_get_channel(hw, ah, chandef);
  50
  51         /* If the operating channel changes, change the survey in-use flags
  52          * along with it.
  53          * Reset the survey data for the new channel, unless we're switching
  54          * back to the operating channel from an off-channel operation.
  55          */
  56         if (!sc->cur_chan->offchannel && sc->cur_survey != &sc->survey[pos]) {
  57                 if (sc->cur_survey)
  58                         sc->cur_survey->filled &= ~SURVEY_INFO_IN_USE;
  59
  60                 sc->cur_survey = &sc->survey[pos];
  61
  62                 memset(sc->cur_survey, 0, sizeof(struct survey_info));
  63                 sc->cur_survey->filled |= SURVEY_INFO_IN_USE;
  64         } else if (!(sc->survey[pos].filled & SURVEY_INFO_IN_USE)) {
  65                 memset(&sc->survey[pos], 0, sizeof(struct survey_info));
  66         }
  67
  68         hchan = &sc->sc_ah->channels[pos];
  69         r = ath_reset_internal(sc, hchan);
  70         if (r)
  71                 return r;
  72
  73         /* The most recent snapshot of channel->noisefloor for the old
  74          * channel is only available after the hardware reset. Copy it to
  75          * the survey stats now.
  76          */
  77         if (old_pos >= 0)
  78                 ath_update_survey_nf(sc, old_pos);
  79
  80         /* Enable radar pulse detection if on a DFS channel. Spectral
  81          * scanning and radar detection can not be used concurrently.
  82          */
  83         if (hw->conf.radar_enabled) {
  84                 u32 rxfilter;
  85
  86                 /* set HW specific DFS configuration */
  87                 ath9k_hw_set_radar_params(ah);
  88                 rxfilter = ath9k_hw_getrxfilter(ah);
  89                 rxfilter |= ATH9K_RX_FILTER_PHYRADAR |
  90                                 ATH9K_RX_FILTER_PHYERR;
  91                 ath9k_hw_setrxfilter(ah, rxfilter);
  92                 ath_dbg(common, DFS, "DFS enabled at freq %d\n",
  93                         chan->center_freq);
  94         } else {
  95                 /* perform spectral scan if requested. */
  96                 if (test_bit(ATH_OP_SCANNING, &common->op_flags) &&
  97                         sc->spectral_mode == SPECTRAL_CHANSCAN)
  98                         ath9k_spectral_scan_trigger(hw);
  99         }
 100
 101         return 0;
 102 }
 103
 104 static bool
 105 ath_chanctx_send_vif_ps_frame(struct ath_softc *sc, struct ath_vif *avp,
 106                               bool powersave)
 107 {
 108         struct ieee80211_vif *vif = avp->vif;
 109         struct ieee80211_sta *sta = NULL;
 110         struct ieee80211_hdr_3addr *nullfunc;
 111         struct ath_tx_control txctl;
 112         struct sk_buff *skb;
 113         int band = sc->cur_chan->chandef.chan->band;
 114
 115         switch (vif->type) {
 116         case NL80211_IFTYPE_STATION:
 117                 if (!vif->bss_conf.assoc)
 118                         return false;
 119
 120                 skb = ieee80211_nullfunc_get(sc->hw, vif);
 121                 if (!skb)
 122                         return false;
 123
 124                 nullfunc = (struct ieee80211_hdr_3addr *) skb->data;
 125                 if (powersave)
 126                         nullfunc->frame_control |=
 127                                 cpu_to_le16(IEEE80211_FCTL_PM);
 128
 129                 skb_set_queue_mapping(skb, IEEE80211_AC_VO);
 130                 if (!ieee80211_tx_prepare_skb(sc->hw, vif, skb, band, &sta)) {
 131                         dev_kfree_skb_any(skb);
 132                         return false;
 133                 }
 134                 break;
 135         default:
 136                 return false;
 137         }
 138
 139         memset(&txctl, 0, sizeof(txctl));
 140         txctl.txq = sc->tx.txq_map[IEEE80211_AC_VO];
 141         txctl.sta = sta;
 142         txctl.force_channel = true;
 143         if (ath_tx_start(sc->hw, skb, &txctl)) {
 144                 ieee80211_free_txskb(sc->hw, skb);
 145                 return false;
 146         }
 147
 148         return true;
 149 }
 150
 151 void ath_chanctx_check_active(struct ath_softc *sc, struct ath_chanctx *ctx)
 152 {
 153         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 154         struct ath_vif *avp;
 155         bool active = false;
 156         u8 n_active = 0;
 157
 158         if (!ctx)
 159                 return;
 160
 161         list_for_each_entry(avp, &ctx->vifs, list) {
 162                 struct ieee80211_vif *vif = avp->vif;
 163
 164                 switch (vif->type) {
 165                 case NL80211_IFTYPE_P2P_CLIENT:
 166                 case NL80211_IFTYPE_STATION:
 167                         if (vif->bss_conf.assoc)
 168                                 active = true;
 169                         break;
 170                 default:
 171                         active = true;
 172                         break;
 173                 }
 174         }
 175         ctx->active = active;
 176
 177         ath_for_each_chanctx(sc, ctx) {
 178                 if (!ctx->assigned || list_empty(&ctx->vifs))
 179                         continue;
 180                 n_active++;
 181         }
 182
 183         if (n_active <= 1) {
 184                 clear_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags);
 185                 return;
 186         }
 187         if (test_and_set_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags))
 188                 return;
 189         ath_chanctx_event(sc, NULL, ATH_CHANCTX_EVENT_ENABLE_MULTICHANNEL);
 190 }
 191
 192 static bool
 193 ath_chanctx_send_ps_frame(struct ath_softc *sc, bool powersave)
 194 {
 195         struct ath_vif *avp;
 196         bool sent = false;
 197
 198         rcu_read_lock();
 199         list_for_each_entry(avp, &sc->cur_chan->vifs, list) {
 200                 if (ath_chanctx_send_vif_ps_frame(sc, avp, powersave))
 201                         sent = true;
 202         }
 203         rcu_read_unlock();
 204
 205         return sent;
 206 }
 207
 208 static bool ath_chanctx_defer_switch(struct ath_softc *sc)
 209 {
 210         if (sc->cur_chan == &sc->offchannel.chan)
 211                 return false;
 212
 213         switch (sc->sched.state) {
 214         case ATH_CHANCTX_STATE_SWITCH:
 215                 return false;
 216         case ATH_CHANCTX_STATE_IDLE:
 217                 if (!sc->cur_chan->switch_after_beacon)
 218                         return false;
 219
 220                 sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;
 221                 break;
 222         default:
 223                 break;
 224         }
 225
 226         return true;
 227 }
 228
 229 static void ath_chanctx_set_next(struct ath_softc *sc, bool force)
 230 {
 231         struct timespec ts;
 232         bool measure_time = false;
 233         bool send_ps = false;
 234
 235         spin_lock_bh(&sc->chan_lock);
 236         if (!sc->next_chan) {
 237                 spin_unlock_bh(&sc->chan_lock);
 238                 return;
 239         }
 240
 241         if (!force && ath_chanctx_defer_switch(sc)) {
 242                 spin_unlock_bh(&sc->chan_lock);
 243                 return;
 244         }
 245
 246         if (sc->cur_chan != sc->next_chan) {
 247                 sc->cur_chan->stopped = true;
 248                 spin_unlock_bh(&sc->chan_lock);
 249
 250                 if (sc->next_chan == &sc->offchannel.chan) {
 251                         getrawmonotonic(&ts);
 252                         measure_time = true;
 253                 }
 254                 __ath9k_flush(sc->hw, ~0, true);
 255
 256                 if (ath_chanctx_send_ps_frame(sc, true))
 257                         __ath9k_flush(sc->hw, BIT(IEEE80211_AC_VO), false);
 258
 259                 send_ps = true;
 260                 spin_lock_bh(&sc->chan_lock);
 261
 262                 if (sc->cur_chan != &sc->offchannel.chan) {
 263                         getrawmonotonic(&sc->cur_chan->tsf_ts);
 264                         sc->cur_chan->tsf_val = ath9k_hw_gettsf64(sc->sc_ah);
 265                 }
 266         }
 267         sc->cur_chan = sc->next_chan;
 268         sc->cur_chan->stopped = false;
 269         sc->next_chan = NULL;
 270         sc->sched.offchannel_duration = 0;
 271         if (sc->sched.state != ATH_CHANCTX_STATE_FORCE_ACTIVE)
 272                 sc->sched.state = ATH_CHANCTX_STATE_IDLE;
 273
 274         spin_unlock_bh(&sc->chan_lock);
 275
 276         if (sc->sc_ah->chip_fullsleep ||
 277             memcmp(&sc->cur_chandef, &sc->cur_chan->chandef,
 278                    sizeof(sc->cur_chandef))) {
 279                 ath_set_channel(sc);
 280                 if (measure_time)
 281                         sc->sched.channel_switch_time =
 282                                 ath9k_hw_get_tsf_offset(&ts, NULL);
 283         }
 284         if (send_ps)
 285                 ath_chanctx_send_ps_frame(sc, false);
 286
 287         ath_offchannel_channel_change(sc);
 288         ath_chanctx_event(sc, NULL, ATH_CHANCTX_EVENT_SWITCH);
 289 }
 290
 291 void ath_chanctx_work(struct work_struct *work)
 292 {
 293         struct ath_softc *sc = container_of(work, struct ath_softc,
 294                                             chanctx_work);
 295         mutex_lock(&sc->mutex);
 296         ath_chanctx_set_next(sc, false);
 297         mutex_unlock(&sc->mutex);
 298 }
 299
 300 void ath_chanctx_init(struct ath_softc *sc)
 301 {
 302         struct ath_chanctx *ctx;
 303         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 304         struct ieee80211_supported_band *sband;
 305         struct ieee80211_channel *chan;
 306         int i, j;
 307
 308         sband = &common->sbands[IEEE80211_BAND_2GHZ];
 309         if (!sband->n_channels)
 310                 sband = &common->sbands[IEEE80211_BAND_5GHZ];
 311
 312         chan = &sband->channels[0];
 313         for (i = 0; i < ATH9K_NUM_CHANCTX; i++) {
 314                 ctx = &sc->chanctx[i];
 315                 cfg80211_chandef_create(&ctx->chandef, chan, NL80211_CHAN_HT20);
 316                 INIT_LIST_HEAD(&ctx->vifs);
 317                 ctx->txpower = ATH_TXPOWER_MAX;
 318                 for (j = 0; j < ARRAY_SIZE(ctx->acq); j++)
 319                         INIT_LIST_HEAD(&ctx->acq[j]);
 320         }
 321         ctx = &sc->offchannel.chan;
 322         cfg80211_chandef_create(&ctx->chandef, chan, NL80211_CHAN_HT20);
 323         INIT_LIST_HEAD(&ctx->vifs);
 324         ctx->txpower = ATH_TXPOWER_MAX;
 325         for (j = 0; j < ARRAY_SIZE(ctx->acq); j++)
 326                 INIT_LIST_HEAD(&ctx->acq[j]);
 327         sc->offchannel.chan.offchannel = true;
 328
 329 }
 330
 331 void ath9k_chanctx_force_active(struct ieee80211_hw *hw,
 332                                 struct ieee80211_vif *vif)
 333 {
 334         struct ath_softc *sc = hw->priv;
 335         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 336         struct ath_vif *avp = (struct ath_vif *) vif->drv_priv;
 337         bool changed = false;
 338
 339         if (!test_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags))
 340                 return;
 341
 342         if (!avp->chanctx)
 343                 return;
 344
 345         mutex_lock(&sc->mutex);
 346
 347         spin_lock_bh(&sc->chan_lock);
 348         if (sc->next_chan || (sc->cur_chan != avp->chanctx)) {
 349                 sc->next_chan = avp->chanctx;
 350                 changed = true;
 351         }
 352         sc->sched.state = ATH_CHANCTX_STATE_FORCE_ACTIVE;
 353         spin_unlock_bh(&sc->chan_lock);
 354
 355         if (changed)
 356                 ath_chanctx_set_next(sc, true);
 357
 358         mutex_unlock(&sc->mutex);
 359 }
 360
 361 void ath_chanctx_switch(struct ath_softc *sc, struct ath_chanctx *ctx,
 362                         struct cfg80211_chan_def *chandef)
 363 {
 364         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 365
 366         spin_lock_bh(&sc->chan_lock);
 367
 368         if (test_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags) &&
 369             (sc->cur_chan != ctx) && (ctx == &sc->offchannel.chan)) {
 370                 sc->sched.offchannel_pending = true;
 371                 spin_unlock_bh(&sc->chan_lock);
 372                 return;
 373         }
 374
 375         sc->next_chan = ctx;
 376         if (chandef)
 377                 ctx->chandef = *chandef;
 378
 379         if (sc->next_chan == &sc->offchannel.chan) {
 380                 sc->sched.offchannel_duration =
 381                         TU_TO_USEC(sc->offchannel.duration) +
 382                         sc->sched.channel_switch_time;
 383         }
 384         spin_unlock_bh(&sc->chan_lock);
 385         ieee80211_queue_work(sc->hw, &sc->chanctx_work);
 386 }
 387
 388 void ath_chanctx_set_channel(struct ath_softc *sc, struct ath_chanctx *ctx,
 389                              struct cfg80211_chan_def *chandef)
 390 {
 391         bool cur_chan;
 392
 393         spin_lock_bh(&sc->chan_lock);
 394         if (chandef)
 395                 memcpy(&ctx->chandef, chandef, sizeof(*chandef));
 396         cur_chan = sc->cur_chan == ctx;
 397         spin_unlock_bh(&sc->chan_lock);
 398
 399         if (!cur_chan)
 400                 return;
 401
 402         ath_set_channel(sc);
 403 }
 404
 405 struct ath_chanctx *ath_chanctx_get_oper_chan(struct ath_softc *sc, bool active)
 406 {
 407         struct ath_chanctx *ctx;
 408
 409         ath_for_each_chanctx(sc, ctx) {
 410                 if (!ctx->assigned || list_empty(&ctx->vifs))
 411                         continue;
 412                 if (active && !ctx->active)
 413                         continue;
 414
 415                 if (ctx->switch_after_beacon)
 416                         return ctx;
 417         }
 418
 419         return &sc->chanctx[0];
 420 }
 421
 422 void ath_chanctx_offchan_switch(struct ath_softc *sc,
 423                                 struct ieee80211_channel *chan)
 424 {
 425         struct cfg80211_chan_def chandef;
 426
 427         cfg80211_chandef_create(&chandef, chan, NL80211_CHAN_NO_HT);
 428
 429         ath_chanctx_switch(sc, &sc->offchannel.chan, &chandef);
 430 }
 431
 432 static struct ath_chanctx *
 433 ath_chanctx_get_next(struct ath_softc *sc, struct ath_chanctx *ctx)
 434 {
 435         int idx = ctx - &sc->chanctx[0];
 436
 437         return &sc->chanctx[!idx];
 438 }
 439
 440 static void ath_chanctx_adjust_tbtt_delta(struct ath_softc *sc)
 441 {
 442         struct ath_chanctx *prev, *cur;
 443         struct timespec ts;
 444         u32 cur_tsf, prev_tsf, beacon_int;
 445         s32 offset;
 446
 447         beacon_int = TU_TO_USEC(sc->cur_chan->beacon.beacon_interval);
 448
 449         cur = sc->cur_chan;
 450         prev = ath_chanctx_get_next(sc, cur);
 451
 452         getrawmonotonic(&ts);
 453         cur_tsf = (u32) cur->tsf_val +
 454                   ath9k_hw_get_tsf_offset(&cur->tsf_ts, &ts);
 455
 456         prev_tsf = prev->last_beacon - (u32) prev->tsf_val + cur_tsf;
 457         prev_tsf -= ath9k_hw_get_tsf_offset(&prev->tsf_ts, &ts);
 458
 459         /* Adjust the TSF time of the AP chanctx to keep its beacons
 460          * at half beacon interval offset relative to the STA chanctx.
 461          */
 462         offset = cur_tsf - prev_tsf;
 463
 464         /* Ignore stale data or spurious timestamps */
 465         if (offset < 0 || offset > 3 * beacon_int)
 466                 return;
 467
 468         offset = beacon_int / 2 - (offset % beacon_int);
 469         prev->tsf_val += offset;
 470 }
 471
 472 void ath_chanctx_timer(unsigned long data)
 473 {
 474         struct ath_softc *sc = (struct ath_softc *) data;
 475
 476         ath_chanctx_event(sc, NULL, ATH_CHANCTX_EVENT_TSF_TIMER);
 477 }
 478
 479 /* Configure the TSF based hardware timer for a channel switch.
 480  * Also set up backup software timer, in case the gen timer fails.
 481  * This could be caused by a hardware reset.
 482  */
 483 static void ath_chanctx_setup_timer(struct ath_softc *sc, u32 tsf_time)
 484 {
 485         struct ath_hw *ah = sc->sc_ah;
 486
 487         ath9k_hw_gen_timer_start(ah, sc->p2p_ps_timer, tsf_time, 1000000);
 488         tsf_time -= ath9k_hw_gettsf32(ah);
 489         tsf_time = msecs_to_jiffies(tsf_time / 1000) + 1;
 490         mod_timer(&sc->sched.timer, tsf_time);
 491 }
 492
 493 void ath_chanctx_event(struct ath_softc *sc, struct ieee80211_vif *vif,
 494                        enum ath_chanctx_event ev)
 495 {
 496         struct ath_hw *ah = sc->sc_ah;
 497         struct ath_common *common = ath9k_hw_common(ah);
 498         struct ath_beacon_config *cur_conf;
 499         struct ath_vif *avp = NULL;
 500         struct ath_chanctx *ctx;
 501         u32 tsf_time;
 502         u32 beacon_int;
 503         bool noa_changed = false;
 504
 505         if (vif)
 506                 avp = (struct ath_vif *) vif->drv_priv;
 507
 508         spin_lock_bh(&sc->chan_lock);
 509
 510         switch (ev) {
 511         case ATH_CHANCTX_EVENT_BEACON_PREPARE:
 512                 if (avp->offchannel_duration)
 513                         avp->offchannel_duration = 0;
 514
 515                 if (avp->chanctx != sc->cur_chan)
 516                         break;
 517
 518                 if (sc->sched.offchannel_pending) {
 519                         sc->sched.offchannel_pending = false;
 520                         sc->next_chan = &sc->offchannel.chan;
 521                         sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;
 522                 }
 523
 524                 ctx = ath_chanctx_get_next(sc, sc->cur_chan);
 525                 if (ctx->active && sc->sched.state == ATH_CHANCTX_STATE_IDLE) {
 526                         sc->next_chan = ctx;
 527                         sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;
 528                 }
 529
 530                 /* if the timer missed its window, use the next interval */
 531                 if (sc->sched.state == ATH_CHANCTX_STATE_WAIT_FOR_TIMER)
 532                         sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;
 533
 534                 if (sc->sched.state != ATH_CHANCTX_STATE_WAIT_FOR_BEACON)
 535                         break;
 536
 537                 sc->sched.beacon_pending = true;
 538                 sc->sched.next_tbtt = REG_READ(ah, AR_NEXT_TBTT_TIMER);
 539
 540                 cur_conf = &sc->cur_chan->beacon;
 541                 beacon_int = TU_TO_USEC(cur_conf->beacon_interval);
 542
 543                 /* defer channel switch by a quarter beacon interval */
 544                 tsf_time = sc->sched.next_tbtt + beacon_int / 4;
 545                 sc->sched.switch_start_time = tsf_time;
 546                 sc->cur_chan->last_beacon = sc->sched.next_tbtt;
 547
 548                 /* Prevent wrap-around issues */
 549                 if (avp->periodic_noa_duration &&
 550                     tsf_time - avp->periodic_noa_start > BIT(30))
 551                         avp->periodic_noa_duration = 0;
 552
 553                 if (ctx->active && !avp->periodic_noa_duration) {
 554                         avp->periodic_noa_start = tsf_time;
 555                         avp->periodic_noa_duration =
 556                                 TU_TO_USEC(cur_conf->beacon_interval) / 2 -
 557                                 sc->sched.channel_switch_time;
 558                         noa_changed = true;
 559                 } else if (!ctx->active && avp->periodic_noa_duration) {
 560                         avp->periodic_noa_duration = 0;
 561                         noa_changed = true;
 562                 }
 563
 564                 /* If at least two consecutive beacons were missed on the STA
 565                  * chanctx, stay on the STA channel for one extra beacon period,
 566                  * to resync the timer properly.
 567                  */
 568                 if (ctx->active && sc->sched.beacon_miss >= 2)
 569                         sc->sched.offchannel_duration = 3 * beacon_int / 2;
 570
 571                 if (sc->sched.offchannel_duration) {
 572                         noa_changed = true;
 573                         avp->offchannel_start = tsf_time;
 574                         avp->offchannel_duration =
 575                                 sc->sched.offchannel_duration;
 576                 }
 577
 578                 if (noa_changed)
 579                         avp->noa_index++;
 580                 break;
 581         case ATH_CHANCTX_EVENT_BEACON_SENT:
 582                 if (!sc->sched.beacon_pending)
 583                         break;
 584
 585                 sc->sched.beacon_pending = false;
 586                 if (sc->sched.state != ATH_CHANCTX_STATE_WAIT_FOR_BEACON)
 587                         break;
 588
 589                 sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_TIMER;
 590                 ath_chanctx_setup_timer(sc, sc->sched.switch_start_time);
 591                 break;
 592         case ATH_CHANCTX_EVENT_TSF_TIMER:
 593                 if (sc->sched.state != ATH_CHANCTX_STATE_WAIT_FOR_TIMER)
 594                         break;
 595
 596                 if (!sc->cur_chan->switch_after_beacon &&
 597                     sc->sched.beacon_pending)
 598                         sc->sched.beacon_miss++;
 599
 600                 sc->sched.state = ATH_CHANCTX_STATE_SWITCH;
 601                 ieee80211_queue_work(sc->hw, &sc->chanctx_work);
 602                 break;
 603         case ATH_CHANCTX_EVENT_BEACON_RECEIVED:
 604                 if (!test_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags) ||
 605                     sc->cur_chan == &sc->offchannel.chan)
 606                         break;
 607
 608                 ath_chanctx_adjust_tbtt_delta(sc);
 609                 sc->sched.beacon_pending = false;
 610                 sc->sched.beacon_miss = 0;
 611
 612                 /* TSF time might have been updated by the incoming beacon,
 613                  * need update the channel switch timer to reflect the change.
 614                  */
 615                 tsf_time = sc->sched.switch_start_time;
 616                 tsf_time -= (u32) sc->cur_chan->tsf_val +
 617                         ath9k_hw_get_tsf_offset(&sc->cur_chan->tsf_ts, NULL);
 618                 tsf_time += ath9k_hw_gettsf32(ah);
 619
 620
 621                 ath_chanctx_setup_timer(sc, tsf_time);
 622                 break;
 623         case ATH_CHANCTX_EVENT_ASSOC:
 624                 if (sc->sched.state != ATH_CHANCTX_STATE_FORCE_ACTIVE ||
 625                     avp->chanctx != sc->cur_chan)
 626                         break;
 627
 628                 sc->sched.state = ATH_CHANCTX_STATE_IDLE;
 629                 /* fall through */
 630         case ATH_CHANCTX_EVENT_SWITCH:
 631                 if (!test_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags) ||
 632                     sc->sched.state == ATH_CHANCTX_STATE_FORCE_ACTIVE ||
 633                     sc->cur_chan->switch_after_beacon ||
 634                     sc->cur_chan == &sc->offchannel.chan)
 635                         break;
 636
 637                 /* If this is a station chanctx, stay active for a half
 638                  * beacon period (minus channel switch time)
 639                  */
 640                 sc->next_chan = ath_chanctx_get_next(sc, sc->cur_chan);
 641                 cur_conf = &sc->cur_chan->beacon;
 642
 643                 sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_TIMER;
 644
 645                 tsf_time = TU_TO_USEC(cur_conf->beacon_interval) / 2;
 646                 if (sc->sched.beacon_miss >= 2) {
 647                         sc->sched.beacon_miss = 0;
 648                         tsf_time *= 3;
 649                 }
 650
 651                 tsf_time -= sc->sched.channel_switch_time;
 652                 tsf_time += ath9k_hw_gettsf32(sc->sc_ah);
 653                 sc->sched.switch_start_time = tsf_time;
 654
 655                 ath_chanctx_setup_timer(sc, tsf_time);
 656                 sc->sched.beacon_pending = true;
 657                 break;
 658         case ATH_CHANCTX_EVENT_ENABLE_MULTICHANNEL:
 659                 if (sc->cur_chan == &sc->offchannel.chan ||
 660                     sc->cur_chan->switch_after_beacon)
 661                         break;
 662
 663                 sc->next_chan = ath_chanctx_get_next(sc, sc->cur_chan);
 664                 ieee80211_queue_work(sc->hw, &sc->chanctx_work);
 665                 break;
 666         case ATH_CHANCTX_EVENT_UNASSIGN:
 667                 if (sc->cur_chan->assigned) {
 668                         if (sc->next_chan && !sc->next_chan->assigned &&
 669                             sc->next_chan != &sc->offchannel.chan)
 670                                 sc->sched.state = ATH_CHANCTX_STATE_IDLE;
 671                         break;
 672                 }
 673
 674                 ctx = ath_chanctx_get_next(sc, sc->cur_chan);
 675                 sc->sched.state = ATH_CHANCTX_STATE_IDLE;
 676                 if (!ctx->assigned)
 677                         break;
 678
 679                 sc->next_chan = ctx;
 680                 ieee80211_queue_work(sc->hw, &sc->chanctx_work);
 681                 break;
 682         }
 683
 684         spin_unlock_bh(&sc->chan_lock);
 685 }