drivers/net/wireless/ath/ath9k/channel.c

   1 /*
   2  * Copyright (c) 2014 Qualcomm Atheros, Inc.
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #include "ath9k.h"
  18
  19 /* Set/change channels.  If the channel is really being changed, it's done
  20  * by reseting the chip.  To accomplish this we must first cleanup any pending
  21  * DMA, then restart stuff.
  22  */
  23 static int ath_set_channel(struct ath_softc *sc)
  24 {
  25         struct ath_hw *ah = sc->sc_ah;
  26         struct ath_common *common = ath9k_hw_common(ah);
  27         struct ieee80211_hw *hw = sc->hw;
  28         struct ath9k_channel *hchan;
  29         struct cfg80211_chan_def *chandef = &sc->cur_chan->chandef;
  30         struct ieee80211_channel *chan = chandef->chan;
  31         int pos = chan->hw_value;
  32         int old_pos = -1;
  33         int r;
  34
  35         if (test_bit(ATH_OP_INVALID, &common->op_flags))
  36                 return -EIO;
  37
  38         if (ah->curchan)
  39                 old_pos = ah->curchan - &ah->channels[0];
  40
  41         ath_dbg(common, CONFIG, "Set channel: %d MHz width: %d\n",
  42                 chan->center_freq, chandef->width);
  43
  44         /* update survey stats for the old channel before switching */
  45         spin_lock_bh(&common->cc_lock);
  46         ath_update_survey_stats(sc);
  47         spin_unlock_bh(&common->cc_lock);
  48
  49         ath9k_cmn_get_channel(hw, ah, chandef);
  50
  51         /* If the operating channel changes, change the survey in-use flags
  52          * along with it.
  53          * Reset the survey data for the new channel, unless we're switching
  54          * back to the operating channel from an off-channel operation.
  55          */
  56         if (!sc->cur_chan->offchannel && sc->cur_survey != &sc->survey[pos]) {
  57                 if (sc->cur_survey)
  58                         sc->cur_survey->filled &= ~SURVEY_INFO_IN_USE;
  59
  60                 sc->cur_survey = &sc->survey[pos];
  61
  62                 memset(sc->cur_survey, 0, sizeof(struct survey_info));
  63                 sc->cur_survey->filled |= SURVEY_INFO_IN_USE;
  64         } else if (!(sc->survey[pos].filled & SURVEY_INFO_IN_USE)) {
  65                 memset(&sc->survey[pos], 0, sizeof(struct survey_info));
  66         }
  67
  68         hchan = &sc->sc_ah->channels[pos];
  69         r = ath_reset_internal(sc, hchan);
  70         if (r)
  71                 return r;
  72
  73         /* The most recent snapshot of channel->noisefloor for the old
  74          * channel is only available after the hardware reset. Copy it to
  75          * the survey stats now.
  76          */
  77         if (old_pos >= 0)
  78                 ath_update_survey_nf(sc, old_pos);
  79
  80         /* Enable radar pulse detection if on a DFS channel. Spectral
  81          * scanning and radar detection can not be used concurrently.
  82          */
  83         if (hw->conf.radar_enabled) {
  84                 u32 rxfilter;
  85
  86                 /* set HW specific DFS configuration */
  87                 ath9k_hw_set_radar_params(ah);
  88                 rxfilter = ath9k_hw_getrxfilter(ah);
  89                 rxfilter |= ATH9K_RX_FILTER_PHYRADAR |
  90                                 ATH9K_RX_FILTER_PHYERR;
  91                 ath9k_hw_setrxfilter(ah, rxfilter);
  92                 ath_dbg(common, DFS, "DFS enabled at freq %d\n",
  93                         chan->center_freq);
  94         } else {
  95                 /* perform spectral scan if requested. */
  96                 if (test_bit(ATH_OP_SCANNING, &common->op_flags) &&
  97                         sc->spectral_mode == SPECTRAL_CHANSCAN)
  98                         ath9k_spectral_scan_trigger(hw);
  99         }
 100
 101         return 0;
 102 }
 103
 104 void ath_chanctx_init(struct ath_softc *sc)
 105 {
 106         struct ath_chanctx *ctx;
 107         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 108         struct ieee80211_supported_band *sband;
 109         struct ieee80211_channel *chan;
 110         int i, j;
 111
 112         sband = &common->sbands[IEEE80211_BAND_2GHZ];
 113         if (!sband->n_channels)
 114                 sband = &common->sbands[IEEE80211_BAND_5GHZ];
 115
 116         chan = &sband->channels[0];
 117         for (i = 0; i < ATH9K_NUM_CHANCTX; i++) {
 118                 ctx = &sc->chanctx[i];
 119                 cfg80211_chandef_create(&ctx->chandef, chan, NL80211_CHAN_HT20);
 120                 INIT_LIST_HEAD(&ctx->vifs);
 121                 ctx->txpower = ATH_TXPOWER_MAX;
 122                 for (j = 0; j < ARRAY_SIZE(ctx->acq); j++)
 123                         INIT_LIST_HEAD(&ctx->acq[j]);
 124         }
 125 }
 126
 127 void ath_chanctx_set_channel(struct ath_softc *sc, struct ath_chanctx *ctx,
 128                              struct cfg80211_chan_def *chandef)
 129 {
 130         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 131         bool cur_chan;
 132
 133         spin_lock_bh(&sc->chan_lock);
 134         if (chandef)
 135                 memcpy(&ctx->chandef, chandef, sizeof(*chandef));
 136         cur_chan = sc->cur_chan == ctx;
 137         spin_unlock_bh(&sc->chan_lock);
 138
 139         if (!cur_chan) {
 140                 ath_dbg(common, CHAN_CTX,
 141                         "Current context differs from the new context\n");
 142                 return;
 143         }
 144
 145         ath_set_channel(sc);
 146 }
 147
 148 #ifdef CONFIG_ATH9K_CHANNEL_CONTEXT
 149
 150 /**********************************************************/
 151 /* Functions to handle the channel context state machine. */
 152 /**********************************************************/
 153
 154 static const char *offchannel_state_string(enum ath_offchannel_state state)
 155 {
 156         switch (state) {
 157                 case_rtn_string(ATH_OFFCHANNEL_IDLE);
 158                 case_rtn_string(ATH_OFFCHANNEL_PROBE_SEND);
 159                 case_rtn_string(ATH_OFFCHANNEL_PROBE_WAIT);
 160                 case_rtn_string(ATH_OFFCHANNEL_SUSPEND);
 161                 case_rtn_string(ATH_OFFCHANNEL_ROC_START);
 162                 case_rtn_string(ATH_OFFCHANNEL_ROC_WAIT);
 163                 case_rtn_string(ATH_OFFCHANNEL_ROC_DONE);
 164         default:
 165                 return "unknown";
 166         }
 167 }
 168
 169 static const char *chanctx_event_string(enum ath_chanctx_event ev)
 170 {
 171         switch (ev) {
 172                 case_rtn_string(ATH_CHANCTX_EVENT_BEACON_PREPARE);
 173                 case_rtn_string(ATH_CHANCTX_EVENT_BEACON_SENT);
 174                 case_rtn_string(ATH_CHANCTX_EVENT_TSF_TIMER);
 175                 case_rtn_string(ATH_CHANCTX_EVENT_BEACON_RECEIVED);
 176                 case_rtn_string(ATH_CHANCTX_EVENT_ASSOC);
 177                 case_rtn_string(ATH_CHANCTX_EVENT_SWITCH);
 178                 case_rtn_string(ATH_CHANCTX_EVENT_ASSIGN);
 179                 case_rtn_string(ATH_CHANCTX_EVENT_UNASSIGN);
 180                 case_rtn_string(ATH_CHANCTX_EVENT_CHANGE);
 181                 case_rtn_string(ATH_CHANCTX_EVENT_ENABLE_MULTICHANNEL);
 182         default:
 183                 return "unknown";
 184         }
 185 }
 186
 187 static const char *chanctx_state_string(enum ath_chanctx_state state)
 188 {
 189         switch (state) {
 190                 case_rtn_string(ATH_CHANCTX_STATE_IDLE);
 191                 case_rtn_string(ATH_CHANCTX_STATE_WAIT_FOR_BEACON);
 192                 case_rtn_string(ATH_CHANCTX_STATE_WAIT_FOR_TIMER);
 193                 case_rtn_string(ATH_CHANCTX_STATE_SWITCH);
 194                 case_rtn_string(ATH_CHANCTX_STATE_FORCE_ACTIVE);
 195         default:
 196                 return "unknown";
 197         }
 198 }
 199
 200 void ath_chanctx_check_active(struct ath_softc *sc, struct ath_chanctx *ctx)
 201 {
 202         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 203         struct ath_vif *avp;
 204         bool active = false;
 205         u8 n_active = 0;
 206
 207         if (!ctx)
 208                 return;
 209
 210         list_for_each_entry(avp, &ctx->vifs, list) {
 211                 struct ieee80211_vif *vif = avp->vif;
 212
 213                 switch (vif->type) {
 214                 case NL80211_IFTYPE_P2P_CLIENT:
 215                 case NL80211_IFTYPE_STATION:
 216                         if (vif->bss_conf.assoc)
 217                                 active = true;
 218                         break;
 219                 default:
 220                         active = true;
 221                         break;
 222                 }
 223         }
 224         ctx->active = active;
 225
 226         ath_for_each_chanctx(sc, ctx) {
 227                 if (!ctx->assigned || list_empty(&ctx->vifs))
 228                         continue;
 229                 n_active++;
 230         }
 231
 232         if (n_active <= 1) {
 233                 clear_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags);
 234                 return;
 235         }
 236         if (test_and_set_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags))
 237                 return;
 238
 239         if (ath9k_is_chanctx_enabled()) {
 240                 ath_chanctx_event(sc, NULL,
 241                                   ATH_CHANCTX_EVENT_ENABLE_MULTICHANNEL);
 242         }
 243 }
 244
 245 static struct ath_chanctx *
 246 ath_chanctx_get_next(struct ath_softc *sc, struct ath_chanctx *ctx)
 247 {
 248         int idx = ctx - &sc->chanctx[0];
 249
 250         return &sc->chanctx[!idx];
 251 }
 252
 253 static void ath_chanctx_adjust_tbtt_delta(struct ath_softc *sc)
 254 {
 255         struct ath_chanctx *prev, *cur;
 256         struct timespec ts;
 257         u32 cur_tsf, prev_tsf, beacon_int;
 258         s32 offset;
 259
 260         beacon_int = TU_TO_USEC(sc->cur_chan->beacon.beacon_interval);
 261
 262         cur = sc->cur_chan;
 263         prev = ath_chanctx_get_next(sc, cur);
 264
 265         getrawmonotonic(&ts);
 266         cur_tsf = (u32) cur->tsf_val +
 267                   ath9k_hw_get_tsf_offset(&cur->tsf_ts, &ts);
 268
 269         prev_tsf = prev->last_beacon - (u32) prev->tsf_val + cur_tsf;
 270         prev_tsf -= ath9k_hw_get_tsf_offset(&prev->tsf_ts, &ts);
 271
 272         /* Adjust the TSF time of the AP chanctx to keep its beacons
 273          * at half beacon interval offset relative to the STA chanctx.
 274          */
 275         offset = cur_tsf - prev_tsf;
 276
 277         /* Ignore stale data or spurious timestamps */
 278         if (offset < 0 || offset > 3 * beacon_int)
 279                 return;
 280
 281         offset = beacon_int / 2 - (offset % beacon_int);
 282         prev->tsf_val += offset;
 283 }
 284
 285 /* Configure the TSF based hardware timer for a channel switch.
 286  * Also set up backup software timer, in case the gen timer fails.
 287  * This could be caused by a hardware reset.
 288  */
 289 static void ath_chanctx_setup_timer(struct ath_softc *sc, u32 tsf_time)
 290 {
 291         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 292         struct ath_hw *ah = sc->sc_ah;
 293
 294         ath9k_hw_gen_timer_start(ah, sc->p2p_ps_timer, tsf_time, 1000000);
 295         tsf_time -= ath9k_hw_gettsf32(ah);
 296         tsf_time = msecs_to_jiffies(tsf_time / 1000) + 1;
 297         mod_timer(&sc->sched.timer, jiffies + tsf_time);
 298
 299         ath_dbg(common, CHAN_CTX,
 300                 "Setup chanctx timer with timeout: %d ms\n", jiffies_to_msecs(tsf_time));
 301 }
 302
 303 void ath_chanctx_event(struct ath_softc *sc, struct ieee80211_vif *vif,
 304                        enum ath_chanctx_event ev)
 305 {
 306         struct ath_hw *ah = sc->sc_ah;
 307         struct ath_common *common = ath9k_hw_common(ah);
 308         struct ath_beacon_config *cur_conf;
 309         struct ath_vif *avp = NULL;
 310         struct ath_chanctx *ctx;
 311         u32 tsf_time;
 312         u32 beacon_int;
 313         bool noa_changed = false;
 314
 315         if (vif)
 316                 avp = (struct ath_vif *) vif->drv_priv;
 317
 318         spin_lock_bh(&sc->chan_lock);
 319
 320         ath_dbg(common, CHAN_CTX, "cur_chan: %d MHz, event: %s, state: %s\n",
 321                 sc->cur_chan->chandef.center_freq1,
 322                 chanctx_event_string(ev),
 323                 chanctx_state_string(sc->sched.state));
 324
 325         switch (ev) {
 326         case ATH_CHANCTX_EVENT_BEACON_PREPARE:
 327                 if (avp->offchannel_duration)
 328                         avp->offchannel_duration = 0;
 329
 330                 if (avp->chanctx != sc->cur_chan) {
 331                         ath_dbg(common, CHAN_CTX,
 332                                 "Contexts differ, not preparing beacon\n");
 333                         break;
 334                 }
 335
 336                 if (sc->sched.offchannel_pending && !sc->sched.wait_switch) {
 337                         sc->sched.offchannel_pending = false;
 338                         sc->next_chan = &sc->offchannel.chan;
 339                         sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;
 340                         ath_dbg(common, CHAN_CTX,
 341                                 "Setting offchannel_pending to false\n");
 342                 }
 343
 344                 ctx = ath_chanctx_get_next(sc, sc->cur_chan);
 345                 if (ctx->active && sc->sched.state == ATH_CHANCTX_STATE_IDLE) {
 346                         sc->next_chan = ctx;
 347                         sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;
 348                         ath_dbg(common, CHAN_CTX,
 349                                 "Set next context, move chanctx state to WAIT_FOR_BEACON\n");
 350                 }
 351
 352                 /* if the timer missed its window, use the next interval */
 353                 if (sc->sched.state == ATH_CHANCTX_STATE_WAIT_FOR_TIMER) {
 354                         sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;
 355                         ath_dbg(common, CHAN_CTX,
 356                                 "Move chanctx state from WAIT_FOR_TIMER to WAIT_FOR_BEACON\n");
 357                 }
 358
 359                 if (sc->sched.state != ATH_CHANCTX_STATE_WAIT_FOR_BEACON)
 360                         break;
 361
 362                 ath_dbg(common, CHAN_CTX, "Preparing beacon for vif: %pM\n", vif->addr);
 363
 364                 sc->sched.beacon_pending = true;
 365                 sc->sched.next_tbtt = REG_READ(ah, AR_NEXT_TBTT_TIMER);
 366
 367                 cur_conf = &sc->cur_chan->beacon;
 368                 beacon_int = TU_TO_USEC(cur_conf->beacon_interval);
 369
 370                 /* defer channel switch by a quarter beacon interval */
 371                 tsf_time = sc->sched.next_tbtt + beacon_int / 4;
 372                 sc->sched.switch_start_time = tsf_time;
 373                 sc->cur_chan->last_beacon = sc->sched.next_tbtt;
 374
 375                 /* Prevent wrap-around issues */
 376                 if (avp->periodic_noa_duration &&
 377                     tsf_time - avp->periodic_noa_start > BIT(30))
 378                         avp->periodic_noa_duration = 0;
 379
 380                 if (ctx->active) {
 381                         avp->periodic_noa_start = tsf_time;
 382                         avp->periodic_noa_duration =
 383                                 TU_TO_USEC(cur_conf->beacon_interval) / 2 -
 384                                 sc->sched.channel_switch_time;
 385                         noa_changed = true;
 386                 } else if (!ctx->active) {
 387                         avp->periodic_noa_duration = 0;
 388                         noa_changed = true;
 389                 }
 390
 391                 /* If at least two consecutive beacons were missed on the STA
 392                  * chanctx, stay on the STA channel for one extra beacon period,
 393                  * to resync the timer properly.
 394                  */
 395                 if (ctx->active && sc->sched.beacon_miss >= 2)
 396                         sc->sched.offchannel_duration = 3 * beacon_int / 2;
 397
 398                 if (sc->sched.offchannel_duration) {
 399                         noa_changed = true;
 400                         avp->offchannel_start = tsf_time;
 401                         avp->offchannel_duration =
 402                                 sc->sched.offchannel_duration;
 403                 }
 404
 405                 if (noa_changed)
 406                         avp->noa_index++;
 407
 408                 ath_dbg(common, CHAN_CTX,
 409                         "periodic_noa_duration: %d, periodic_noa_start: %d, noa_index: %d\n",
 410                         avp->periodic_noa_duration,
 411                         avp->periodic_noa_start,
 412                         avp->noa_index);
 413
 414                 break;
 415         case ATH_CHANCTX_EVENT_BEACON_SENT:
 416                 if (!sc->sched.beacon_pending) {
 417                         ath_dbg(common, CHAN_CTX,
 418                                 "No pending beacon\n");
 419                         break;
 420                 }
 421
 422                 sc->sched.beacon_pending = false;
 423                 if (sc->sched.state != ATH_CHANCTX_STATE_WAIT_FOR_BEACON)
 424                         break;
 425
 426                 ath_dbg(common, CHAN_CTX,
 427                         "Move chanctx state to WAIT_FOR_TIMER\n");
 428
 429                 sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_TIMER;
 430                 ath_chanctx_setup_timer(sc, sc->sched.switch_start_time);
 431                 break;
 432         case ATH_CHANCTX_EVENT_TSF_TIMER:
 433                 if (sc->sched.state != ATH_CHANCTX_STATE_WAIT_FOR_TIMER)
 434                         break;
 435
 436                 if (!sc->cur_chan->switch_after_beacon &&
 437                     sc->sched.beacon_pending)
 438                         sc->sched.beacon_miss++;
 439
 440                 ath_dbg(common, CHAN_CTX,
 441                         "Move chanctx state to SWITCH\n");
 442
 443                 sc->sched.state = ATH_CHANCTX_STATE_SWITCH;
 444                 ieee80211_queue_work(sc->hw, &sc->chanctx_work);
 445                 break;
 446         case ATH_CHANCTX_EVENT_BEACON_RECEIVED:
 447                 if (!test_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags) ||
 448                     sc->cur_chan == &sc->offchannel.chan)
 449                         break;
 450
 451                 ath_chanctx_adjust_tbtt_delta(sc);
 452                 sc->sched.beacon_pending = false;
 453                 sc->sched.beacon_miss = 0;
 454
 455                 /* TSF time might have been updated by the incoming beacon,
 456                  * need update the channel switch timer to reflect the change.
 457                  */
 458                 tsf_time = sc->sched.switch_start_time;
 459                 tsf_time -= (u32) sc->cur_chan->tsf_val +
 460                         ath9k_hw_get_tsf_offset(&sc->cur_chan->tsf_ts, NULL);
 461                 tsf_time += ath9k_hw_gettsf32(ah);
 462
 463
 464                 ath_chanctx_setup_timer(sc, tsf_time);
 465                 break;
 466         case ATH_CHANCTX_EVENT_ASSOC:
 467                 if (sc->sched.state != ATH_CHANCTX_STATE_FORCE_ACTIVE ||
 468                     avp->chanctx != sc->cur_chan)
 469                         break;
 470
 471                 ath_dbg(common, CHAN_CTX,
 472                         "Move chanctx state from FORCE_ACTIVE to IDLE\n");
 473
 474                 sc->sched.state = ATH_CHANCTX_STATE_IDLE;
 475                 /* fall through */
 476         case ATH_CHANCTX_EVENT_SWITCH:
 477                 if (!test_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags) ||
 478                     sc->sched.state == ATH_CHANCTX_STATE_FORCE_ACTIVE ||
 479                     sc->cur_chan->switch_after_beacon ||
 480                     sc->cur_chan == &sc->offchannel.chan)
 481                         break;
 482
 483                 /* If this is a station chanctx, stay active for a half
 484                  * beacon period (minus channel switch time)
 485                  */
 486                 sc->next_chan = ath_chanctx_get_next(sc, sc->cur_chan);
 487                 cur_conf = &sc->cur_chan->beacon;
 488
 489                 ath_dbg(common, CHAN_CTX,
 490                         "Move chanctx state to WAIT_FOR_TIMER (event SWITCH)\n");
 491
 492                 sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_TIMER;
 493                 sc->sched.wait_switch = false;
 494
 495                 tsf_time = TU_TO_USEC(cur_conf->beacon_interval) / 2;
 496                 if (sc->sched.beacon_miss >= 2) {
 497                         sc->sched.beacon_miss = 0;
 498                         tsf_time *= 3;
 499                 }
 500
 501                 tsf_time -= sc->sched.channel_switch_time;
 502                 tsf_time += ath9k_hw_gettsf32(sc->sc_ah);
 503                 sc->sched.switch_start_time = tsf_time;
 504
 505                 ath_chanctx_setup_timer(sc, tsf_time);
 506                 sc->sched.beacon_pending = true;
 507                 break;
 508         case ATH_CHANCTX_EVENT_ENABLE_MULTICHANNEL:
 509                 if (sc->cur_chan == &sc->offchannel.chan ||
 510                     sc->cur_chan->switch_after_beacon)
 511                         break;
 512
 513                 sc->next_chan = ath_chanctx_get_next(sc, sc->cur_chan);
 514                 ieee80211_queue_work(sc->hw, &sc->chanctx_work);
 515                 break;
 516         case ATH_CHANCTX_EVENT_UNASSIGN:
 517                 if (sc->cur_chan->assigned) {
 518                         if (sc->next_chan && !sc->next_chan->assigned &&
 519                             sc->next_chan != &sc->offchannel.chan)
 520                                 sc->sched.state = ATH_CHANCTX_STATE_IDLE;
 521                         break;
 522                 }
 523
 524                 ctx = ath_chanctx_get_next(sc, sc->cur_chan);
 525                 sc->sched.state = ATH_CHANCTX_STATE_IDLE;
 526                 if (!ctx->assigned)
 527                         break;
 528
 529                 sc->next_chan = ctx;
 530                 ieee80211_queue_work(sc->hw, &sc->chanctx_work);
 531                 break;
 532         case ATH_CHANCTX_EVENT_ASSIGN:
 533                 /*
 534                  * When adding a new channel context, check if a scan
 535                  * is in progress and abort it since the addition of
 536                  * a new channel context is usually followed by VIF
 537                  * assignment, in which case we have to start multi-channel
 538                  * operation.
 539                  */
 540                 if (test_bit(ATH_OP_SCANNING, &common->op_flags)) {
 541                         ath_dbg(common, CHAN_CTX,
 542                                 "Aborting HW scan to add new context\n");
 543
 544                         spin_unlock_bh(&sc->chan_lock);
 545                         del_timer_sync(&sc->offchannel.timer);
 546                         ath_scan_complete(sc, true);
 547                         spin_lock_bh(&sc->chan_lock);
 548                 }
 549                 break;
 550         case ATH_CHANCTX_EVENT_CHANGE:
 551                 break;
 552         }
 553
 554         spin_unlock_bh(&sc->chan_lock);
 555 }
 556
 557 void ath_chanctx_beacon_sent_ev(struct ath_softc *sc,
 558                                 enum ath_chanctx_event ev)
 559 {
 560         if (sc->sched.beacon_pending)
 561                 ath_chanctx_event(sc, NULL, ev);
 562 }
 563
 564 void ath_chanctx_beacon_recv_ev(struct ath_softc *sc, u32 ts,
 565                                 enum ath_chanctx_event ev)
 566 {
 567         sc->sched.next_tbtt = ts;
 568         ath_chanctx_event(sc, NULL, ev);
 569 }
 570
 571 static int ath_scan_channel_duration(struct ath_softc *sc,
 572                                      struct ieee80211_channel *chan)
 573 {
 574         struct cfg80211_scan_request *req = sc->offchannel.scan_req;
 575
 576         if (!req->n_ssids || (chan->flags & IEEE80211_CHAN_NO_IR))
 577                 return (HZ / 9); /* ~110 ms */
 578
 579         return (HZ / 16); /* ~60 ms */
 580 }
 581
 582 static void ath_chanctx_switch(struct ath_softc *sc, struct ath_chanctx *ctx,
 583                                struct cfg80211_chan_def *chandef)
 584 {
 585         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 586
 587         spin_lock_bh(&sc->chan_lock);
 588
 589         if (test_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags) &&
 590             (sc->cur_chan != ctx) && (ctx == &sc->offchannel.chan)) {
 591                 if (chandef)
 592                         ctx->chandef = *chandef;
 593
 594                 sc->sched.offchannel_pending = true;
 595                 sc->sched.wait_switch = true;
 596                 sc->sched.offchannel_duration =
 597                         jiffies_to_usecs(sc->offchannel.duration) +
 598                         sc->sched.channel_switch_time;
 599
 600                 spin_unlock_bh(&sc->chan_lock);
 601                 ath_dbg(common, CHAN_CTX,
 602                         "Set offchannel_pending to true\n");
 603                 return;
 604         }
 605
 606         sc->next_chan = ctx;
 607         if (chandef) {
 608                 ctx->chandef = *chandef;
 609                 ath_dbg(common, CHAN_CTX,
 610                         "Assigned next_chan to %d MHz\n", chandef->center_freq1);
 611         }
 612
 613         if (sc->next_chan == &sc->offchannel.chan) {
 614                 sc->sched.offchannel_duration =
 615                         jiffies_to_usecs(sc->offchannel.duration) +
 616                         sc->sched.channel_switch_time;
 617
 618                 if (chandef) {
 619                         ath_dbg(common, CHAN_CTX,
 620                                 "Offchannel duration for chan %d MHz : %u\n",
 621                                 chandef->center_freq1,
 622                                 sc->sched.offchannel_duration);
 623                 }
 624         }
 625         spin_unlock_bh(&sc->chan_lock);
 626         ieee80211_queue_work(sc->hw, &sc->chanctx_work);
 627 }
 628
 629 static void ath_chanctx_offchan_switch(struct ath_softc *sc,
 630                                        struct ieee80211_channel *chan)
 631 {
 632         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 633         struct cfg80211_chan_def chandef;
 634
 635         cfg80211_chandef_create(&chandef, chan, NL80211_CHAN_NO_HT);
 636         ath_dbg(common, CHAN_CTX,
 637                 "Channel definition created: %d MHz\n", chandef.center_freq1);
 638
 639         ath_chanctx_switch(sc, &sc->offchannel.chan, &chandef);
 640 }
 641
 642 static struct ath_chanctx *ath_chanctx_get_oper_chan(struct ath_softc *sc,
 643                                                      bool active)
 644 {
 645         struct ath_chanctx *ctx;
 646
 647         ath_for_each_chanctx(sc, ctx) {
 648                 if (!ctx->assigned || list_empty(&ctx->vifs))
 649                         continue;
 650                 if (active && !ctx->active)
 651                         continue;
 652
 653                 if (ctx->switch_after_beacon)
 654                         return ctx;
 655         }
 656
 657         return &sc->chanctx[0];
 658 }
 659
 660 static void
 661 ath_scan_next_channel(struct ath_softc *sc)
 662 {
 663         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 664         struct cfg80211_scan_request *req = sc->offchannel.scan_req;
 665         struct ieee80211_channel *chan;
 666
 667         if (sc->offchannel.scan_idx >= req->n_channels) {
 668                 ath_dbg(common, CHAN_CTX,
 669                         "Moving offchannel state to ATH_OFFCHANNEL_IDLE, "
 670                         "scan_idx: %d, n_channels: %d\n",
 671                         sc->offchannel.scan_idx,
 672                         req->n_channels);
 673
 674                 sc->offchannel.state = ATH_OFFCHANNEL_IDLE;
 675                 ath_chanctx_switch(sc, ath_chanctx_get_oper_chan(sc, false),
 676                                    NULL);
 677                 return;
 678         }
 679
 680         ath_dbg(common, CHAN_CTX,
 681                 "Moving offchannel state to ATH_OFFCHANNEL_PROBE_SEND, scan_idx: %d\n",
 682                 sc->offchannel.scan_idx);
 683
 684         chan = req->channels[sc->offchannel.scan_idx++];
 685         sc->offchannel.duration = ath_scan_channel_duration(sc, chan);
 686         sc->offchannel.state = ATH_OFFCHANNEL_PROBE_SEND;
 687
 688         ath_chanctx_offchan_switch(sc, chan);
 689 }
 690
 691 void ath_offchannel_next(struct ath_softc *sc)
 692 {
 693         struct ieee80211_vif *vif;
 694
 695         if (sc->offchannel.scan_req) {
 696                 vif = sc->offchannel.scan_vif;
 697                 sc->offchannel.chan.txpower = vif->bss_conf.txpower;
 698                 ath_scan_next_channel(sc);
 699         } else if (sc->offchannel.roc_vif) {
 700                 vif = sc->offchannel.roc_vif;
 701                 sc->offchannel.chan.txpower = vif->bss_conf.txpower;
 702                 sc->offchannel.duration =
 703                         msecs_to_jiffies(sc->offchannel.roc_duration);
 704                 sc->offchannel.state = ATH_OFFCHANNEL_ROC_START;
 705                 ath_chanctx_offchan_switch(sc, sc->offchannel.roc_chan);
 706         } else {
 707                 ath_chanctx_switch(sc, ath_chanctx_get_oper_chan(sc, false),
 708                                    NULL);
 709                 sc->offchannel.state = ATH_OFFCHANNEL_IDLE;
 710                 if (sc->ps_idle)
 711                         ath_cancel_work(sc);
 712         }
 713 }
 714
 715 void ath_roc_complete(struct ath_softc *sc, bool abort)
 716 {
 717         sc->offchannel.roc_vif = NULL;
 718         sc->offchannel.roc_chan = NULL;
 719         if (!abort)
 720                 ieee80211_remain_on_channel_expired(sc->hw);
 721         ath_offchannel_next(sc);
 722         ath9k_ps_restore(sc);
 723 }
 724
 725 void ath_scan_complete(struct ath_softc *sc, bool abort)
 726 {
 727         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 728
 729         if (abort)
 730                 ath_dbg(common, CHAN_CTX, "HW scan aborted\n");
 731         else
 732                 ath_dbg(common, CHAN_CTX, "HW scan complete\n");
 733
 734         sc->offchannel.scan_req = NULL;
 735         sc->offchannel.scan_vif = NULL;
 736         sc->offchannel.state = ATH_OFFCHANNEL_IDLE;
 737         ieee80211_scan_completed(sc->hw, abort);
 738         clear_bit(ATH_OP_SCANNING, &common->op_flags);
 739         ath_offchannel_next(sc);
 740         ath9k_ps_restore(sc);
 741 }
 742
 743 static void ath_scan_send_probe(struct ath_softc *sc,
 744                                 struct cfg80211_ssid *ssid)
 745 {
 746         struct cfg80211_scan_request *req = sc->offchannel.scan_req;
 747         struct ieee80211_vif *vif = sc->offchannel.scan_vif;
 748         struct ath_tx_control txctl = {};
 749         struct sk_buff *skb;
 750         struct ieee80211_tx_info *info;
 751         int band = sc->offchannel.chan.chandef.chan->band;
 752
 753         skb = ieee80211_probereq_get(sc->hw, vif,
 754                         ssid->ssid, ssid->ssid_len, req->ie_len);
 755         if (!skb)
 756                 return;
 757
 758         info = IEEE80211_SKB_CB(skb);
 759         if (req->no_cck)
 760                 info->flags |= IEEE80211_TX_CTL_NO_CCK_RATE;
 761
 762         if (req->ie_len)
 763                 memcpy(skb_put(skb, req->ie_len), req->ie, req->ie_len);
 764
 765         skb_set_queue_mapping(skb, IEEE80211_AC_VO);
 766
 767         if (!ieee80211_tx_prepare_skb(sc->hw, vif, skb, band, NULL))
 768                 goto error;
 769
 770         txctl.txq = sc->tx.txq_map[IEEE80211_AC_VO];
 771         txctl.force_channel = true;
 772         if (ath_tx_start(sc->hw, skb, &txctl))
 773                 goto error;
 774
 775         return;
 776
 777 error:
 778         ieee80211_free_txskb(sc->hw, skb);
 779 }
 780
 781 static void ath_scan_channel_start(struct ath_softc *sc)
 782 {
 783         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 784         struct cfg80211_scan_request *req = sc->offchannel.scan_req;
 785         int i;
 786
 787         if (!(sc->cur_chan->chandef.chan->flags & IEEE80211_CHAN_NO_IR) &&
 788             req->n_ssids) {
 789                 for (i = 0; i < req->n_ssids; i++)
 790                         ath_scan_send_probe(sc, &req->ssids[i]);
 791
 792         }
 793
 794         ath_dbg(common, CHAN_CTX,
 795                 "Moving offchannel state to ATH_OFFCHANNEL_PROBE_WAIT\n");
 796
 797         sc->offchannel.state = ATH_OFFCHANNEL_PROBE_WAIT;
 798         mod_timer(&sc->offchannel.timer, jiffies + sc->offchannel.duration);
 799 }
 800
 801 static void ath_chanctx_timer(unsigned long data)
 802 {
 803         struct ath_softc *sc = (struct ath_softc *) data;
 804         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 805
 806         ath_dbg(common, CHAN_CTX,
 807                 "Channel context timer invoked\n");
 808
 809         ath_chanctx_event(sc, NULL, ATH_CHANCTX_EVENT_TSF_TIMER);
 810 }
 811
 812 static void ath_offchannel_timer(unsigned long data)
 813 {
 814         struct ath_softc *sc = (struct ath_softc *)data;
 815         struct ath_chanctx *ctx;
 816         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 817
 818         ath_dbg(common, CHAN_CTX, "%s: offchannel state: %s\n",
 819                 __func__, offchannel_state_string(sc->offchannel.state));
 820
 821         switch (sc->offchannel.state) {
 822         case ATH_OFFCHANNEL_PROBE_WAIT:
 823                 if (!sc->offchannel.scan_req)
 824                         return;
 825
 826                 /* get first active channel context */
 827                 ctx = ath_chanctx_get_oper_chan(sc, true);
 828                 if (ctx->active) {
 829                         ath_dbg(common, CHAN_CTX,
 830                                 "Switch to oper/active context, "
 831                                 "move offchannel state to ATH_OFFCHANNEL_SUSPEND\n");
 832
 833                         sc->offchannel.state = ATH_OFFCHANNEL_SUSPEND;
 834                         ath_chanctx_switch(sc, ctx, NULL);
 835                         mod_timer(&sc->offchannel.timer, jiffies + HZ / 10);
 836                         break;
 837                 }
 838                 /* fall through */
 839         case ATH_OFFCHANNEL_SUSPEND:
 840                 if (!sc->offchannel.scan_req)
 841                         return;
 842
 843                 ath_scan_next_channel(sc);
 844                 break;
 845         case ATH_OFFCHANNEL_ROC_START:
 846         case ATH_OFFCHANNEL_ROC_WAIT:
 847                 ctx = ath_chanctx_get_oper_chan(sc, false);
 848                 sc->offchannel.state = ATH_OFFCHANNEL_ROC_DONE;
 849                 ath_chanctx_switch(sc, ctx, NULL);
 850                 break;
 851         default:
 852                 break;
 853         }
 854 }
 855
 856 static bool
 857 ath_chanctx_send_vif_ps_frame(struct ath_softc *sc, struct ath_vif *avp,
 858                               bool powersave)
 859 {
 860         struct ieee80211_vif *vif = avp->vif;
 861         struct ieee80211_sta *sta = NULL;
 862         struct ieee80211_hdr_3addr *nullfunc;
 863         struct ath_tx_control txctl;
 864         struct sk_buff *skb;
 865         int band = sc->cur_chan->chandef.chan->band;
 866
 867         switch (vif->type) {
 868         case NL80211_IFTYPE_STATION:
 869                 if (!vif->bss_conf.assoc)
 870                         return false;
 871
 872                 skb = ieee80211_nullfunc_get(sc->hw, vif);
 873                 if (!skb)
 874                         return false;
 875
 876                 nullfunc = (struct ieee80211_hdr_3addr *) skb->data;
 877                 if (powersave)
 878                         nullfunc->frame_control |=
 879                                 cpu_to_le16(IEEE80211_FCTL_PM);
 880
 881                 skb_set_queue_mapping(skb, IEEE80211_AC_VO);
 882                 if (!ieee80211_tx_prepare_skb(sc->hw, vif, skb, band, &sta)) {
 883                         dev_kfree_skb_any(skb);
 884                         return false;
 885                 }
 886                 break;
 887         default:
 888                 return false;
 889         }
 890
 891         memset(&txctl, 0, sizeof(txctl));
 892         txctl.txq = sc->tx.txq_map[IEEE80211_AC_VO];
 893         txctl.sta = sta;
 894         txctl.force_channel = true;
 895         if (ath_tx_start(sc->hw, skb, &txctl)) {
 896                 ieee80211_free_txskb(sc->hw, skb);
 897                 return false;
 898         }
 899
 900         return true;
 901 }
 902
 903 static bool
 904 ath_chanctx_send_ps_frame(struct ath_softc *sc, bool powersave)
 905 {
 906         struct ath_vif *avp;
 907         bool sent = false;
 908
 909         rcu_read_lock();
 910         list_for_each_entry(avp, &sc->cur_chan->vifs, list) {
 911                 if (ath_chanctx_send_vif_ps_frame(sc, avp, powersave))
 912                         sent = true;
 913         }
 914         rcu_read_unlock();
 915
 916         return sent;
 917 }
 918
 919 static bool ath_chanctx_defer_switch(struct ath_softc *sc)
 920 {
 921         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 922
 923         if (sc->cur_chan == &sc->offchannel.chan)
 924                 return false;
 925
 926         switch (sc->sched.state) {
 927         case ATH_CHANCTX_STATE_SWITCH:
 928                 return false;
 929         case ATH_CHANCTX_STATE_IDLE:
 930                 if (!sc->cur_chan->switch_after_beacon)
 931                         return false;
 932
 933                 ath_dbg(common, CHAN_CTX,
 934                         "Defer switch, set chanctx state to WAIT_FOR_BEACON\n");
 935
 936                 sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;
 937                 break;
 938         default:
 939                 break;
 940         }
 941
 942         return true;
 943 }
 944
 945 static void ath_offchannel_channel_change(struct ath_softc *sc)
 946 {
 947         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 948
 949         ath_dbg(common, CHAN_CTX, "%s: offchannel state: %s\n",
 950                 __func__, offchannel_state_string(sc->offchannel.state));
 951
 952         switch (sc->offchannel.state) {
 953         case ATH_OFFCHANNEL_PROBE_SEND:
 954                 if (!sc->offchannel.scan_req)
 955                         return;
 956
 957                 if (sc->cur_chan->chandef.chan !=
 958                     sc->offchannel.chan.chandef.chan)
 959                         return;
 960
 961                 ath_scan_channel_start(sc);
 962                 break;
 963         case ATH_OFFCHANNEL_IDLE:
 964                 if (!sc->offchannel.scan_req)
 965                         return;
 966
 967                 ath_scan_complete(sc, false);
 968                 break;
 969         case ATH_OFFCHANNEL_ROC_START:
 970                 if (sc->cur_chan != &sc->offchannel.chan)
 971                         break;
 972
 973                 sc->offchannel.state = ATH_OFFCHANNEL_ROC_WAIT;
 974                 mod_timer(&sc->offchannel.timer,
 975                           jiffies + sc->offchannel.duration);
 976                 ieee80211_ready_on_channel(sc->hw);
 977                 break;
 978         case ATH_OFFCHANNEL_ROC_DONE:
 979                 ath_roc_complete(sc, false);
 980                 break;
 981         default:
 982                 break;
 983         }
 984 }
 985
 986 void ath_chanctx_set_next(struct ath_softc *sc, bool force)
 987 {
 988         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 989         struct timespec ts;
 990         bool measure_time = false;
 991         bool send_ps = false;
 992
 993         spin_lock_bh(&sc->chan_lock);
 994         if (!sc->next_chan) {
 995                 spin_unlock_bh(&sc->chan_lock);
 996                 return;
 997         }
 998
 999         if (!force && ath_chanctx_defer_switch(sc)) {
1000                 spin_unlock_bh(&sc->chan_lock);
1001                 return;
1002         }
1003
1004         ath_dbg(common, CHAN_CTX,
1005                 "%s: current: %d MHz, next: %d MHz\n",
1006                 __func__,
1007                 sc->cur_chan->chandef.center_freq1,
1008                 sc->next_chan->chandef.center_freq1);
1009
1010         if (sc->cur_chan != sc->next_chan) {
1011                 ath_dbg(common, CHAN_CTX,
1012                         "Stopping current chanctx: %d\n",
1013                         sc->cur_chan->chandef.center_freq1);
1014                 sc->cur_chan->stopped = true;
1015                 spin_unlock_bh(&sc->chan_lock);
1016
1017                 if (sc->next_chan == &sc->offchannel.chan) {
1018                         getrawmonotonic(&ts);
1019                         measure_time = true;
1020                 }
1021                 __ath9k_flush(sc->hw, ~0, true);
1022
1023                 if (ath_chanctx_send_ps_frame(sc, true))
1024                         __ath9k_flush(sc->hw, BIT(IEEE80211_AC_VO), false);
1025
1026                 send_ps = true;
1027                 spin_lock_bh(&sc->chan_lock);
1028
1029                 if (sc->cur_chan != &sc->offchannel.chan) {
1030                         getrawmonotonic(&sc->cur_chan->tsf_ts);
1031                         sc->cur_chan->tsf_val = ath9k_hw_gettsf64(sc->sc_ah);
1032                 }
1033         }
1034         sc->cur_chan = sc->next_chan;
1035         sc->cur_chan->stopped = false;
1036         sc->next_chan = NULL;
1037         sc->sched.offchannel_duration = 0;
1038         if (sc->sched.state != ATH_CHANCTX_STATE_FORCE_ACTIVE)
1039                 sc->sched.state = ATH_CHANCTX_STATE_IDLE;
1040
1041         spin_unlock_bh(&sc->chan_lock);
1042
1043         if (sc->sc_ah->chip_fullsleep ||
1044             memcmp(&sc->cur_chandef, &sc->cur_chan->chandef,
1045                    sizeof(sc->cur_chandef))) {
1046                 ath_dbg(common, CHAN_CTX,
1047                         "%s: Set channel %d MHz\n",
1048                         __func__, sc->cur_chan->chandef.center_freq1);
1049                 ath_set_channel(sc);
1050                 if (measure_time)
1051                         sc->sched.channel_switch_time =
1052                                 ath9k_hw_get_tsf_offset(&ts, NULL);
1053         }
1054         if (send_ps)
1055                 ath_chanctx_send_ps_frame(sc, false);
1056
1057         ath_offchannel_channel_change(sc);
1058         ath_chanctx_event(sc, NULL, ATH_CHANCTX_EVENT_SWITCH);
1059 }
1060
1061 static void ath_chanctx_work(struct work_struct *work)
1062 {
1063         struct ath_softc *sc = container_of(work, struct ath_softc,
1064                                             chanctx_work);
1065         mutex_lock(&sc->mutex);
1066         ath_chanctx_set_next(sc, false);
1067         mutex_unlock(&sc->mutex);
1068 }
1069
1070 void ath9k_offchannel_init(struct ath_softc *sc)
1071 {
1072         struct ath_chanctx *ctx;
1073         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1074         struct ieee80211_supported_band *sband;
1075         struct ieee80211_channel *chan;
1076         int i;
1077
1078         sband = &common->sbands[IEEE80211_BAND_2GHZ];
1079         if (!sband->n_channels)
1080                 sband = &common->sbands[IEEE80211_BAND_5GHZ];
1081
1082         chan = &sband->channels[0];
1083
1084         ctx = &sc->offchannel.chan;
1085         INIT_LIST_HEAD(&ctx->vifs);
1086         ctx->txpower = ATH_TXPOWER_MAX;
1087         cfg80211_chandef_create(&ctx->chandef, chan, NL80211_CHAN_HT20);
1088
1089         for (i = 0; i < ARRAY_SIZE(ctx->acq); i++)
1090                 INIT_LIST_HEAD(&ctx->acq[i]);
1091
1092         sc->offchannel.chan.offchannel = true;
1093 }
1094
1095 void ath9k_init_channel_context(struct ath_softc *sc)
1096 {
1097         INIT_WORK(&sc->chanctx_work, ath_chanctx_work);
1098
1099         setup_timer(&sc->offchannel.timer, ath_offchannel_timer,
1100                     (unsigned long)sc);
1101         setup_timer(&sc->sched.timer, ath_chanctx_timer,
1102                     (unsigned long)sc);
1103 }
1104
1105 void ath9k_deinit_channel_context(struct ath_softc *sc)
1106 {
1107         cancel_work_sync(&sc->chanctx_work);
1108 }
1109
1110 bool ath9k_is_chanctx_enabled(void)
1111 {
1112         return (ath9k_use_chanctx == 1);
1113 }
1114
1115 /********************/
1116 /* Queue management */
1117 /********************/
1118
1119 void ath9k_chanctx_wake_queues(struct ath_softc *sc)
1120 {
1121         struct ath_hw *ah = sc->sc_ah;
1122         int i;
1123
1124         if (sc->cur_chan == &sc->offchannel.chan) {
1125                 ieee80211_wake_queue(sc->hw,
1126                                      sc->hw->offchannel_tx_hw_queue);
1127         } else {
1128                 for (i = 0; i < IEEE80211_NUM_ACS; i++)
1129                         ieee80211_wake_queue(sc->hw,
1130                                              sc->cur_chan->hw_queue_base + i);
1131         }
1132
1133         if (ah->opmode == NL80211_IFTYPE_AP)
1134                 ieee80211_wake_queue(sc->hw, sc->hw->queues - 2);
1135 }
1136
1137 /*****************/
1138 /* P2P Powersave */
1139 /*****************/
1140
1141 static void ath9k_update_p2p_ps_timer(struct ath_softc *sc, struct ath_vif *avp)
1142 {
1143         struct ath_hw *ah = sc->sc_ah;
1144         s32 tsf, target_tsf;
1145
1146         if (!avp || !avp->noa.has_next_tsf)
1147                 return;
1148
1149         ath9k_hw_gen_timer_stop(ah, sc->p2p_ps_timer);
1150
1151         tsf = ath9k_hw_gettsf32(sc->sc_ah);
1152
1153         target_tsf = avp->noa.next_tsf;
1154         if (!avp->noa.absent)
1155                 target_tsf -= ATH_P2P_PS_STOP_TIME;
1156
1157         if (target_tsf - tsf < ATH_P2P_PS_STOP_TIME)
1158                 target_tsf = tsf + ATH_P2P_PS_STOP_TIME;
1159
1160         ath9k_hw_gen_timer_start(ah, sc->p2p_ps_timer, (u32) target_tsf, 1000000);
1161 }
1162
1163 static void ath9k_update_p2p_ps(struct ath_softc *sc, struct ieee80211_vif *vif)
1164 {
1165         struct ath_vif *avp = (void *)vif->drv_priv;
1166         u32 tsf;
1167
1168         if (!sc->p2p_ps_timer)
1169                 return;
1170
1171         if (vif->type != NL80211_IFTYPE_STATION || !vif->p2p)
1172                 return;
1173
1174         sc->p2p_ps_vif = avp;
1175         tsf = ath9k_hw_gettsf32(sc->sc_ah);
1176         ieee80211_parse_p2p_noa(&vif->bss_conf.p2p_noa_attr, &avp->noa, tsf);
1177         ath9k_update_p2p_ps_timer(sc, avp);
1178 }
1179
1180 static u8 ath9k_get_ctwin(struct ath_softc *sc, struct ath_vif *avp)
1181 {
1182         struct ath_beacon_config *cur_conf = &sc->cur_chan->beacon;
1183         u8 switch_time, ctwin;
1184
1185         /*
1186          * Channel switch in multi-channel mode is deferred
1187          * by a quarter beacon interval when handling
1188          * ATH_CHANCTX_EVENT_BEACON_PREPARE, so the P2P-GO
1189          * interface is guaranteed to be discoverable
1190          * for that duration after a TBTT.
1191          */
1192         switch_time = cur_conf->beacon_interval / 4;
1193
1194         ctwin = avp->vif->bss_conf.p2p_noa_attr.oppps_ctwindow;
1195         if (ctwin && (ctwin < switch_time))
1196                 return ctwin;
1197
1198         if (switch_time < P2P_DEFAULT_CTWIN)
1199                 return 0;
1200
1201         return P2P_DEFAULT_CTWIN;
1202 }
1203
1204 void ath9k_beacon_add_noa(struct ath_softc *sc, struct ath_vif *avp,
1205                           struct sk_buff *skb)
1206 {
1207         static const u8 noa_ie_hdr[] = {
1208                 WLAN_EID_VENDOR_SPECIFIC,       /* type */
1209                 0,                              /* length */
1210                 0x50, 0x6f, 0x9a,               /* WFA OUI */
1211                 0x09,                           /* P2P subtype */
1212                 0x0c,                           /* Notice of Absence */
1213                 0x00,                           /* LSB of little-endian len */
1214                 0x00,                           /* MSB of little-endian len */
1215         };
1216
1217         struct ieee80211_p2p_noa_attr *noa;
1218         int noa_len, noa_desc, i = 0;
1219         u8 *hdr;
1220
1221         if (!avp->offchannel_duration && !avp->periodic_noa_duration)
1222                 return;
1223
1224         noa_desc = !!avp->offchannel_duration + !!avp->periodic_noa_duration;
1225         noa_len = 2 + sizeof(struct ieee80211_p2p_noa_desc) * noa_desc;
1226
1227         hdr = skb_put(skb, sizeof(noa_ie_hdr));
1228         memcpy(hdr, noa_ie_hdr, sizeof(noa_ie_hdr));
1229         hdr[1] = sizeof(noa_ie_hdr) + noa_len - 2;
1230         hdr[7] = noa_len;
1231
1232         noa = (void *) skb_put(skb, noa_len);
1233         memset(noa, 0, noa_len);
1234
1235         noa->index = avp->noa_index;
1236         noa->oppps_ctwindow = ath9k_get_ctwin(sc, avp);
1237
1238         if (avp->periodic_noa_duration) {
1239                 u32 interval = TU_TO_USEC(sc->cur_chan->beacon.beacon_interval);
1240
1241                 noa->desc[i].count = 255;
1242                 noa->desc[i].start_time = cpu_to_le32(avp->periodic_noa_start);
1243                 noa->desc[i].duration = cpu_to_le32(avp->periodic_noa_duration);
1244                 noa->desc[i].interval = cpu_to_le32(interval);
1245                 i++;
1246         }
1247
1248         if (avp->offchannel_duration) {
1249                 noa->desc[i].count = 1;
1250                 noa->desc[i].start_time = cpu_to_le32(avp->offchannel_start);
1251                 noa->desc[i].duration = cpu_to_le32(avp->offchannel_duration);
1252         }
1253 }
1254
1255 void ath9k_p2p_ps_timer(void *priv)
1256 {
1257         struct ath_softc *sc = priv;
1258         struct ath_vif *avp = sc->p2p_ps_vif;
1259         struct ieee80211_vif *vif;
1260         struct ieee80211_sta *sta;
1261         struct ath_node *an;
1262         u32 tsf;
1263
1264         del_timer_sync(&sc->sched.timer);
1265         ath9k_hw_gen_timer_stop(sc->sc_ah, sc->p2p_ps_timer);
1266         ath_chanctx_event(sc, NULL, ATH_CHANCTX_EVENT_TSF_TIMER);
1267
1268         if (!avp || avp->chanctx != sc->cur_chan)
1269                 return;
1270
1271         tsf = ath9k_hw_gettsf32(sc->sc_ah);
1272         if (!avp->noa.absent)
1273                 tsf += ATH_P2P_PS_STOP_TIME;
1274
1275         if (!avp->noa.has_next_tsf ||
1276             avp->noa.next_tsf - tsf > BIT(31))
1277                 ieee80211_update_p2p_noa(&avp->noa, tsf);
1278
1279         ath9k_update_p2p_ps_timer(sc, avp);
1280
1281         rcu_read_lock();
1282
1283         vif = avp->vif;
1284         sta = ieee80211_find_sta(vif, vif->bss_conf.bssid);
1285         if (!sta)
1286                 goto out;
1287
1288         an = (void *) sta->drv_priv;
1289         if (an->sleeping == !!avp->noa.absent)
1290                 goto out;
1291
1292         an->sleeping = avp->noa.absent;
1293         if (an->sleeping)
1294                 ath_tx_aggr_sleep(sta, sc, an);
1295         else
1296                 ath_tx_aggr_wakeup(sc, an);
1297
1298 out:
1299         rcu_read_unlock();
1300 }
1301
1302 void ath9k_p2p_bss_info_changed(struct ath_softc *sc,
1303                                 struct ieee80211_vif *vif)
1304 {
1305         unsigned long flags;
1306
1307         spin_lock_bh(&sc->sc_pcu_lock);
1308         spin_lock_irqsave(&sc->sc_pm_lock, flags);
1309         if (!(sc->ps_flags & PS_BEACON_SYNC))
1310                 ath9k_update_p2p_ps(sc, vif);
1311         spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
1312         spin_unlock_bh(&sc->sc_pcu_lock);
1313 }
1314
1315 void ath9k_p2p_beacon_sync(struct ath_softc *sc)
1316 {
1317         if (sc->p2p_ps_vif)
1318                 ath9k_update_p2p_ps(sc, sc->p2p_ps_vif->vif);
1319 }
1320
1321 void ath9k_p2p_remove_vif(struct ath_softc *sc,
1322                           struct ieee80211_vif *vif)
1323 {
1324         struct ath_vif *avp = (void *)vif->drv_priv;
1325
1326         spin_lock_bh(&sc->sc_pcu_lock);
1327         if (avp == sc->p2p_ps_vif) {
1328                 sc->p2p_ps_vif = NULL;
1329                 ath9k_update_p2p_ps_timer(sc, NULL);
1330         }
1331         spin_unlock_bh(&sc->sc_pcu_lock);
1332 }
1333
1334 int ath9k_init_p2p(struct ath_softc *sc)
1335 {
1336         sc->p2p_ps_timer = ath_gen_timer_alloc(sc->sc_ah, ath9k_p2p_ps_timer,
1337                                                NULL, sc, AR_FIRST_NDP_TIMER);
1338         if (!sc->p2p_ps_timer)
1339                 return -ENOMEM;
1340
1341         return 0;
1342 }
1343
1344 void ath9k_deinit_p2p(struct ath_softc *sc)
1345 {
1346         if (sc->p2p_ps_timer)
1347                 ath_gen_timer_free(sc->sc_ah, sc->p2p_ps_timer);
1348 }
1349
1350 #endif /* CONFIG_ATH9K_CHANNEL_CONTEXT */