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_event(struct ath_softc *sc, struct ieee80211_vif *vif,
 473                        enum ath_chanctx_event ev)
 474 {
 475         struct ath_hw *ah = sc->sc_ah;
 476         struct ath_common *common = ath9k_hw_common(ah);
 477         struct ath_vif *avp = NULL;
 478         struct ath_chanctx *ctx;
 479         u32 tsf_time;
 480         bool noa_changed = false;
 481
 482         if (vif)
 483                 avp = (struct ath_vif *) vif->drv_priv;
 484
 485         spin_lock_bh(&sc->chan_lock);
 486
 487         switch (ev) {
 488         case ATH_CHANCTX_EVENT_BEACON_PREPARE:
 489                 if (avp->offchannel_duration)
 490                         avp->offchannel_duration = 0;
 491
 492                 if (avp->chanctx != sc->cur_chan)
 493                         break;
 494
 495                 if (sc->sched.offchannel_pending) {
 496                         sc->sched.offchannel_pending = false;
 497                         sc->next_chan = &sc->offchannel.chan;
 498                         sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;
 499                 }
 500
 501                 ctx = ath_chanctx_get_next(sc, sc->cur_chan);
 502                 if (ctx->active && sc->sched.state == ATH_CHANCTX_STATE_IDLE) {
 503                         sc->next_chan = ctx;
 504                         sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;
 505                 }
 506
 507                 /* if the timer missed its window, use the next interval */
 508                 if (sc->sched.state == ATH_CHANCTX_STATE_WAIT_FOR_TIMER)
 509                         sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;
 510
 511                 if (sc->sched.state != ATH_CHANCTX_STATE_WAIT_FOR_BEACON)
 512                         break;
 513
 514                 sc->sched.beacon_pending = true;
 515                 sc->sched.next_tbtt = REG_READ(ah, AR_NEXT_TBTT_TIMER);
 516
 517                 /* defer channel switch by a quarter beacon interval */
 518                 tsf_time = TU_TO_USEC(sc->cur_chan->beacon.beacon_interval);
 519                 tsf_time = sc->sched.next_tbtt + tsf_time / 4;
 520                 sc->sched.switch_start_time = tsf_time;
 521                 sc->cur_chan->last_beacon = sc->sched.next_tbtt;
 522
 523                 if (sc->sched.offchannel_duration) {
 524                         noa_changed = true;
 525                         avp->offchannel_start = tsf_time;
 526                         avp->offchannel_duration =
 527                                 sc->sched.offchannel_duration;
 528                 }
 529
 530                 if (noa_changed)
 531                         avp->noa_index++;
 532                 break;
 533         case ATH_CHANCTX_EVENT_BEACON_SENT:
 534                 if (!sc->sched.beacon_pending)
 535                         break;
 536
 537                 sc->sched.beacon_pending = false;
 538                 if (sc->sched.state != ATH_CHANCTX_STATE_WAIT_FOR_BEACON)
 539                         break;
 540
 541                 sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_TIMER;
 542                 ath9k_hw_gen_timer_start(ah, sc->p2p_ps_timer,
 543                                          sc->sched.switch_start_time,
 544                                          1000000);
 545                 break;
 546         case ATH_CHANCTX_EVENT_TSF_TIMER:
 547                 if (sc->sched.state != ATH_CHANCTX_STATE_WAIT_FOR_TIMER)
 548                         break;
 549
 550                 sc->sched.state = ATH_CHANCTX_STATE_SWITCH;
 551                 ieee80211_queue_work(sc->hw, &sc->chanctx_work);
 552                 break;
 553         case ATH_CHANCTX_EVENT_BEACON_RECEIVED:
 554                 if (!test_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags) ||
 555                     sc->cur_chan == &sc->offchannel.chan)
 556                         break;
 557
 558                 ath_chanctx_adjust_tbtt_delta(sc);
 559                 break;
 560         case ATH_CHANCTX_EVENT_ASSOC:
 561                 if (sc->sched.state != ATH_CHANCTX_STATE_FORCE_ACTIVE ||
 562                     avp->chanctx != sc->cur_chan)
 563                         break;
 564
 565                 sc->sched.state = ATH_CHANCTX_STATE_IDLE;
 566                 /* fall through */
 567         case ATH_CHANCTX_EVENT_SWITCH:
 568                 if (!test_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags) ||
 569                     sc->sched.state == ATH_CHANCTX_STATE_FORCE_ACTIVE ||
 570                     sc->cur_chan->switch_after_beacon ||
 571                     sc->cur_chan == &sc->offchannel.chan)
 572                         break;
 573
 574                 /* If this is a station chanctx, stay active for a half
 575                  * beacon period (minus channel switch time)
 576                  */
 577                 sc->next_chan = ath_chanctx_get_next(sc, sc->cur_chan);
 578
 579                 sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_TIMER;
 580                 tsf_time = ath9k_hw_gettsf32(sc->sc_ah);
 581                 tsf_time +=
 582                         TU_TO_USEC(sc->cur_chan->beacon.beacon_interval) / 2;
 583                 tsf_time -= sc->sched.channel_switch_time;
 584                 sc->sched.switch_start_time = tsf_time;
 585
 586                 ath9k_hw_gen_timer_start(ah, sc->p2p_ps_timer,
 587                                          tsf_time, 1000000);
 588                 break;
 589         case ATH_CHANCTX_EVENT_ENABLE_MULTICHANNEL:
 590                 if (sc->cur_chan == &sc->offchannel.chan ||
 591                     sc->cur_chan->switch_after_beacon)
 592                         break;
 593
 594                 sc->next_chan = ath_chanctx_get_next(sc, sc->cur_chan);
 595                 ieee80211_queue_work(sc->hw, &sc->chanctx_work);
 596                 break;
 597         case ATH_CHANCTX_EVENT_UNASSIGN:
 598                 if (sc->cur_chan->assigned) {
 599                         if (sc->next_chan && !sc->next_chan->assigned &&
 600                             sc->next_chan != &sc->offchannel.chan)
 601                                 sc->sched.state = ATH_CHANCTX_STATE_IDLE;
 602                         break;
 603                 }
 604
 605                 ctx = ath_chanctx_get_next(sc, sc->cur_chan);
 606                 sc->sched.state = ATH_CHANCTX_STATE_IDLE;
 607                 if (!ctx->assigned)
 608                         break;
 609
 610                 sc->next_chan = ctx;
 611                 ieee80211_queue_work(sc->hw, &sc->chanctx_work);
 612                 break;
 613         }
 614
 615         spin_unlock_bh(&sc->chan_lock);
 616 }