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 static const char *offchannel_state_string(enum ath_offchannel_state state)
  20 {
  21 #define case_rtn_string(val) case val: return #val
  22
  23         switch (state) {
  24                 case_rtn_string(ATH_OFFCHANNEL_IDLE);
  25                 case_rtn_string(ATH_OFFCHANNEL_PROBE_SEND);
  26                 case_rtn_string(ATH_OFFCHANNEL_PROBE_WAIT);
  27                 case_rtn_string(ATH_OFFCHANNEL_SUSPEND);
  28                 case_rtn_string(ATH_OFFCHANNEL_ROC_START);
  29                 case_rtn_string(ATH_OFFCHANNEL_ROC_WAIT);
  30                 case_rtn_string(ATH_OFFCHANNEL_ROC_DONE);
  31         default:
  32                 return "unknown";
  33         }
  34 }
  35
  36 /* Set/change channels.  If the channel is really being changed, it's done
  37  * by reseting the chip.  To accomplish this we must first cleanup any pending
  38  * DMA, then restart stuff.
  39  */
  40 static int ath_set_channel(struct ath_softc *sc)
  41 {
  42         struct ath_hw *ah = sc->sc_ah;
  43         struct ath_common *common = ath9k_hw_common(ah);
  44         struct ieee80211_hw *hw = sc->hw;
  45         struct ath9k_channel *hchan;
  46         struct cfg80211_chan_def *chandef = &sc->cur_chan->chandef;
  47         struct ieee80211_channel *chan = chandef->chan;
  48         int pos = chan->hw_value;
  49         int old_pos = -1;
  50         int r;
  51
  52         if (test_bit(ATH_OP_INVALID, &common->op_flags))
  53                 return -EIO;
  54
  55         if (ah->curchan)
  56                 old_pos = ah->curchan - &ah->channels[0];
  57
  58         ath_dbg(common, CONFIG, "Set channel: %d MHz width: %d\n",
  59                 chan->center_freq, chandef->width);
  60
  61         /* update survey stats for the old channel before switching */
  62         spin_lock_bh(&common->cc_lock);
  63         ath_update_survey_stats(sc);
  64         spin_unlock_bh(&common->cc_lock);
  65
  66         ath9k_cmn_get_channel(hw, ah, chandef);
  67
  68         /* If the operating channel changes, change the survey in-use flags
  69          * along with it.
  70          * Reset the survey data for the new channel, unless we're switching
  71          * back to the operating channel from an off-channel operation.
  72          */
  73         if (!sc->cur_chan->offchannel && sc->cur_survey != &sc->survey[pos]) {
  74                 if (sc->cur_survey)
  75                         sc->cur_survey->filled &= ~SURVEY_INFO_IN_USE;
  76
  77                 sc->cur_survey = &sc->survey[pos];
  78
  79                 memset(sc->cur_survey, 0, sizeof(struct survey_info));
  80                 sc->cur_survey->filled |= SURVEY_INFO_IN_USE;
  81         } else if (!(sc->survey[pos].filled & SURVEY_INFO_IN_USE)) {
  82                 memset(&sc->survey[pos], 0, sizeof(struct survey_info));
  83         }
  84
  85         hchan = &sc->sc_ah->channels[pos];
  86         r = ath_reset_internal(sc, hchan);
  87         if (r)
  88                 return r;
  89
  90         /* The most recent snapshot of channel->noisefloor for the old
  91          * channel is only available after the hardware reset. Copy it to
  92          * the survey stats now.
  93          */
  94         if (old_pos >= 0)
  95                 ath_update_survey_nf(sc, old_pos);
  96
  97         /* Enable radar pulse detection if on a DFS channel. Spectral
  98          * scanning and radar detection can not be used concurrently.
  99          */
 100         if (hw->conf.radar_enabled) {
 101                 u32 rxfilter;
 102
 103                 /* set HW specific DFS configuration */
 104                 ath9k_hw_set_radar_params(ah);
 105                 rxfilter = ath9k_hw_getrxfilter(ah);
 106                 rxfilter |= ATH9K_RX_FILTER_PHYRADAR |
 107                                 ATH9K_RX_FILTER_PHYERR;
 108                 ath9k_hw_setrxfilter(ah, rxfilter);
 109                 ath_dbg(common, DFS, "DFS enabled at freq %d\n",
 110                         chan->center_freq);
 111         } else {
 112                 /* perform spectral scan if requested. */
 113                 if (test_bit(ATH_OP_SCANNING, &common->op_flags) &&
 114                         sc->spectral_mode == SPECTRAL_CHANSCAN)
 115                         ath9k_spectral_scan_trigger(hw);
 116         }
 117
 118         return 0;
 119 }
 120
 121 static bool
 122 ath_chanctx_send_vif_ps_frame(struct ath_softc *sc, struct ath_vif *avp,
 123                               bool powersave)
 124 {
 125         struct ieee80211_vif *vif = avp->vif;
 126         struct ieee80211_sta *sta = NULL;
 127         struct ieee80211_hdr_3addr *nullfunc;
 128         struct ath_tx_control txctl;
 129         struct sk_buff *skb;
 130         int band = sc->cur_chan->chandef.chan->band;
 131
 132         switch (vif->type) {
 133         case NL80211_IFTYPE_STATION:
 134                 if (!vif->bss_conf.assoc)
 135                         return false;
 136
 137                 skb = ieee80211_nullfunc_get(sc->hw, vif);
 138                 if (!skb)
 139                         return false;
 140
 141                 nullfunc = (struct ieee80211_hdr_3addr *) skb->data;
 142                 if (powersave)
 143                         nullfunc->frame_control |=
 144                                 cpu_to_le16(IEEE80211_FCTL_PM);
 145
 146                 skb_set_queue_mapping(skb, IEEE80211_AC_VO);
 147                 if (!ieee80211_tx_prepare_skb(sc->hw, vif, skb, band, &sta)) {
 148                         dev_kfree_skb_any(skb);
 149                         return false;
 150                 }
 151                 break;
 152         default:
 153                 return false;
 154         }
 155
 156         memset(&txctl, 0, sizeof(txctl));
 157         txctl.txq = sc->tx.txq_map[IEEE80211_AC_VO];
 158         txctl.sta = sta;
 159         txctl.force_channel = true;
 160         if (ath_tx_start(sc->hw, skb, &txctl)) {
 161                 ieee80211_free_txskb(sc->hw, skb);
 162                 return false;
 163         }
 164
 165         return true;
 166 }
 167
 168 void ath_chanctx_check_active(struct ath_softc *sc, struct ath_chanctx *ctx)
 169 {
 170         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 171         struct ath_vif *avp;
 172         bool active = false;
 173         u8 n_active = 0;
 174
 175         if (!ctx)
 176                 return;
 177
 178         list_for_each_entry(avp, &ctx->vifs, list) {
 179                 struct ieee80211_vif *vif = avp->vif;
 180
 181                 switch (vif->type) {
 182                 case NL80211_IFTYPE_P2P_CLIENT:
 183                 case NL80211_IFTYPE_STATION:
 184                         if (vif->bss_conf.assoc)
 185                                 active = true;
 186                         break;
 187                 default:
 188                         active = true;
 189                         break;
 190                 }
 191         }
 192         ctx->active = active;
 193
 194         ath_for_each_chanctx(sc, ctx) {
 195                 if (!ctx->assigned || list_empty(&ctx->vifs))
 196                         continue;
 197                 n_active++;
 198         }
 199
 200         if (n_active <= 1) {
 201                 clear_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags);
 202                 return;
 203         }
 204         if (test_and_set_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags))
 205                 return;
 206         ath_chanctx_event(sc, NULL, ATH_CHANCTX_EVENT_ENABLE_MULTICHANNEL);
 207 }
 208
 209 static bool
 210 ath_chanctx_send_ps_frame(struct ath_softc *sc, bool powersave)
 211 {
 212         struct ath_vif *avp;
 213         bool sent = false;
 214
 215         rcu_read_lock();
 216         list_for_each_entry(avp, &sc->cur_chan->vifs, list) {
 217                 if (ath_chanctx_send_vif_ps_frame(sc, avp, powersave))
 218                         sent = true;
 219         }
 220         rcu_read_unlock();
 221
 222         return sent;
 223 }
 224
 225 static bool ath_chanctx_defer_switch(struct ath_softc *sc)
 226 {
 227         if (sc->cur_chan == &sc->offchannel.chan)
 228                 return false;
 229
 230         switch (sc->sched.state) {
 231         case ATH_CHANCTX_STATE_SWITCH:
 232                 return false;
 233         case ATH_CHANCTX_STATE_IDLE:
 234                 if (!sc->cur_chan->switch_after_beacon)
 235                         return false;
 236
 237                 sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;
 238                 break;
 239         default:
 240                 break;
 241         }
 242
 243         return true;
 244 }
 245
 246 static void ath_chanctx_set_next(struct ath_softc *sc, bool force)
 247 {
 248         struct timespec ts;
 249         bool measure_time = false;
 250         bool send_ps = false;
 251
 252         spin_lock_bh(&sc->chan_lock);
 253         if (!sc->next_chan) {
 254                 spin_unlock_bh(&sc->chan_lock);
 255                 return;
 256         }
 257
 258         if (!force && ath_chanctx_defer_switch(sc)) {
 259                 spin_unlock_bh(&sc->chan_lock);
 260                 return;
 261         }
 262
 263         if (sc->cur_chan != sc->next_chan) {
 264                 sc->cur_chan->stopped = true;
 265                 spin_unlock_bh(&sc->chan_lock);
 266
 267                 if (sc->next_chan == &sc->offchannel.chan) {
 268                         getrawmonotonic(&ts);
 269                         measure_time = true;
 270                 }
 271                 __ath9k_flush(sc->hw, ~0, true);
 272
 273                 if (ath_chanctx_send_ps_frame(sc, true))
 274                         __ath9k_flush(sc->hw, BIT(IEEE80211_AC_VO), false);
 275
 276                 send_ps = true;
 277                 spin_lock_bh(&sc->chan_lock);
 278
 279                 if (sc->cur_chan != &sc->offchannel.chan) {
 280                         getrawmonotonic(&sc->cur_chan->tsf_ts);
 281                         sc->cur_chan->tsf_val = ath9k_hw_gettsf64(sc->sc_ah);
 282                 }
 283         }
 284         sc->cur_chan = sc->next_chan;
 285         sc->cur_chan->stopped = false;
 286         sc->next_chan = NULL;
 287         sc->sched.offchannel_duration = 0;
 288         if (sc->sched.state != ATH_CHANCTX_STATE_FORCE_ACTIVE)
 289                 sc->sched.state = ATH_CHANCTX_STATE_IDLE;
 290
 291         spin_unlock_bh(&sc->chan_lock);
 292
 293         if (sc->sc_ah->chip_fullsleep ||
 294             memcmp(&sc->cur_chandef, &sc->cur_chan->chandef,
 295                    sizeof(sc->cur_chandef))) {
 296                 ath_set_channel(sc);
 297                 if (measure_time)
 298                         sc->sched.channel_switch_time =
 299                                 ath9k_hw_get_tsf_offset(&ts, NULL);
 300         }
 301         if (send_ps)
 302                 ath_chanctx_send_ps_frame(sc, false);
 303
 304         ath_offchannel_channel_change(sc);
 305         ath_chanctx_event(sc, NULL, ATH_CHANCTX_EVENT_SWITCH);
 306 }
 307
 308 void ath_chanctx_work(struct work_struct *work)
 309 {
 310         struct ath_softc *sc = container_of(work, struct ath_softc,
 311                                             chanctx_work);
 312         mutex_lock(&sc->mutex);
 313         ath_chanctx_set_next(sc, false);
 314         mutex_unlock(&sc->mutex);
 315 }
 316
 317 void ath_chanctx_init(struct ath_softc *sc)
 318 {
 319         struct ath_chanctx *ctx;
 320         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 321         struct ieee80211_supported_band *sband;
 322         struct ieee80211_channel *chan;
 323         int i, j;
 324
 325         sband = &common->sbands[IEEE80211_BAND_2GHZ];
 326         if (!sband->n_channels)
 327                 sband = &common->sbands[IEEE80211_BAND_5GHZ];
 328
 329         chan = &sband->channels[0];
 330         for (i = 0; i < ATH9K_NUM_CHANCTX; i++) {
 331                 ctx = &sc->chanctx[i];
 332                 cfg80211_chandef_create(&ctx->chandef, chan, NL80211_CHAN_HT20);
 333                 INIT_LIST_HEAD(&ctx->vifs);
 334                 ctx->txpower = ATH_TXPOWER_MAX;
 335                 for (j = 0; j < ARRAY_SIZE(ctx->acq); j++)
 336                         INIT_LIST_HEAD(&ctx->acq[j]);
 337         }
 338         ctx = &sc->offchannel.chan;
 339         cfg80211_chandef_create(&ctx->chandef, chan, NL80211_CHAN_HT20);
 340         INIT_LIST_HEAD(&ctx->vifs);
 341         ctx->txpower = ATH_TXPOWER_MAX;
 342         for (j = 0; j < ARRAY_SIZE(ctx->acq); j++)
 343                 INIT_LIST_HEAD(&ctx->acq[j]);
 344         sc->offchannel.chan.offchannel = true;
 345
 346 }
 347
 348 void ath9k_chanctx_force_active(struct ieee80211_hw *hw,
 349                                 struct ieee80211_vif *vif)
 350 {
 351         struct ath_softc *sc = hw->priv;
 352         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 353         struct ath_vif *avp = (struct ath_vif *) vif->drv_priv;
 354         bool changed = false;
 355
 356         if (!test_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags))
 357                 return;
 358
 359         if (!avp->chanctx)
 360                 return;
 361
 362         mutex_lock(&sc->mutex);
 363
 364         spin_lock_bh(&sc->chan_lock);
 365         if (sc->next_chan || (sc->cur_chan != avp->chanctx)) {
 366                 sc->next_chan = avp->chanctx;
 367                 changed = true;
 368         }
 369         sc->sched.state = ATH_CHANCTX_STATE_FORCE_ACTIVE;
 370         spin_unlock_bh(&sc->chan_lock);
 371
 372         if (changed)
 373                 ath_chanctx_set_next(sc, true);
 374
 375         mutex_unlock(&sc->mutex);
 376 }
 377
 378 void ath_chanctx_switch(struct ath_softc *sc, struct ath_chanctx *ctx,
 379                         struct cfg80211_chan_def *chandef)
 380 {
 381         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 382
 383         spin_lock_bh(&sc->chan_lock);
 384
 385         if (test_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags) &&
 386             (sc->cur_chan != ctx) && (ctx == &sc->offchannel.chan)) {
 387                 sc->sched.offchannel_pending = true;
 388                 spin_unlock_bh(&sc->chan_lock);
 389                 return;
 390         }
 391
 392         sc->next_chan = ctx;
 393         if (chandef) {
 394                 ctx->chandef = *chandef;
 395                 ath_dbg(common, CHAN_CTX,
 396                         "Assigned next_chan to %d MHz\n", chandef->center_freq1);
 397         }
 398
 399         if (sc->next_chan == &sc->offchannel.chan) {
 400                 sc->sched.offchannel_duration =
 401                         TU_TO_USEC(sc->offchannel.duration) +
 402                         sc->sched.channel_switch_time;
 403
 404                 if (chandef) {
 405                         ath_dbg(common, CHAN_CTX,
 406                                 "Offchannel duration for chan %d MHz : %u\n",
 407                                 chandef->center_freq1,
 408                                 sc->sched.offchannel_duration);
 409                 }
 410         }
 411         spin_unlock_bh(&sc->chan_lock);
 412         ieee80211_queue_work(sc->hw, &sc->chanctx_work);
 413 }
 414
 415 void ath_chanctx_set_channel(struct ath_softc *sc, struct ath_chanctx *ctx,
 416                              struct cfg80211_chan_def *chandef)
 417 {
 418         bool cur_chan;
 419
 420         spin_lock_bh(&sc->chan_lock);
 421         if (chandef)
 422                 memcpy(&ctx->chandef, chandef, sizeof(*chandef));
 423         cur_chan = sc->cur_chan == ctx;
 424         spin_unlock_bh(&sc->chan_lock);
 425
 426         if (!cur_chan)
 427                 return;
 428
 429         ath_set_channel(sc);
 430 }
 431
 432 struct ath_chanctx *ath_chanctx_get_oper_chan(struct ath_softc *sc, bool active)
 433 {
 434         struct ath_chanctx *ctx;
 435
 436         ath_for_each_chanctx(sc, ctx) {
 437                 if (!ctx->assigned || list_empty(&ctx->vifs))
 438                         continue;
 439                 if (active && !ctx->active)
 440                         continue;
 441
 442                 if (ctx->switch_after_beacon)
 443                         return ctx;
 444         }
 445
 446         return &sc->chanctx[0];
 447 }
 448
 449 void ath_chanctx_offchan_switch(struct ath_softc *sc,
 450                                 struct ieee80211_channel *chan)
 451 {
 452         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 453         struct cfg80211_chan_def chandef;
 454
 455         cfg80211_chandef_create(&chandef, chan, NL80211_CHAN_NO_HT);
 456         ath_dbg(common, CHAN_CTX,
 457                 "Channel definition created: %d MHz\n", chandef.center_freq1);
 458
 459         ath_chanctx_switch(sc, &sc->offchannel.chan, &chandef);
 460 }
 461
 462 static struct ath_chanctx *
 463 ath_chanctx_get_next(struct ath_softc *sc, struct ath_chanctx *ctx)
 464 {
 465         int idx = ctx - &sc->chanctx[0];
 466
 467         return &sc->chanctx[!idx];
 468 }
 469
 470 static void ath_chanctx_adjust_tbtt_delta(struct ath_softc *sc)
 471 {
 472         struct ath_chanctx *prev, *cur;
 473         struct timespec ts;
 474         u32 cur_tsf, prev_tsf, beacon_int;
 475         s32 offset;
 476
 477         beacon_int = TU_TO_USEC(sc->cur_chan->beacon.beacon_interval);
 478
 479         cur = sc->cur_chan;
 480         prev = ath_chanctx_get_next(sc, cur);
 481
 482         getrawmonotonic(&ts);
 483         cur_tsf = (u32) cur->tsf_val +
 484                   ath9k_hw_get_tsf_offset(&cur->tsf_ts, &ts);
 485
 486         prev_tsf = prev->last_beacon - (u32) prev->tsf_val + cur_tsf;
 487         prev_tsf -= ath9k_hw_get_tsf_offset(&prev->tsf_ts, &ts);
 488
 489         /* Adjust the TSF time of the AP chanctx to keep its beacons
 490          * at half beacon interval offset relative to the STA chanctx.
 491          */
 492         offset = cur_tsf - prev_tsf;
 493
 494         /* Ignore stale data or spurious timestamps */
 495         if (offset < 0 || offset > 3 * beacon_int)
 496                 return;
 497
 498         offset = beacon_int / 2 - (offset % beacon_int);
 499         prev->tsf_val += offset;
 500 }
 501
 502 void ath_chanctx_timer(unsigned long data)
 503 {
 504         struct ath_softc *sc = (struct ath_softc *) data;
 505
 506         ath_chanctx_event(sc, NULL, ATH_CHANCTX_EVENT_TSF_TIMER);
 507 }
 508
 509 /* Configure the TSF based hardware timer for a channel switch.
 510  * Also set up backup software timer, in case the gen timer fails.
 511  * This could be caused by a hardware reset.
 512  */
 513 static void ath_chanctx_setup_timer(struct ath_softc *sc, u32 tsf_time)
 514 {
 515         struct ath_hw *ah = sc->sc_ah;
 516
 517 #ifdef CONFIG_ATH9K_CHANNEL_CONTEXT
 518         ath9k_hw_gen_timer_start(ah, sc->p2p_ps_timer, tsf_time, 1000000);
 519 #endif
 520         tsf_time -= ath9k_hw_gettsf32(ah);
 521         tsf_time = msecs_to_jiffies(tsf_time / 1000) + 1;
 522         mod_timer(&sc->sched.timer, tsf_time);
 523 }
 524
 525 void ath_chanctx_event(struct ath_softc *sc, struct ieee80211_vif *vif,
 526                        enum ath_chanctx_event ev)
 527 {
 528         struct ath_hw *ah = sc->sc_ah;
 529         struct ath_common *common = ath9k_hw_common(ah);
 530         struct ath_beacon_config *cur_conf;
 531         struct ath_vif *avp = NULL;
 532         struct ath_chanctx *ctx;
 533         u32 tsf_time;
 534         u32 beacon_int;
 535         bool noa_changed = false;
 536
 537         if (vif)
 538                 avp = (struct ath_vif *) vif->drv_priv;
 539
 540         spin_lock_bh(&sc->chan_lock);
 541
 542         switch (ev) {
 543         case ATH_CHANCTX_EVENT_BEACON_PREPARE:
 544                 if (avp->offchannel_duration)
 545                         avp->offchannel_duration = 0;
 546
 547                 if (avp->chanctx != sc->cur_chan)
 548                         break;
 549
 550                 if (sc->sched.offchannel_pending) {
 551                         sc->sched.offchannel_pending = false;
 552                         sc->next_chan = &sc->offchannel.chan;
 553                         sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;
 554                 }
 555
 556                 ctx = ath_chanctx_get_next(sc, sc->cur_chan);
 557                 if (ctx->active && sc->sched.state == ATH_CHANCTX_STATE_IDLE) {
 558                         sc->next_chan = ctx;
 559                         sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;
 560                 }
 561
 562                 /* if the timer missed its window, use the next interval */
 563                 if (sc->sched.state == ATH_CHANCTX_STATE_WAIT_FOR_TIMER)
 564                         sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;
 565
 566                 if (sc->sched.state != ATH_CHANCTX_STATE_WAIT_FOR_BEACON)
 567                         break;
 568
 569                 sc->sched.beacon_pending = true;
 570                 sc->sched.next_tbtt = REG_READ(ah, AR_NEXT_TBTT_TIMER);
 571
 572                 cur_conf = &sc->cur_chan->beacon;
 573                 beacon_int = TU_TO_USEC(cur_conf->beacon_interval);
 574
 575                 /* defer channel switch by a quarter beacon interval */
 576                 tsf_time = sc->sched.next_tbtt + beacon_int / 4;
 577                 sc->sched.switch_start_time = tsf_time;
 578                 sc->cur_chan->last_beacon = sc->sched.next_tbtt;
 579
 580                 /* Prevent wrap-around issues */
 581                 if (avp->periodic_noa_duration &&
 582                     tsf_time - avp->periodic_noa_start > BIT(30))
 583                         avp->periodic_noa_duration = 0;
 584
 585                 if (ctx->active && !avp->periodic_noa_duration) {
 586                         avp->periodic_noa_start = tsf_time;
 587                         avp->periodic_noa_duration =
 588                                 TU_TO_USEC(cur_conf->beacon_interval) / 2 -
 589                                 sc->sched.channel_switch_time;
 590                         noa_changed = true;
 591                 } else if (!ctx->active && avp->periodic_noa_duration) {
 592                         avp->periodic_noa_duration = 0;
 593                         noa_changed = true;
 594                 }
 595
 596                 /* If at least two consecutive beacons were missed on the STA
 597                  * chanctx, stay on the STA channel for one extra beacon period,
 598                  * to resync the timer properly.
 599                  */
 600                 if (ctx->active && sc->sched.beacon_miss >= 2)
 601                         sc->sched.offchannel_duration = 3 * beacon_int / 2;
 602
 603                 if (sc->sched.offchannel_duration) {
 604                         noa_changed = true;
 605                         avp->offchannel_start = tsf_time;
 606                         avp->offchannel_duration =
 607                                 sc->sched.offchannel_duration;
 608                 }
 609
 610                 if (noa_changed)
 611                         avp->noa_index++;
 612                 break;
 613         case ATH_CHANCTX_EVENT_BEACON_SENT:
 614                 if (!sc->sched.beacon_pending)
 615                         break;
 616
 617                 sc->sched.beacon_pending = false;
 618                 if (sc->sched.state != ATH_CHANCTX_STATE_WAIT_FOR_BEACON)
 619                         break;
 620
 621                 sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_TIMER;
 622                 ath_chanctx_setup_timer(sc, sc->sched.switch_start_time);
 623                 break;
 624         case ATH_CHANCTX_EVENT_TSF_TIMER:
 625                 if (sc->sched.state != ATH_CHANCTX_STATE_WAIT_FOR_TIMER)
 626                         break;
 627
 628                 if (!sc->cur_chan->switch_after_beacon &&
 629                     sc->sched.beacon_pending)
 630                         sc->sched.beacon_miss++;
 631
 632                 sc->sched.state = ATH_CHANCTX_STATE_SWITCH;
 633                 ieee80211_queue_work(sc->hw, &sc->chanctx_work);
 634                 break;
 635         case ATH_CHANCTX_EVENT_BEACON_RECEIVED:
 636                 if (!test_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags) ||
 637                     sc->cur_chan == &sc->offchannel.chan)
 638                         break;
 639
 640                 ath_chanctx_adjust_tbtt_delta(sc);
 641                 sc->sched.beacon_pending = false;
 642                 sc->sched.beacon_miss = 0;
 643
 644                 /* TSF time might have been updated by the incoming beacon,
 645                  * need update the channel switch timer to reflect the change.
 646                  */
 647                 tsf_time = sc->sched.switch_start_time;
 648                 tsf_time -= (u32) sc->cur_chan->tsf_val +
 649                         ath9k_hw_get_tsf_offset(&sc->cur_chan->tsf_ts, NULL);
 650                 tsf_time += ath9k_hw_gettsf32(ah);
 651
 652
 653                 ath_chanctx_setup_timer(sc, tsf_time);
 654                 break;
 655         case ATH_CHANCTX_EVENT_ASSOC:
 656                 if (sc->sched.state != ATH_CHANCTX_STATE_FORCE_ACTIVE ||
 657                     avp->chanctx != sc->cur_chan)
 658                         break;
 659
 660                 sc->sched.state = ATH_CHANCTX_STATE_IDLE;
 661                 /* fall through */
 662         case ATH_CHANCTX_EVENT_SWITCH:
 663                 if (!test_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags) ||
 664                     sc->sched.state == ATH_CHANCTX_STATE_FORCE_ACTIVE ||
 665                     sc->cur_chan->switch_after_beacon ||
 666                     sc->cur_chan == &sc->offchannel.chan)
 667                         break;
 668
 669                 /* If this is a station chanctx, stay active for a half
 670                  * beacon period (minus channel switch time)
 671                  */
 672                 sc->next_chan = ath_chanctx_get_next(sc, sc->cur_chan);
 673                 cur_conf = &sc->cur_chan->beacon;
 674
 675                 sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_TIMER;
 676
 677                 tsf_time = TU_TO_USEC(cur_conf->beacon_interval) / 2;
 678                 if (sc->sched.beacon_miss >= 2) {
 679                         sc->sched.beacon_miss = 0;
 680                         tsf_time *= 3;
 681                 }
 682
 683                 tsf_time -= sc->sched.channel_switch_time;
 684                 tsf_time += ath9k_hw_gettsf32(sc->sc_ah);
 685                 sc->sched.switch_start_time = tsf_time;
 686
 687                 ath_chanctx_setup_timer(sc, tsf_time);
 688                 sc->sched.beacon_pending = true;
 689                 break;
 690         case ATH_CHANCTX_EVENT_ENABLE_MULTICHANNEL:
 691                 if (sc->cur_chan == &sc->offchannel.chan ||
 692                     sc->cur_chan->switch_after_beacon)
 693                         break;
 694
 695                 sc->next_chan = ath_chanctx_get_next(sc, sc->cur_chan);
 696                 ieee80211_queue_work(sc->hw, &sc->chanctx_work);
 697                 break;
 698         case ATH_CHANCTX_EVENT_UNASSIGN:
 699                 if (sc->cur_chan->assigned) {
 700                         if (sc->next_chan && !sc->next_chan->assigned &&
 701                             sc->next_chan != &sc->offchannel.chan)
 702                                 sc->sched.state = ATH_CHANCTX_STATE_IDLE;
 703                         break;
 704                 }
 705
 706                 ctx = ath_chanctx_get_next(sc, sc->cur_chan);
 707                 sc->sched.state = ATH_CHANCTX_STATE_IDLE;
 708                 if (!ctx->assigned)
 709                         break;
 710
 711                 sc->next_chan = ctx;
 712                 ieee80211_queue_work(sc->hw, &sc->chanctx_work);
 713                 break;
 714         }
 715
 716         spin_unlock_bh(&sc->chan_lock);
 717 }
 718
 719 static int ath_scan_channel_duration(struct ath_softc *sc,
 720                                      struct ieee80211_channel *chan)
 721 {
 722         struct cfg80211_scan_request *req = sc->offchannel.scan_req;
 723
 724         if (!req->n_ssids || (chan->flags & IEEE80211_CHAN_NO_IR))
 725                 return (HZ / 9); /* ~110 ms */
 726
 727         return (HZ / 16); /* ~60 ms */
 728 }
 729
 730 static void
 731 ath_scan_next_channel(struct ath_softc *sc)
 732 {
 733         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 734         struct cfg80211_scan_request *req = sc->offchannel.scan_req;
 735         struct ieee80211_channel *chan;
 736
 737         if (sc->offchannel.scan_idx >= req->n_channels) {
 738                 ath_dbg(common, CHAN_CTX,
 739                         "Moving to ATH_OFFCHANNEL_IDLE state, scan_idx: %d, n_channels: %d\n",
 740                         sc->offchannel.scan_idx,
 741                         req->n_channels);
 742
 743                 sc->offchannel.state = ATH_OFFCHANNEL_IDLE;
 744                 ath_chanctx_switch(sc, ath_chanctx_get_oper_chan(sc, false),
 745                                    NULL);
 746                 return;
 747         }
 748
 749         ath_dbg(common, CHAN_CTX,
 750                 "Moving to ATH_OFFCHANNEL_PROBE_SEND state, scan_idx: %d\n",
 751                 sc->offchannel.scan_idx);
 752
 753         chan = req->channels[sc->offchannel.scan_idx++];
 754         sc->offchannel.duration = ath_scan_channel_duration(sc, chan);
 755         sc->offchannel.state = ATH_OFFCHANNEL_PROBE_SEND;
 756
 757         ath_chanctx_offchan_switch(sc, chan);
 758 }
 759
 760 void ath_offchannel_next(struct ath_softc *sc)
 761 {
 762         struct ieee80211_vif *vif;
 763
 764         if (sc->offchannel.scan_req) {
 765                 vif = sc->offchannel.scan_vif;
 766                 sc->offchannel.chan.txpower = vif->bss_conf.txpower;
 767                 ath_scan_next_channel(sc);
 768         } else if (sc->offchannel.roc_vif) {
 769                 vif = sc->offchannel.roc_vif;
 770                 sc->offchannel.chan.txpower = vif->bss_conf.txpower;
 771                 sc->offchannel.duration = sc->offchannel.roc_duration;
 772                 sc->offchannel.state = ATH_OFFCHANNEL_ROC_START;
 773                 ath_chanctx_offchan_switch(sc, sc->offchannel.roc_chan);
 774         } else {
 775                 ath_chanctx_switch(sc, ath_chanctx_get_oper_chan(sc, false),
 776                                    NULL);
 777                 sc->offchannel.state = ATH_OFFCHANNEL_IDLE;
 778                 if (sc->ps_idle)
 779                         ath_cancel_work(sc);
 780         }
 781 }
 782
 783 void ath_roc_complete(struct ath_softc *sc, bool abort)
 784 {
 785         sc->offchannel.roc_vif = NULL;
 786         sc->offchannel.roc_chan = NULL;
 787         if (!abort)
 788                 ieee80211_remain_on_channel_expired(sc->hw);
 789         ath_offchannel_next(sc);
 790         ath9k_ps_restore(sc);
 791 }
 792
 793 void ath_scan_complete(struct ath_softc *sc, bool abort)
 794 {
 795         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 796
 797         if (abort)
 798                 ath_dbg(common, CHAN_CTX, "HW scan aborted\n");
 799         else
 800                 ath_dbg(common, CHAN_CTX, "HW scan complete\n");
 801
 802         sc->offchannel.scan_req = NULL;
 803         sc->offchannel.scan_vif = NULL;
 804         sc->offchannel.state = ATH_OFFCHANNEL_IDLE;
 805         ieee80211_scan_completed(sc->hw, abort);
 806         clear_bit(ATH_OP_SCANNING, &common->op_flags);
 807         ath_offchannel_next(sc);
 808         ath9k_ps_restore(sc);
 809 }
 810
 811 static void ath_scan_send_probe(struct ath_softc *sc,
 812                                 struct cfg80211_ssid *ssid)
 813 {
 814         struct cfg80211_scan_request *req = sc->offchannel.scan_req;
 815         struct ieee80211_vif *vif = sc->offchannel.scan_vif;
 816         struct ath_tx_control txctl = {};
 817         struct sk_buff *skb;
 818         struct ieee80211_tx_info *info;
 819         int band = sc->offchannel.chan.chandef.chan->band;
 820
 821         skb = ieee80211_probereq_get(sc->hw, vif,
 822                         ssid->ssid, ssid->ssid_len, req->ie_len);
 823         if (!skb)
 824                 return;
 825
 826         info = IEEE80211_SKB_CB(skb);
 827         if (req->no_cck)
 828                 info->flags |= IEEE80211_TX_CTL_NO_CCK_RATE;
 829
 830         if (req->ie_len)
 831                 memcpy(skb_put(skb, req->ie_len), req->ie, req->ie_len);
 832
 833         skb_set_queue_mapping(skb, IEEE80211_AC_VO);
 834
 835         if (!ieee80211_tx_prepare_skb(sc->hw, vif, skb, band, NULL))
 836                 goto error;
 837
 838         txctl.txq = sc->tx.txq_map[IEEE80211_AC_VO];
 839         txctl.force_channel = true;
 840         if (ath_tx_start(sc->hw, skb, &txctl))
 841                 goto error;
 842
 843         return;
 844
 845 error:
 846         ieee80211_free_txskb(sc->hw, skb);
 847 }
 848
 849 static void ath_scan_channel_start(struct ath_softc *sc)
 850 {
 851         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 852         struct cfg80211_scan_request *req = sc->offchannel.scan_req;
 853         int i;
 854
 855         if (!(sc->cur_chan->chandef.chan->flags & IEEE80211_CHAN_NO_IR) &&
 856             req->n_ssids) {
 857                 for (i = 0; i < req->n_ssids; i++)
 858                         ath_scan_send_probe(sc, &req->ssids[i]);
 859
 860         }
 861
 862         ath_dbg(common, CHAN_CTX,
 863                 "Moving to ATH_OFFCHANNEL_PROBE_WAIT state\n");
 864
 865         sc->offchannel.state = ATH_OFFCHANNEL_PROBE_WAIT;
 866         mod_timer(&sc->offchannel.timer, jiffies + sc->offchannel.duration);
 867 }
 868
 869 void ath_offchannel_channel_change(struct ath_softc *sc)
 870 {
 871         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 872
 873         ath_dbg(common, CHAN_CTX, "%s: state: %s\n",
 874                 __func__, offchannel_state_string(sc->offchannel.state));
 875
 876         switch (sc->offchannel.state) {
 877         case ATH_OFFCHANNEL_PROBE_SEND:
 878                 if (!sc->offchannel.scan_req)
 879                         return;
 880
 881                 if (sc->cur_chan->chandef.chan !=
 882                     sc->offchannel.chan.chandef.chan)
 883                         return;
 884
 885                 ath_scan_channel_start(sc);
 886                 break;
 887         case ATH_OFFCHANNEL_IDLE:
 888                 if (!sc->offchannel.scan_req)
 889                         return;
 890
 891                 ath_scan_complete(sc, false);
 892                 break;
 893         case ATH_OFFCHANNEL_ROC_START:
 894                 if (sc->cur_chan != &sc->offchannel.chan)
 895                         break;
 896
 897                 sc->offchannel.state = ATH_OFFCHANNEL_ROC_WAIT;
 898                 mod_timer(&sc->offchannel.timer, jiffies +
 899                           msecs_to_jiffies(sc->offchannel.duration));
 900                 ieee80211_ready_on_channel(sc->hw);
 901                 break;
 902         case ATH_OFFCHANNEL_ROC_DONE:
 903                 ath_roc_complete(sc, false);
 904                 break;
 905         default:
 906                 break;
 907         }
 908 }
 909
 910 void ath_offchannel_timer(unsigned long data)
 911 {
 912         struct ath_softc *sc = (struct ath_softc *)data;
 913         struct ath_chanctx *ctx;
 914         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 915
 916         ath_dbg(common, CHAN_CTX, "%s: state: %s\n",
 917                 __func__, offchannel_state_string(sc->offchannel.state));
 918
 919         switch (sc->offchannel.state) {
 920         case ATH_OFFCHANNEL_PROBE_WAIT:
 921                 if (!sc->offchannel.scan_req)
 922                         return;
 923
 924                 /* get first active channel context */
 925                 ctx = ath_chanctx_get_oper_chan(sc, true);
 926                 if (ctx->active) {
 927                         sc->offchannel.state = ATH_OFFCHANNEL_SUSPEND;
 928                         ath_chanctx_switch(sc, ctx, NULL);
 929                         mod_timer(&sc->offchannel.timer, jiffies + HZ / 10);
 930                         break;
 931                 }
 932                 /* fall through */
 933         case ATH_OFFCHANNEL_SUSPEND:
 934                 if (!sc->offchannel.scan_req)
 935                         return;
 936
 937                 ath_scan_next_channel(sc);
 938                 break;
 939         case ATH_OFFCHANNEL_ROC_START:
 940         case ATH_OFFCHANNEL_ROC_WAIT:
 941                 ctx = ath_chanctx_get_oper_chan(sc, false);
 942                 sc->offchannel.state = ATH_OFFCHANNEL_ROC_DONE;
 943                 ath_chanctx_switch(sc, ctx, NULL);
 944                 break;
 945         default:
 946                 break;
 947         }
 948 }
 949
 950 #ifdef CONFIG_ATH9K_CHANNEL_CONTEXT
 951
 952 bool ath9k_is_chanctx_enabled(void)
 953 {
 954         return (ath9k_use_chanctx == 1);
 955 }
 956
 957 /*****************/
 958 /* P2P Powersave */
 959 /*****************/
 960
 961 static void ath9k_update_p2p_ps_timer(struct ath_softc *sc, struct ath_vif *avp)
 962 {
 963         struct ath_hw *ah = sc->sc_ah;
 964         s32 tsf, target_tsf;
 965
 966         if (!avp || !avp->noa.has_next_tsf)
 967                 return;
 968
 969         ath9k_hw_gen_timer_stop(ah, sc->p2p_ps_timer);
 970
 971         tsf = ath9k_hw_gettsf32(sc->sc_ah);
 972
 973         target_tsf = avp->noa.next_tsf;
 974         if (!avp->noa.absent)
 975                 target_tsf -= ATH_P2P_PS_STOP_TIME;
 976
 977         if (target_tsf - tsf < ATH_P2P_PS_STOP_TIME)
 978                 target_tsf = tsf + ATH_P2P_PS_STOP_TIME;
 979
 980         ath9k_hw_gen_timer_start(ah, sc->p2p_ps_timer, (u32) target_tsf, 1000000);
 981 }
 982
 983 static void ath9k_update_p2p_ps(struct ath_softc *sc, struct ieee80211_vif *vif)
 984 {
 985         struct ath_vif *avp = (void *)vif->drv_priv;
 986         u32 tsf;
 987
 988         if (!sc->p2p_ps_timer)
 989                 return;
 990
 991         if (vif->type != NL80211_IFTYPE_STATION || !vif->p2p)
 992                 return;
 993
 994         sc->p2p_ps_vif = avp;
 995         tsf = ath9k_hw_gettsf32(sc->sc_ah);
 996         ieee80211_parse_p2p_noa(&vif->bss_conf.p2p_noa_attr, &avp->noa, tsf);
 997         ath9k_update_p2p_ps_timer(sc, avp);
 998 }
 999
1000 void ath9k_p2p_ps_timer(void *priv)
1001 {
1002         struct ath_softc *sc = priv;
1003         struct ath_vif *avp = sc->p2p_ps_vif;
1004         struct ieee80211_vif *vif;
1005         struct ieee80211_sta *sta;
1006         struct ath_node *an;
1007         u32 tsf;
1008
1009         del_timer_sync(&sc->sched.timer);
1010         ath9k_hw_gen_timer_stop(sc->sc_ah, sc->p2p_ps_timer);
1011         ath_chanctx_event(sc, NULL, ATH_CHANCTX_EVENT_TSF_TIMER);
1012
1013         if (!avp || avp->chanctx != sc->cur_chan)
1014                 return;
1015
1016         tsf = ath9k_hw_gettsf32(sc->sc_ah);
1017         if (!avp->noa.absent)
1018                 tsf += ATH_P2P_PS_STOP_TIME;
1019
1020         if (!avp->noa.has_next_tsf ||
1021             avp->noa.next_tsf - tsf > BIT(31))
1022                 ieee80211_update_p2p_noa(&avp->noa, tsf);
1023
1024         ath9k_update_p2p_ps_timer(sc, avp);
1025
1026         rcu_read_lock();
1027
1028         vif = avp->vif;
1029         sta = ieee80211_find_sta(vif, vif->bss_conf.bssid);
1030         if (!sta)
1031                 goto out;
1032
1033         an = (void *) sta->drv_priv;
1034         if (an->sleeping == !!avp->noa.absent)
1035                 goto out;
1036
1037         an->sleeping = avp->noa.absent;
1038         if (an->sleeping)
1039                 ath_tx_aggr_sleep(sta, sc, an);
1040         else
1041                 ath_tx_aggr_wakeup(sc, an);
1042
1043 out:
1044         rcu_read_unlock();
1045 }
1046
1047 void ath9k_p2p_bss_info_changed(struct ath_softc *sc,
1048                                 struct ieee80211_vif *vif)
1049 {
1050         unsigned long flags;
1051
1052         spin_lock_bh(&sc->sc_pcu_lock);
1053         spin_lock_irqsave(&sc->sc_pm_lock, flags);
1054         if (!(sc->ps_flags & PS_BEACON_SYNC))
1055                 ath9k_update_p2p_ps(sc, vif);
1056         spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
1057         spin_unlock_bh(&sc->sc_pcu_lock);
1058 }
1059
1060 void ath9k_p2p_beacon_sync(struct ath_softc *sc)
1061 {
1062         if (sc->p2p_ps_vif)
1063                 ath9k_update_p2p_ps(sc, sc->p2p_ps_vif->vif);
1064 }
1065
1066 void ath9k_p2p_remove_vif(struct ath_softc *sc,
1067                           struct ieee80211_vif *vif)
1068 {
1069         struct ath_vif *avp = (void *)vif->drv_priv;
1070
1071         spin_lock_bh(&sc->sc_pcu_lock);
1072         if (avp == sc->p2p_ps_vif) {
1073                 sc->p2p_ps_vif = NULL;
1074                 ath9k_update_p2p_ps_timer(sc, NULL);
1075         }
1076         spin_unlock_bh(&sc->sc_pcu_lock);
1077 }
1078
1079 int ath9k_init_p2p(struct ath_softc *sc)
1080 {
1081         sc->p2p_ps_timer = ath_gen_timer_alloc(sc->sc_ah, ath9k_p2p_ps_timer,
1082                                                NULL, sc, AR_FIRST_NDP_TIMER);
1083         if (!sc->p2p_ps_timer)
1084                 return -ENOMEM;
1085
1086         return 0;
1087 }
1088
1089 void ath9k_deinit_p2p(struct ath_softc *sc)
1090 {
1091         if (sc->p2p_ps_timer)
1092                 ath_gen_timer_free(sc->sc_ah, sc->p2p_ps_timer);
1093 }
1094
1095 #endif /* CONFIG_ATH9K_CHANNEL_CONTEXT */