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(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                 rxfilter = ath9k_hw_getrxfilter(ah);
  87                 rxfilter |= ATH9K_RX_FILTER_PHYRADAR |
  88                                 ATH9K_RX_FILTER_PHYERR;
  89                 ath9k_hw_setrxfilter(ah, rxfilter);
  90                 ath_dbg(common, DFS, "DFS enabled at freq %d\n",
  91                         chan->center_freq);
  92         } else {
  93                 /* perform spectral scan if requested. */
  94                 if (test_bit(ATH_OP_SCANNING, &common->op_flags) &&
  95                         sc->spec_priv.spectral_mode == SPECTRAL_CHANSCAN)
  96                         ath9k_cmn_spectral_scan_trigger(common, &sc->spec_priv);
  97         }
  98
  99         return 0;
 100 }
 101
 102 void ath_chanctx_init(struct ath_softc *sc)
 103 {
 104         struct ath_chanctx *ctx;
 105         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 106         struct ieee80211_supported_band *sband;
 107         struct ieee80211_channel *chan;
 108         int i, j;
 109
 110         sband = &common->sbands[NL80211_BAND_2GHZ];
 111         if (!sband->n_channels)
 112                 sband = &common->sbands[NL80211_BAND_5GHZ];
 113
 114         chan = &sband->channels[0];
 115         for (i = 0; i < ATH9K_NUM_CHANCTX; i++) {
 116                 ctx = &sc->chanctx[i];
 117                 cfg80211_chandef_create(&ctx->chandef, chan, NL80211_CHAN_HT20);
 118                 INIT_LIST_HEAD(&ctx->vifs);
 119                 ctx->txpower = ATH_TXPOWER_MAX;
 120                 ctx->flush_timeout = HZ / 5; /* 200ms */
 121                 for (j = 0; j < ARRAY_SIZE(ctx->acq); j++)
 122                         INIT_LIST_HEAD(&ctx->acq[j]);
 123         }
 124 }
 125
 126 void ath_chanctx_set_channel(struct ath_softc *sc, struct ath_chanctx *ctx,
 127                              struct cfg80211_chan_def *chandef)
 128 {
 129         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 130         bool cur_chan;
 131
 132         spin_lock_bh(&sc->chan_lock);
 133         if (chandef)
 134                 memcpy(&ctx->chandef, chandef, sizeof(*chandef));
 135         cur_chan = sc->cur_chan == ctx;
 136         spin_unlock_bh(&sc->chan_lock);
 137
 138         if (!cur_chan) {
 139                 ath_dbg(common, CHAN_CTX,
 140                         "Current context differs from the new context\n");
 141                 return;
 142         }
 143
 144         ath_set_channel(sc);
 145 }
 146
 147 #ifdef CONFIG_ATH9K_CHANNEL_CONTEXT
 148
 149 /*************/
 150 /* Utilities */
 151 /*************/
 152
 153 struct ath_chanctx* ath_is_go_chanctx_present(struct ath_softc *sc)
 154 {
 155         struct ath_chanctx *ctx;
 156         struct ath_vif *avp;
 157         struct ieee80211_vif *vif;
 158
 159         spin_lock_bh(&sc->chan_lock);
 160
 161         ath_for_each_chanctx(sc, ctx) {
 162                 if (!ctx->active)
 163                         continue;
 164
 165                 list_for_each_entry(avp, &ctx->vifs, list) {
 166                         vif = avp->vif;
 167
 168                         if (ieee80211_vif_type_p2p(vif) == NL80211_IFTYPE_P2P_GO) {
 169                                 spin_unlock_bh(&sc->chan_lock);
 170                                 return ctx;
 171                         }
 172                 }
 173         }
 174
 175         spin_unlock_bh(&sc->chan_lock);
 176         return NULL;
 177 }
 178
 179 /**********************************************************/
 180 /* Functions to handle the channel context state machine. */
 181 /**********************************************************/
 182
 183 static const char *offchannel_state_string(enum ath_offchannel_state state)
 184 {
 185         switch (state) {
 186                 case_rtn_string(ATH_OFFCHANNEL_IDLE);
 187                 case_rtn_string(ATH_OFFCHANNEL_PROBE_SEND);
 188                 case_rtn_string(ATH_OFFCHANNEL_PROBE_WAIT);
 189                 case_rtn_string(ATH_OFFCHANNEL_SUSPEND);
 190                 case_rtn_string(ATH_OFFCHANNEL_ROC_START);
 191                 case_rtn_string(ATH_OFFCHANNEL_ROC_WAIT);
 192                 case_rtn_string(ATH_OFFCHANNEL_ROC_DONE);
 193         default:
 194                 return "unknown";
 195         }
 196 }
 197
 198 static const char *chanctx_event_string(enum ath_chanctx_event ev)
 199 {
 200         switch (ev) {
 201                 case_rtn_string(ATH_CHANCTX_EVENT_BEACON_PREPARE);
 202                 case_rtn_string(ATH_CHANCTX_EVENT_BEACON_SENT);
 203                 case_rtn_string(ATH_CHANCTX_EVENT_TSF_TIMER);
 204                 case_rtn_string(ATH_CHANCTX_EVENT_BEACON_RECEIVED);
 205                 case_rtn_string(ATH_CHANCTX_EVENT_AUTHORIZED);
 206                 case_rtn_string(ATH_CHANCTX_EVENT_SWITCH);
 207                 case_rtn_string(ATH_CHANCTX_EVENT_ASSIGN);
 208                 case_rtn_string(ATH_CHANCTX_EVENT_UNASSIGN);
 209                 case_rtn_string(ATH_CHANCTX_EVENT_CHANGE);
 210                 case_rtn_string(ATH_CHANCTX_EVENT_ENABLE_MULTICHANNEL);
 211         default:
 212                 return "unknown";
 213         }
 214 }
 215
 216 static const char *chanctx_state_string(enum ath_chanctx_state state)
 217 {
 218         switch (state) {
 219                 case_rtn_string(ATH_CHANCTX_STATE_IDLE);
 220                 case_rtn_string(ATH_CHANCTX_STATE_WAIT_FOR_BEACON);
 221                 case_rtn_string(ATH_CHANCTX_STATE_WAIT_FOR_TIMER);
 222                 case_rtn_string(ATH_CHANCTX_STATE_SWITCH);
 223                 case_rtn_string(ATH_CHANCTX_STATE_FORCE_ACTIVE);
 224         default:
 225                 return "unknown";
 226         }
 227 }
 228
 229 static u32 chanctx_event_delta(struct ath_softc *sc)
 230 {
 231         u64 ms;
 232         struct timespec ts, *old;
 233
 234         getrawmonotonic(&ts);
 235         old = &sc->last_event_time;
 236         ms = ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
 237         ms -= old->tv_sec * 1000 + old->tv_nsec / 1000000;
 238         sc->last_event_time = ts;
 239
 240         return (u32)ms;
 241 }
 242
 243 void ath_chanctx_check_active(struct ath_softc *sc, struct ath_chanctx *ctx)
 244 {
 245         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 246         struct ath_chanctx *ictx;
 247         struct ath_vif *avp;
 248         bool active = false;
 249         u8 n_active = 0;
 250
 251         if (!ctx)
 252                 return;
 253
 254         if (ctx == &sc->offchannel.chan) {
 255                 spin_lock_bh(&sc->chan_lock);
 256
 257                 if (likely(sc->sched.channel_switch_time))
 258                         ctx->flush_timeout =
 259                                 usecs_to_jiffies(sc->sched.channel_switch_time);
 260                 else
 261                         ctx->flush_timeout =
 262                                 msecs_to_jiffies(10);
 263
 264                 spin_unlock_bh(&sc->chan_lock);
 265
 266                 /*
 267                  * There is no need to iterate over the
 268                  * active/assigned channel contexts if
 269                  * the current context is offchannel.
 270                  */
 271                 return;
 272         }
 273
 274         ictx = ctx;
 275
 276         list_for_each_entry(avp, &ctx->vifs, list) {
 277                 struct ieee80211_vif *vif = avp->vif;
 278
 279                 switch (vif->type) {
 280                 case NL80211_IFTYPE_P2P_CLIENT:
 281                 case NL80211_IFTYPE_STATION:
 282                         if (avp->assoc)
 283                                 active = true;
 284                         break;
 285                 default:
 286                         active = true;
 287                         break;
 288                 }
 289         }
 290         ctx->active = active;
 291
 292         ath_for_each_chanctx(sc, ctx) {
 293                 if (!ctx->assigned || list_empty(&ctx->vifs))
 294                         continue;
 295                 n_active++;
 296         }
 297
 298         spin_lock_bh(&sc->chan_lock);
 299
 300         if (n_active <= 1) {
 301                 ictx->flush_timeout = HZ / 5;
 302                 clear_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags);
 303                 spin_unlock_bh(&sc->chan_lock);
 304                 return;
 305         }
 306
 307         ictx->flush_timeout = usecs_to_jiffies(sc->sched.channel_switch_time);
 308
 309         if (test_and_set_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags)) {
 310                 spin_unlock_bh(&sc->chan_lock);
 311                 return;
 312         }
 313
 314         spin_unlock_bh(&sc->chan_lock);
 315
 316         if (ath9k_is_chanctx_enabled()) {
 317                 ath_chanctx_event(sc, NULL,
 318                                   ATH_CHANCTX_EVENT_ENABLE_MULTICHANNEL);
 319         }
 320 }
 321
 322 static struct ath_chanctx *
 323 ath_chanctx_get_next(struct ath_softc *sc, struct ath_chanctx *ctx)
 324 {
 325         int idx = ctx - &sc->chanctx[0];
 326
 327         return &sc->chanctx[!idx];
 328 }
 329
 330 static void ath_chanctx_adjust_tbtt_delta(struct ath_softc *sc)
 331 {
 332         struct ath_chanctx *prev, *cur;
 333         struct timespec ts;
 334         u32 cur_tsf, prev_tsf, beacon_int;
 335         s32 offset;
 336
 337         beacon_int = TU_TO_USEC(sc->cur_chan->beacon.beacon_interval);
 338
 339         cur = sc->cur_chan;
 340         prev = ath_chanctx_get_next(sc, cur);
 341
 342         if (!prev->switch_after_beacon)
 343                 return;
 344
 345         getrawmonotonic(&ts);
 346         cur_tsf = (u32) cur->tsf_val +
 347                   ath9k_hw_get_tsf_offset(&cur->tsf_ts, &ts);
 348
 349         prev_tsf = prev->last_beacon - (u32) prev->tsf_val + cur_tsf;
 350         prev_tsf -= ath9k_hw_get_tsf_offset(&prev->tsf_ts, &ts);
 351
 352         /* Adjust the TSF time of the AP chanctx to keep its beacons
 353          * at half beacon interval offset relative to the STA chanctx.
 354          */
 355         offset = cur_tsf - prev_tsf;
 356
 357         /* Ignore stale data or spurious timestamps */
 358         if (offset < 0 || offset > 3 * beacon_int)
 359                 return;
 360
 361         offset = beacon_int / 2 - (offset % beacon_int);
 362         prev->tsf_val += offset;
 363 }
 364
 365 /* Configure the TSF based hardware timer for a channel switch.
 366  * Also set up backup software timer, in case the gen timer fails.
 367  * This could be caused by a hardware reset.
 368  */
 369 static void ath_chanctx_setup_timer(struct ath_softc *sc, u32 tsf_time)
 370 {
 371         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 372         struct ath_hw *ah = sc->sc_ah;
 373         unsigned long timeout;
 374
 375         ath9k_hw_gen_timer_start(ah, sc->p2p_ps_timer, tsf_time, 1000000);
 376         tsf_time -= ath9k_hw_gettsf32(ah);
 377         timeout = msecs_to_jiffies(tsf_time / 1000) + 1;
 378         mod_timer(&sc->sched.timer, jiffies + timeout);
 379
 380         ath_dbg(common, CHAN_CTX,
 381                 "Setup chanctx timer with timeout: %d (%d) ms\n",
 382                 tsf_time / 1000, jiffies_to_msecs(timeout));
 383 }
 384
 385 static void ath_chanctx_handle_bmiss(struct ath_softc *sc,
 386                                      struct ath_chanctx *ctx,
 387                                      struct ath_vif *avp)
 388 {
 389         /*
 390          * Clear the extend_absence flag if it had been
 391          * set during the previous beacon transmission,
 392          * since we need to revert to the normal NoA
 393          * schedule.
 394          */
 395         if (ctx->active && sc->sched.extend_absence) {
 396                 avp->noa_duration = 0;
 397                 sc->sched.extend_absence = false;
 398         }
 399
 400         /* If at least two consecutive beacons were missed on the STA
 401          * chanctx, stay on the STA channel for one extra beacon period,
 402          * to resync the timer properly.
 403          */
 404         if (ctx->active && sc->sched.beacon_miss >= 2) {
 405                 avp->noa_duration = 0;
 406                 sc->sched.extend_absence = true;
 407         }
 408 }
 409
 410 static void ath_chanctx_offchannel_noa(struct ath_softc *sc,
 411                                        struct ath_chanctx *ctx,
 412                                        struct ath_vif *avp,
 413                                        u32 tsf_time)
 414 {
 415         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 416
 417         avp->noa_index++;
 418         avp->offchannel_start = tsf_time;
 419         avp->offchannel_duration = sc->sched.offchannel_duration;
 420
 421         ath_dbg(common, CHAN_CTX,
 422                 "offchannel noa_duration: %d, noa_start: %u, noa_index: %d\n",
 423                 avp->offchannel_duration,
 424                 avp->offchannel_start,
 425                 avp->noa_index);
 426
 427         /*
 428          * When multiple contexts are active, the NoA
 429          * has to be recalculated and advertised after
 430          * an offchannel operation.
 431          */
 432         if (ctx->active && avp->noa_duration)
 433                 avp->noa_duration = 0;
 434 }
 435
 436 static void ath_chanctx_set_periodic_noa(struct ath_softc *sc,
 437                                          struct ath_vif *avp,
 438                                          struct ath_beacon_config *cur_conf,
 439                                          u32 tsf_time,
 440                                          u32 beacon_int)
 441 {
 442         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 443
 444         avp->noa_index++;
 445         avp->noa_start = tsf_time;
 446
 447         if (sc->sched.extend_absence)
 448                 avp->noa_duration = (3 * beacon_int / 2) +
 449                         sc->sched.channel_switch_time;
 450         else
 451                 avp->noa_duration =
 452                         TU_TO_USEC(cur_conf->beacon_interval) / 2 +
 453                         sc->sched.channel_switch_time;
 454
 455         if (test_bit(ATH_OP_SCANNING, &common->op_flags) ||
 456             sc->sched.extend_absence)
 457                 avp->periodic_noa = false;
 458         else
 459                 avp->periodic_noa = true;
 460
 461         ath_dbg(common, CHAN_CTX,
 462                 "noa_duration: %d, noa_start: %u, noa_index: %d, periodic: %d\n",
 463                 avp->noa_duration,
 464                 avp->noa_start,
 465                 avp->noa_index,
 466                 avp->periodic_noa);
 467 }
 468
 469 static void ath_chanctx_set_oneshot_noa(struct ath_softc *sc,
 470                                         struct ath_vif *avp,
 471                                         u32 tsf_time,
 472                                         u32 duration)
 473 {
 474         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 475
 476         avp->noa_index++;
 477         avp->noa_start = tsf_time;
 478         avp->periodic_noa = false;
 479         avp->oneshot_noa = true;
 480         avp->noa_duration = duration + sc->sched.channel_switch_time;
 481
 482         ath_dbg(common, CHAN_CTX,
 483                 "oneshot noa_duration: %d, noa_start: %u, noa_index: %d, periodic: %d\n",
 484                 avp->noa_duration,
 485                 avp->noa_start,
 486                 avp->noa_index,
 487                 avp->periodic_noa);
 488 }
 489
 490 void ath_chanctx_event(struct ath_softc *sc, struct ieee80211_vif *vif,
 491                        enum ath_chanctx_event ev)
 492 {
 493         struct ath_hw *ah = sc->sc_ah;
 494         struct ath_common *common = ath9k_hw_common(ah);
 495         struct ath_beacon_config *cur_conf;
 496         struct ath_vif *avp = NULL;
 497         struct ath_chanctx *ctx;
 498         u32 tsf_time;
 499         u32 beacon_int;
 500
 501         if (vif)
 502                 avp = (struct ath_vif *) vif->drv_priv;
 503
 504         spin_lock_bh(&sc->chan_lock);
 505
 506         ath_dbg(common, CHAN_CTX, "cur_chan: %d MHz, event: %s, state: %s, delta: %u ms\n",
 507                 sc->cur_chan->chandef.center_freq1,
 508                 chanctx_event_string(ev),
 509                 chanctx_state_string(sc->sched.state),
 510                 chanctx_event_delta(sc));
 511
 512         switch (ev) {
 513         case ATH_CHANCTX_EVENT_BEACON_PREPARE:
 514                 if (avp->offchannel_duration)
 515                         avp->offchannel_duration = 0;
 516
 517                 if (avp->oneshot_noa) {
 518                         avp->noa_duration = 0;
 519                         avp->oneshot_noa = false;
 520
 521                         ath_dbg(common, CHAN_CTX,
 522                                 "Clearing oneshot NoA\n");
 523                 }
 524
 525                 if (avp->chanctx != sc->cur_chan) {
 526                         ath_dbg(common, CHAN_CTX,
 527                                 "Contexts differ, not preparing beacon\n");
 528                         break;
 529                 }
 530
 531                 if (sc->sched.offchannel_pending && !sc->sched.wait_switch) {
 532                         sc->sched.offchannel_pending = false;
 533                         sc->next_chan = &sc->offchannel.chan;
 534                         sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;
 535                         ath_dbg(common, CHAN_CTX,
 536                                 "Setting offchannel_pending to false\n");
 537                 }
 538
 539                 ctx = ath_chanctx_get_next(sc, sc->cur_chan);
 540                 if (ctx->active && sc->sched.state == ATH_CHANCTX_STATE_IDLE) {
 541                         sc->next_chan = ctx;
 542                         sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;
 543                         ath_dbg(common, CHAN_CTX,
 544                                 "Set next context, move chanctx state to WAIT_FOR_BEACON\n");
 545                 }
 546
 547                 /* if the timer missed its window, use the next interval */
 548                 if (sc->sched.state == ATH_CHANCTX_STATE_WAIT_FOR_TIMER) {
 549                         sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;
 550                         ath_dbg(common, CHAN_CTX,
 551                                 "Move chanctx state from WAIT_FOR_TIMER to WAIT_FOR_BEACON\n");
 552                 }
 553
 554                 if (sc->sched.mgd_prepare_tx)
 555                         sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;
 556
 557                 /*
 558                  * When a context becomes inactive, for example,
 559                  * disassociation of a station context, the NoA
 560                  * attribute needs to be removed from subsequent
 561                  * beacons.
 562                  */
 563                 if (!ctx->active && avp->noa_duration &&
 564                     sc->sched.state != ATH_CHANCTX_STATE_WAIT_FOR_BEACON) {
 565                         avp->noa_duration = 0;
 566                         avp->periodic_noa = false;
 567
 568                         ath_dbg(common, CHAN_CTX,
 569                                 "Clearing NoA schedule\n");
 570                 }
 571
 572                 if (sc->sched.state != ATH_CHANCTX_STATE_WAIT_FOR_BEACON)
 573                         break;
 574
 575                 ath_dbg(common, CHAN_CTX, "Preparing beacon for vif: %pM\n", vif->addr);
 576
 577                 sc->sched.beacon_pending = true;
 578                 sc->sched.next_tbtt = REG_READ(ah, AR_NEXT_TBTT_TIMER);
 579
 580                 cur_conf = &sc->cur_chan->beacon;
 581                 beacon_int = TU_TO_USEC(cur_conf->beacon_interval);
 582
 583                 /* defer channel switch by a quarter beacon interval */
 584                 tsf_time = sc->sched.next_tbtt + beacon_int / 4;
 585                 sc->sched.switch_start_time = tsf_time;
 586                 sc->cur_chan->last_beacon = sc->sched.next_tbtt;
 587
 588                 /*
 589                  * If an offchannel switch is scheduled to happen after
 590                  * a beacon transmission, update the NoA with one-shot
 591                  * values and increment the index.
 592                  */
 593                 if (sc->next_chan == &sc->offchannel.chan) {
 594                         ath_chanctx_offchannel_noa(sc, ctx, avp, tsf_time);
 595                         break;
 596                 }
 597
 598                 ath_chanctx_handle_bmiss(sc, ctx, avp);
 599
 600                 /*
 601                  * If a mgd_prepare_tx() has been called by mac80211,
 602                  * a one-shot NoA needs to be sent. This can happen
 603                  * with one or more active channel contexts - in both
 604                  * cases, a new NoA schedule has to be advertised.
 605                  */
 606                 if (sc->sched.mgd_prepare_tx) {
 607                         ath_chanctx_set_oneshot_noa(sc, avp, tsf_time,
 608                                                     jiffies_to_usecs(HZ / 5));
 609                         break;
 610                 }
 611
 612                 /* Prevent wrap-around issues */
 613                 if (avp->noa_duration && tsf_time - avp->noa_start > BIT(30))
 614                         avp->noa_duration = 0;
 615
 616                 /*
 617                  * If multiple contexts are active, start periodic
 618                  * NoA and increment the index for the first
 619                  * announcement.
 620                  */
 621                 if (ctx->active &&
 622                     (!avp->noa_duration || sc->sched.force_noa_update))
 623                         ath_chanctx_set_periodic_noa(sc, avp, cur_conf,
 624                                                      tsf_time, beacon_int);
 625
 626                 if (ctx->active && sc->sched.force_noa_update)
 627                         sc->sched.force_noa_update = false;
 628
 629                 break;
 630         case ATH_CHANCTX_EVENT_BEACON_SENT:
 631                 if (!sc->sched.beacon_pending) {
 632                         ath_dbg(common, CHAN_CTX,
 633                                 "No pending beacon\n");
 634                         break;
 635                 }
 636
 637                 sc->sched.beacon_pending = false;
 638
 639                 if (sc->sched.mgd_prepare_tx) {
 640                         sc->sched.mgd_prepare_tx = false;
 641                         complete(&sc->go_beacon);
 642                         ath_dbg(common, CHAN_CTX,
 643                                 "Beacon sent, complete go_beacon\n");
 644                         break;
 645                 }
 646
 647                 if (sc->sched.state != ATH_CHANCTX_STATE_WAIT_FOR_BEACON)
 648                         break;
 649
 650                 ath_dbg(common, CHAN_CTX,
 651                         "Move chanctx state to WAIT_FOR_TIMER\n");
 652
 653                 sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_TIMER;
 654                 ath_chanctx_setup_timer(sc, sc->sched.switch_start_time);
 655                 break;
 656         case ATH_CHANCTX_EVENT_TSF_TIMER:
 657                 if (sc->sched.state != ATH_CHANCTX_STATE_WAIT_FOR_TIMER)
 658                         break;
 659
 660                 if (!sc->cur_chan->switch_after_beacon &&
 661                     sc->sched.beacon_pending)
 662                         sc->sched.beacon_miss++;
 663
 664                 ath_dbg(common, CHAN_CTX,
 665                         "Move chanctx state to SWITCH\n");
 666
 667                 sc->sched.state = ATH_CHANCTX_STATE_SWITCH;
 668                 ieee80211_queue_work(sc->hw, &sc->chanctx_work);
 669                 break;
 670         case ATH_CHANCTX_EVENT_BEACON_RECEIVED:
 671                 if (!test_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags) ||
 672                     sc->cur_chan == &sc->offchannel.chan)
 673                         break;
 674
 675                 sc->sched.beacon_pending = false;
 676                 sc->sched.beacon_miss = 0;
 677
 678                 if (sc->sched.state == ATH_CHANCTX_STATE_FORCE_ACTIVE ||
 679                     !sc->sched.beacon_adjust ||
 680                     !sc->cur_chan->tsf_val)
 681                         break;
 682
 683                 ath_chanctx_adjust_tbtt_delta(sc);
 684
 685                 /* TSF time might have been updated by the incoming beacon,
 686                  * need update the channel switch timer to reflect the change.
 687                  */
 688                 tsf_time = sc->sched.switch_start_time;
 689                 tsf_time -= (u32) sc->cur_chan->tsf_val +
 690                         ath9k_hw_get_tsf_offset(&sc->cur_chan->tsf_ts, NULL);
 691                 tsf_time += ath9k_hw_gettsf32(ah);
 692
 693                 sc->sched.beacon_adjust = false;
 694                 ath_chanctx_setup_timer(sc, tsf_time);
 695                 break;
 696         case ATH_CHANCTX_EVENT_AUTHORIZED:
 697                 if (sc->sched.state != ATH_CHANCTX_STATE_FORCE_ACTIVE ||
 698                     avp->chanctx != sc->cur_chan)
 699                         break;
 700
 701                 ath_dbg(common, CHAN_CTX,
 702                         "Move chanctx state from FORCE_ACTIVE to IDLE\n");
 703
 704                 sc->sched.state = ATH_CHANCTX_STATE_IDLE;
 705                 /* fall through */
 706         case ATH_CHANCTX_EVENT_SWITCH:
 707                 if (!test_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags) ||
 708                     sc->sched.state == ATH_CHANCTX_STATE_FORCE_ACTIVE ||
 709                     sc->cur_chan->switch_after_beacon ||
 710                     sc->cur_chan == &sc->offchannel.chan)
 711                         break;
 712
 713                 /* If this is a station chanctx, stay active for a half
 714                  * beacon period (minus channel switch time)
 715                  */
 716                 sc->next_chan = ath_chanctx_get_next(sc, sc->cur_chan);
 717                 cur_conf = &sc->cur_chan->beacon;
 718
 719                 ath_dbg(common, CHAN_CTX,
 720                         "Move chanctx state to WAIT_FOR_TIMER (event SWITCH)\n");
 721
 722                 sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_TIMER;
 723                 sc->sched.wait_switch = false;
 724
 725                 tsf_time = TU_TO_USEC(cur_conf->beacon_interval) / 2;
 726
 727                 if (sc->sched.extend_absence) {
 728                         sc->sched.beacon_miss = 0;
 729                         tsf_time *= 3;
 730                 }
 731
 732                 tsf_time -= sc->sched.channel_switch_time;
 733                 tsf_time += ath9k_hw_gettsf32(sc->sc_ah);
 734                 sc->sched.switch_start_time = tsf_time;
 735
 736                 ath_chanctx_setup_timer(sc, tsf_time);
 737                 sc->sched.beacon_pending = true;
 738                 sc->sched.beacon_adjust = true;
 739                 break;
 740         case ATH_CHANCTX_EVENT_ENABLE_MULTICHANNEL:
 741                 if (sc->cur_chan == &sc->offchannel.chan ||
 742                     sc->cur_chan->switch_after_beacon)
 743                         break;
 744
 745                 sc->next_chan = ath_chanctx_get_next(sc, sc->cur_chan);
 746                 ieee80211_queue_work(sc->hw, &sc->chanctx_work);
 747                 break;
 748         case ATH_CHANCTX_EVENT_UNASSIGN:
 749                 if (sc->cur_chan->assigned) {
 750                         if (sc->next_chan && !sc->next_chan->assigned &&
 751                             sc->next_chan != &sc->offchannel.chan)
 752                                 sc->sched.state = ATH_CHANCTX_STATE_IDLE;
 753                         break;
 754                 }
 755
 756                 ctx = ath_chanctx_get_next(sc, sc->cur_chan);
 757                 sc->sched.state = ATH_CHANCTX_STATE_IDLE;
 758                 if (!ctx->assigned)
 759                         break;
 760
 761                 sc->next_chan = ctx;
 762                 ieee80211_queue_work(sc->hw, &sc->chanctx_work);
 763                 break;
 764         case ATH_CHANCTX_EVENT_ASSIGN:
 765                 break;
 766         case ATH_CHANCTX_EVENT_CHANGE:
 767                 break;
 768         }
 769
 770         spin_unlock_bh(&sc->chan_lock);
 771 }
 772
 773 void ath_chanctx_beacon_sent_ev(struct ath_softc *sc,
 774                                 enum ath_chanctx_event ev)
 775 {
 776         if (sc->sched.beacon_pending)
 777                 ath_chanctx_event(sc, NULL, ev);
 778 }
 779
 780 void ath_chanctx_beacon_recv_ev(struct ath_softc *sc,
 781                                 enum ath_chanctx_event ev)
 782 {
 783         ath_chanctx_event(sc, NULL, ev);
 784 }
 785
 786 static int ath_scan_channel_duration(struct ath_softc *sc,
 787                                      struct ieee80211_channel *chan)
 788 {
 789         struct cfg80211_scan_request *req = sc->offchannel.scan_req;
 790
 791         if (!req->n_ssids || (chan->flags & IEEE80211_CHAN_NO_IR))
 792                 return (HZ / 9); /* ~110 ms */
 793
 794         return (HZ / 16); /* ~60 ms */
 795 }
 796
 797 static void ath_chanctx_switch(struct ath_softc *sc, struct ath_chanctx *ctx,
 798                                struct cfg80211_chan_def *chandef)
 799 {
 800         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 801
 802         spin_lock_bh(&sc->chan_lock);
 803
 804         if (test_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags) &&
 805             (sc->cur_chan != ctx) && (ctx == &sc->offchannel.chan)) {
 806                 if (chandef)
 807                         ctx->chandef = *chandef;
 808
 809                 sc->sched.offchannel_pending = true;
 810                 sc->sched.wait_switch = true;
 811                 sc->sched.offchannel_duration =
 812                         jiffies_to_usecs(sc->offchannel.duration) +
 813                         sc->sched.channel_switch_time;
 814
 815                 spin_unlock_bh(&sc->chan_lock);
 816                 ath_dbg(common, CHAN_CTX,
 817                         "Set offchannel_pending to true\n");
 818                 return;
 819         }
 820
 821         sc->next_chan = ctx;
 822         if (chandef) {
 823                 ctx->chandef = *chandef;
 824                 ath_dbg(common, CHAN_CTX,
 825                         "Assigned next_chan to %d MHz\n", chandef->center_freq1);
 826         }
 827
 828         if (sc->next_chan == &sc->offchannel.chan) {
 829                 sc->sched.offchannel_duration =
 830                         jiffies_to_usecs(sc->offchannel.duration) +
 831                         sc->sched.channel_switch_time;
 832
 833                 if (chandef) {
 834                         ath_dbg(common, CHAN_CTX,
 835                                 "Offchannel duration for chan %d MHz : %u\n",
 836                                 chandef->center_freq1,
 837                                 sc->sched.offchannel_duration);
 838                 }
 839         }
 840         spin_unlock_bh(&sc->chan_lock);
 841         ieee80211_queue_work(sc->hw, &sc->chanctx_work);
 842 }
 843
 844 static void ath_chanctx_offchan_switch(struct ath_softc *sc,
 845                                        struct ieee80211_channel *chan)
 846 {
 847         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 848         struct cfg80211_chan_def chandef;
 849
 850         cfg80211_chandef_create(&chandef, chan, NL80211_CHAN_NO_HT);
 851         ath_dbg(common, CHAN_CTX,
 852                 "Channel definition created: %d MHz\n", chandef.center_freq1);
 853
 854         ath_chanctx_switch(sc, &sc->offchannel.chan, &chandef);
 855 }
 856
 857 static struct ath_chanctx *ath_chanctx_get_oper_chan(struct ath_softc *sc,
 858                                                      bool active)
 859 {
 860         struct ath_chanctx *ctx;
 861
 862         ath_for_each_chanctx(sc, ctx) {
 863                 if (!ctx->assigned || list_empty(&ctx->vifs))
 864                         continue;
 865                 if (active && !ctx->active)
 866                         continue;
 867
 868                 if (ctx->switch_after_beacon)
 869                         return ctx;
 870         }
 871
 872         return &sc->chanctx[0];
 873 }
 874
 875 static void
 876 ath_scan_next_channel(struct ath_softc *sc)
 877 {
 878         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 879         struct cfg80211_scan_request *req = sc->offchannel.scan_req;
 880         struct ieee80211_channel *chan;
 881
 882         if (sc->offchannel.scan_idx >= req->n_channels) {
 883                 ath_dbg(common, CHAN_CTX,
 884                         "Moving offchannel state to ATH_OFFCHANNEL_IDLE, "
 885                         "scan_idx: %d, n_channels: %d\n",
 886                         sc->offchannel.scan_idx,
 887                         req->n_channels);
 888
 889                 sc->offchannel.state = ATH_OFFCHANNEL_IDLE;
 890                 ath_chanctx_switch(sc, ath_chanctx_get_oper_chan(sc, false),
 891                                    NULL);
 892                 return;
 893         }
 894
 895         ath_dbg(common, CHAN_CTX,
 896                 "Moving offchannel state to ATH_OFFCHANNEL_PROBE_SEND, scan_idx: %d\n",
 897                 sc->offchannel.scan_idx);
 898
 899         chan = req->channels[sc->offchannel.scan_idx++];
 900         sc->offchannel.duration = ath_scan_channel_duration(sc, chan);
 901         sc->offchannel.state = ATH_OFFCHANNEL_PROBE_SEND;
 902
 903         ath_chanctx_offchan_switch(sc, chan);
 904 }
 905
 906 void ath_offchannel_next(struct ath_softc *sc)
 907 {
 908         struct ieee80211_vif *vif;
 909
 910         if (sc->offchannel.scan_req) {
 911                 vif = sc->offchannel.scan_vif;
 912                 sc->offchannel.chan.txpower = vif->bss_conf.txpower;
 913                 ath_scan_next_channel(sc);
 914         } else if (sc->offchannel.roc_vif) {
 915                 vif = sc->offchannel.roc_vif;
 916                 sc->offchannel.chan.txpower = vif->bss_conf.txpower;
 917                 sc->offchannel.duration =
 918                         msecs_to_jiffies(sc->offchannel.roc_duration);
 919                 sc->offchannel.state = ATH_OFFCHANNEL_ROC_START;
 920                 ath_chanctx_offchan_switch(sc, sc->offchannel.roc_chan);
 921         } else {
 922                 spin_lock_bh(&sc->chan_lock);
 923                 sc->sched.offchannel_pending = false;
 924                 sc->sched.wait_switch = false;
 925                 spin_unlock_bh(&sc->chan_lock);
 926
 927                 ath_chanctx_switch(sc, ath_chanctx_get_oper_chan(sc, false),
 928                                    NULL);
 929                 sc->offchannel.state = ATH_OFFCHANNEL_IDLE;
 930                 if (sc->ps_idle)
 931                         ath_cancel_work(sc);
 932         }
 933 }
 934
 935 void ath_roc_complete(struct ath_softc *sc, enum ath_roc_complete_reason reason)
 936 {
 937         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 938
 939         sc->offchannel.roc_vif = NULL;
 940         sc->offchannel.roc_chan = NULL;
 941
 942         switch (reason) {
 943         case ATH_ROC_COMPLETE_ABORT:
 944                 ath_dbg(common, CHAN_CTX, "RoC aborted\n");
 945                 ieee80211_remain_on_channel_expired(sc->hw);
 946                 break;
 947         case ATH_ROC_COMPLETE_EXPIRE:
 948                 ath_dbg(common, CHAN_CTX, "RoC expired\n");
 949                 ieee80211_remain_on_channel_expired(sc->hw);
 950                 break;
 951         case ATH_ROC_COMPLETE_CANCEL:
 952                 ath_dbg(common, CHAN_CTX, "RoC canceled\n");
 953                 break;
 954         }
 955
 956         ath_offchannel_next(sc);
 957         ath9k_ps_restore(sc);
 958 }
 959
 960 void ath_scan_complete(struct ath_softc *sc, bool abort)
 961 {
 962         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 963         struct cfg80211_scan_info info = {
 964                 .aborted = abort,
 965         };
 966
 967         if (abort)
 968                 ath_dbg(common, CHAN_CTX, "HW scan aborted\n");
 969         else
 970                 ath_dbg(common, CHAN_CTX, "HW scan complete\n");
 971
 972         sc->offchannel.scan_req = NULL;
 973         sc->offchannel.scan_vif = NULL;
 974         sc->offchannel.state = ATH_OFFCHANNEL_IDLE;
 975         ieee80211_scan_completed(sc->hw, &info);
 976         clear_bit(ATH_OP_SCANNING, &common->op_flags);
 977         spin_lock_bh(&sc->chan_lock);
 978         if (test_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags))
 979                 sc->sched.force_noa_update = true;
 980         spin_unlock_bh(&sc->chan_lock);
 981         ath_offchannel_next(sc);
 982         ath9k_ps_restore(sc);
 983 }
 984
 985 static void ath_scan_send_probe(struct ath_softc *sc,
 986                                 struct cfg80211_ssid *ssid)
 987 {
 988         struct cfg80211_scan_request *req = sc->offchannel.scan_req;
 989         struct ieee80211_vif *vif = sc->offchannel.scan_vif;
 990         struct ath_tx_control txctl = {};
 991         struct sk_buff *skb;
 992         struct ieee80211_tx_info *info;
 993         int band = sc->offchannel.chan.chandef.chan->band;
 994
 995         skb = ieee80211_probereq_get(sc->hw, vif->addr,
 996                         ssid->ssid, ssid->ssid_len, req->ie_len);
 997         if (!skb)
 998                 return;
 999
1000         info = IEEE80211_SKB_CB(skb);
1001         if (req->no_cck)
1002                 info->flags |= IEEE80211_TX_CTL_NO_CCK_RATE;
1003
1004         if (req->ie_len)
1005                 memcpy(skb_put(skb, req->ie_len), req->ie, req->ie_len);
1006
1007         skb_set_queue_mapping(skb, IEEE80211_AC_VO);
1008
1009         if (!ieee80211_tx_prepare_skb(sc->hw, vif, skb, band, NULL))
1010                 goto error;
1011
1012         txctl.txq = sc->tx.txq_map[IEEE80211_AC_VO];
1013         txctl.force_channel = true;
1014         if (ath_tx_start(sc->hw, skb, &txctl))
1015                 goto error;
1016
1017         return;
1018
1019 error:
1020         ieee80211_free_txskb(sc->hw, skb);
1021 }
1022
1023 static void ath_scan_channel_start(struct ath_softc *sc)
1024 {
1025         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1026         struct cfg80211_scan_request *req = sc->offchannel.scan_req;
1027         int i;
1028
1029         if (!(sc->cur_chan->chandef.chan->flags & IEEE80211_CHAN_NO_IR) &&
1030             req->n_ssids) {
1031                 for (i = 0; i < req->n_ssids; i++)
1032                         ath_scan_send_probe(sc, &req->ssids[i]);
1033
1034         }
1035
1036         ath_dbg(common, CHAN_CTX,
1037                 "Moving offchannel state to ATH_OFFCHANNEL_PROBE_WAIT\n");
1038
1039         sc->offchannel.state = ATH_OFFCHANNEL_PROBE_WAIT;
1040         mod_timer(&sc->offchannel.timer, jiffies + sc->offchannel.duration);
1041 }
1042
1043 static void ath_chanctx_timer(unsigned long data)
1044 {
1045         struct ath_softc *sc = (struct ath_softc *) data;
1046         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1047
1048         ath_dbg(common, CHAN_CTX,
1049                 "Channel context timer invoked\n");
1050
1051         ath_chanctx_event(sc, NULL, ATH_CHANCTX_EVENT_TSF_TIMER);
1052 }
1053
1054 static void ath_offchannel_timer(unsigned long data)
1055 {
1056         struct ath_softc *sc = (struct ath_softc *)data;
1057         struct ath_chanctx *ctx;
1058         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1059
1060         ath_dbg(common, CHAN_CTX, "%s: offchannel state: %s\n",
1061                 __func__, offchannel_state_string(sc->offchannel.state));
1062
1063         switch (sc->offchannel.state) {
1064         case ATH_OFFCHANNEL_PROBE_WAIT:
1065                 if (!sc->offchannel.scan_req)
1066                         return;
1067
1068                 /* get first active channel context */
1069                 ctx = ath_chanctx_get_oper_chan(sc, true);
1070                 if (ctx->active) {
1071                         ath_dbg(common, CHAN_CTX,
1072                                 "Switch to oper/active context, "
1073                                 "move offchannel state to ATH_OFFCHANNEL_SUSPEND\n");
1074
1075                         sc->offchannel.state = ATH_OFFCHANNEL_SUSPEND;
1076                         ath_chanctx_switch(sc, ctx, NULL);
1077                         mod_timer(&sc->offchannel.timer, jiffies + HZ / 10);
1078                         break;
1079                 }
1080                 /* fall through */
1081         case ATH_OFFCHANNEL_SUSPEND:
1082                 if (!sc->offchannel.scan_req)
1083                         return;
1084
1085                 ath_scan_next_channel(sc);
1086                 break;
1087         case ATH_OFFCHANNEL_ROC_START:
1088         case ATH_OFFCHANNEL_ROC_WAIT:
1089                 sc->offchannel.state = ATH_OFFCHANNEL_ROC_DONE;
1090                 ath_roc_complete(sc, ATH_ROC_COMPLETE_EXPIRE);
1091                 break;
1092         default:
1093                 break;
1094         }
1095 }
1096
1097 static bool
1098 ath_chanctx_send_vif_ps_frame(struct ath_softc *sc, struct ath_vif *avp,
1099                               bool powersave)
1100 {
1101         struct ieee80211_vif *vif = avp->vif;
1102         struct ieee80211_sta *sta = NULL;
1103         struct ieee80211_hdr_3addr *nullfunc;
1104         struct ath_tx_control txctl;
1105         struct sk_buff *skb;
1106         int band = sc->cur_chan->chandef.chan->band;
1107
1108         switch (vif->type) {
1109         case NL80211_IFTYPE_STATION:
1110                 if (!avp->assoc)
1111                         return false;
1112
1113                 skb = ieee80211_nullfunc_get(sc->hw, vif);
1114                 if (!skb)
1115                         return false;
1116
1117                 nullfunc = (struct ieee80211_hdr_3addr *) skb->data;
1118                 if (powersave)
1119                         nullfunc->frame_control |=
1120                                 cpu_to_le16(IEEE80211_FCTL_PM);
1121
1122                 skb->priority = 7;
1123                 skb_set_queue_mapping(skb, IEEE80211_AC_VO);
1124                 if (!ieee80211_tx_prepare_skb(sc->hw, vif, skb, band, &sta)) {
1125                         dev_kfree_skb_any(skb);
1126                         return false;
1127                 }
1128                 break;
1129         default:
1130                 return false;
1131         }
1132
1133         memset(&txctl, 0, sizeof(txctl));
1134         txctl.txq = sc->tx.txq_map[IEEE80211_AC_VO];
1135         txctl.sta = sta;
1136         txctl.force_channel = true;
1137         if (ath_tx_start(sc->hw, skb, &txctl)) {
1138                 ieee80211_free_txskb(sc->hw, skb);
1139                 return false;
1140         }
1141
1142         return true;
1143 }
1144
1145 static bool
1146 ath_chanctx_send_ps_frame(struct ath_softc *sc, bool powersave)
1147 {
1148         struct ath_vif *avp;
1149         bool sent = false;
1150
1151         rcu_read_lock();
1152         list_for_each_entry(avp, &sc->cur_chan->vifs, list) {
1153                 if (ath_chanctx_send_vif_ps_frame(sc, avp, powersave))
1154                         sent = true;
1155         }
1156         rcu_read_unlock();
1157
1158         return sent;
1159 }
1160
1161 static bool ath_chanctx_defer_switch(struct ath_softc *sc)
1162 {
1163         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1164
1165         if (sc->cur_chan == &sc->offchannel.chan)
1166                 return false;
1167
1168         switch (sc->sched.state) {
1169         case ATH_CHANCTX_STATE_SWITCH:
1170                 return false;
1171         case ATH_CHANCTX_STATE_IDLE:
1172                 if (!sc->cur_chan->switch_after_beacon)
1173                         return false;
1174
1175                 ath_dbg(common, CHAN_CTX,
1176                         "Defer switch, set chanctx state to WAIT_FOR_BEACON\n");
1177
1178                 sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;
1179                 break;
1180         default:
1181                 break;
1182         }
1183
1184         return true;
1185 }
1186
1187 static void ath_offchannel_channel_change(struct ath_softc *sc)
1188 {
1189         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1190
1191         ath_dbg(common, CHAN_CTX, "%s: offchannel state: %s\n",
1192                 __func__, offchannel_state_string(sc->offchannel.state));
1193
1194         switch (sc->offchannel.state) {
1195         case ATH_OFFCHANNEL_PROBE_SEND:
1196                 if (!sc->offchannel.scan_req)
1197                         return;
1198
1199                 if (sc->cur_chan->chandef.chan !=
1200                     sc->offchannel.chan.chandef.chan)
1201                         return;
1202
1203                 ath_scan_channel_start(sc);
1204                 break;
1205         case ATH_OFFCHANNEL_IDLE:
1206                 if (!sc->offchannel.scan_req)
1207                         return;
1208
1209                 ath_scan_complete(sc, false);
1210                 break;
1211         case ATH_OFFCHANNEL_ROC_START:
1212                 if (sc->cur_chan != &sc->offchannel.chan)
1213                         break;
1214
1215                 sc->offchannel.state = ATH_OFFCHANNEL_ROC_WAIT;
1216                 mod_timer(&sc->offchannel.timer,
1217                           jiffies + sc->offchannel.duration);
1218                 ieee80211_ready_on_channel(sc->hw);
1219                 break;
1220         case ATH_OFFCHANNEL_ROC_DONE:
1221                 break;
1222         default:
1223                 break;
1224         }
1225 }
1226
1227 void ath_chanctx_set_next(struct ath_softc *sc, bool force)
1228 {
1229         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1230         struct ath_chanctx *old_ctx;
1231         struct timespec ts;
1232         bool measure_time = false;
1233         bool send_ps = false;
1234         bool queues_stopped = false;
1235
1236         spin_lock_bh(&sc->chan_lock);
1237         if (!sc->next_chan) {
1238                 spin_unlock_bh(&sc->chan_lock);
1239                 return;
1240         }
1241
1242         if (!force && ath_chanctx_defer_switch(sc)) {
1243                 spin_unlock_bh(&sc->chan_lock);
1244                 return;
1245         }
1246
1247         ath_dbg(common, CHAN_CTX,
1248                 "%s: current: %d MHz, next: %d MHz\n",
1249                 __func__,
1250                 sc->cur_chan->chandef.center_freq1,
1251                 sc->next_chan->chandef.center_freq1);
1252
1253         if (sc->cur_chan != sc->next_chan) {
1254                 ath_dbg(common, CHAN_CTX,
1255                         "Stopping current chanctx: %d\n",
1256                         sc->cur_chan->chandef.center_freq1);
1257                 sc->cur_chan->stopped = true;
1258                 spin_unlock_bh(&sc->chan_lock);
1259
1260                 if (sc->next_chan == &sc->offchannel.chan) {
1261                         getrawmonotonic(&ts);
1262                         measure_time = true;
1263                 }
1264
1265                 ath9k_chanctx_stop_queues(sc, sc->cur_chan);
1266                 queues_stopped = true;
1267
1268                 __ath9k_flush(sc->hw, ~0, true, false, false);
1269
1270                 if (ath_chanctx_send_ps_frame(sc, true))
1271                         __ath9k_flush(sc->hw, BIT(IEEE80211_AC_VO),
1272                                       false, false, false);
1273
1274                 send_ps = true;
1275                 spin_lock_bh(&sc->chan_lock);
1276
1277                 if (sc->cur_chan != &sc->offchannel.chan) {
1278                         getrawmonotonic(&sc->cur_chan->tsf_ts);
1279                         sc->cur_chan->tsf_val = ath9k_hw_gettsf64(sc->sc_ah);
1280                 }
1281         }
1282         old_ctx = sc->cur_chan;
1283         sc->cur_chan = sc->next_chan;
1284         sc->cur_chan->stopped = false;
1285         sc->next_chan = NULL;
1286
1287         if (!sc->sched.offchannel_pending)
1288                 sc->sched.offchannel_duration = 0;
1289
1290         if (sc->sched.state != ATH_CHANCTX_STATE_FORCE_ACTIVE)
1291                 sc->sched.state = ATH_CHANCTX_STATE_IDLE;
1292
1293         spin_unlock_bh(&sc->chan_lock);
1294
1295         if (sc->sc_ah->chip_fullsleep ||
1296             memcmp(&sc->cur_chandef, &sc->cur_chan->chandef,
1297                    sizeof(sc->cur_chandef))) {
1298                 ath_dbg(common, CHAN_CTX,
1299                         "%s: Set channel %d MHz\n",
1300                         __func__, sc->cur_chan->chandef.center_freq1);
1301                 ath_set_channel(sc);
1302                 if (measure_time)
1303                         sc->sched.channel_switch_time =
1304                                 ath9k_hw_get_tsf_offset(&ts, NULL);
1305                 /*
1306                  * A reset will ensure that all queues are woken up,
1307                  * so there is no need to awaken them again.
1308                  */
1309                 goto out;
1310         }
1311
1312         if (queues_stopped)
1313                 ath9k_chanctx_wake_queues(sc, old_ctx);
1314 out:
1315         if (send_ps)
1316                 ath_chanctx_send_ps_frame(sc, false);
1317
1318         ath_offchannel_channel_change(sc);
1319         ath_chanctx_event(sc, NULL, ATH_CHANCTX_EVENT_SWITCH);
1320 }
1321
1322 static void ath_chanctx_work(struct work_struct *work)
1323 {
1324         struct ath_softc *sc = container_of(work, struct ath_softc,
1325                                             chanctx_work);
1326         mutex_lock(&sc->mutex);
1327         ath_chanctx_set_next(sc, false);
1328         mutex_unlock(&sc->mutex);
1329 }
1330
1331 void ath9k_offchannel_init(struct ath_softc *sc)
1332 {
1333         struct ath_chanctx *ctx;
1334         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1335         struct ieee80211_supported_band *sband;
1336         struct ieee80211_channel *chan;
1337         int i;
1338
1339         sband = &common->sbands[NL80211_BAND_2GHZ];
1340         if (!sband->n_channels)
1341                 sband = &common->sbands[NL80211_BAND_5GHZ];
1342
1343         chan = &sband->channels[0];
1344
1345         ctx = &sc->offchannel.chan;
1346         INIT_LIST_HEAD(&ctx->vifs);
1347         ctx->txpower = ATH_TXPOWER_MAX;
1348         cfg80211_chandef_create(&ctx->chandef, chan, NL80211_CHAN_HT20);
1349
1350         for (i = 0; i < ARRAY_SIZE(ctx->acq); i++)
1351                 INIT_LIST_HEAD(&ctx->acq[i]);
1352
1353         sc->offchannel.chan.offchannel = true;
1354 }
1355
1356 void ath9k_init_channel_context(struct ath_softc *sc)
1357 {
1358         INIT_WORK(&sc->chanctx_work, ath_chanctx_work);
1359
1360         setup_timer(&sc->offchannel.timer, ath_offchannel_timer,
1361                     (unsigned long)sc);
1362         setup_timer(&sc->sched.timer, ath_chanctx_timer,
1363                     (unsigned long)sc);
1364
1365         init_completion(&sc->go_beacon);
1366 }
1367
1368 void ath9k_deinit_channel_context(struct ath_softc *sc)
1369 {
1370         cancel_work_sync(&sc->chanctx_work);
1371 }
1372
1373 bool ath9k_is_chanctx_enabled(void)
1374 {
1375         return (ath9k_use_chanctx == 1);
1376 }
1377
1378 /********************/
1379 /* Queue management */
1380 /********************/
1381
1382 void ath9k_chanctx_stop_queues(struct ath_softc *sc, struct ath_chanctx *ctx)
1383 {
1384         struct ath_hw *ah = sc->sc_ah;
1385         int i;
1386
1387         if (ctx == &sc->offchannel.chan) {
1388                 ieee80211_stop_queue(sc->hw,
1389                                      sc->hw->offchannel_tx_hw_queue);
1390         } else {
1391                 for (i = 0; i < IEEE80211_NUM_ACS; i++)
1392                         ieee80211_stop_queue(sc->hw,
1393                                              ctx->hw_queue_base + i);
1394         }
1395
1396         if (ah->opmode == NL80211_IFTYPE_AP)
1397                 ieee80211_stop_queue(sc->hw, sc->hw->queues - 2);
1398 }
1399
1400
1401 void ath9k_chanctx_wake_queues(struct ath_softc *sc, struct ath_chanctx *ctx)
1402 {
1403         struct ath_hw *ah = sc->sc_ah;
1404         int i;
1405
1406         if (ctx == &sc->offchannel.chan) {
1407                 ieee80211_wake_queue(sc->hw,
1408                                      sc->hw->offchannel_tx_hw_queue);
1409         } else {
1410                 for (i = 0; i < IEEE80211_NUM_ACS; i++)
1411                         ieee80211_wake_queue(sc->hw,
1412                                              ctx->hw_queue_base + i);
1413         }
1414
1415         if (ah->opmode == NL80211_IFTYPE_AP)
1416                 ieee80211_wake_queue(sc->hw, sc->hw->queues - 2);
1417 }
1418
1419 /*****************/
1420 /* P2P Powersave */
1421 /*****************/
1422
1423 static void ath9k_update_p2p_ps_timer(struct ath_softc *sc, struct ath_vif *avp)
1424 {
1425         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1426         struct ath_hw *ah = sc->sc_ah;
1427         u32 tsf, target_tsf;
1428
1429         if (!avp || !avp->noa.has_next_tsf)
1430                 return;
1431
1432         ath9k_hw_gen_timer_stop(ah, sc->p2p_ps_timer);
1433
1434         tsf = ath9k_hw_gettsf32(sc->sc_ah);
1435
1436         target_tsf = avp->noa.next_tsf;
1437         if (!avp->noa.absent)
1438                 target_tsf -= ATH_P2P_PS_STOP_TIME;
1439         else
1440                 target_tsf += ATH_P2P_PS_STOP_TIME;
1441
1442         if (target_tsf - tsf < ATH_P2P_PS_STOP_TIME)
1443                 target_tsf = tsf + ATH_P2P_PS_STOP_TIME;
1444
1445         ath_dbg(common, CHAN_CTX, "%s absent %d tsf 0x%08X next_tsf 0x%08X (%dms)\n",
1446                 __func__, avp->noa.absent, tsf, target_tsf,
1447                 (target_tsf - tsf) / 1000);
1448
1449         ath9k_hw_gen_timer_start(ah, sc->p2p_ps_timer, target_tsf, 1000000);
1450 }
1451
1452 static void ath9k_update_p2p_ps(struct ath_softc *sc, struct ieee80211_vif *vif)
1453 {
1454         struct ath_vif *avp = (void *)vif->drv_priv;
1455         u32 tsf;
1456
1457         if (!sc->p2p_ps_timer)
1458                 return;
1459
1460         if (vif->type != NL80211_IFTYPE_STATION)
1461                 return;
1462
1463         sc->p2p_ps_vif = avp;
1464
1465         if (sc->ps_flags & PS_BEACON_SYNC)
1466                 return;
1467
1468         tsf = ath9k_hw_gettsf32(sc->sc_ah);
1469         ieee80211_parse_p2p_noa(&vif->bss_conf.p2p_noa_attr, &avp->noa, tsf);
1470         ath9k_update_p2p_ps_timer(sc, avp);
1471 }
1472
1473 static u8 ath9k_get_ctwin(struct ath_softc *sc, struct ath_vif *avp)
1474 {
1475         struct ath_beacon_config *cur_conf = &sc->cur_chan->beacon;
1476         u8 switch_time, ctwin;
1477
1478         /*
1479          * Channel switch in multi-channel mode is deferred
1480          * by a quarter beacon interval when handling
1481          * ATH_CHANCTX_EVENT_BEACON_PREPARE, so the P2P-GO
1482          * interface is guaranteed to be discoverable
1483          * for that duration after a TBTT.
1484          */
1485         switch_time = cur_conf->beacon_interval / 4;
1486
1487         ctwin = avp->vif->bss_conf.p2p_noa_attr.oppps_ctwindow;
1488         if (ctwin && (ctwin < switch_time))
1489                 return ctwin;
1490
1491         if (switch_time < P2P_DEFAULT_CTWIN)
1492                 return 0;
1493
1494         return P2P_DEFAULT_CTWIN;
1495 }
1496
1497 void ath9k_beacon_add_noa(struct ath_softc *sc, struct ath_vif *avp,
1498                           struct sk_buff *skb)
1499 {
1500         static const u8 noa_ie_hdr[] = {
1501                 WLAN_EID_VENDOR_SPECIFIC,       /* type */
1502                 0,                              /* length */
1503                 0x50, 0x6f, 0x9a,               /* WFA OUI */
1504                 0x09,                           /* P2P subtype */
1505                 0x0c,                           /* Notice of Absence */
1506                 0x00,                           /* LSB of little-endian len */
1507                 0x00,                           /* MSB of little-endian len */
1508         };
1509
1510         struct ieee80211_p2p_noa_attr *noa;
1511         int noa_len, noa_desc, i = 0;
1512         u8 *hdr;
1513
1514         if (!avp->offchannel_duration && !avp->noa_duration)
1515                 return;
1516
1517         noa_desc = !!avp->offchannel_duration + !!avp->noa_duration;
1518         noa_len = 2 + sizeof(struct ieee80211_p2p_noa_desc) * noa_desc;
1519
1520         hdr = skb_put(skb, sizeof(noa_ie_hdr));
1521         memcpy(hdr, noa_ie_hdr, sizeof(noa_ie_hdr));
1522         hdr[1] = sizeof(noa_ie_hdr) + noa_len - 2;
1523         hdr[7] = noa_len;
1524
1525         noa = (void *) skb_put(skb, noa_len);
1526         memset(noa, 0, noa_len);
1527
1528         noa->index = avp->noa_index;
1529         noa->oppps_ctwindow = ath9k_get_ctwin(sc, avp);
1530         if (noa->oppps_ctwindow)
1531                 noa->oppps_ctwindow |= BIT(7);
1532
1533         if (avp->noa_duration) {
1534                 if (avp->periodic_noa) {
1535                         u32 interval = TU_TO_USEC(sc->cur_chan->beacon.beacon_interval);
1536                         noa->desc[i].count = 255;
1537                         noa->desc[i].interval = cpu_to_le32(interval);
1538                 } else {
1539                         noa->desc[i].count = 1;
1540                 }
1541
1542                 noa->desc[i].start_time = cpu_to_le32(avp->noa_start);
1543                 noa->desc[i].duration = cpu_to_le32(avp->noa_duration);
1544                 i++;
1545         }
1546
1547         if (avp->offchannel_duration) {
1548                 noa->desc[i].count = 1;
1549                 noa->desc[i].start_time = cpu_to_le32(avp->offchannel_start);
1550                 noa->desc[i].duration = cpu_to_le32(avp->offchannel_duration);
1551         }
1552 }
1553
1554 void ath9k_p2p_ps_timer(void *priv)
1555 {
1556         struct ath_softc *sc = priv;
1557         struct ath_vif *avp = sc->p2p_ps_vif;
1558         struct ieee80211_vif *vif;
1559         struct ieee80211_sta *sta;
1560         struct ath_node *an;
1561         u32 tsf;
1562
1563         del_timer_sync(&sc->sched.timer);
1564         ath9k_hw_gen_timer_stop(sc->sc_ah, sc->p2p_ps_timer);
1565         ath_chanctx_event(sc, NULL, ATH_CHANCTX_EVENT_TSF_TIMER);
1566
1567         if (!avp || avp->chanctx != sc->cur_chan)
1568                 return;
1569
1570         tsf = ath9k_hw_gettsf32(sc->sc_ah);
1571         if (!avp->noa.absent)
1572                 tsf += ATH_P2P_PS_STOP_TIME;
1573         else
1574                 tsf -= ATH_P2P_PS_STOP_TIME;
1575
1576         if (!avp->noa.has_next_tsf ||
1577             avp->noa.next_tsf - tsf > BIT(31))
1578                 ieee80211_update_p2p_noa(&avp->noa, tsf);
1579
1580         ath9k_update_p2p_ps_timer(sc, avp);
1581
1582         rcu_read_lock();
1583
1584         vif = avp->vif;
1585         sta = ieee80211_find_sta(vif, avp->bssid);
1586         if (!sta)
1587                 goto out;
1588
1589         an = (void *) sta->drv_priv;
1590         if (an->sleeping == !!avp->noa.absent)
1591                 goto out;
1592
1593         an->sleeping = avp->noa.absent;
1594         if (an->sleeping)
1595                 ath_tx_aggr_sleep(sta, sc, an);
1596         else
1597                 ath_tx_aggr_wakeup(sc, an);
1598
1599 out:
1600         rcu_read_unlock();
1601 }
1602
1603 void ath9k_p2p_bss_info_changed(struct ath_softc *sc,
1604                                 struct ieee80211_vif *vif)
1605 {
1606         unsigned long flags;
1607
1608         spin_lock_bh(&sc->sc_pcu_lock);
1609         spin_lock_irqsave(&sc->sc_pm_lock, flags);
1610         ath9k_update_p2p_ps(sc, vif);
1611         spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
1612         spin_unlock_bh(&sc->sc_pcu_lock);
1613 }
1614
1615 void ath9k_p2p_beacon_sync(struct ath_softc *sc)
1616 {
1617         if (sc->p2p_ps_vif)
1618                 ath9k_update_p2p_ps(sc, sc->p2p_ps_vif->vif);
1619 }
1620
1621 void ath9k_p2p_remove_vif(struct ath_softc *sc,
1622                           struct ieee80211_vif *vif)
1623 {
1624         struct ath_vif *avp = (void *)vif->drv_priv;
1625
1626         spin_lock_bh(&sc->sc_pcu_lock);
1627         if (avp == sc->p2p_ps_vif) {
1628                 sc->p2p_ps_vif = NULL;
1629                 ath9k_update_p2p_ps_timer(sc, NULL);
1630         }
1631         spin_unlock_bh(&sc->sc_pcu_lock);
1632 }
1633
1634 int ath9k_init_p2p(struct ath_softc *sc)
1635 {
1636         sc->p2p_ps_timer = ath_gen_timer_alloc(sc->sc_ah, ath9k_p2p_ps_timer,
1637                                                NULL, sc, AR_FIRST_NDP_TIMER);
1638         if (!sc->p2p_ps_timer)
1639                 return -ENOMEM;
1640
1641         return 0;
1642 }
1643
1644 void ath9k_deinit_p2p(struct ath_softc *sc)
1645 {
1646         if (sc->p2p_ps_timer)
1647                 ath_gen_timer_free(sc->sc_ah, sc->p2p_ps_timer);
1648 }
1649
1650 #endif /* CONFIG_ATH9K_CHANNEL_CONTEXT */