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