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