2 * Copyright (c) 2014 Qualcomm Atheros, Inc.
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.
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.
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.
23 static int ath_set_channel(struct ath_softc *sc)
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;
35 if (test_bit(ATH_OP_INVALID, &common->op_flags))
39 old_pos = ah->curchan - &ah->channels[0];
41 ath_dbg(common, CONFIG, "Set channel: %d MHz width: %d\n",
42 chan->center_freq, chandef->width);
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);
49 ath9k_cmn_get_channel(hw, ah, chandef);
51 /* If the operating channel changes, change the survey in-use flags
53 * Reset the survey data for the new channel, unless we're switching
54 * back to the operating channel from an off-channel operation.
56 if (!sc->cur_chan->offchannel && sc->cur_survey != &sc->survey[pos]) {
58 sc->cur_survey->filled &= ~SURVEY_INFO_IN_USE;
60 sc->cur_survey = &sc->survey[pos];
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));
68 hchan = &sc->sc_ah->channels[pos];
69 r = ath_reset_internal(sc, hchan);
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.
78 ath_update_survey_nf(sc, old_pos);
80 /* Enable radar pulse detection if on a DFS channel. Spectral
81 * scanning and radar detection can not be used concurrently.
83 if (hw->conf.radar_enabled) {
86 /* set HW specific DFS configuration */
87 ath9k_hw_set_radar_params(ah);
88 rxfilter = ath9k_hw_getrxfilter(ah);
89 rxfilter |= ATH9K_RX_FILTER_PHYRADAR |
90 ATH9K_RX_FILTER_PHYERR;
91 ath9k_hw_setrxfilter(ah, rxfilter);
92 ath_dbg(common, DFS, "DFS enabled at freq %d\n",
95 /* perform spectral scan if requested. */
96 if (test_bit(ATH_OP_SCANNING, &common->op_flags) &&
97 sc->spectral_mode == SPECTRAL_CHANSCAN)
98 ath9k_spectral_scan_trigger(hw);
104 void ath_chanctx_init(struct ath_softc *sc)
106 struct ath_chanctx *ctx;
107 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
108 struct ieee80211_supported_band *sband;
109 struct ieee80211_channel *chan;
112 sband = &common->sbands[IEEE80211_BAND_2GHZ];
113 if (!sband->n_channels)
114 sband = &common->sbands[IEEE80211_BAND_5GHZ];
116 chan = &sband->channels[0];
117 for (i = 0; i < ATH9K_NUM_CHANCTX; i++) {
118 ctx = &sc->chanctx[i];
119 cfg80211_chandef_create(&ctx->chandef, chan, NL80211_CHAN_HT20);
120 INIT_LIST_HEAD(&ctx->vifs);
121 ctx->txpower = ATH_TXPOWER_MAX;
122 for (j = 0; j < ARRAY_SIZE(ctx->acq); j++)
123 INIT_LIST_HEAD(&ctx->acq[j]);
127 void ath_chanctx_set_channel(struct ath_softc *sc, struct ath_chanctx *ctx,
128 struct cfg80211_chan_def *chandef)
130 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
133 spin_lock_bh(&sc->chan_lock);
135 memcpy(&ctx->chandef, chandef, sizeof(*chandef));
136 cur_chan = sc->cur_chan == ctx;
137 spin_unlock_bh(&sc->chan_lock);
140 ath_dbg(common, CHAN_CTX,
141 "Current context differs from the new context\n");
148 #ifdef CONFIG_ATH9K_CHANNEL_CONTEXT
150 /**********************************************************/
151 /* Functions to handle the channel context state machine. */
152 /**********************************************************/
154 static const char *offchannel_state_string(enum ath_offchannel_state state)
157 case_rtn_string(ATH_OFFCHANNEL_IDLE);
158 case_rtn_string(ATH_OFFCHANNEL_PROBE_SEND);
159 case_rtn_string(ATH_OFFCHANNEL_PROBE_WAIT);
160 case_rtn_string(ATH_OFFCHANNEL_SUSPEND);
161 case_rtn_string(ATH_OFFCHANNEL_ROC_START);
162 case_rtn_string(ATH_OFFCHANNEL_ROC_WAIT);
163 case_rtn_string(ATH_OFFCHANNEL_ROC_DONE);
169 static const char *chanctx_event_string(enum ath_chanctx_event ev)
172 case_rtn_string(ATH_CHANCTX_EVENT_BEACON_PREPARE);
173 case_rtn_string(ATH_CHANCTX_EVENT_BEACON_SENT);
174 case_rtn_string(ATH_CHANCTX_EVENT_TSF_TIMER);
175 case_rtn_string(ATH_CHANCTX_EVENT_BEACON_RECEIVED);
176 case_rtn_string(ATH_CHANCTX_EVENT_ASSOC);
177 case_rtn_string(ATH_CHANCTX_EVENT_SWITCH);
178 case_rtn_string(ATH_CHANCTX_EVENT_ASSIGN);
179 case_rtn_string(ATH_CHANCTX_EVENT_UNASSIGN);
180 case_rtn_string(ATH_CHANCTX_EVENT_CHANGE);
181 case_rtn_string(ATH_CHANCTX_EVENT_ENABLE_MULTICHANNEL);
187 static const char *chanctx_state_string(enum ath_chanctx_state state)
190 case_rtn_string(ATH_CHANCTX_STATE_IDLE);
191 case_rtn_string(ATH_CHANCTX_STATE_WAIT_FOR_BEACON);
192 case_rtn_string(ATH_CHANCTX_STATE_WAIT_FOR_TIMER);
193 case_rtn_string(ATH_CHANCTX_STATE_SWITCH);
194 case_rtn_string(ATH_CHANCTX_STATE_FORCE_ACTIVE);
200 void ath_chanctx_check_active(struct ath_softc *sc, struct ath_chanctx *ctx)
202 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
210 list_for_each_entry(avp, &ctx->vifs, list) {
211 struct ieee80211_vif *vif = avp->vif;
214 case NL80211_IFTYPE_P2P_CLIENT:
215 case NL80211_IFTYPE_STATION:
216 if (vif->bss_conf.assoc)
224 ctx->active = active;
226 ath_for_each_chanctx(sc, ctx) {
227 if (!ctx->assigned || list_empty(&ctx->vifs))
233 clear_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags);
236 if (test_and_set_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags))
239 if (ath9k_is_chanctx_enabled()) {
240 ath_chanctx_event(sc, NULL,
241 ATH_CHANCTX_EVENT_ENABLE_MULTICHANNEL);
245 static struct ath_chanctx *
246 ath_chanctx_get_next(struct ath_softc *sc, struct ath_chanctx *ctx)
248 int idx = ctx - &sc->chanctx[0];
250 return &sc->chanctx[!idx];
253 static void ath_chanctx_adjust_tbtt_delta(struct ath_softc *sc)
255 struct ath_chanctx *prev, *cur;
257 u32 cur_tsf, prev_tsf, beacon_int;
260 beacon_int = TU_TO_USEC(sc->cur_chan->beacon.beacon_interval);
263 prev = ath_chanctx_get_next(sc, cur);
265 getrawmonotonic(&ts);
266 cur_tsf = (u32) cur->tsf_val +
267 ath9k_hw_get_tsf_offset(&cur->tsf_ts, &ts);
269 prev_tsf = prev->last_beacon - (u32) prev->tsf_val + cur_tsf;
270 prev_tsf -= ath9k_hw_get_tsf_offset(&prev->tsf_ts, &ts);
272 /* Adjust the TSF time of the AP chanctx to keep its beacons
273 * at half beacon interval offset relative to the STA chanctx.
275 offset = cur_tsf - prev_tsf;
277 /* Ignore stale data or spurious timestamps */
278 if (offset < 0 || offset > 3 * beacon_int)
281 offset = beacon_int / 2 - (offset % beacon_int);
282 prev->tsf_val += offset;
285 /* Configure the TSF based hardware timer for a channel switch.
286 * Also set up backup software timer, in case the gen timer fails.
287 * This could be caused by a hardware reset.
289 static void ath_chanctx_setup_timer(struct ath_softc *sc, u32 tsf_time)
291 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
292 struct ath_hw *ah = sc->sc_ah;
294 ath9k_hw_gen_timer_start(ah, sc->p2p_ps_timer, tsf_time, 1000000);
295 tsf_time -= ath9k_hw_gettsf32(ah);
296 tsf_time = msecs_to_jiffies(tsf_time / 1000) + 1;
297 mod_timer(&sc->sched.timer, jiffies + tsf_time);
299 ath_dbg(common, CHAN_CTX,
300 "Setup chanctx timer with timeout: %d ms\n", jiffies_to_msecs(tsf_time));
303 void ath_chanctx_event(struct ath_softc *sc, struct ieee80211_vif *vif,
304 enum ath_chanctx_event ev)
306 struct ath_hw *ah = sc->sc_ah;
307 struct ath_common *common = ath9k_hw_common(ah);
308 struct ath_beacon_config *cur_conf;
309 struct ath_vif *avp = NULL;
310 struct ath_chanctx *ctx;
315 avp = (struct ath_vif *) vif->drv_priv;
317 spin_lock_bh(&sc->chan_lock);
319 ath_dbg(common, CHAN_CTX, "cur_chan: %d MHz, event: %s, state: %s\n",
320 sc->cur_chan->chandef.center_freq1,
321 chanctx_event_string(ev),
322 chanctx_state_string(sc->sched.state));
325 case ATH_CHANCTX_EVENT_BEACON_PREPARE:
326 if (avp->offchannel_duration)
327 avp->offchannel_duration = 0;
329 if (avp->chanctx != sc->cur_chan) {
330 ath_dbg(common, CHAN_CTX,
331 "Contexts differ, not preparing beacon\n");
335 if (sc->sched.offchannel_pending && !sc->sched.wait_switch) {
336 sc->sched.offchannel_pending = false;
337 sc->next_chan = &sc->offchannel.chan;
338 sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;
339 ath_dbg(common, CHAN_CTX,
340 "Setting offchannel_pending to false\n");
343 ctx = ath_chanctx_get_next(sc, sc->cur_chan);
344 if (ctx->active && sc->sched.state == ATH_CHANCTX_STATE_IDLE) {
346 sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;
347 ath_dbg(common, CHAN_CTX,
348 "Set next context, move chanctx state to WAIT_FOR_BEACON\n");
351 /* if the timer missed its window, use the next interval */
352 if (sc->sched.state == ATH_CHANCTX_STATE_WAIT_FOR_TIMER) {
353 sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;
354 ath_dbg(common, CHAN_CTX,
355 "Move chanctx state from WAIT_FOR_TIMER to WAIT_FOR_BEACON\n");
358 if (sc->sched.state != ATH_CHANCTX_STATE_WAIT_FOR_BEACON)
361 ath_dbg(common, CHAN_CTX, "Preparing beacon for vif: %pM\n", vif->addr);
363 sc->sched.beacon_pending = true;
364 sc->sched.next_tbtt = REG_READ(ah, AR_NEXT_TBTT_TIMER);
366 cur_conf = &sc->cur_chan->beacon;
367 beacon_int = TU_TO_USEC(cur_conf->beacon_interval);
369 /* defer channel switch by a quarter beacon interval */
370 tsf_time = sc->sched.next_tbtt + beacon_int / 4;
371 sc->sched.switch_start_time = tsf_time;
372 sc->cur_chan->last_beacon = sc->sched.next_tbtt;
375 * If an offchannel switch is scheduled to happen after
376 * a beacon transmission, update the NoA with one-shot
377 * values and increment the index.
379 if (sc->next_chan == &sc->offchannel.chan) {
381 avp->offchannel_start = tsf_time;
382 avp->offchannel_duration = sc->sched.offchannel_duration;
384 ath_dbg(common, CHAN_CTX,
385 "offchannel noa_duration: %d, noa_start: %d, noa_index: %d\n",
386 avp->offchannel_duration,
387 avp->offchannel_start,
391 * When multiple contexts are active, the NoA
392 * has to be recalculated and advertised after
393 * an offchannel operation.
395 if (ctx->active && avp->noa_duration)
396 avp->noa_duration = 0;
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
408 if (ctx->active && sc->sched.extend_absence) {
409 avp->noa_duration = 0;
410 sc->sched.extend_absence = false;
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.
417 if (ctx->active && sc->sched.beacon_miss >= 2) {
418 avp->noa_duration = 0;
419 sc->sched.extend_absence = true;
421 /* Prevent wrap-around issues */
422 if (avp->noa_duration && tsf_time - avp->noa_start > BIT(30))
423 avp->noa_duration = 0;
426 * If multiple contexts are active, start periodic
427 * NoA and increment the index for the first
431 (!avp->noa_duration || sc->sched.force_noa_update)) {
433 avp->noa_start = tsf_time;
435 if (sc->sched.extend_absence)
436 avp->noa_duration = (3 * beacon_int / 2) +
437 sc->sched.channel_switch_time;
440 TU_TO_USEC(cur_conf->beacon_interval) / 2 +
441 sc->sched.channel_switch_time;
443 if (test_bit(ATH_OP_SCANNING, &common->op_flags) ||
444 sc->sched.extend_absence)
445 avp->periodic_noa = false;
447 avp->periodic_noa = true;
449 ath_dbg(common, CHAN_CTX,
450 "noa_duration: %d, noa_start: %d, noa_index: %d, periodic: %d\n",
457 if (ctx->active && sc->sched.force_noa_update)
458 sc->sched.force_noa_update = false;
461 case ATH_CHANCTX_EVENT_BEACON_SENT:
462 if (!sc->sched.beacon_pending) {
463 ath_dbg(common, CHAN_CTX,
464 "No pending beacon\n");
468 sc->sched.beacon_pending = false;
469 if (sc->sched.state != ATH_CHANCTX_STATE_WAIT_FOR_BEACON)
472 ath_dbg(common, CHAN_CTX,
473 "Move chanctx state to WAIT_FOR_TIMER\n");
475 sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_TIMER;
476 ath_chanctx_setup_timer(sc, sc->sched.switch_start_time);
478 case ATH_CHANCTX_EVENT_TSF_TIMER:
479 if (sc->sched.state != ATH_CHANCTX_STATE_WAIT_FOR_TIMER)
482 if (!sc->cur_chan->switch_after_beacon &&
483 sc->sched.beacon_pending)
484 sc->sched.beacon_miss++;
486 ath_dbg(common, CHAN_CTX,
487 "Move chanctx state to SWITCH\n");
489 sc->sched.state = ATH_CHANCTX_STATE_SWITCH;
490 ieee80211_queue_work(sc->hw, &sc->chanctx_work);
492 case ATH_CHANCTX_EVENT_BEACON_RECEIVED:
493 if (!test_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags) ||
494 sc->cur_chan == &sc->offchannel.chan)
497 ath_chanctx_adjust_tbtt_delta(sc);
498 sc->sched.beacon_pending = false;
499 sc->sched.beacon_miss = 0;
501 /* TSF time might have been updated by the incoming beacon,
502 * need update the channel switch timer to reflect the change.
504 tsf_time = sc->sched.switch_start_time;
505 tsf_time -= (u32) sc->cur_chan->tsf_val +
506 ath9k_hw_get_tsf_offset(&sc->cur_chan->tsf_ts, NULL);
507 tsf_time += ath9k_hw_gettsf32(ah);
510 ath_chanctx_setup_timer(sc, tsf_time);
512 case ATH_CHANCTX_EVENT_ASSOC:
513 if (sc->sched.state != ATH_CHANCTX_STATE_FORCE_ACTIVE ||
514 avp->chanctx != sc->cur_chan)
517 ath_dbg(common, CHAN_CTX,
518 "Move chanctx state from FORCE_ACTIVE to IDLE\n");
520 sc->sched.state = ATH_CHANCTX_STATE_IDLE;
522 case ATH_CHANCTX_EVENT_SWITCH:
523 if (!test_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags) ||
524 sc->sched.state == ATH_CHANCTX_STATE_FORCE_ACTIVE ||
525 sc->cur_chan->switch_after_beacon ||
526 sc->cur_chan == &sc->offchannel.chan)
529 /* If this is a station chanctx, stay active for a half
530 * beacon period (minus channel switch time)
532 sc->next_chan = ath_chanctx_get_next(sc, sc->cur_chan);
533 cur_conf = &sc->cur_chan->beacon;
535 ath_dbg(common, CHAN_CTX,
536 "Move chanctx state to WAIT_FOR_TIMER (event SWITCH)\n");
538 sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_TIMER;
539 sc->sched.wait_switch = false;
541 tsf_time = TU_TO_USEC(cur_conf->beacon_interval) / 2;
543 if (sc->sched.extend_absence) {
544 sc->sched.beacon_miss = 0;
548 tsf_time -= sc->sched.channel_switch_time;
549 tsf_time += ath9k_hw_gettsf32(sc->sc_ah);
550 sc->sched.switch_start_time = tsf_time;
552 ath_chanctx_setup_timer(sc, tsf_time);
553 sc->sched.beacon_pending = true;
555 case ATH_CHANCTX_EVENT_ENABLE_MULTICHANNEL:
556 if (sc->cur_chan == &sc->offchannel.chan ||
557 sc->cur_chan->switch_after_beacon)
560 sc->next_chan = ath_chanctx_get_next(sc, sc->cur_chan);
561 ieee80211_queue_work(sc->hw, &sc->chanctx_work);
563 case ATH_CHANCTX_EVENT_UNASSIGN:
564 if (sc->cur_chan->assigned) {
565 if (sc->next_chan && !sc->next_chan->assigned &&
566 sc->next_chan != &sc->offchannel.chan)
567 sc->sched.state = ATH_CHANCTX_STATE_IDLE;
571 ctx = ath_chanctx_get_next(sc, sc->cur_chan);
572 sc->sched.state = ATH_CHANCTX_STATE_IDLE;
577 ieee80211_queue_work(sc->hw, &sc->chanctx_work);
579 case ATH_CHANCTX_EVENT_ASSIGN:
581 * When adding a new channel context, check if a scan
582 * is in progress and abort it since the addition of
583 * a new channel context is usually followed by VIF
584 * assignment, in which case we have to start multi-channel
587 if (test_bit(ATH_OP_SCANNING, &common->op_flags)) {
588 ath_dbg(common, CHAN_CTX,
589 "Aborting HW scan to add new context\n");
591 spin_unlock_bh(&sc->chan_lock);
592 del_timer_sync(&sc->offchannel.timer);
593 ath_scan_complete(sc, true);
594 spin_lock_bh(&sc->chan_lock);
597 case ATH_CHANCTX_EVENT_CHANGE:
601 spin_unlock_bh(&sc->chan_lock);
604 void ath_chanctx_beacon_sent_ev(struct ath_softc *sc,
605 enum ath_chanctx_event ev)
607 if (sc->sched.beacon_pending)
608 ath_chanctx_event(sc, NULL, ev);
611 void ath_chanctx_beacon_recv_ev(struct ath_softc *sc, u32 ts,
612 enum ath_chanctx_event ev)
614 sc->sched.next_tbtt = ts;
615 ath_chanctx_event(sc, NULL, ev);
618 static int ath_scan_channel_duration(struct ath_softc *sc,
619 struct ieee80211_channel *chan)
621 struct cfg80211_scan_request *req = sc->offchannel.scan_req;
623 if (!req->n_ssids || (chan->flags & IEEE80211_CHAN_NO_IR))
624 return (HZ / 9); /* ~110 ms */
626 return (HZ / 16); /* ~60 ms */
629 static void ath_chanctx_switch(struct ath_softc *sc, struct ath_chanctx *ctx,
630 struct cfg80211_chan_def *chandef)
632 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
634 spin_lock_bh(&sc->chan_lock);
636 if (test_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags) &&
637 (sc->cur_chan != ctx) && (ctx == &sc->offchannel.chan)) {
639 ctx->chandef = *chandef;
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;
647 spin_unlock_bh(&sc->chan_lock);
648 ath_dbg(common, CHAN_CTX,
649 "Set offchannel_pending to true\n");
655 ctx->chandef = *chandef;
656 ath_dbg(common, CHAN_CTX,
657 "Assigned next_chan to %d MHz\n", chandef->center_freq1);
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;
666 ath_dbg(common, CHAN_CTX,
667 "Offchannel duration for chan %d MHz : %u\n",
668 chandef->center_freq1,
669 sc->sched.offchannel_duration);
672 spin_unlock_bh(&sc->chan_lock);
673 ieee80211_queue_work(sc->hw, &sc->chanctx_work);
676 static void ath_chanctx_offchan_switch(struct ath_softc *sc,
677 struct ieee80211_channel *chan)
679 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
680 struct cfg80211_chan_def chandef;
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);
686 ath_chanctx_switch(sc, &sc->offchannel.chan, &chandef);
689 static struct ath_chanctx *ath_chanctx_get_oper_chan(struct ath_softc *sc,
692 struct ath_chanctx *ctx;
694 ath_for_each_chanctx(sc, ctx) {
695 if (!ctx->assigned || list_empty(&ctx->vifs))
697 if (active && !ctx->active)
700 if (ctx->switch_after_beacon)
704 return &sc->chanctx[0];
708 ath_scan_next_channel(struct ath_softc *sc)
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;
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,
721 sc->offchannel.state = ATH_OFFCHANNEL_IDLE;
722 ath_chanctx_switch(sc, ath_chanctx_get_oper_chan(sc, false),
727 ath_dbg(common, CHAN_CTX,
728 "Moving offchannel state to ATH_OFFCHANNEL_PROBE_SEND, scan_idx: %d\n",
729 sc->offchannel.scan_idx);
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;
735 ath_chanctx_offchan_switch(sc, chan);
738 void ath_offchannel_next(struct ath_softc *sc)
740 struct ieee80211_vif *vif;
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);
754 ath_chanctx_switch(sc, ath_chanctx_get_oper_chan(sc, false),
756 sc->offchannel.state = ATH_OFFCHANNEL_IDLE;
762 void ath_roc_complete(struct ath_softc *sc, bool abort)
764 sc->offchannel.roc_vif = NULL;
765 sc->offchannel.roc_chan = NULL;
767 ieee80211_remain_on_channel_expired(sc->hw);
768 ath_offchannel_next(sc);
769 ath9k_ps_restore(sc);
772 void ath_scan_complete(struct ath_softc *sc, bool abort)
774 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
777 ath_dbg(common, CHAN_CTX, "HW scan aborted\n");
779 ath_dbg(common, CHAN_CTX, "HW scan complete\n");
781 sc->offchannel.scan_req = NULL;
782 sc->offchannel.scan_vif = NULL;
783 sc->offchannel.state = ATH_OFFCHANNEL_IDLE;
784 ieee80211_scan_completed(sc->hw, abort);
785 clear_bit(ATH_OP_SCANNING, &common->op_flags);
786 spin_lock_bh(&sc->chan_lock);
787 if (test_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags))
788 sc->sched.force_noa_update = true;
789 spin_unlock_bh(&sc->chan_lock);
790 ath_offchannel_next(sc);
791 ath9k_ps_restore(sc);
794 static void ath_scan_send_probe(struct ath_softc *sc,
795 struct cfg80211_ssid *ssid)
797 struct cfg80211_scan_request *req = sc->offchannel.scan_req;
798 struct ieee80211_vif *vif = sc->offchannel.scan_vif;
799 struct ath_tx_control txctl = {};
801 struct ieee80211_tx_info *info;
802 int band = sc->offchannel.chan.chandef.chan->band;
804 skb = ieee80211_probereq_get(sc->hw, vif,
805 ssid->ssid, ssid->ssid_len, req->ie_len);
809 info = IEEE80211_SKB_CB(skb);
811 info->flags |= IEEE80211_TX_CTL_NO_CCK_RATE;
814 memcpy(skb_put(skb, req->ie_len), req->ie, req->ie_len);
816 skb_set_queue_mapping(skb, IEEE80211_AC_VO);
818 if (!ieee80211_tx_prepare_skb(sc->hw, vif, skb, band, NULL))
821 txctl.txq = sc->tx.txq_map[IEEE80211_AC_VO];
822 txctl.force_channel = true;
823 if (ath_tx_start(sc->hw, skb, &txctl))
829 ieee80211_free_txskb(sc->hw, skb);
832 static void ath_scan_channel_start(struct ath_softc *sc)
834 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
835 struct cfg80211_scan_request *req = sc->offchannel.scan_req;
838 if (!(sc->cur_chan->chandef.chan->flags & IEEE80211_CHAN_NO_IR) &&
840 for (i = 0; i < req->n_ssids; i++)
841 ath_scan_send_probe(sc, &req->ssids[i]);
845 ath_dbg(common, CHAN_CTX,
846 "Moving offchannel state to ATH_OFFCHANNEL_PROBE_WAIT\n");
848 sc->offchannel.state = ATH_OFFCHANNEL_PROBE_WAIT;
849 mod_timer(&sc->offchannel.timer, jiffies + sc->offchannel.duration);
852 static void ath_chanctx_timer(unsigned long data)
854 struct ath_softc *sc = (struct ath_softc *) data;
855 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
857 ath_dbg(common, CHAN_CTX,
858 "Channel context timer invoked\n");
860 ath_chanctx_event(sc, NULL, ATH_CHANCTX_EVENT_TSF_TIMER);
863 static void ath_offchannel_timer(unsigned long data)
865 struct ath_softc *sc = (struct ath_softc *)data;
866 struct ath_chanctx *ctx;
867 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
869 ath_dbg(common, CHAN_CTX, "%s: offchannel state: %s\n",
870 __func__, offchannel_state_string(sc->offchannel.state));
872 switch (sc->offchannel.state) {
873 case ATH_OFFCHANNEL_PROBE_WAIT:
874 if (!sc->offchannel.scan_req)
877 /* get first active channel context */
878 ctx = ath_chanctx_get_oper_chan(sc, true);
880 ath_dbg(common, CHAN_CTX,
881 "Switch to oper/active context, "
882 "move offchannel state to ATH_OFFCHANNEL_SUSPEND\n");
884 sc->offchannel.state = ATH_OFFCHANNEL_SUSPEND;
885 ath_chanctx_switch(sc, ctx, NULL);
886 mod_timer(&sc->offchannel.timer, jiffies + HZ / 10);
890 case ATH_OFFCHANNEL_SUSPEND:
891 if (!sc->offchannel.scan_req)
894 ath_scan_next_channel(sc);
896 case ATH_OFFCHANNEL_ROC_START:
897 case ATH_OFFCHANNEL_ROC_WAIT:
898 ctx = ath_chanctx_get_oper_chan(sc, false);
899 sc->offchannel.state = ATH_OFFCHANNEL_ROC_DONE;
900 ath_chanctx_switch(sc, ctx, NULL);
908 ath_chanctx_send_vif_ps_frame(struct ath_softc *sc, struct ath_vif *avp,
911 struct ieee80211_vif *vif = avp->vif;
912 struct ieee80211_sta *sta = NULL;
913 struct ieee80211_hdr_3addr *nullfunc;
914 struct ath_tx_control txctl;
916 int band = sc->cur_chan->chandef.chan->band;
919 case NL80211_IFTYPE_STATION:
920 if (!vif->bss_conf.assoc)
923 skb = ieee80211_nullfunc_get(sc->hw, vif);
927 nullfunc = (struct ieee80211_hdr_3addr *) skb->data;
929 nullfunc->frame_control |=
930 cpu_to_le16(IEEE80211_FCTL_PM);
932 skb_set_queue_mapping(skb, IEEE80211_AC_VO);
933 if (!ieee80211_tx_prepare_skb(sc->hw, vif, skb, band, &sta)) {
934 dev_kfree_skb_any(skb);
942 memset(&txctl, 0, sizeof(txctl));
943 txctl.txq = sc->tx.txq_map[IEEE80211_AC_VO];
945 txctl.force_channel = true;
946 if (ath_tx_start(sc->hw, skb, &txctl)) {
947 ieee80211_free_txskb(sc->hw, skb);
955 ath_chanctx_send_ps_frame(struct ath_softc *sc, bool powersave)
961 list_for_each_entry(avp, &sc->cur_chan->vifs, list) {
962 if (ath_chanctx_send_vif_ps_frame(sc, avp, powersave))
970 static bool ath_chanctx_defer_switch(struct ath_softc *sc)
972 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
974 if (sc->cur_chan == &sc->offchannel.chan)
977 switch (sc->sched.state) {
978 case ATH_CHANCTX_STATE_SWITCH:
980 case ATH_CHANCTX_STATE_IDLE:
981 if (!sc->cur_chan->switch_after_beacon)
984 ath_dbg(common, CHAN_CTX,
985 "Defer switch, set chanctx state to WAIT_FOR_BEACON\n");
987 sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;
996 static void ath_offchannel_channel_change(struct ath_softc *sc)
998 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1000 ath_dbg(common, CHAN_CTX, "%s: offchannel state: %s\n",
1001 __func__, offchannel_state_string(sc->offchannel.state));
1003 switch (sc->offchannel.state) {
1004 case ATH_OFFCHANNEL_PROBE_SEND:
1005 if (!sc->offchannel.scan_req)
1008 if (sc->cur_chan->chandef.chan !=
1009 sc->offchannel.chan.chandef.chan)
1012 ath_scan_channel_start(sc);
1014 case ATH_OFFCHANNEL_IDLE:
1015 if (!sc->offchannel.scan_req)
1018 ath_scan_complete(sc, false);
1020 case ATH_OFFCHANNEL_ROC_START:
1021 if (sc->cur_chan != &sc->offchannel.chan)
1024 sc->offchannel.state = ATH_OFFCHANNEL_ROC_WAIT;
1025 mod_timer(&sc->offchannel.timer,
1026 jiffies + sc->offchannel.duration);
1027 ieee80211_ready_on_channel(sc->hw);
1029 case ATH_OFFCHANNEL_ROC_DONE:
1030 ath_roc_complete(sc, false);
1037 void ath_chanctx_set_next(struct ath_softc *sc, bool force)
1039 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1041 bool measure_time = false;
1042 bool send_ps = false;
1044 spin_lock_bh(&sc->chan_lock);
1045 if (!sc->next_chan) {
1046 spin_unlock_bh(&sc->chan_lock);
1050 if (!force && ath_chanctx_defer_switch(sc)) {
1051 spin_unlock_bh(&sc->chan_lock);
1055 ath_dbg(common, CHAN_CTX,
1056 "%s: current: %d MHz, next: %d MHz\n",
1058 sc->cur_chan->chandef.center_freq1,
1059 sc->next_chan->chandef.center_freq1);
1061 if (sc->cur_chan != sc->next_chan) {
1062 ath_dbg(common, CHAN_CTX,
1063 "Stopping current chanctx: %d\n",
1064 sc->cur_chan->chandef.center_freq1);
1065 sc->cur_chan->stopped = true;
1066 spin_unlock_bh(&sc->chan_lock);
1068 if (sc->next_chan == &sc->offchannel.chan) {
1069 getrawmonotonic(&ts);
1070 measure_time = true;
1072 __ath9k_flush(sc->hw, ~0, true);
1074 if (ath_chanctx_send_ps_frame(sc, true))
1075 __ath9k_flush(sc->hw, BIT(IEEE80211_AC_VO), false);
1078 spin_lock_bh(&sc->chan_lock);
1080 if (sc->cur_chan != &sc->offchannel.chan) {
1081 getrawmonotonic(&sc->cur_chan->tsf_ts);
1082 sc->cur_chan->tsf_val = ath9k_hw_gettsf64(sc->sc_ah);
1085 sc->cur_chan = sc->next_chan;
1086 sc->cur_chan->stopped = false;
1087 sc->next_chan = NULL;
1089 if (!sc->sched.offchannel_pending)
1090 sc->sched.offchannel_duration = 0;
1092 if (sc->sched.state != ATH_CHANCTX_STATE_FORCE_ACTIVE)
1093 sc->sched.state = ATH_CHANCTX_STATE_IDLE;
1095 spin_unlock_bh(&sc->chan_lock);
1097 if (sc->sc_ah->chip_fullsleep ||
1098 memcmp(&sc->cur_chandef, &sc->cur_chan->chandef,
1099 sizeof(sc->cur_chandef))) {
1100 ath_dbg(common, CHAN_CTX,
1101 "%s: Set channel %d MHz\n",
1102 __func__, sc->cur_chan->chandef.center_freq1);
1103 ath_set_channel(sc);
1105 sc->sched.channel_switch_time =
1106 ath9k_hw_get_tsf_offset(&ts, NULL);
1109 ath_chanctx_send_ps_frame(sc, false);
1111 ath_offchannel_channel_change(sc);
1112 ath_chanctx_event(sc, NULL, ATH_CHANCTX_EVENT_SWITCH);
1115 static void ath_chanctx_work(struct work_struct *work)
1117 struct ath_softc *sc = container_of(work, struct ath_softc,
1119 mutex_lock(&sc->mutex);
1120 ath_chanctx_set_next(sc, false);
1121 mutex_unlock(&sc->mutex);
1124 void ath9k_offchannel_init(struct ath_softc *sc)
1126 struct ath_chanctx *ctx;
1127 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1128 struct ieee80211_supported_band *sband;
1129 struct ieee80211_channel *chan;
1132 sband = &common->sbands[IEEE80211_BAND_2GHZ];
1133 if (!sband->n_channels)
1134 sband = &common->sbands[IEEE80211_BAND_5GHZ];
1136 chan = &sband->channels[0];
1138 ctx = &sc->offchannel.chan;
1139 INIT_LIST_HEAD(&ctx->vifs);
1140 ctx->txpower = ATH_TXPOWER_MAX;
1141 cfg80211_chandef_create(&ctx->chandef, chan, NL80211_CHAN_HT20);
1143 for (i = 0; i < ARRAY_SIZE(ctx->acq); i++)
1144 INIT_LIST_HEAD(&ctx->acq[i]);
1146 sc->offchannel.chan.offchannel = true;
1149 void ath9k_init_channel_context(struct ath_softc *sc)
1151 INIT_WORK(&sc->chanctx_work, ath_chanctx_work);
1153 setup_timer(&sc->offchannel.timer, ath_offchannel_timer,
1155 setup_timer(&sc->sched.timer, ath_chanctx_timer,
1159 void ath9k_deinit_channel_context(struct ath_softc *sc)
1161 cancel_work_sync(&sc->chanctx_work);
1164 bool ath9k_is_chanctx_enabled(void)
1166 return (ath9k_use_chanctx == 1);
1169 /********************/
1170 /* Queue management */
1171 /********************/
1173 void ath9k_chanctx_wake_queues(struct ath_softc *sc)
1175 struct ath_hw *ah = sc->sc_ah;
1178 if (sc->cur_chan == &sc->offchannel.chan) {
1179 ieee80211_wake_queue(sc->hw,
1180 sc->hw->offchannel_tx_hw_queue);
1182 for (i = 0; i < IEEE80211_NUM_ACS; i++)
1183 ieee80211_wake_queue(sc->hw,
1184 sc->cur_chan->hw_queue_base + i);
1187 if (ah->opmode == NL80211_IFTYPE_AP)
1188 ieee80211_wake_queue(sc->hw, sc->hw->queues - 2);
1195 static void ath9k_update_p2p_ps_timer(struct ath_softc *sc, struct ath_vif *avp)
1197 struct ath_hw *ah = sc->sc_ah;
1198 s32 tsf, target_tsf;
1200 if (!avp || !avp->noa.has_next_tsf)
1203 ath9k_hw_gen_timer_stop(ah, sc->p2p_ps_timer);
1205 tsf = ath9k_hw_gettsf32(sc->sc_ah);
1207 target_tsf = avp->noa.next_tsf;
1208 if (!avp->noa.absent)
1209 target_tsf -= ATH_P2P_PS_STOP_TIME;
1211 if (target_tsf - tsf < ATH_P2P_PS_STOP_TIME)
1212 target_tsf = tsf + ATH_P2P_PS_STOP_TIME;
1214 ath9k_hw_gen_timer_start(ah, sc->p2p_ps_timer, (u32) target_tsf, 1000000);
1217 static void ath9k_update_p2p_ps(struct ath_softc *sc, struct ieee80211_vif *vif)
1219 struct ath_vif *avp = (void *)vif->drv_priv;
1222 if (!sc->p2p_ps_timer)
1225 if (vif->type != NL80211_IFTYPE_STATION || !vif->p2p)
1228 sc->p2p_ps_vif = avp;
1229 tsf = ath9k_hw_gettsf32(sc->sc_ah);
1230 ieee80211_parse_p2p_noa(&vif->bss_conf.p2p_noa_attr, &avp->noa, tsf);
1231 ath9k_update_p2p_ps_timer(sc, avp);
1234 static u8 ath9k_get_ctwin(struct ath_softc *sc, struct ath_vif *avp)
1236 struct ath_beacon_config *cur_conf = &sc->cur_chan->beacon;
1237 u8 switch_time, ctwin;
1240 * Channel switch in multi-channel mode is deferred
1241 * by a quarter beacon interval when handling
1242 * ATH_CHANCTX_EVENT_BEACON_PREPARE, so the P2P-GO
1243 * interface is guaranteed to be discoverable
1244 * for that duration after a TBTT.
1246 switch_time = cur_conf->beacon_interval / 4;
1248 ctwin = avp->vif->bss_conf.p2p_noa_attr.oppps_ctwindow;
1249 if (ctwin && (ctwin < switch_time))
1252 if (switch_time < P2P_DEFAULT_CTWIN)
1255 return P2P_DEFAULT_CTWIN;
1258 void ath9k_beacon_add_noa(struct ath_softc *sc, struct ath_vif *avp,
1259 struct sk_buff *skb)
1261 static const u8 noa_ie_hdr[] = {
1262 WLAN_EID_VENDOR_SPECIFIC, /* type */
1264 0x50, 0x6f, 0x9a, /* WFA OUI */
1265 0x09, /* P2P subtype */
1266 0x0c, /* Notice of Absence */
1267 0x00, /* LSB of little-endian len */
1268 0x00, /* MSB of little-endian len */
1271 struct ieee80211_p2p_noa_attr *noa;
1272 int noa_len, noa_desc, i = 0;
1275 if (!avp->offchannel_duration && !avp->noa_duration)
1278 noa_desc = !!avp->offchannel_duration + !!avp->noa_duration;
1279 noa_len = 2 + sizeof(struct ieee80211_p2p_noa_desc) * noa_desc;
1281 hdr = skb_put(skb, sizeof(noa_ie_hdr));
1282 memcpy(hdr, noa_ie_hdr, sizeof(noa_ie_hdr));
1283 hdr[1] = sizeof(noa_ie_hdr) + noa_len - 2;
1286 noa = (void *) skb_put(skb, noa_len);
1287 memset(noa, 0, noa_len);
1289 noa->index = avp->noa_index;
1290 noa->oppps_ctwindow = ath9k_get_ctwin(sc, avp);
1292 if (avp->noa_duration) {
1293 if (avp->periodic_noa) {
1294 u32 interval = TU_TO_USEC(sc->cur_chan->beacon.beacon_interval);
1295 noa->desc[i].count = 255;
1296 noa->desc[i].interval = cpu_to_le32(interval);
1298 noa->desc[i].count = 1;
1301 noa->desc[i].start_time = cpu_to_le32(avp->noa_start);
1302 noa->desc[i].duration = cpu_to_le32(avp->noa_duration);
1306 if (avp->offchannel_duration) {
1307 noa->desc[i].count = 1;
1308 noa->desc[i].start_time = cpu_to_le32(avp->offchannel_start);
1309 noa->desc[i].duration = cpu_to_le32(avp->offchannel_duration);
1313 void ath9k_p2p_ps_timer(void *priv)
1315 struct ath_softc *sc = priv;
1316 struct ath_vif *avp = sc->p2p_ps_vif;
1317 struct ieee80211_vif *vif;
1318 struct ieee80211_sta *sta;
1319 struct ath_node *an;
1322 del_timer_sync(&sc->sched.timer);
1323 ath9k_hw_gen_timer_stop(sc->sc_ah, sc->p2p_ps_timer);
1324 ath_chanctx_event(sc, NULL, ATH_CHANCTX_EVENT_TSF_TIMER);
1326 if (!avp || avp->chanctx != sc->cur_chan)
1329 tsf = ath9k_hw_gettsf32(sc->sc_ah);
1330 if (!avp->noa.absent)
1331 tsf += ATH_P2P_PS_STOP_TIME;
1333 if (!avp->noa.has_next_tsf ||
1334 avp->noa.next_tsf - tsf > BIT(31))
1335 ieee80211_update_p2p_noa(&avp->noa, tsf);
1337 ath9k_update_p2p_ps_timer(sc, avp);
1342 sta = ieee80211_find_sta(vif, vif->bss_conf.bssid);
1346 an = (void *) sta->drv_priv;
1347 if (an->sleeping == !!avp->noa.absent)
1350 an->sleeping = avp->noa.absent;
1352 ath_tx_aggr_sleep(sta, sc, an);
1354 ath_tx_aggr_wakeup(sc, an);
1360 void ath9k_p2p_bss_info_changed(struct ath_softc *sc,
1361 struct ieee80211_vif *vif)
1363 unsigned long flags;
1365 spin_lock_bh(&sc->sc_pcu_lock);
1366 spin_lock_irqsave(&sc->sc_pm_lock, flags);
1367 if (!(sc->ps_flags & PS_BEACON_SYNC))
1368 ath9k_update_p2p_ps(sc, vif);
1369 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
1370 spin_unlock_bh(&sc->sc_pcu_lock);
1373 void ath9k_p2p_beacon_sync(struct ath_softc *sc)
1376 ath9k_update_p2p_ps(sc, sc->p2p_ps_vif->vif);
1379 void ath9k_p2p_remove_vif(struct ath_softc *sc,
1380 struct ieee80211_vif *vif)
1382 struct ath_vif *avp = (void *)vif->drv_priv;
1384 spin_lock_bh(&sc->sc_pcu_lock);
1385 if (avp == sc->p2p_ps_vif) {
1386 sc->p2p_ps_vif = NULL;
1387 ath9k_update_p2p_ps_timer(sc, NULL);
1389 spin_unlock_bh(&sc->sc_pcu_lock);
1392 int ath9k_init_p2p(struct ath_softc *sc)
1394 sc->p2p_ps_timer = ath_gen_timer_alloc(sc->sc_ah, ath9k_p2p_ps_timer,
1395 NULL, sc, AR_FIRST_NDP_TIMER);
1396 if (!sc->p2p_ps_timer)
1402 void ath9k_deinit_p2p(struct ath_softc *sc)
1404 if (sc->p2p_ps_timer)
1405 ath_gen_timer_free(sc->sc_ah, sc->p2p_ps_timer);
1408 #endif /* CONFIG_ATH9K_CHANNEL_CONTEXT */