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[IEEE80211_BAND_2GHZ]; 111 if (!sband->n_channels) 112 sband = &common->sbands[IEEE80211_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 964 if (abort) 965 ath_dbg(common, CHAN_CTX, "HW scan aborted\n"); 966 else 967 ath_dbg(common, CHAN_CTX, "HW scan complete\n"); 968 969 sc->offchannel.scan_req = NULL; 970 sc->offchannel.scan_vif = NULL; 971 sc->offchannel.state = ATH_OFFCHANNEL_IDLE; 972 ieee80211_scan_completed(sc->hw, abort); 973 clear_bit(ATH_OP_SCANNING, &common->op_flags); 974 spin_lock_bh(&sc->chan_lock); 975 if (test_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags)) 976 sc->sched.force_noa_update = true; 977 spin_unlock_bh(&sc->chan_lock); 978 ath_offchannel_next(sc); 979 ath9k_ps_restore(sc); 980 } 981 982 static void ath_scan_send_probe(struct ath_softc *sc, 983 struct cfg80211_ssid *ssid) 984 { 985 struct cfg80211_scan_request *req = sc->offchannel.scan_req; 986 struct ieee80211_vif *vif = sc->offchannel.scan_vif; 987 struct ath_tx_control txctl = {}; 988 struct sk_buff *skb; 989 struct ieee80211_tx_info *info; 990 int band = sc->offchannel.chan.chandef.chan->band; 991 992 skb = ieee80211_probereq_get(sc->hw, vif->addr, 993 ssid->ssid, ssid->ssid_len, req->ie_len); 994 if (!skb) 995 return; 996 997 info = IEEE80211_SKB_CB(skb); 998 if (req->no_cck) 999 info->flags |= IEEE80211_TX_CTL_NO_CCK_RATE; 1000 1001 if (req->ie_len) 1002 memcpy(skb_put(skb, req->ie_len), req->ie, req->ie_len); 1003 1004 skb_set_queue_mapping(skb, IEEE80211_AC_VO); 1005 1006 if (!ieee80211_tx_prepare_skb(sc->hw, vif, skb, band, NULL)) 1007 goto error; 1008 1009 txctl.txq = sc->tx.txq_map[IEEE80211_AC_VO]; 1010 txctl.force_channel = true; 1011 if (ath_tx_start(sc->hw, skb, &txctl)) 1012 goto error; 1013 1014 return; 1015 1016 error: 1017 ieee80211_free_txskb(sc->hw, skb); 1018 } 1019 1020 static void ath_scan_channel_start(struct ath_softc *sc) 1021 { 1022 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 1023 struct cfg80211_scan_request *req = sc->offchannel.scan_req; 1024 int i; 1025 1026 if (!(sc->cur_chan->chandef.chan->flags & IEEE80211_CHAN_NO_IR) && 1027 req->n_ssids) { 1028 for (i = 0; i < req->n_ssids; i++) 1029 ath_scan_send_probe(sc, &req->ssids[i]); 1030 1031 } 1032 1033 ath_dbg(common, CHAN_CTX, 1034 "Moving offchannel state to ATH_OFFCHANNEL_PROBE_WAIT\n"); 1035 1036 sc->offchannel.state = ATH_OFFCHANNEL_PROBE_WAIT; 1037 mod_timer(&sc->offchannel.timer, jiffies + sc->offchannel.duration); 1038 } 1039 1040 static void ath_chanctx_timer(unsigned long data) 1041 { 1042 struct ath_softc *sc = (struct ath_softc *) data; 1043 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 1044 1045 ath_dbg(common, CHAN_CTX, 1046 "Channel context timer invoked\n"); 1047 1048 ath_chanctx_event(sc, NULL, ATH_CHANCTX_EVENT_TSF_TIMER); 1049 } 1050 1051 static void ath_offchannel_timer(unsigned long data) 1052 { 1053 struct ath_softc *sc = (struct ath_softc *)data; 1054 struct ath_chanctx *ctx; 1055 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 1056 1057 ath_dbg(common, CHAN_CTX, "%s: offchannel state: %s\n", 1058 __func__, offchannel_state_string(sc->offchannel.state)); 1059 1060 switch (sc->offchannel.state) { 1061 case ATH_OFFCHANNEL_PROBE_WAIT: 1062 if (!sc->offchannel.scan_req) 1063 return; 1064 1065 /* get first active channel context */ 1066 ctx = ath_chanctx_get_oper_chan(sc, true); 1067 if (ctx->active) { 1068 ath_dbg(common, CHAN_CTX, 1069 "Switch to oper/active context, " 1070 "move offchannel state to ATH_OFFCHANNEL_SUSPEND\n"); 1071 1072 sc->offchannel.state = ATH_OFFCHANNEL_SUSPEND; 1073 ath_chanctx_switch(sc, ctx, NULL); 1074 mod_timer(&sc->offchannel.timer, jiffies + HZ / 10); 1075 break; 1076 } 1077 /* fall through */ 1078 case ATH_OFFCHANNEL_SUSPEND: 1079 if (!sc->offchannel.scan_req) 1080 return; 1081 1082 ath_scan_next_channel(sc); 1083 break; 1084 case ATH_OFFCHANNEL_ROC_START: 1085 case ATH_OFFCHANNEL_ROC_WAIT: 1086 sc->offchannel.state = ATH_OFFCHANNEL_ROC_DONE; 1087 ath_roc_complete(sc, ATH_ROC_COMPLETE_EXPIRE); 1088 break; 1089 default: 1090 break; 1091 } 1092 } 1093 1094 static bool 1095 ath_chanctx_send_vif_ps_frame(struct ath_softc *sc, struct ath_vif *avp, 1096 bool powersave) 1097 { 1098 struct ieee80211_vif *vif = avp->vif; 1099 struct ieee80211_sta *sta = NULL; 1100 struct ieee80211_hdr_3addr *nullfunc; 1101 struct ath_tx_control txctl; 1102 struct sk_buff *skb; 1103 int band = sc->cur_chan->chandef.chan->band; 1104 1105 switch (vif->type) { 1106 case NL80211_IFTYPE_STATION: 1107 if (!avp->assoc) 1108 return false; 1109 1110 skb = ieee80211_nullfunc_get(sc->hw, vif); 1111 if (!skb) 1112 return false; 1113 1114 nullfunc = (struct ieee80211_hdr_3addr *) skb->data; 1115 if (powersave) 1116 nullfunc->frame_control |= 1117 cpu_to_le16(IEEE80211_FCTL_PM); 1118 1119 skb->priority = 7; 1120 skb_set_queue_mapping(skb, IEEE80211_AC_VO); 1121 if (!ieee80211_tx_prepare_skb(sc->hw, vif, skb, band, &sta)) { 1122 dev_kfree_skb_any(skb); 1123 return false; 1124 } 1125 break; 1126 default: 1127 return false; 1128 } 1129 1130 memset(&txctl, 0, sizeof(txctl)); 1131 txctl.txq = sc->tx.txq_map[IEEE80211_AC_VO]; 1132 txctl.sta = sta; 1133 txctl.force_channel = true; 1134 if (ath_tx_start(sc->hw, skb, &txctl)) { 1135 ieee80211_free_txskb(sc->hw, skb); 1136 return false; 1137 } 1138 1139 return true; 1140 } 1141 1142 static bool 1143 ath_chanctx_send_ps_frame(struct ath_softc *sc, bool powersave) 1144 { 1145 struct ath_vif *avp; 1146 bool sent = false; 1147 1148 rcu_read_lock(); 1149 list_for_each_entry(avp, &sc->cur_chan->vifs, list) { 1150 if (ath_chanctx_send_vif_ps_frame(sc, avp, powersave)) 1151 sent = true; 1152 } 1153 rcu_read_unlock(); 1154 1155 return sent; 1156 } 1157 1158 static bool ath_chanctx_defer_switch(struct ath_softc *sc) 1159 { 1160 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 1161 1162 if (sc->cur_chan == &sc->offchannel.chan) 1163 return false; 1164 1165 switch (sc->sched.state) { 1166 case ATH_CHANCTX_STATE_SWITCH: 1167 return false; 1168 case ATH_CHANCTX_STATE_IDLE: 1169 if (!sc->cur_chan->switch_after_beacon) 1170 return false; 1171 1172 ath_dbg(common, CHAN_CTX, 1173 "Defer switch, set chanctx state to WAIT_FOR_BEACON\n"); 1174 1175 sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON; 1176 break; 1177 default: 1178 break; 1179 } 1180 1181 return true; 1182 } 1183 1184 static void ath_offchannel_channel_change(struct ath_softc *sc) 1185 { 1186 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 1187 1188 ath_dbg(common, CHAN_CTX, "%s: offchannel state: %s\n", 1189 __func__, offchannel_state_string(sc->offchannel.state)); 1190 1191 switch (sc->offchannel.state) { 1192 case ATH_OFFCHANNEL_PROBE_SEND: 1193 if (!sc->offchannel.scan_req) 1194 return; 1195 1196 if (sc->cur_chan->chandef.chan != 1197 sc->offchannel.chan.chandef.chan) 1198 return; 1199 1200 ath_scan_channel_start(sc); 1201 break; 1202 case ATH_OFFCHANNEL_IDLE: 1203 if (!sc->offchannel.scan_req) 1204 return; 1205 1206 ath_scan_complete(sc, false); 1207 break; 1208 case ATH_OFFCHANNEL_ROC_START: 1209 if (sc->cur_chan != &sc->offchannel.chan) 1210 break; 1211 1212 sc->offchannel.state = ATH_OFFCHANNEL_ROC_WAIT; 1213 mod_timer(&sc->offchannel.timer, 1214 jiffies + sc->offchannel.duration); 1215 ieee80211_ready_on_channel(sc->hw); 1216 break; 1217 case ATH_OFFCHANNEL_ROC_DONE: 1218 break; 1219 default: 1220 break; 1221 } 1222 } 1223 1224 void ath_chanctx_set_next(struct ath_softc *sc, bool force) 1225 { 1226 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 1227 struct ath_chanctx *old_ctx; 1228 struct timespec ts; 1229 bool measure_time = false; 1230 bool send_ps = false; 1231 bool queues_stopped = false; 1232 1233 spin_lock_bh(&sc->chan_lock); 1234 if (!sc->next_chan) { 1235 spin_unlock_bh(&sc->chan_lock); 1236 return; 1237 } 1238 1239 if (!force && ath_chanctx_defer_switch(sc)) { 1240 spin_unlock_bh(&sc->chan_lock); 1241 return; 1242 } 1243 1244 ath_dbg(common, CHAN_CTX, 1245 "%s: current: %d MHz, next: %d MHz\n", 1246 __func__, 1247 sc->cur_chan->chandef.center_freq1, 1248 sc->next_chan->chandef.center_freq1); 1249 1250 if (sc->cur_chan != sc->next_chan) { 1251 ath_dbg(common, CHAN_CTX, 1252 "Stopping current chanctx: %d\n", 1253 sc->cur_chan->chandef.center_freq1); 1254 sc->cur_chan->stopped = true; 1255 spin_unlock_bh(&sc->chan_lock); 1256 1257 if (sc->next_chan == &sc->offchannel.chan) { 1258 getrawmonotonic(&ts); 1259 measure_time = true; 1260 } 1261 1262 ath9k_chanctx_stop_queues(sc, sc->cur_chan); 1263 queues_stopped = true; 1264 1265 __ath9k_flush(sc->hw, ~0, true, false, false); 1266 1267 if (ath_chanctx_send_ps_frame(sc, true)) 1268 __ath9k_flush(sc->hw, BIT(IEEE80211_AC_VO), 1269 false, false, false); 1270 1271 send_ps = true; 1272 spin_lock_bh(&sc->chan_lock); 1273 1274 if (sc->cur_chan != &sc->offchannel.chan) { 1275 getrawmonotonic(&sc->cur_chan->tsf_ts); 1276 sc->cur_chan->tsf_val = ath9k_hw_gettsf64(sc->sc_ah); 1277 } 1278 } 1279 old_ctx = sc->cur_chan; 1280 sc->cur_chan = sc->next_chan; 1281 sc->cur_chan->stopped = false; 1282 sc->next_chan = NULL; 1283 1284 if (!sc->sched.offchannel_pending) 1285 sc->sched.offchannel_duration = 0; 1286 1287 if (sc->sched.state != ATH_CHANCTX_STATE_FORCE_ACTIVE) 1288 sc->sched.state = ATH_CHANCTX_STATE_IDLE; 1289 1290 spin_unlock_bh(&sc->chan_lock); 1291 1292 if (sc->sc_ah->chip_fullsleep || 1293 memcmp(&sc->cur_chandef, &sc->cur_chan->chandef, 1294 sizeof(sc->cur_chandef))) { 1295 ath_dbg(common, CHAN_CTX, 1296 "%s: Set channel %d MHz\n", 1297 __func__, sc->cur_chan->chandef.center_freq1); 1298 ath_set_channel(sc); 1299 if (measure_time) 1300 sc->sched.channel_switch_time = 1301 ath9k_hw_get_tsf_offset(&ts, NULL); 1302 /* 1303 * A reset will ensure that all queues are woken up, 1304 * so there is no need to awaken them again. 1305 */ 1306 goto out; 1307 } 1308 1309 if (queues_stopped) 1310 ath9k_chanctx_wake_queues(sc, old_ctx); 1311 out: 1312 if (send_ps) 1313 ath_chanctx_send_ps_frame(sc, false); 1314 1315 ath_offchannel_channel_change(sc); 1316 ath_chanctx_event(sc, NULL, ATH_CHANCTX_EVENT_SWITCH); 1317 } 1318 1319 static void ath_chanctx_work(struct work_struct *work) 1320 { 1321 struct ath_softc *sc = container_of(work, struct ath_softc, 1322 chanctx_work); 1323 mutex_lock(&sc->mutex); 1324 ath_chanctx_set_next(sc, false); 1325 mutex_unlock(&sc->mutex); 1326 } 1327 1328 void ath9k_offchannel_init(struct ath_softc *sc) 1329 { 1330 struct ath_chanctx *ctx; 1331 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 1332 struct ieee80211_supported_band *sband; 1333 struct ieee80211_channel *chan; 1334 int i; 1335 1336 sband = &common->sbands[IEEE80211_BAND_2GHZ]; 1337 if (!sband->n_channels) 1338 sband = &common->sbands[IEEE80211_BAND_5GHZ]; 1339 1340 chan = &sband->channels[0]; 1341 1342 ctx = &sc->offchannel.chan; 1343 INIT_LIST_HEAD(&ctx->vifs); 1344 ctx->txpower = ATH_TXPOWER_MAX; 1345 cfg80211_chandef_create(&ctx->chandef, chan, NL80211_CHAN_HT20); 1346 1347 for (i = 0; i < ARRAY_SIZE(ctx->acq); i++) 1348 INIT_LIST_HEAD(&ctx->acq[i]); 1349 1350 sc->offchannel.chan.offchannel = true; 1351 } 1352 1353 void ath9k_init_channel_context(struct ath_softc *sc) 1354 { 1355 INIT_WORK(&sc->chanctx_work, ath_chanctx_work); 1356 1357 setup_timer(&sc->offchannel.timer, ath_offchannel_timer, 1358 (unsigned long)sc); 1359 setup_timer(&sc->sched.timer, ath_chanctx_timer, 1360 (unsigned long)sc); 1361 1362 init_completion(&sc->go_beacon); 1363 } 1364 1365 void ath9k_deinit_channel_context(struct ath_softc *sc) 1366 { 1367 cancel_work_sync(&sc->chanctx_work); 1368 } 1369 1370 bool ath9k_is_chanctx_enabled(void) 1371 { 1372 return (ath9k_use_chanctx == 1); 1373 } 1374 1375 /********************/ 1376 /* Queue management */ 1377 /********************/ 1378 1379 void ath9k_chanctx_stop_queues(struct ath_softc *sc, struct ath_chanctx *ctx) 1380 { 1381 struct ath_hw *ah = sc->sc_ah; 1382 int i; 1383 1384 if (ctx == &sc->offchannel.chan) { 1385 ieee80211_stop_queue(sc->hw, 1386 sc->hw->offchannel_tx_hw_queue); 1387 } else { 1388 for (i = 0; i < IEEE80211_NUM_ACS; i++) 1389 ieee80211_stop_queue(sc->hw, 1390 ctx->hw_queue_base + i); 1391 } 1392 1393 if (ah->opmode == NL80211_IFTYPE_AP) 1394 ieee80211_stop_queue(sc->hw, sc->hw->queues - 2); 1395 } 1396 1397 1398 void ath9k_chanctx_wake_queues(struct ath_softc *sc, struct ath_chanctx *ctx) 1399 { 1400 struct ath_hw *ah = sc->sc_ah; 1401 int i; 1402 1403 if (ctx == &sc->offchannel.chan) { 1404 ieee80211_wake_queue(sc->hw, 1405 sc->hw->offchannel_tx_hw_queue); 1406 } else { 1407 for (i = 0; i < IEEE80211_NUM_ACS; i++) 1408 ieee80211_wake_queue(sc->hw, 1409 ctx->hw_queue_base + i); 1410 } 1411 1412 if (ah->opmode == NL80211_IFTYPE_AP) 1413 ieee80211_wake_queue(sc->hw, sc->hw->queues - 2); 1414 } 1415 1416 /*****************/ 1417 /* P2P Powersave */ 1418 /*****************/ 1419 1420 static void ath9k_update_p2p_ps_timer(struct ath_softc *sc, struct ath_vif *avp) 1421 { 1422 struct ath_common *common = ath9k_hw_common(sc->sc_ah); 1423 struct ath_hw *ah = sc->sc_ah; 1424 u32 tsf, target_tsf; 1425 1426 if (!avp || !avp->noa.has_next_tsf) 1427 return; 1428 1429 ath9k_hw_gen_timer_stop(ah, sc->p2p_ps_timer); 1430 1431 tsf = ath9k_hw_gettsf32(sc->sc_ah); 1432 1433 target_tsf = avp->noa.next_tsf; 1434 if (!avp->noa.absent) 1435 target_tsf -= ATH_P2P_PS_STOP_TIME; 1436 else 1437 target_tsf += ATH_P2P_PS_STOP_TIME; 1438 1439 if (target_tsf - tsf < ATH_P2P_PS_STOP_TIME) 1440 target_tsf = tsf + ATH_P2P_PS_STOP_TIME; 1441 1442 ath_dbg(common, CHAN_CTX, "%s absent %d tsf 0x%08X next_tsf 0x%08X (%dms)\n", 1443 __func__, avp->noa.absent, tsf, target_tsf, 1444 (target_tsf - tsf) / 1000); 1445 1446 ath9k_hw_gen_timer_start(ah, sc->p2p_ps_timer, target_tsf, 1000000); 1447 } 1448 1449 static void ath9k_update_p2p_ps(struct ath_softc *sc, struct ieee80211_vif *vif) 1450 { 1451 struct ath_vif *avp = (void *)vif->drv_priv; 1452 u32 tsf; 1453 1454 if (!sc->p2p_ps_timer) 1455 return; 1456 1457 if (vif->type != NL80211_IFTYPE_STATION) 1458 return; 1459 1460 sc->p2p_ps_vif = avp; 1461 1462 if (sc->ps_flags & PS_BEACON_SYNC) 1463 return; 1464 1465 tsf = ath9k_hw_gettsf32(sc->sc_ah); 1466 ieee80211_parse_p2p_noa(&vif->bss_conf.p2p_noa_attr, &avp->noa, tsf); 1467 ath9k_update_p2p_ps_timer(sc, avp); 1468 } 1469 1470 static u8 ath9k_get_ctwin(struct ath_softc *sc, struct ath_vif *avp) 1471 { 1472 struct ath_beacon_config *cur_conf = &sc->cur_chan->beacon; 1473 u8 switch_time, ctwin; 1474 1475 /* 1476 * Channel switch in multi-channel mode is deferred 1477 * by a quarter beacon interval when handling 1478 * ATH_CHANCTX_EVENT_BEACON_PREPARE, so the P2P-GO 1479 * interface is guaranteed to be discoverable 1480 * for that duration after a TBTT. 1481 */ 1482 switch_time = cur_conf->beacon_interval / 4; 1483 1484 ctwin = avp->vif->bss_conf.p2p_noa_attr.oppps_ctwindow; 1485 if (ctwin && (ctwin < switch_time)) 1486 return ctwin; 1487 1488 if (switch_time < P2P_DEFAULT_CTWIN) 1489 return 0; 1490 1491 return P2P_DEFAULT_CTWIN; 1492 } 1493 1494 void ath9k_beacon_add_noa(struct ath_softc *sc, struct ath_vif *avp, 1495 struct sk_buff *skb) 1496 { 1497 static const u8 noa_ie_hdr[] = { 1498 WLAN_EID_VENDOR_SPECIFIC, /* type */ 1499 0, /* length */ 1500 0x50, 0x6f, 0x9a, /* WFA OUI */ 1501 0x09, /* P2P subtype */ 1502 0x0c, /* Notice of Absence */ 1503 0x00, /* LSB of little-endian len */ 1504 0x00, /* MSB of little-endian len */ 1505 }; 1506 1507 struct ieee80211_p2p_noa_attr *noa; 1508 int noa_len, noa_desc, i = 0; 1509 u8 *hdr; 1510 1511 if (!avp->offchannel_duration && !avp->noa_duration) 1512 return; 1513 1514 noa_desc = !!avp->offchannel_duration + !!avp->noa_duration; 1515 noa_len = 2 + sizeof(struct ieee80211_p2p_noa_desc) * noa_desc; 1516 1517 hdr = skb_put(skb, sizeof(noa_ie_hdr)); 1518 memcpy(hdr, noa_ie_hdr, sizeof(noa_ie_hdr)); 1519 hdr[1] = sizeof(noa_ie_hdr) + noa_len - 2; 1520 hdr[7] = noa_len; 1521 1522 noa = (void *) skb_put(skb, noa_len); 1523 memset(noa, 0, noa_len); 1524 1525 noa->index = avp->noa_index; 1526 noa->oppps_ctwindow = ath9k_get_ctwin(sc, avp); 1527 if (noa->oppps_ctwindow) 1528 noa->oppps_ctwindow |= BIT(7); 1529 1530 if (avp->noa_duration) { 1531 if (avp->periodic_noa) { 1532 u32 interval = TU_TO_USEC(sc->cur_chan->beacon.beacon_interval); 1533 noa->desc[i].count = 255; 1534 noa->desc[i].interval = cpu_to_le32(interval); 1535 } else { 1536 noa->desc[i].count = 1; 1537 } 1538 1539 noa->desc[i].start_time = cpu_to_le32(avp->noa_start); 1540 noa->desc[i].duration = cpu_to_le32(avp->noa_duration); 1541 i++; 1542 } 1543 1544 if (avp->offchannel_duration) { 1545 noa->desc[i].count = 1; 1546 noa->desc[i].start_time = cpu_to_le32(avp->offchannel_start); 1547 noa->desc[i].duration = cpu_to_le32(avp->offchannel_duration); 1548 } 1549 } 1550 1551 void ath9k_p2p_ps_timer(void *priv) 1552 { 1553 struct ath_softc *sc = priv; 1554 struct ath_vif *avp = sc->p2p_ps_vif; 1555 struct ieee80211_vif *vif; 1556 struct ieee80211_sta *sta; 1557 struct ath_node *an; 1558 u32 tsf; 1559 1560 del_timer_sync(&sc->sched.timer); 1561 ath9k_hw_gen_timer_stop(sc->sc_ah, sc->p2p_ps_timer); 1562 ath_chanctx_event(sc, NULL, ATH_CHANCTX_EVENT_TSF_TIMER); 1563 1564 if (!avp || avp->chanctx != sc->cur_chan) 1565 return; 1566 1567 tsf = ath9k_hw_gettsf32(sc->sc_ah); 1568 if (!avp->noa.absent) 1569 tsf += ATH_P2P_PS_STOP_TIME; 1570 else 1571 tsf -= ATH_P2P_PS_STOP_TIME; 1572 1573 if (!avp->noa.has_next_tsf || 1574 avp->noa.next_tsf - tsf > BIT(31)) 1575 ieee80211_update_p2p_noa(&avp->noa, tsf); 1576 1577 ath9k_update_p2p_ps_timer(sc, avp); 1578 1579 rcu_read_lock(); 1580 1581 vif = avp->vif; 1582 sta = ieee80211_find_sta(vif, avp->bssid); 1583 if (!sta) 1584 goto out; 1585 1586 an = (void *) sta->drv_priv; 1587 if (an->sleeping == !!avp->noa.absent) 1588 goto out; 1589 1590 an->sleeping = avp->noa.absent; 1591 if (an->sleeping) 1592 ath_tx_aggr_sleep(sta, sc, an); 1593 else 1594 ath_tx_aggr_wakeup(sc, an); 1595 1596 out: 1597 rcu_read_unlock(); 1598 } 1599 1600 void ath9k_p2p_bss_info_changed(struct ath_softc *sc, 1601 struct ieee80211_vif *vif) 1602 { 1603 unsigned long flags; 1604 1605 spin_lock_bh(&sc->sc_pcu_lock); 1606 spin_lock_irqsave(&sc->sc_pm_lock, flags); 1607 ath9k_update_p2p_ps(sc, vif); 1608 spin_unlock_irqrestore(&sc->sc_pm_lock, flags); 1609 spin_unlock_bh(&sc->sc_pcu_lock); 1610 } 1611 1612 void ath9k_p2p_beacon_sync(struct ath_softc *sc) 1613 { 1614 if (sc->p2p_ps_vif) 1615 ath9k_update_p2p_ps(sc, sc->p2p_ps_vif->vif); 1616 } 1617 1618 void ath9k_p2p_remove_vif(struct ath_softc *sc, 1619 struct ieee80211_vif *vif) 1620 { 1621 struct ath_vif *avp = (void *)vif->drv_priv; 1622 1623 spin_lock_bh(&sc->sc_pcu_lock); 1624 if (avp == sc->p2p_ps_vif) { 1625 sc->p2p_ps_vif = NULL; 1626 ath9k_update_p2p_ps_timer(sc, NULL); 1627 } 1628 spin_unlock_bh(&sc->sc_pcu_lock); 1629 } 1630 1631 int ath9k_init_p2p(struct ath_softc *sc) 1632 { 1633 sc->p2p_ps_timer = ath_gen_timer_alloc(sc->sc_ah, ath9k_p2p_ps_timer, 1634 NULL, sc, AR_FIRST_NDP_TIMER); 1635 if (!sc->p2p_ps_timer) 1636 return -ENOMEM; 1637 1638 return 0; 1639 } 1640 1641 void ath9k_deinit_p2p(struct ath_softc *sc) 1642 { 1643 if (sc->p2p_ps_timer) 1644 ath_gen_timer_free(sc->sc_ah, sc->p2p_ps_timer); 1645 } 1646 1647 #endif /* CONFIG_ATH9K_CHANNEL_CONTEXT */ 1648