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