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