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
;
36 if (test_bit(ATH_OP_INVALID
, &common
->op_flags
))
40 old_pos
= ah
->curchan
- &ah
->channels
[0];
42 ath_dbg(common
, CONFIG
, "Set channel: %d MHz width: %d\n",
43 chan
->center_freq
, chandef
->width
);
45 /* update survey stats for the old channel before switching */
46 spin_lock_irqsave(&common
->cc_lock
, flags
);
47 ath_update_survey_stats(sc
);
48 spin_unlock_irqrestore(&common
->cc_lock
, flags
);
50 ath9k_cmn_get_channel(hw
, ah
, chandef
);
52 /* If the operating channel changes, change the survey in-use flags
54 * Reset the survey data for the new channel, unless we're switching
55 * back to the operating channel from an off-channel operation.
57 if (!sc
->cur_chan
->offchannel
&& sc
->cur_survey
!= &sc
->survey
[pos
]) {
59 sc
->cur_survey
->filled
&= ~SURVEY_INFO_IN_USE
;
61 sc
->cur_survey
= &sc
->survey
[pos
];
63 memset(sc
->cur_survey
, 0, sizeof(struct survey_info
));
64 sc
->cur_survey
->filled
|= SURVEY_INFO_IN_USE
;
65 } else if (!(sc
->survey
[pos
].filled
& SURVEY_INFO_IN_USE
)) {
66 memset(&sc
->survey
[pos
], 0, sizeof(struct survey_info
));
69 hchan
= &sc
->sc_ah
->channels
[pos
];
70 r
= ath_reset(sc
, hchan
);
74 /* The most recent snapshot of channel->noisefloor for the old
75 * channel is only available after the hardware reset. Copy it to
76 * the survey stats now.
79 ath_update_survey_nf(sc
, old_pos
);
81 /* Enable radar pulse detection if on a DFS channel. Spectral
82 * scanning and radar detection can not be used concurrently.
84 if (hw
->conf
.radar_enabled
) {
87 rxfilter
= ath9k_hw_getrxfilter(ah
);
88 rxfilter
|= ATH9K_RX_FILTER_PHYRADAR
|
89 ATH9K_RX_FILTER_PHYERR
;
90 ath9k_hw_setrxfilter(ah
, rxfilter
);
91 ath_dbg(common
, DFS
, "DFS enabled at freq %d\n",
94 /* perform spectral scan if requested. */
95 if (test_bit(ATH_OP_SCANNING
, &common
->op_flags
) &&
96 sc
->spec_priv
.spectral_mode
== SPECTRAL_CHANSCAN
)
97 ath9k_cmn_spectral_scan_trigger(common
, &sc
->spec_priv
);
103 void ath_chanctx_init(struct ath_softc
*sc
)
105 struct ath_chanctx
*ctx
;
106 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
107 struct ieee80211_supported_band
*sband
;
108 struct ieee80211_channel
*chan
;
111 sband
= &common
->sbands
[NL80211_BAND_2GHZ
];
112 if (!sband
->n_channels
)
113 sband
= &common
->sbands
[NL80211_BAND_5GHZ
];
115 chan
= &sband
->channels
[0];
116 for (i
= 0; i
< ATH9K_NUM_CHANCTX
; i
++) {
117 ctx
= &sc
->chanctx
[i
];
118 cfg80211_chandef_create(&ctx
->chandef
, chan
, NL80211_CHAN_HT20
);
119 INIT_LIST_HEAD(&ctx
->vifs
);
120 ctx
->txpower
= ATH_TXPOWER_MAX
;
121 ctx
->flush_timeout
= HZ
/ 5; /* 200ms */
122 for (j
= 0; j
< ARRAY_SIZE(ctx
->acq
); j
++) {
123 INIT_LIST_HEAD(&ctx
->acq
[j
].acq_new
);
124 INIT_LIST_HEAD(&ctx
->acq
[j
].acq_old
);
125 spin_lock_init(&ctx
->acq
[j
].lock
);
130 void ath_chanctx_set_channel(struct ath_softc
*sc
, struct ath_chanctx
*ctx
,
131 struct cfg80211_chan_def
*chandef
)
133 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
136 spin_lock_bh(&sc
->chan_lock
);
138 memcpy(&ctx
->chandef
, chandef
, sizeof(*chandef
));
139 cur_chan
= sc
->cur_chan
== ctx
;
140 spin_unlock_bh(&sc
->chan_lock
);
143 ath_dbg(common
, CHAN_CTX
,
144 "Current context differs from the new context\n");
151 #ifdef CONFIG_ATH9K_CHANNEL_CONTEXT
157 struct ath_chanctx
* ath_is_go_chanctx_present(struct ath_softc
*sc
)
159 struct ath_chanctx
*ctx
;
161 struct ieee80211_vif
*vif
;
163 spin_lock_bh(&sc
->chan_lock
);
165 ath_for_each_chanctx(sc
, ctx
) {
169 list_for_each_entry(avp
, &ctx
->vifs
, list
) {
172 if (ieee80211_vif_type_p2p(vif
) == NL80211_IFTYPE_P2P_GO
) {
173 spin_unlock_bh(&sc
->chan_lock
);
179 spin_unlock_bh(&sc
->chan_lock
);
183 /**********************************************************/
184 /* Functions to handle the channel context state machine. */
185 /**********************************************************/
187 static const char *offchannel_state_string(enum ath_offchannel_state state
)
190 case_rtn_string(ATH_OFFCHANNEL_IDLE
);
191 case_rtn_string(ATH_OFFCHANNEL_PROBE_SEND
);
192 case_rtn_string(ATH_OFFCHANNEL_PROBE_WAIT
);
193 case_rtn_string(ATH_OFFCHANNEL_SUSPEND
);
194 case_rtn_string(ATH_OFFCHANNEL_ROC_START
);
195 case_rtn_string(ATH_OFFCHANNEL_ROC_WAIT
);
196 case_rtn_string(ATH_OFFCHANNEL_ROC_DONE
);
202 static const char *chanctx_event_string(enum ath_chanctx_event ev
)
205 case_rtn_string(ATH_CHANCTX_EVENT_BEACON_PREPARE
);
206 case_rtn_string(ATH_CHANCTX_EVENT_BEACON_SENT
);
207 case_rtn_string(ATH_CHANCTX_EVENT_TSF_TIMER
);
208 case_rtn_string(ATH_CHANCTX_EVENT_BEACON_RECEIVED
);
209 case_rtn_string(ATH_CHANCTX_EVENT_AUTHORIZED
);
210 case_rtn_string(ATH_CHANCTX_EVENT_SWITCH
);
211 case_rtn_string(ATH_CHANCTX_EVENT_ASSIGN
);
212 case_rtn_string(ATH_CHANCTX_EVENT_UNASSIGN
);
213 case_rtn_string(ATH_CHANCTX_EVENT_CHANGE
);
214 case_rtn_string(ATH_CHANCTX_EVENT_ENABLE_MULTICHANNEL
);
220 static const char *chanctx_state_string(enum ath_chanctx_state state
)
223 case_rtn_string(ATH_CHANCTX_STATE_IDLE
);
224 case_rtn_string(ATH_CHANCTX_STATE_WAIT_FOR_BEACON
);
225 case_rtn_string(ATH_CHANCTX_STATE_WAIT_FOR_TIMER
);
226 case_rtn_string(ATH_CHANCTX_STATE_SWITCH
);
227 case_rtn_string(ATH_CHANCTX_STATE_FORCE_ACTIVE
);
233 static u32
chanctx_event_delta(struct ath_softc
*sc
)
236 struct timespec ts
, *old
;
238 getrawmonotonic(&ts
);
239 old
= &sc
->last_event_time
;
240 ms
= ts
.tv_sec
* 1000 + ts
.tv_nsec
/ 1000000;
241 ms
-= old
->tv_sec
* 1000 + old
->tv_nsec
/ 1000000;
242 sc
->last_event_time
= ts
;
247 void ath_chanctx_check_active(struct ath_softc
*sc
, struct ath_chanctx
*ctx
)
249 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
250 struct ath_chanctx
*ictx
;
258 if (ctx
== &sc
->offchannel
.chan
) {
259 spin_lock_bh(&sc
->chan_lock
);
261 if (likely(sc
->sched
.channel_switch_time
))
263 usecs_to_jiffies(sc
->sched
.channel_switch_time
);
266 msecs_to_jiffies(10);
268 spin_unlock_bh(&sc
->chan_lock
);
271 * There is no need to iterate over the
272 * active/assigned channel contexts if
273 * the current context is offchannel.
280 list_for_each_entry(avp
, &ctx
->vifs
, list
) {
281 struct ieee80211_vif
*vif
= avp
->vif
;
284 case NL80211_IFTYPE_P2P_CLIENT
:
285 case NL80211_IFTYPE_STATION
:
294 ctx
->active
= active
;
296 ath_for_each_chanctx(sc
, ctx
) {
297 if (!ctx
->assigned
|| list_empty(&ctx
->vifs
))
302 spin_lock_bh(&sc
->chan_lock
);
305 ictx
->flush_timeout
= HZ
/ 5;
306 clear_bit(ATH_OP_MULTI_CHANNEL
, &common
->op_flags
);
307 spin_unlock_bh(&sc
->chan_lock
);
311 ictx
->flush_timeout
= usecs_to_jiffies(sc
->sched
.channel_switch_time
);
313 if (test_and_set_bit(ATH_OP_MULTI_CHANNEL
, &common
->op_flags
)) {
314 spin_unlock_bh(&sc
->chan_lock
);
318 spin_unlock_bh(&sc
->chan_lock
);
320 if (ath9k_is_chanctx_enabled()) {
321 ath_chanctx_event(sc
, NULL
,
322 ATH_CHANCTX_EVENT_ENABLE_MULTICHANNEL
);
326 static struct ath_chanctx
*
327 ath_chanctx_get_next(struct ath_softc
*sc
, struct ath_chanctx
*ctx
)
329 int idx
= ctx
- &sc
->chanctx
[0];
331 return &sc
->chanctx
[!idx
];
334 static void ath_chanctx_adjust_tbtt_delta(struct ath_softc
*sc
)
336 struct ath_chanctx
*prev
, *cur
;
338 u32 cur_tsf
, prev_tsf
, beacon_int
;
341 beacon_int
= TU_TO_USEC(sc
->cur_chan
->beacon
.beacon_interval
);
344 prev
= ath_chanctx_get_next(sc
, cur
);
346 if (!prev
->switch_after_beacon
)
349 getrawmonotonic(&ts
);
350 cur_tsf
= (u32
) cur
->tsf_val
+
351 ath9k_hw_get_tsf_offset(&cur
->tsf_ts
, &ts
);
353 prev_tsf
= prev
->last_beacon
- (u32
) prev
->tsf_val
+ cur_tsf
;
354 prev_tsf
-= ath9k_hw_get_tsf_offset(&prev
->tsf_ts
, &ts
);
356 /* Adjust the TSF time of the AP chanctx to keep its beacons
357 * at half beacon interval offset relative to the STA chanctx.
359 offset
= cur_tsf
- prev_tsf
;
361 /* Ignore stale data or spurious timestamps */
362 if (offset
< 0 || offset
> 3 * beacon_int
)
365 offset
= beacon_int
/ 2 - (offset
% beacon_int
);
366 prev
->tsf_val
+= offset
;
369 /* Configure the TSF based hardware timer for a channel switch.
370 * Also set up backup software timer, in case the gen timer fails.
371 * This could be caused by a hardware reset.
373 static void ath_chanctx_setup_timer(struct ath_softc
*sc
, u32 tsf_time
)
375 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
376 struct ath_hw
*ah
= sc
->sc_ah
;
377 unsigned long timeout
;
379 ath9k_hw_gen_timer_start(ah
, sc
->p2p_ps_timer
, tsf_time
, 1000000);
380 tsf_time
-= ath9k_hw_gettsf32(ah
);
381 timeout
= msecs_to_jiffies(tsf_time
/ 1000) + 1;
382 mod_timer(&sc
->sched
.timer
, jiffies
+ timeout
);
384 ath_dbg(common
, CHAN_CTX
,
385 "Setup chanctx timer with timeout: %d (%d) ms\n",
386 tsf_time
/ 1000, jiffies_to_msecs(timeout
));
389 static void ath_chanctx_handle_bmiss(struct ath_softc
*sc
,
390 struct ath_chanctx
*ctx
,
394 * Clear the extend_absence flag if it had been
395 * set during the previous beacon transmission,
396 * since we need to revert to the normal NoA
399 if (ctx
->active
&& sc
->sched
.extend_absence
) {
400 avp
->noa_duration
= 0;
401 sc
->sched
.extend_absence
= false;
404 /* If at least two consecutive beacons were missed on the STA
405 * chanctx, stay on the STA channel for one extra beacon period,
406 * to resync the timer properly.
408 if (ctx
->active
&& sc
->sched
.beacon_miss
>= 2) {
409 avp
->noa_duration
= 0;
410 sc
->sched
.extend_absence
= true;
414 static void ath_chanctx_offchannel_noa(struct ath_softc
*sc
,
415 struct ath_chanctx
*ctx
,
419 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
422 avp
->offchannel_start
= tsf_time
;
423 avp
->offchannel_duration
= sc
->sched
.offchannel_duration
;
425 ath_dbg(common
, CHAN_CTX
,
426 "offchannel noa_duration: %d, noa_start: %u, noa_index: %d\n",
427 avp
->offchannel_duration
,
428 avp
->offchannel_start
,
432 * When multiple contexts are active, the NoA
433 * has to be recalculated and advertised after
434 * an offchannel operation.
436 if (ctx
->active
&& avp
->noa_duration
)
437 avp
->noa_duration
= 0;
440 static void ath_chanctx_set_periodic_noa(struct ath_softc
*sc
,
442 struct ath_beacon_config
*cur_conf
,
446 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
449 avp
->noa_start
= tsf_time
;
451 if (sc
->sched
.extend_absence
)
452 avp
->noa_duration
= (3 * beacon_int
/ 2) +
453 sc
->sched
.channel_switch_time
;
456 TU_TO_USEC(cur_conf
->beacon_interval
) / 2 +
457 sc
->sched
.channel_switch_time
;
459 if (test_bit(ATH_OP_SCANNING
, &common
->op_flags
) ||
460 sc
->sched
.extend_absence
)
461 avp
->periodic_noa
= false;
463 avp
->periodic_noa
= true;
465 ath_dbg(common
, CHAN_CTX
,
466 "noa_duration: %d, noa_start: %u, noa_index: %d, periodic: %d\n",
473 static void ath_chanctx_set_oneshot_noa(struct ath_softc
*sc
,
478 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
481 avp
->noa_start
= tsf_time
;
482 avp
->periodic_noa
= false;
483 avp
->oneshot_noa
= true;
484 avp
->noa_duration
= duration
+ sc
->sched
.channel_switch_time
;
486 ath_dbg(common
, CHAN_CTX
,
487 "oneshot noa_duration: %d, noa_start: %u, noa_index: %d, periodic: %d\n",
494 void ath_chanctx_event(struct ath_softc
*sc
, struct ieee80211_vif
*vif
,
495 enum ath_chanctx_event ev
)
497 struct ath_hw
*ah
= sc
->sc_ah
;
498 struct ath_common
*common
= ath9k_hw_common(ah
);
499 struct ath_beacon_config
*cur_conf
;
500 struct ath_vif
*avp
= NULL
;
501 struct ath_chanctx
*ctx
;
506 avp
= (struct ath_vif
*) vif
->drv_priv
;
508 spin_lock_bh(&sc
->chan_lock
);
510 ath_dbg(common
, CHAN_CTX
, "cur_chan: %d MHz, event: %s, state: %s, delta: %u ms\n",
511 sc
->cur_chan
->chandef
.center_freq1
,
512 chanctx_event_string(ev
),
513 chanctx_state_string(sc
->sched
.state
),
514 chanctx_event_delta(sc
));
517 case ATH_CHANCTX_EVENT_BEACON_PREPARE
:
518 if (avp
->offchannel_duration
)
519 avp
->offchannel_duration
= 0;
521 if (avp
->oneshot_noa
) {
522 avp
->noa_duration
= 0;
523 avp
->oneshot_noa
= false;
525 ath_dbg(common
, CHAN_CTX
,
526 "Clearing oneshot NoA\n");
529 if (avp
->chanctx
!= sc
->cur_chan
) {
530 ath_dbg(common
, CHAN_CTX
,
531 "Contexts differ, not preparing beacon\n");
535 if (sc
->sched
.offchannel_pending
&& !sc
->sched
.wait_switch
) {
536 sc
->sched
.offchannel_pending
= false;
537 sc
->next_chan
= &sc
->offchannel
.chan
;
538 sc
->sched
.state
= ATH_CHANCTX_STATE_WAIT_FOR_BEACON
;
539 ath_dbg(common
, CHAN_CTX
,
540 "Setting offchannel_pending to false\n");
543 ctx
= ath_chanctx_get_next(sc
, sc
->cur_chan
);
544 if (ctx
->active
&& sc
->sched
.state
== ATH_CHANCTX_STATE_IDLE
) {
546 sc
->sched
.state
= ATH_CHANCTX_STATE_WAIT_FOR_BEACON
;
547 ath_dbg(common
, CHAN_CTX
,
548 "Set next context, move chanctx state to WAIT_FOR_BEACON\n");
551 /* if the timer missed its window, use the next interval */
552 if (sc
->sched
.state
== ATH_CHANCTX_STATE_WAIT_FOR_TIMER
) {
553 sc
->sched
.state
= ATH_CHANCTX_STATE_WAIT_FOR_BEACON
;
554 ath_dbg(common
, CHAN_CTX
,
555 "Move chanctx state from WAIT_FOR_TIMER to WAIT_FOR_BEACON\n");
558 if (sc
->sched
.mgd_prepare_tx
)
559 sc
->sched
.state
= ATH_CHANCTX_STATE_WAIT_FOR_BEACON
;
562 * When a context becomes inactive, for example,
563 * disassociation of a station context, the NoA
564 * attribute needs to be removed from subsequent
567 if (!ctx
->active
&& avp
->noa_duration
&&
568 sc
->sched
.state
!= ATH_CHANCTX_STATE_WAIT_FOR_BEACON
) {
569 avp
->noa_duration
= 0;
570 avp
->periodic_noa
= false;
572 ath_dbg(common
, CHAN_CTX
,
573 "Clearing NoA schedule\n");
576 if (sc
->sched
.state
!= ATH_CHANCTX_STATE_WAIT_FOR_BEACON
)
579 ath_dbg(common
, CHAN_CTX
, "Preparing beacon for vif: %pM\n", vif
->addr
);
581 sc
->sched
.beacon_pending
= true;
582 sc
->sched
.next_tbtt
= REG_READ(ah
, AR_NEXT_TBTT_TIMER
);
584 cur_conf
= &sc
->cur_chan
->beacon
;
585 beacon_int
= TU_TO_USEC(cur_conf
->beacon_interval
);
587 /* defer channel switch by a quarter beacon interval */
588 tsf_time
= sc
->sched
.next_tbtt
+ beacon_int
/ 4;
589 sc
->sched
.switch_start_time
= tsf_time
;
590 sc
->cur_chan
->last_beacon
= sc
->sched
.next_tbtt
;
593 * If an offchannel switch is scheduled to happen after
594 * a beacon transmission, update the NoA with one-shot
595 * values and increment the index.
597 if (sc
->next_chan
== &sc
->offchannel
.chan
) {
598 ath_chanctx_offchannel_noa(sc
, ctx
, avp
, tsf_time
);
602 ath_chanctx_handle_bmiss(sc
, ctx
, avp
);
605 * If a mgd_prepare_tx() has been called by mac80211,
606 * a one-shot NoA needs to be sent. This can happen
607 * with one or more active channel contexts - in both
608 * cases, a new NoA schedule has to be advertised.
610 if (sc
->sched
.mgd_prepare_tx
) {
611 ath_chanctx_set_oneshot_noa(sc
, avp
, tsf_time
,
612 jiffies_to_usecs(HZ
/ 5));
616 /* Prevent wrap-around issues */
617 if (avp
->noa_duration
&& tsf_time
- avp
->noa_start
> BIT(30))
618 avp
->noa_duration
= 0;
621 * If multiple contexts are active, start periodic
622 * NoA and increment the index for the first
626 (!avp
->noa_duration
|| sc
->sched
.force_noa_update
))
627 ath_chanctx_set_periodic_noa(sc
, avp
, cur_conf
,
628 tsf_time
, beacon_int
);
630 if (ctx
->active
&& sc
->sched
.force_noa_update
)
631 sc
->sched
.force_noa_update
= false;
634 case ATH_CHANCTX_EVENT_BEACON_SENT
:
635 if (!sc
->sched
.beacon_pending
) {
636 ath_dbg(common
, CHAN_CTX
,
637 "No pending beacon\n");
641 sc
->sched
.beacon_pending
= false;
643 if (sc
->sched
.mgd_prepare_tx
) {
644 sc
->sched
.mgd_prepare_tx
= false;
645 complete(&sc
->go_beacon
);
646 ath_dbg(common
, CHAN_CTX
,
647 "Beacon sent, complete go_beacon\n");
651 if (sc
->sched
.state
!= ATH_CHANCTX_STATE_WAIT_FOR_BEACON
)
654 ath_dbg(common
, CHAN_CTX
,
655 "Move chanctx state to WAIT_FOR_TIMER\n");
657 sc
->sched
.state
= ATH_CHANCTX_STATE_WAIT_FOR_TIMER
;
658 ath_chanctx_setup_timer(sc
, sc
->sched
.switch_start_time
);
660 case ATH_CHANCTX_EVENT_TSF_TIMER
:
661 if (sc
->sched
.state
!= ATH_CHANCTX_STATE_WAIT_FOR_TIMER
)
664 if (!sc
->cur_chan
->switch_after_beacon
&&
665 sc
->sched
.beacon_pending
)
666 sc
->sched
.beacon_miss
++;
668 ath_dbg(common
, CHAN_CTX
,
669 "Move chanctx state to SWITCH\n");
671 sc
->sched
.state
= ATH_CHANCTX_STATE_SWITCH
;
672 ieee80211_queue_work(sc
->hw
, &sc
->chanctx_work
);
674 case ATH_CHANCTX_EVENT_BEACON_RECEIVED
:
675 if (!test_bit(ATH_OP_MULTI_CHANNEL
, &common
->op_flags
) ||
676 sc
->cur_chan
== &sc
->offchannel
.chan
)
679 sc
->sched
.beacon_pending
= false;
680 sc
->sched
.beacon_miss
= 0;
682 if (sc
->sched
.state
== ATH_CHANCTX_STATE_FORCE_ACTIVE
||
683 !sc
->sched
.beacon_adjust
||
684 !sc
->cur_chan
->tsf_val
)
687 ath_chanctx_adjust_tbtt_delta(sc
);
689 /* TSF time might have been updated by the incoming beacon,
690 * need update the channel switch timer to reflect the change.
692 tsf_time
= sc
->sched
.switch_start_time
;
693 tsf_time
-= (u32
) sc
->cur_chan
->tsf_val
+
694 ath9k_hw_get_tsf_offset(&sc
->cur_chan
->tsf_ts
, NULL
);
695 tsf_time
+= ath9k_hw_gettsf32(ah
);
697 sc
->sched
.beacon_adjust
= false;
698 ath_chanctx_setup_timer(sc
, tsf_time
);
700 case ATH_CHANCTX_EVENT_AUTHORIZED
:
701 if (sc
->sched
.state
!= ATH_CHANCTX_STATE_FORCE_ACTIVE
||
702 avp
->chanctx
!= sc
->cur_chan
)
705 ath_dbg(common
, CHAN_CTX
,
706 "Move chanctx state from FORCE_ACTIVE to IDLE\n");
708 sc
->sched
.state
= ATH_CHANCTX_STATE_IDLE
;
710 case ATH_CHANCTX_EVENT_SWITCH
:
711 if (!test_bit(ATH_OP_MULTI_CHANNEL
, &common
->op_flags
) ||
712 sc
->sched
.state
== ATH_CHANCTX_STATE_FORCE_ACTIVE
||
713 sc
->cur_chan
->switch_after_beacon
||
714 sc
->cur_chan
== &sc
->offchannel
.chan
)
717 /* If this is a station chanctx, stay active for a half
718 * beacon period (minus channel switch time)
720 sc
->next_chan
= ath_chanctx_get_next(sc
, sc
->cur_chan
);
721 cur_conf
= &sc
->cur_chan
->beacon
;
723 ath_dbg(common
, CHAN_CTX
,
724 "Move chanctx state to WAIT_FOR_TIMER (event SWITCH)\n");
726 sc
->sched
.state
= ATH_CHANCTX_STATE_WAIT_FOR_TIMER
;
727 sc
->sched
.wait_switch
= false;
729 tsf_time
= TU_TO_USEC(cur_conf
->beacon_interval
) / 2;
731 if (sc
->sched
.extend_absence
) {
732 sc
->sched
.beacon_miss
= 0;
736 tsf_time
-= sc
->sched
.channel_switch_time
;
737 tsf_time
+= ath9k_hw_gettsf32(sc
->sc_ah
);
738 sc
->sched
.switch_start_time
= tsf_time
;
740 ath_chanctx_setup_timer(sc
, tsf_time
);
741 sc
->sched
.beacon_pending
= true;
742 sc
->sched
.beacon_adjust
= true;
744 case ATH_CHANCTX_EVENT_ENABLE_MULTICHANNEL
:
745 if (sc
->cur_chan
== &sc
->offchannel
.chan
||
746 sc
->cur_chan
->switch_after_beacon
)
749 sc
->next_chan
= ath_chanctx_get_next(sc
, sc
->cur_chan
);
750 ieee80211_queue_work(sc
->hw
, &sc
->chanctx_work
);
752 case ATH_CHANCTX_EVENT_UNASSIGN
:
753 if (sc
->cur_chan
->assigned
) {
754 if (sc
->next_chan
&& !sc
->next_chan
->assigned
&&
755 sc
->next_chan
!= &sc
->offchannel
.chan
)
756 sc
->sched
.state
= ATH_CHANCTX_STATE_IDLE
;
760 ctx
= ath_chanctx_get_next(sc
, sc
->cur_chan
);
761 sc
->sched
.state
= ATH_CHANCTX_STATE_IDLE
;
766 ieee80211_queue_work(sc
->hw
, &sc
->chanctx_work
);
768 case ATH_CHANCTX_EVENT_ASSIGN
:
770 case ATH_CHANCTX_EVENT_CHANGE
:
774 spin_unlock_bh(&sc
->chan_lock
);
777 void ath_chanctx_beacon_sent_ev(struct ath_softc
*sc
,
778 enum ath_chanctx_event ev
)
780 if (sc
->sched
.beacon_pending
)
781 ath_chanctx_event(sc
, NULL
, ev
);
784 void ath_chanctx_beacon_recv_ev(struct ath_softc
*sc
,
785 enum ath_chanctx_event ev
)
787 ath_chanctx_event(sc
, NULL
, ev
);
790 static int ath_scan_channel_duration(struct ath_softc
*sc
,
791 struct ieee80211_channel
*chan
)
793 struct cfg80211_scan_request
*req
= sc
->offchannel
.scan_req
;
795 if (!req
->n_ssids
|| (chan
->flags
& IEEE80211_CHAN_NO_IR
))
796 return (HZ
/ 9); /* ~110 ms */
798 return (HZ
/ 16); /* ~60 ms */
801 static void ath_chanctx_switch(struct ath_softc
*sc
, struct ath_chanctx
*ctx
,
802 struct cfg80211_chan_def
*chandef
)
804 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
806 spin_lock_bh(&sc
->chan_lock
);
808 if (test_bit(ATH_OP_MULTI_CHANNEL
, &common
->op_flags
) &&
809 (sc
->cur_chan
!= ctx
) && (ctx
== &sc
->offchannel
.chan
)) {
811 ctx
->chandef
= *chandef
;
813 sc
->sched
.offchannel_pending
= true;
814 sc
->sched
.wait_switch
= true;
815 sc
->sched
.offchannel_duration
=
816 jiffies_to_usecs(sc
->offchannel
.duration
) +
817 sc
->sched
.channel_switch_time
;
819 spin_unlock_bh(&sc
->chan_lock
);
820 ath_dbg(common
, CHAN_CTX
,
821 "Set offchannel_pending to true\n");
827 ctx
->chandef
= *chandef
;
828 ath_dbg(common
, CHAN_CTX
,
829 "Assigned next_chan to %d MHz\n", chandef
->center_freq1
);
832 if (sc
->next_chan
== &sc
->offchannel
.chan
) {
833 sc
->sched
.offchannel_duration
=
834 jiffies_to_usecs(sc
->offchannel
.duration
) +
835 sc
->sched
.channel_switch_time
;
838 ath_dbg(common
, CHAN_CTX
,
839 "Offchannel duration for chan %d MHz : %u\n",
840 chandef
->center_freq1
,
841 sc
->sched
.offchannel_duration
);
844 spin_unlock_bh(&sc
->chan_lock
);
845 ieee80211_queue_work(sc
->hw
, &sc
->chanctx_work
);
848 static void ath_chanctx_offchan_switch(struct ath_softc
*sc
,
849 struct ieee80211_channel
*chan
)
851 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
852 struct cfg80211_chan_def chandef
;
854 cfg80211_chandef_create(&chandef
, chan
, NL80211_CHAN_NO_HT
);
855 ath_dbg(common
, CHAN_CTX
,
856 "Channel definition created: %d MHz\n", chandef
.center_freq1
);
858 ath_chanctx_switch(sc
, &sc
->offchannel
.chan
, &chandef
);
861 static struct ath_chanctx
*ath_chanctx_get_oper_chan(struct ath_softc
*sc
,
864 struct ath_chanctx
*ctx
;
866 ath_for_each_chanctx(sc
, ctx
) {
867 if (!ctx
->assigned
|| list_empty(&ctx
->vifs
))
869 if (active
&& !ctx
->active
)
872 if (ctx
->switch_after_beacon
)
876 return &sc
->chanctx
[0];
880 ath_scan_next_channel(struct ath_softc
*sc
)
882 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
883 struct cfg80211_scan_request
*req
= sc
->offchannel
.scan_req
;
884 struct ieee80211_channel
*chan
;
886 if (sc
->offchannel
.scan_idx
>= req
->n_channels
) {
887 ath_dbg(common
, CHAN_CTX
,
888 "Moving offchannel state to ATH_OFFCHANNEL_IDLE, "
889 "scan_idx: %d, n_channels: %d\n",
890 sc
->offchannel
.scan_idx
,
893 sc
->offchannel
.state
= ATH_OFFCHANNEL_IDLE
;
894 ath_chanctx_switch(sc
, ath_chanctx_get_oper_chan(sc
, false),
899 ath_dbg(common
, CHAN_CTX
,
900 "Moving offchannel state to ATH_OFFCHANNEL_PROBE_SEND, scan_idx: %d\n",
901 sc
->offchannel
.scan_idx
);
903 chan
= req
->channels
[sc
->offchannel
.scan_idx
++];
904 sc
->offchannel
.duration
= ath_scan_channel_duration(sc
, chan
);
905 sc
->offchannel
.state
= ATH_OFFCHANNEL_PROBE_SEND
;
907 ath_chanctx_offchan_switch(sc
, chan
);
910 void ath_offchannel_next(struct ath_softc
*sc
)
912 struct ieee80211_vif
*vif
;
914 if (sc
->offchannel
.scan_req
) {
915 vif
= sc
->offchannel
.scan_vif
;
916 sc
->offchannel
.chan
.txpower
= vif
->bss_conf
.txpower
;
917 ath_scan_next_channel(sc
);
918 } else if (sc
->offchannel
.roc_vif
) {
919 vif
= sc
->offchannel
.roc_vif
;
920 sc
->offchannel
.chan
.txpower
= vif
->bss_conf
.txpower
;
921 sc
->offchannel
.duration
=
922 msecs_to_jiffies(sc
->offchannel
.roc_duration
);
923 sc
->offchannel
.state
= ATH_OFFCHANNEL_ROC_START
;
924 ath_chanctx_offchan_switch(sc
, sc
->offchannel
.roc_chan
);
926 spin_lock_bh(&sc
->chan_lock
);
927 sc
->sched
.offchannel_pending
= false;
928 sc
->sched
.wait_switch
= false;
929 spin_unlock_bh(&sc
->chan_lock
);
931 ath_chanctx_switch(sc
, ath_chanctx_get_oper_chan(sc
, false),
933 sc
->offchannel
.state
= ATH_OFFCHANNEL_IDLE
;
939 void ath_roc_complete(struct ath_softc
*sc
, enum ath_roc_complete_reason reason
)
941 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
943 sc
->offchannel
.roc_vif
= NULL
;
944 sc
->offchannel
.roc_chan
= NULL
;
947 case ATH_ROC_COMPLETE_ABORT
:
948 ath_dbg(common
, CHAN_CTX
, "RoC aborted\n");
949 ieee80211_remain_on_channel_expired(sc
->hw
);
951 case ATH_ROC_COMPLETE_EXPIRE
:
952 ath_dbg(common
, CHAN_CTX
, "RoC expired\n");
953 ieee80211_remain_on_channel_expired(sc
->hw
);
955 case ATH_ROC_COMPLETE_CANCEL
:
956 ath_dbg(common
, CHAN_CTX
, "RoC canceled\n");
960 ath_offchannel_next(sc
);
961 ath9k_ps_restore(sc
);
964 void ath_scan_complete(struct ath_softc
*sc
, bool abort
)
966 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
967 struct cfg80211_scan_info info
= {
972 ath_dbg(common
, CHAN_CTX
, "HW scan aborted\n");
974 ath_dbg(common
, CHAN_CTX
, "HW scan complete\n");
976 sc
->offchannel
.scan_req
= NULL
;
977 sc
->offchannel
.scan_vif
= NULL
;
978 sc
->offchannel
.state
= ATH_OFFCHANNEL_IDLE
;
979 ieee80211_scan_completed(sc
->hw
, &info
);
980 clear_bit(ATH_OP_SCANNING
, &common
->op_flags
);
981 spin_lock_bh(&sc
->chan_lock
);
982 if (test_bit(ATH_OP_MULTI_CHANNEL
, &common
->op_flags
))
983 sc
->sched
.force_noa_update
= true;
984 spin_unlock_bh(&sc
->chan_lock
);
985 ath_offchannel_next(sc
);
986 ath9k_ps_restore(sc
);
989 static void ath_scan_send_probe(struct ath_softc
*sc
,
990 struct cfg80211_ssid
*ssid
)
992 struct cfg80211_scan_request
*req
= sc
->offchannel
.scan_req
;
993 struct ieee80211_vif
*vif
= sc
->offchannel
.scan_vif
;
994 struct ath_tx_control txctl
= {};
996 struct ieee80211_tx_info
*info
;
997 int band
= sc
->offchannel
.chan
.chandef
.chan
->band
;
999 skb
= ieee80211_probereq_get(sc
->hw
, vif
->addr
,
1000 ssid
->ssid
, ssid
->ssid_len
, req
->ie_len
);
1004 info
= IEEE80211_SKB_CB(skb
);
1006 info
->flags
|= IEEE80211_TX_CTL_NO_CCK_RATE
;
1009 skb_put_data(skb
, req
->ie
, req
->ie_len
);
1011 skb_set_queue_mapping(skb
, IEEE80211_AC_VO
);
1013 if (!ieee80211_tx_prepare_skb(sc
->hw
, vif
, skb
, band
, NULL
))
1016 txctl
.txq
= sc
->tx
.txq_map
[IEEE80211_AC_VO
];
1017 if (ath_tx_start(sc
->hw
, skb
, &txctl
))
1023 ieee80211_free_txskb(sc
->hw
, skb
);
1026 static void ath_scan_channel_start(struct ath_softc
*sc
)
1028 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
1029 struct cfg80211_scan_request
*req
= sc
->offchannel
.scan_req
;
1032 if (!(sc
->cur_chan
->chandef
.chan
->flags
& IEEE80211_CHAN_NO_IR
) &&
1034 for (i
= 0; i
< req
->n_ssids
; i
++)
1035 ath_scan_send_probe(sc
, &req
->ssids
[i
]);
1039 ath_dbg(common
, CHAN_CTX
,
1040 "Moving offchannel state to ATH_OFFCHANNEL_PROBE_WAIT\n");
1042 sc
->offchannel
.state
= ATH_OFFCHANNEL_PROBE_WAIT
;
1043 mod_timer(&sc
->offchannel
.timer
, jiffies
+ sc
->offchannel
.duration
);
1046 static void ath_chanctx_timer(struct timer_list
*t
)
1048 struct ath_softc
*sc
= from_timer(sc
, t
, sched
.timer
);
1049 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
1051 ath_dbg(common
, CHAN_CTX
,
1052 "Channel context timer invoked\n");
1054 ath_chanctx_event(sc
, NULL
, ATH_CHANCTX_EVENT_TSF_TIMER
);
1057 static void ath_offchannel_timer(struct timer_list
*t
)
1059 struct ath_softc
*sc
= from_timer(sc
, t
, offchannel
.timer
);
1060 struct ath_chanctx
*ctx
;
1061 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
1063 ath_dbg(common
, CHAN_CTX
, "%s: offchannel state: %s\n",
1064 __func__
, offchannel_state_string(sc
->offchannel
.state
));
1066 switch (sc
->offchannel
.state
) {
1067 case ATH_OFFCHANNEL_PROBE_WAIT
:
1068 if (!sc
->offchannel
.scan_req
)
1071 /* get first active channel context */
1072 ctx
= ath_chanctx_get_oper_chan(sc
, true);
1074 ath_dbg(common
, CHAN_CTX
,
1075 "Switch to oper/active context, "
1076 "move offchannel state to ATH_OFFCHANNEL_SUSPEND\n");
1078 sc
->offchannel
.state
= ATH_OFFCHANNEL_SUSPEND
;
1079 ath_chanctx_switch(sc
, ctx
, NULL
);
1080 mod_timer(&sc
->offchannel
.timer
, jiffies
+ HZ
/ 10);
1084 case ATH_OFFCHANNEL_SUSPEND
:
1085 if (!sc
->offchannel
.scan_req
)
1088 ath_scan_next_channel(sc
);
1090 case ATH_OFFCHANNEL_ROC_START
:
1091 case ATH_OFFCHANNEL_ROC_WAIT
:
1092 sc
->offchannel
.state
= ATH_OFFCHANNEL_ROC_DONE
;
1093 ath_roc_complete(sc
, ATH_ROC_COMPLETE_EXPIRE
);
1101 ath_chanctx_send_vif_ps_frame(struct ath_softc
*sc
, struct ath_vif
*avp
,
1104 struct ieee80211_vif
*vif
= avp
->vif
;
1105 struct ieee80211_sta
*sta
= NULL
;
1106 struct ieee80211_hdr_3addr
*nullfunc
;
1107 struct ath_tx_control txctl
;
1108 struct sk_buff
*skb
;
1109 int band
= sc
->cur_chan
->chandef
.chan
->band
;
1111 switch (vif
->type
) {
1112 case NL80211_IFTYPE_STATION
:
1116 skb
= ieee80211_nullfunc_get(sc
->hw
, vif
);
1120 nullfunc
= (struct ieee80211_hdr_3addr
*) skb
->data
;
1122 nullfunc
->frame_control
|=
1123 cpu_to_le16(IEEE80211_FCTL_PM
);
1126 skb_set_queue_mapping(skb
, IEEE80211_AC_VO
);
1127 if (!ieee80211_tx_prepare_skb(sc
->hw
, vif
, skb
, band
, &sta
)) {
1128 dev_kfree_skb_any(skb
);
1136 memset(&txctl
, 0, sizeof(txctl
));
1137 txctl
.txq
= sc
->tx
.txq_map
[IEEE80211_AC_VO
];
1139 if (ath_tx_start(sc
->hw
, skb
, &txctl
)) {
1140 ieee80211_free_txskb(sc
->hw
, skb
);
1148 ath_chanctx_send_ps_frame(struct ath_softc
*sc
, bool powersave
)
1150 struct ath_vif
*avp
;
1154 list_for_each_entry(avp
, &sc
->cur_chan
->vifs
, list
) {
1155 if (ath_chanctx_send_vif_ps_frame(sc
, avp
, powersave
))
1163 static bool ath_chanctx_defer_switch(struct ath_softc
*sc
)
1165 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
1167 if (sc
->cur_chan
== &sc
->offchannel
.chan
)
1170 switch (sc
->sched
.state
) {
1171 case ATH_CHANCTX_STATE_SWITCH
:
1173 case ATH_CHANCTX_STATE_IDLE
:
1174 if (!sc
->cur_chan
->switch_after_beacon
)
1177 ath_dbg(common
, CHAN_CTX
,
1178 "Defer switch, set chanctx state to WAIT_FOR_BEACON\n");
1180 sc
->sched
.state
= ATH_CHANCTX_STATE_WAIT_FOR_BEACON
;
1189 static void ath_offchannel_channel_change(struct ath_softc
*sc
)
1191 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
1193 ath_dbg(common
, CHAN_CTX
, "%s: offchannel state: %s\n",
1194 __func__
, offchannel_state_string(sc
->offchannel
.state
));
1196 switch (sc
->offchannel
.state
) {
1197 case ATH_OFFCHANNEL_PROBE_SEND
:
1198 if (!sc
->offchannel
.scan_req
)
1201 if (sc
->cur_chan
->chandef
.chan
!=
1202 sc
->offchannel
.chan
.chandef
.chan
)
1205 ath_scan_channel_start(sc
);
1207 case ATH_OFFCHANNEL_IDLE
:
1208 if (!sc
->offchannel
.scan_req
)
1211 ath_scan_complete(sc
, false);
1213 case ATH_OFFCHANNEL_ROC_START
:
1214 if (sc
->cur_chan
!= &sc
->offchannel
.chan
)
1217 sc
->offchannel
.state
= ATH_OFFCHANNEL_ROC_WAIT
;
1218 mod_timer(&sc
->offchannel
.timer
,
1219 jiffies
+ sc
->offchannel
.duration
);
1220 ieee80211_ready_on_channel(sc
->hw
);
1222 case ATH_OFFCHANNEL_ROC_DONE
:
1229 void ath_chanctx_set_next(struct ath_softc
*sc
, bool force
)
1231 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
1232 struct ath_chanctx
*old_ctx
;
1234 bool measure_time
= false;
1235 bool send_ps
= false;
1236 bool queues_stopped
= false;
1238 spin_lock_bh(&sc
->chan_lock
);
1239 if (!sc
->next_chan
) {
1240 spin_unlock_bh(&sc
->chan_lock
);
1244 if (!force
&& ath_chanctx_defer_switch(sc
)) {
1245 spin_unlock_bh(&sc
->chan_lock
);
1249 ath_dbg(common
, CHAN_CTX
,
1250 "%s: current: %d MHz, next: %d MHz\n",
1252 sc
->cur_chan
->chandef
.center_freq1
,
1253 sc
->next_chan
->chandef
.center_freq1
);
1255 if (sc
->cur_chan
!= sc
->next_chan
) {
1256 ath_dbg(common
, CHAN_CTX
,
1257 "Stopping current chanctx: %d\n",
1258 sc
->cur_chan
->chandef
.center_freq1
);
1259 sc
->cur_chan
->stopped
= true;
1260 spin_unlock_bh(&sc
->chan_lock
);
1262 if (sc
->next_chan
== &sc
->offchannel
.chan
) {
1263 getrawmonotonic(&ts
);
1264 measure_time
= true;
1267 ath9k_chanctx_stop_queues(sc
, sc
->cur_chan
);
1268 queues_stopped
= true;
1270 __ath9k_flush(sc
->hw
, ~0, true, false, false);
1272 if (ath_chanctx_send_ps_frame(sc
, true))
1273 __ath9k_flush(sc
->hw
, BIT(IEEE80211_AC_VO
),
1274 false, false, false);
1277 spin_lock_bh(&sc
->chan_lock
);
1279 if (sc
->cur_chan
!= &sc
->offchannel
.chan
) {
1280 getrawmonotonic(&sc
->cur_chan
->tsf_ts
);
1281 sc
->cur_chan
->tsf_val
= ath9k_hw_gettsf64(sc
->sc_ah
);
1284 old_ctx
= sc
->cur_chan
;
1285 sc
->cur_chan
= sc
->next_chan
;
1286 sc
->cur_chan
->stopped
= false;
1287 sc
->next_chan
= NULL
;
1289 if (!sc
->sched
.offchannel_pending
)
1290 sc
->sched
.offchannel_duration
= 0;
1292 if (sc
->sched
.state
!= ATH_CHANCTX_STATE_FORCE_ACTIVE
)
1293 sc
->sched
.state
= ATH_CHANCTX_STATE_IDLE
;
1295 spin_unlock_bh(&sc
->chan_lock
);
1297 if (sc
->sc_ah
->chip_fullsleep
||
1298 memcmp(&sc
->cur_chandef
, &sc
->cur_chan
->chandef
,
1299 sizeof(sc
->cur_chandef
))) {
1300 ath_dbg(common
, CHAN_CTX
,
1301 "%s: Set channel %d MHz\n",
1302 __func__
, sc
->cur_chan
->chandef
.center_freq1
);
1303 ath_set_channel(sc
);
1305 sc
->sched
.channel_switch_time
=
1306 ath9k_hw_get_tsf_offset(&ts
, NULL
);
1308 * A reset will ensure that all queues are woken up,
1309 * so there is no need to awaken them again.
1315 ath9k_chanctx_wake_queues(sc
, old_ctx
);
1318 ath_chanctx_send_ps_frame(sc
, false);
1320 ath_offchannel_channel_change(sc
);
1321 ath_chanctx_event(sc
, NULL
, ATH_CHANCTX_EVENT_SWITCH
);
1324 static void ath_chanctx_work(struct work_struct
*work
)
1326 struct ath_softc
*sc
= container_of(work
, struct ath_softc
,
1328 mutex_lock(&sc
->mutex
);
1329 ath_chanctx_set_next(sc
, false);
1330 mutex_unlock(&sc
->mutex
);
1333 void ath9k_offchannel_init(struct ath_softc
*sc
)
1335 struct ath_chanctx
*ctx
;
1336 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
1337 struct ieee80211_supported_band
*sband
;
1338 struct ieee80211_channel
*chan
;
1341 sband
= &common
->sbands
[NL80211_BAND_2GHZ
];
1342 if (!sband
->n_channels
)
1343 sband
= &common
->sbands
[NL80211_BAND_5GHZ
];
1345 chan
= &sband
->channels
[0];
1347 ctx
= &sc
->offchannel
.chan
;
1348 INIT_LIST_HEAD(&ctx
->vifs
);
1349 ctx
->txpower
= ATH_TXPOWER_MAX
;
1350 cfg80211_chandef_create(&ctx
->chandef
, chan
, NL80211_CHAN_HT20
);
1352 for (i
= 0; i
< ARRAY_SIZE(ctx
->acq
); i
++) {
1353 INIT_LIST_HEAD(&ctx
->acq
[i
].acq_new
);
1354 INIT_LIST_HEAD(&ctx
->acq
[i
].acq_old
);
1355 spin_lock_init(&ctx
->acq
[i
].lock
);
1358 sc
->offchannel
.chan
.offchannel
= true;
1361 void ath9k_init_channel_context(struct ath_softc
*sc
)
1363 INIT_WORK(&sc
->chanctx_work
, ath_chanctx_work
);
1365 timer_setup(&sc
->offchannel
.timer
, ath_offchannel_timer
, 0);
1366 timer_setup(&sc
->sched
.timer
, ath_chanctx_timer
, 0);
1368 init_completion(&sc
->go_beacon
);
1371 void ath9k_deinit_channel_context(struct ath_softc
*sc
)
1373 cancel_work_sync(&sc
->chanctx_work
);
1376 bool ath9k_is_chanctx_enabled(void)
1378 return (ath9k_use_chanctx
== 1);
1381 /********************/
1382 /* Queue management */
1383 /********************/
1385 void ath9k_chanctx_stop_queues(struct ath_softc
*sc
, struct ath_chanctx
*ctx
)
1387 struct ath_hw
*ah
= sc
->sc_ah
;
1390 if (ctx
== &sc
->offchannel
.chan
) {
1391 ieee80211_stop_queue(sc
->hw
,
1392 sc
->hw
->offchannel_tx_hw_queue
);
1394 for (i
= 0; i
< IEEE80211_NUM_ACS
; i
++)
1395 ieee80211_stop_queue(sc
->hw
,
1396 ctx
->hw_queue_base
+ i
);
1399 if (ah
->opmode
== NL80211_IFTYPE_AP
)
1400 ieee80211_stop_queue(sc
->hw
, sc
->hw
->queues
- 2);
1404 void ath9k_chanctx_wake_queues(struct ath_softc
*sc
, struct ath_chanctx
*ctx
)
1406 struct ath_hw
*ah
= sc
->sc_ah
;
1409 if (ctx
== &sc
->offchannel
.chan
) {
1410 ieee80211_wake_queue(sc
->hw
,
1411 sc
->hw
->offchannel_tx_hw_queue
);
1413 for (i
= 0; i
< IEEE80211_NUM_ACS
; i
++)
1414 ieee80211_wake_queue(sc
->hw
,
1415 ctx
->hw_queue_base
+ i
);
1418 if (ah
->opmode
== NL80211_IFTYPE_AP
)
1419 ieee80211_wake_queue(sc
->hw
, sc
->hw
->queues
- 2);
1426 static void ath9k_update_p2p_ps_timer(struct ath_softc
*sc
, struct ath_vif
*avp
)
1428 struct ath_common
*common
= ath9k_hw_common(sc
->sc_ah
);
1429 struct ath_hw
*ah
= sc
->sc_ah
;
1430 u32 tsf
, target_tsf
;
1432 if (!avp
|| !avp
->noa
.has_next_tsf
)
1435 ath9k_hw_gen_timer_stop(ah
, sc
->p2p_ps_timer
);
1437 tsf
= ath9k_hw_gettsf32(sc
->sc_ah
);
1439 target_tsf
= avp
->noa
.next_tsf
;
1440 if (!avp
->noa
.absent
)
1441 target_tsf
-= ATH_P2P_PS_STOP_TIME
;
1443 target_tsf
+= ATH_P2P_PS_STOP_TIME
;
1445 if (target_tsf
- tsf
< ATH_P2P_PS_STOP_TIME
)
1446 target_tsf
= tsf
+ ATH_P2P_PS_STOP_TIME
;
1448 ath_dbg(common
, CHAN_CTX
, "%s absent %d tsf 0x%08X next_tsf 0x%08X (%dms)\n",
1449 __func__
, avp
->noa
.absent
, tsf
, target_tsf
,
1450 (target_tsf
- tsf
) / 1000);
1452 ath9k_hw_gen_timer_start(ah
, sc
->p2p_ps_timer
, target_tsf
, 1000000);
1455 static void ath9k_update_p2p_ps(struct ath_softc
*sc
, struct ieee80211_vif
*vif
)
1457 struct ath_vif
*avp
= (void *)vif
->drv_priv
;
1460 if (!sc
->p2p_ps_timer
)
1463 if (vif
->type
!= NL80211_IFTYPE_STATION
)
1466 sc
->p2p_ps_vif
= avp
;
1468 if (sc
->ps_flags
& PS_BEACON_SYNC
)
1471 tsf
= ath9k_hw_gettsf32(sc
->sc_ah
);
1472 ieee80211_parse_p2p_noa(&vif
->bss_conf
.p2p_noa_attr
, &avp
->noa
, tsf
);
1473 ath9k_update_p2p_ps_timer(sc
, avp
);
1476 static u8
ath9k_get_ctwin(struct ath_softc
*sc
, struct ath_vif
*avp
)
1478 struct ath_beacon_config
*cur_conf
= &sc
->cur_chan
->beacon
;
1479 u8 switch_time
, ctwin
;
1482 * Channel switch in multi-channel mode is deferred
1483 * by a quarter beacon interval when handling
1484 * ATH_CHANCTX_EVENT_BEACON_PREPARE, so the P2P-GO
1485 * interface is guaranteed to be discoverable
1486 * for that duration after a TBTT.
1488 switch_time
= cur_conf
->beacon_interval
/ 4;
1490 ctwin
= avp
->vif
->bss_conf
.p2p_noa_attr
.oppps_ctwindow
;
1491 if (ctwin
&& (ctwin
< switch_time
))
1494 if (switch_time
< P2P_DEFAULT_CTWIN
)
1497 return P2P_DEFAULT_CTWIN
;
1500 void ath9k_beacon_add_noa(struct ath_softc
*sc
, struct ath_vif
*avp
,
1501 struct sk_buff
*skb
)
1503 static const u8 noa_ie_hdr
[] = {
1504 WLAN_EID_VENDOR_SPECIFIC
, /* type */
1506 0x50, 0x6f, 0x9a, /* WFA OUI */
1507 0x09, /* P2P subtype */
1508 0x0c, /* Notice of Absence */
1509 0x00, /* LSB of little-endian len */
1510 0x00, /* MSB of little-endian len */
1513 struct ieee80211_p2p_noa_attr
*noa
;
1514 int noa_len
, noa_desc
, i
= 0;
1517 if (!avp
->offchannel_duration
&& !avp
->noa_duration
)
1520 noa_desc
= !!avp
->offchannel_duration
+ !!avp
->noa_duration
;
1521 noa_len
= 2 + sizeof(struct ieee80211_p2p_noa_desc
) * noa_desc
;
1523 hdr
= skb_put_data(skb
, noa_ie_hdr
, sizeof(noa_ie_hdr
));
1524 hdr
[1] = sizeof(noa_ie_hdr
) + noa_len
- 2;
1527 noa
= skb_put_zero(skb
, noa_len
);
1529 noa
->index
= avp
->noa_index
;
1530 noa
->oppps_ctwindow
= ath9k_get_ctwin(sc
, avp
);
1531 if (noa
->oppps_ctwindow
)
1532 noa
->oppps_ctwindow
|= BIT(7);
1534 if (avp
->noa_duration
) {
1535 if (avp
->periodic_noa
) {
1536 u32 interval
= TU_TO_USEC(sc
->cur_chan
->beacon
.beacon_interval
);
1537 noa
->desc
[i
].count
= 255;
1538 noa
->desc
[i
].interval
= cpu_to_le32(interval
);
1540 noa
->desc
[i
].count
= 1;
1543 noa
->desc
[i
].start_time
= cpu_to_le32(avp
->noa_start
);
1544 noa
->desc
[i
].duration
= cpu_to_le32(avp
->noa_duration
);
1548 if (avp
->offchannel_duration
) {
1549 noa
->desc
[i
].count
= 1;
1550 noa
->desc
[i
].start_time
= cpu_to_le32(avp
->offchannel_start
);
1551 noa
->desc
[i
].duration
= cpu_to_le32(avp
->offchannel_duration
);
1555 void ath9k_p2p_ps_timer(void *priv
)
1557 struct ath_softc
*sc
= priv
;
1558 struct ath_vif
*avp
= sc
->p2p_ps_vif
;
1559 struct ieee80211_vif
*vif
;
1560 struct ieee80211_sta
*sta
;
1561 struct ath_node
*an
;
1564 del_timer_sync(&sc
->sched
.timer
);
1565 ath9k_hw_gen_timer_stop(sc
->sc_ah
, sc
->p2p_ps_timer
);
1566 ath_chanctx_event(sc
, NULL
, ATH_CHANCTX_EVENT_TSF_TIMER
);
1568 if (!avp
|| avp
->chanctx
!= sc
->cur_chan
)
1571 tsf
= ath9k_hw_gettsf32(sc
->sc_ah
);
1572 if (!avp
->noa
.absent
)
1573 tsf
+= ATH_P2P_PS_STOP_TIME
;
1575 tsf
-= ATH_P2P_PS_STOP_TIME
;
1577 if (!avp
->noa
.has_next_tsf
||
1578 avp
->noa
.next_tsf
- tsf
> BIT(31))
1579 ieee80211_update_p2p_noa(&avp
->noa
, tsf
);
1581 ath9k_update_p2p_ps_timer(sc
, avp
);
1586 sta
= ieee80211_find_sta(vif
, avp
->bssid
);
1590 an
= (void *) sta
->drv_priv
;
1591 if (an
->sleeping
== !!avp
->noa
.absent
)
1594 an
->sleeping
= avp
->noa
.absent
;
1596 ath_tx_aggr_sleep(sta
, sc
, an
);
1598 ath_tx_aggr_wakeup(sc
, an
);
1604 void ath9k_p2p_bss_info_changed(struct ath_softc
*sc
,
1605 struct ieee80211_vif
*vif
)
1607 unsigned long flags
;
1609 spin_lock_bh(&sc
->sc_pcu_lock
);
1610 spin_lock_irqsave(&sc
->sc_pm_lock
, flags
);
1611 ath9k_update_p2p_ps(sc
, vif
);
1612 spin_unlock_irqrestore(&sc
->sc_pm_lock
, flags
);
1613 spin_unlock_bh(&sc
->sc_pcu_lock
);
1616 void ath9k_p2p_beacon_sync(struct ath_softc
*sc
)
1619 ath9k_update_p2p_ps(sc
, sc
->p2p_ps_vif
->vif
);
1622 void ath9k_p2p_remove_vif(struct ath_softc
*sc
,
1623 struct ieee80211_vif
*vif
)
1625 struct ath_vif
*avp
= (void *)vif
->drv_priv
;
1627 spin_lock_bh(&sc
->sc_pcu_lock
);
1628 if (avp
== sc
->p2p_ps_vif
) {
1629 sc
->p2p_ps_vif
= NULL
;
1630 ath9k_update_p2p_ps_timer(sc
, NULL
);
1632 spin_unlock_bh(&sc
->sc_pcu_lock
);
1635 int ath9k_init_p2p(struct ath_softc
*sc
)
1637 sc
->p2p_ps_timer
= ath_gen_timer_alloc(sc
->sc_ah
, ath9k_p2p_ps_timer
,
1638 NULL
, sc
, AR_FIRST_NDP_TIMER
);
1639 if (!sc
->p2p_ps_timer
)
1645 void ath9k_deinit_p2p(struct ath_softc
*sc
)
1647 if (sc
->p2p_ps_timer
)
1648 ath_gen_timer_free(sc
->sc_ah
, sc
->p2p_ps_timer
);
1651 #endif /* CONFIG_ATH9K_CHANNEL_CONTEXT */