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