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