linux/drivers/net/wireless/ath/ath9k/channel.c
<<
>>
Prefs
   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 */
  23static 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
 103void 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
 130void 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
 157struct 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
 187static 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
 202static 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
 220static 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
 233static u32 chanctx_event_delta(struct ath_softc *sc)
 234{
 235        u64 ms;
 236        struct timespec64 ts, *old;
 237
 238        ktime_get_raw_ts64(&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
 247void 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
 326static struct ath_chanctx *
 327ath_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
 334static void ath_chanctx_adjust_tbtt_delta(struct ath_softc *sc)
 335{
 336        struct ath_chanctx *prev, *cur;
 337        struct timespec64 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        ktime_get_raw_ts64(&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 */
 373static 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
 389static 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
 414static 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
 440static 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
 473static 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
 494void 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
 777void 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
 784void 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
 790static 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
 801static 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
 848static 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
 861static 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
 879static void
 880ath_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
 910void 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
 939void 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
 964void 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
 989static 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
1022error:
1023        ieee80211_free_txskb(sc->hw, skb);
1024}
1025
1026static 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
1046static 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
1057static 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
1100static bool
1101ath_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, false);
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
1147static bool
1148ath_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
1163static 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
1189static 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
1229void 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 timespec64 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                        ktime_get_raw_ts64(&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                        ktime_get_raw_ts64(&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);
1316out:
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
1324static 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
1333void 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
1361void 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
1371void ath9k_deinit_channel_context(struct ath_softc *sc)
1372{
1373        cancel_work_sync(&sc->chanctx_work);
1374}
1375
1376bool ath9k_is_chanctx_enabled(void)
1377{
1378        return (ath9k_use_chanctx == 1);
1379}
1380
1381/********************/
1382/* Queue management */
1383/********************/
1384
1385void 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
1404void 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
1426static 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
1455static 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
1476static 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
1500void 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
1555void 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
1600out:
1601        rcu_read_unlock();
1602}
1603
1604void 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
1616void 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
1622void 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
1635int 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
1645void 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 */
1652