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