?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
treewide: remove redundant IS_ERR() before error code check
[linux/fpc-iii.git] / drivers / net / wireless / ath / ath9k / channel.c
blobfd61ae4782b63632c7f8a7ccc9a107e7274bd587
1 /*
2 * Copyright (c) 2014 Qualcomm Atheros, Inc.
3 *
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 */
16
17 #include "ath9k.h"
18
19 /* Set/change channels. If the channel is really being changed, it's done
20 * by reseting the chip. To accomplish this we must first cleanup any pending
21 * DMA, then restart stuff.
22 */
23 static int ath_set_channel(struct ath_softc *sc)
24 {
25 struct ath_hw *ah = sc->sc_ah;
26 struct ath_common *common = ath9k_hw_common(ah);
27 struct ieee80211_hw *hw = sc->hw;
28 struct ath9k_channel *hchan;
29 struct cfg80211_chan_def *chandef = &sc->cur_chan->chandef;
30 struct ieee80211_channel *chan = chandef->chan;
31 int pos = chan->hw_value;
32 unsigned long flags;
33 int old_pos = -1;
34 int r;
35
36 if (test_bit(ATH_OP_INVALID, &common->op_flags))
37 return -EIO;
38
39 if (ah->curchan)
40 old_pos = ah->curchan - &ah->channels[0];
41
42 ath_dbg(common, CONFIG, "Set channel: %d MHz width: %d\n",
43 chan->center_freq, chandef->width);
44
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);
49
50 ath9k_cmn_get_channel(hw, ah, chandef);
51
52 /* If the operating channel changes, change the survey in-use flags
53 * along with it.
54 * Reset the survey data for the new channel, unless we're switching
55 * back to the operating channel from an off-channel operation.
56 */
57 if (!sc->cur_chan->offchannel && sc->cur_survey != &sc->survey[pos]) {
58 if (sc->cur_survey)
59 sc->cur_survey->filled &= ~SURVEY_INFO_IN_USE;
60
61 sc->cur_survey = &sc->survey[pos];
62
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));
67 }
68
69 hchan = &sc->sc_ah->channels[pos];
70 r = ath_reset(sc, hchan);
71 if (r)
72 return r;
73
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.
77 */
78 if (old_pos >= 0)
79 ath_update_survey_nf(sc, old_pos);
80
81 /* Enable radar pulse detection if on a DFS channel. Spectral
82 * scanning and radar detection can not be used concurrently.
83 */
84 if (hw->conf.radar_enabled) {
85 u32 rxfilter;
86
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",
92 chan->center_freq);
93 } else {
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);
98 }
99
100 return 0;
101 }
102
103 void ath_chanctx_init(struct ath_softc *sc)
104 {
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;
109 int i, j;
110
111 sband = &common->sbands[NL80211_BAND_2GHZ];
112 if (!sband->n_channels)
113 sband = &common->sbands[NL80211_BAND_5GHZ];
114
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);
126 }
127 }
128 }
129
130 void ath_chanctx_set_channel(struct ath_softc *sc, struct ath_chanctx *ctx,
131 struct cfg80211_chan_def *chandef)
132 {
133 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
134 bool cur_chan;
135
136 spin_lock_bh(&sc->chan_lock);
137 if (chandef)
138 memcpy(&ctx->chandef, chandef, sizeof(*chandef));
139 cur_chan = sc->cur_chan == ctx;
140 spin_unlock_bh(&sc->chan_lock);
141
142 if (!cur_chan) {
143 ath_dbg(common, CHAN_CTX,
144 "Current context differs from the new context\n");
145 return;
146 }
147
148 ath_set_channel(sc);
149 }
150
151 #ifdef CONFIG_ATH9K_CHANNEL_CONTEXT
152
153 /*************/
154 /* Utilities */
155 /*************/
156
157 struct ath_chanctx* ath_is_go_chanctx_present(struct ath_softc *sc)
158 {
159 struct ath_chanctx *ctx;
160 struct ath_vif *avp;
161 struct ieee80211_vif *vif;
162
163 spin_lock_bh(&sc->chan_lock);
164
165 ath_for_each_chanctx(sc, ctx) {
166 if (!ctx->active)
167 continue;
168
169 list_for_each_entry(avp, &ctx->vifs, list) {
170 vif = avp->vif;
171
172 if (ieee80211_vif_type_p2p(vif) == NL80211_IFTYPE_P2P_GO) {
173 spin_unlock_bh(&sc->chan_lock);
174 return ctx;
175 }
176 }
177 }
178
179 spin_unlock_bh(&sc->chan_lock);
180 return NULL;
181 }
182
183 /**********************************************************/
184 /* Functions to handle the channel context state machine. */
185 /**********************************************************/
186
187 static const char *offchannel_state_string(enum ath_offchannel_state state)
188 {
189 switch (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);
197 default:
198 return "unknown";
199 }
200 }
201
202 static const char *chanctx_event_string(enum ath_chanctx_event ev)
203 {
204 switch (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);
215 default:
216 return "unknown";
217 }
218 }
219
220 static const char *chanctx_state_string(enum ath_chanctx_state state)
221 {
222 switch (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);
228 default:
229 return "unknown";
230 }
231 }
232
233 static u32 chanctx_event_delta(struct ath_softc *sc)
234 {
235 u64 ms;
236 struct timespec64 ts, *old;
237
238 ktime_get_raw_ts64(&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;
243
244 return (u32)ms;
245 }
246
247 void ath_chanctx_check_active(struct ath_softc *sc, struct ath_chanctx *ctx)
248 {
249 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
250 struct ath_chanctx *ictx;
251 struct ath_vif *avp;
252 bool active = false;
253 u8 n_active = 0;
254
255 if (!ctx)
256 return;
257
258 if (ctx == &sc->offchannel.chan) {
259 spin_lock_bh(&sc->chan_lock);
260
261 if (likely(sc->sched.channel_switch_time))
262 ctx->flush_timeout =
263 usecs_to_jiffies(sc->sched.channel_switch_time);
264 else
265 ctx->flush_timeout =
266 msecs_to_jiffies(10);
267
268 spin_unlock_bh(&sc->chan_lock);
269
270 /*
271 * There is no need to iterate over the
272 * active/assigned channel contexts if
273 * the current context is offchannel.
274 */
275 return;
276 }
277
278 ictx = ctx;
279
280 list_for_each_entry(avp, &ctx->vifs, list) {
281 struct ieee80211_vif *vif = avp->vif;
282
283 switch (vif->type) {
284 case NL80211_IFTYPE_P2P_CLIENT:
285 case NL80211_IFTYPE_STATION:
286 if (avp->assoc)
287 active = true;
288 break;
289 default:
290 active = true;
291 break;
292 }
293 }
294 ctx->active = active;
295
296 ath_for_each_chanctx(sc, ctx) {
297 if (!ctx->assigned || list_empty(&ctx->vifs))
298 continue;
299 n_active++;
300 }
301
302 spin_lock_bh(&sc->chan_lock);
303
304 if (n_active <= 1) {
305 ictx->flush_timeout = HZ / 5;
306 clear_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags);
307 spin_unlock_bh(&sc->chan_lock);
308 return;
309 }
310
311 ictx->flush_timeout = usecs_to_jiffies(sc->sched.channel_switch_time);
312
313 if (test_and_set_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags)) {
314 spin_unlock_bh(&sc->chan_lock);
315 return;
316 }
317
318 spin_unlock_bh(&sc->chan_lock);
319
320 if (ath9k_is_chanctx_enabled()) {
321 ath_chanctx_event(sc, NULL,
322 ATH_CHANCTX_EVENT_ENABLE_MULTICHANNEL);
323 }
324 }
325
326 static struct ath_chanctx *
327 ath_chanctx_get_next(struct ath_softc *sc, struct ath_chanctx *ctx)
328 {
329 int idx = ctx - &sc->chanctx[0];
330
331 return &sc->chanctx[!idx];
332 }
333
334 static void ath_chanctx_adjust_tbtt_delta(struct ath_softc *sc)
335 {
336 struct ath_chanctx *prev, *cur;
337 struct timespec64 ts;
338 u32 cur_tsf, prev_tsf, beacon_int;
339 s32 offset;
340
341 beacon_int = TU_TO_USEC(sc->cur_chan->beacon.beacon_interval);
342
343 cur = sc->cur_chan;
344 prev = ath_chanctx_get_next(sc, cur);
345
346 if (!prev->switch_after_beacon)
347 return;
348
349 ktime_get_raw_ts64(&ts);
350 cur_tsf = (u32) cur->tsf_val +
351 ath9k_hw_get_tsf_offset(&cur->tsf_ts, &ts);
352
353 prev_tsf = prev->last_beacon - (u32) prev->tsf_val + cur_tsf;
354 prev_tsf -= ath9k_hw_get_tsf_offset(&prev->tsf_ts, &ts);
355
356 /* Adjust the TSF time of the AP chanctx to keep its beacons
357 * at half beacon interval offset relative to the STA chanctx.
358 */
359 offset = cur_tsf - prev_tsf;
360
361 /* Ignore stale data or spurious timestamps */
362 if (offset < 0 || offset > 3 * beacon_int)
363 return;
364
365 offset = beacon_int / 2 - (offset % beacon_int);
366 prev->tsf_val += offset;
367 }
368
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.
372 */
373 static void ath_chanctx_setup_timer(struct ath_softc *sc, u32 tsf_time)
374 {
375 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
376 struct ath_hw *ah = sc->sc_ah;
377 unsigned long timeout;
378
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);
383
384 ath_dbg(common, CHAN_CTX,
385 "Setup chanctx timer with timeout: %d (%d) ms\n",
386 tsf_time / 1000, jiffies_to_msecs(timeout));
387 }
388
389 static void ath_chanctx_handle_bmiss(struct ath_softc *sc,
390 struct ath_chanctx *ctx,
391 struct ath_vif *avp)
392 {
393 /*
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
397 * schedule.
398 */
399 if (ctx->active && sc->sched.extend_absence) {
400 avp->noa_duration = 0;
401 sc->sched.extend_absence = false;
402 }
403
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.
407 */
408 if (ctx->active && sc->sched.beacon_miss >= 2) {
409 avp->noa_duration = 0;
410 sc->sched.extend_absence = true;
411 }
412 }
413
414 static void ath_chanctx_offchannel_noa(struct ath_softc *sc,
415 struct ath_chanctx *ctx,
416 struct ath_vif *avp,
417 u32 tsf_time)
418 {
419 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
420
421 avp->noa_index++;
422 avp->offchannel_start = tsf_time;
423 avp->offchannel_duration = sc->sched.offchannel_duration;
424
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,
429 avp->noa_index);
430
431 /*
432 * When multiple contexts are active, the NoA
433 * has to be recalculated and advertised after
434 * an offchannel operation.
435 */
436 if (ctx->active && avp->noa_duration)
437 avp->noa_duration = 0;
438 }
439
440 static void ath_chanctx_set_periodic_noa(struct ath_softc *sc,
441 struct ath_vif *avp,
442 struct ath_beacon_config *cur_conf,
443 u32 tsf_time,
444 u32 beacon_int)
445 {
446 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
447
448 avp->noa_index++;
449 avp->noa_start = tsf_time;
450
451 if (sc->sched.extend_absence)
452 avp->noa_duration = (3 * beacon_int / 2) +
453 sc->sched.channel_switch_time;
454 else
455 avp->noa_duration =
456 TU_TO_USEC(cur_conf->beacon_interval) / 2 +
457 sc->sched.channel_switch_time;
458
459 if (test_bit(ATH_OP_SCANNING, &common->op_flags) ||
460 sc->sched.extend_absence)
461 avp->periodic_noa = false;
462 else
463 avp->periodic_noa = true;
464
465 ath_dbg(common, CHAN_CTX,
466 "noa_duration: %d, noa_start: %u, noa_index: %d, periodic: %d\n",
467 avp->noa_duration,
468 avp->noa_start,
469 avp->noa_index,
470 avp->periodic_noa);
471 }
472
473 static void ath_chanctx_set_oneshot_noa(struct ath_softc *sc,
474 struct ath_vif *avp,
475 u32 tsf_time,
476 u32 duration)
477 {
478 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
479
480 avp->noa_index++;
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;
485
486 ath_dbg(common, CHAN_CTX,
487 "oneshot noa_duration: %d, noa_start: %u, noa_index: %d, periodic: %d\n",
488 avp->noa_duration,
489 avp->noa_start,
490 avp->noa_index,
491 avp->periodic_noa);
492 }
493
494 void ath_chanctx_event(struct ath_softc *sc, struct ieee80211_vif *vif,
495 enum ath_chanctx_event ev)
496 {
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;
502 u32 tsf_time;
503 u32 beacon_int;
504
505 if (vif)
506 avp = (struct ath_vif *) vif->drv_priv;
507
508 spin_lock_bh(&sc->chan_lock);
509
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));
515
516 switch (ev) {
517 case ATH_CHANCTX_EVENT_BEACON_PREPARE:
518 if (avp->offchannel_duration)
519 avp->offchannel_duration = 0;
520
521 if (avp->oneshot_noa) {
522 avp->noa_duration = 0;
523 avp->oneshot_noa = false;
524
525 ath_dbg(common, CHAN_CTX,
526 "Clearing oneshot NoA\n");
527 }
528
529 if (avp->chanctx != sc->cur_chan) {
530 ath_dbg(common, CHAN_CTX,
531 "Contexts differ, not preparing beacon\n");
532 break;
533 }
534
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");
541 }
542
543 ctx = ath_chanctx_get_next(sc, sc->cur_chan);
544 if (ctx->active && sc->sched.state == ATH_CHANCTX_STATE_IDLE) {
545 sc->next_chan = ctx;
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");
549 }
550
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");
556 }
557
558 if (sc->sched.mgd_prepare_tx)
559 sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;
560
561 /*
562 * When a context becomes inactive, for example,
563 * disassociation of a station context, the NoA
564 * attribute needs to be removed from subsequent
565 * beacons.
566 */
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;
571
572 ath_dbg(common, CHAN_CTX,
573 "Clearing NoA schedule\n");
574 }
575
576 if (sc->sched.state != ATH_CHANCTX_STATE_WAIT_FOR_BEACON)
577 break;
578
579 ath_dbg(common, CHAN_CTX, "Preparing beacon for vif: %pM\n", vif->addr);
580
581 sc->sched.beacon_pending = true;
582 sc->sched.next_tbtt = REG_READ(ah, AR_NEXT_TBTT_TIMER);
583
584 cur_conf = &sc->cur_chan->beacon;
585 beacon_int = TU_TO_USEC(cur_conf->beacon_interval);
586
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;
591
592 /*
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.
596 */
597 if (sc->next_chan == &sc->offchannel.chan) {
598 ath_chanctx_offchannel_noa(sc, ctx, avp, tsf_time);
599 break;
600 }
601
602 ath_chanctx_handle_bmiss(sc, ctx, avp);
603
604 /*
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.
609 */
610 if (sc->sched.mgd_prepare_tx) {
611 ath_chanctx_set_oneshot_noa(sc, avp, tsf_time,
612 jiffies_to_usecs(HZ / 5));
613 break;
614 }
615
616 /* Prevent wrap-around issues */
617 if (avp->noa_duration && tsf_time - avp->noa_start > BIT(30))
618 avp->noa_duration = 0;
619
620 /*
621 * If multiple contexts are active, start periodic
622 * NoA and increment the index for the first
623 * announcement.
624 */
625 if (ctx->active &&
626 (!avp->noa_duration || sc->sched.force_noa_update))
627 ath_chanctx_set_periodic_noa(sc, avp, cur_conf,
628 tsf_time, beacon_int);
629
630 if (ctx->active && sc->sched.force_noa_update)
631 sc->sched.force_noa_update = false;
632
633 break;
634 case ATH_CHANCTX_EVENT_BEACON_SENT:
635 if (!sc->sched.beacon_pending) {
636 ath_dbg(common, CHAN_CTX,
637 "No pending beacon\n");
638 break;
639 }
640
641 sc->sched.beacon_pending = false;
642
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");
648 break;
649 }
650
651 if (sc->sched.state != ATH_CHANCTX_STATE_WAIT_FOR_BEACON)
652 break;
653
654 ath_dbg(common, CHAN_CTX,
655 "Move chanctx state to WAIT_FOR_TIMER\n");
656
657 sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_TIMER;
658 ath_chanctx_setup_timer(sc, sc->sched.switch_start_time);
659 break;
660 case ATH_CHANCTX_EVENT_TSF_TIMER:
661 if (sc->sched.state != ATH_CHANCTX_STATE_WAIT_FOR_TIMER)
662 break;
663
664 if (!sc->cur_chan->switch_after_beacon &&
665 sc->sched.beacon_pending)
666 sc->sched.beacon_miss++;
667
668 ath_dbg(common, CHAN_CTX,
669 "Move chanctx state to SWITCH\n");
670
671 sc->sched.state = ATH_CHANCTX_STATE_SWITCH;
672 ieee80211_queue_work(sc->hw, &sc->chanctx_work);
673 break;
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)
677 break;
678
679 sc->sched.beacon_pending = false;
680 sc->sched.beacon_miss = 0;
681
682 if (sc->sched.state == ATH_CHANCTX_STATE_FORCE_ACTIVE ||
683 !sc->sched.beacon_adjust ||
684 !sc->cur_chan->tsf_val)
685 break;
686
687 ath_chanctx_adjust_tbtt_delta(sc);
688
689 /* TSF time might have been updated by the incoming beacon,
690 * need update the channel switch timer to reflect the change.
691 */
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);
696
697 sc->sched.beacon_adjust = false;
698 ath_chanctx_setup_timer(sc, tsf_time);
699 break;
700 case ATH_CHANCTX_EVENT_AUTHORIZED:
701 if (sc->sched.state != ATH_CHANCTX_STATE_FORCE_ACTIVE ||
702 avp->chanctx != sc->cur_chan)
703 break;
704
705 ath_dbg(common, CHAN_CTX,
706 "Move chanctx state from FORCE_ACTIVE to IDLE\n");
707
708 sc->sched.state = ATH_CHANCTX_STATE_IDLE;
709 /* fall through */
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)
715 break;
716
717 /* If this is a station chanctx, stay active for a half
718 * beacon period (minus channel switch time)
719 */
720 sc->next_chan = ath_chanctx_get_next(sc, sc->cur_chan);
721 cur_conf = &sc->cur_chan->beacon;
722
723 ath_dbg(common, CHAN_CTX,
724 "Move chanctx state to WAIT_FOR_TIMER (event SWITCH)\n");
725
726 sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_TIMER;
727 sc->sched.wait_switch = false;
728
729 tsf_time = TU_TO_USEC(cur_conf->beacon_interval) / 2;
730
731 if (sc->sched.extend_absence) {
732 sc->sched.beacon_miss = 0;
733 tsf_time *= 3;
734 }
735
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;
739
740 ath_chanctx_setup_timer(sc, tsf_time);
741 sc->sched.beacon_pending = true;
742 sc->sched.beacon_adjust = true;
743 break;
744 case ATH_CHANCTX_EVENT_ENABLE_MULTICHANNEL:
745 if (sc->cur_chan == &sc->offchannel.chan ||
746 sc->cur_chan->switch_after_beacon)
747 break;
748
749 sc->next_chan = ath_chanctx_get_next(sc, sc->cur_chan);
750 ieee80211_queue_work(sc->hw, &sc->chanctx_work);
751 break;
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;
757 break;
758 }
759
760 ctx = ath_chanctx_get_next(sc, sc->cur_chan);
761 sc->sched.state = ATH_CHANCTX_STATE_IDLE;
762 if (!ctx->assigned)
763 break;
764
765 sc->next_chan = ctx;
766 ieee80211_queue_work(sc->hw, &sc->chanctx_work);
767 break;
768 case ATH_CHANCTX_EVENT_ASSIGN:
769 break;
770 case ATH_CHANCTX_EVENT_CHANGE:
771 break;
772 }
773
774 spin_unlock_bh(&sc->chan_lock);
775 }
776
777 void ath_chanctx_beacon_sent_ev(struct ath_softc *sc,
778 enum ath_chanctx_event ev)
779 {
780 if (sc->sched.beacon_pending)
781 ath_chanctx_event(sc, NULL, ev);
782 }
783
784 void ath_chanctx_beacon_recv_ev(struct ath_softc *sc,
785 enum ath_chanctx_event ev)
786 {
787 ath_chanctx_event(sc, NULL, ev);
788 }
789
790 static int ath_scan_channel_duration(struct ath_softc *sc,
791 struct ieee80211_channel *chan)
792 {
793 struct cfg80211_scan_request *req = sc->offchannel.scan_req;
794
795 if (!req->n_ssids || (chan->flags & IEEE80211_CHAN_NO_IR))
796 return (HZ / 9); /* ~110 ms */
797
798 return (HZ / 16); /* ~60 ms */
799 }
800
801 static void ath_chanctx_switch(struct ath_softc *sc, struct ath_chanctx *ctx,
802 struct cfg80211_chan_def *chandef)
803 {
804 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
805
806 spin_lock_bh(&sc->chan_lock);
807
808 if (test_bit(ATH_OP_MULTI_CHANNEL, &common->op_flags) &&
809 (sc->cur_chan != ctx) && (ctx == &sc->offchannel.chan)) {
810 if (chandef)
811 ctx->chandef = *chandef;
812
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;
818
819 spin_unlock_bh(&sc->chan_lock);
820 ath_dbg(common, CHAN_CTX,
821 "Set offchannel_pending to true\n");
822 return;
823 }
824
825 sc->next_chan = ctx;
826 if (chandef) {
827 ctx->chandef = *chandef;
828 ath_dbg(common, CHAN_CTX,
829 "Assigned next_chan to %d MHz\n", chandef->center_freq1);
830 }
831
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;
836
837 if (chandef) {
838 ath_dbg(common, CHAN_CTX,
839 "Offchannel duration for chan %d MHz : %u\n",
840 chandef->center_freq1,
841 sc->sched.offchannel_duration);
842 }
843 }
844 spin_unlock_bh(&sc->chan_lock);
845 ieee80211_queue_work(sc->hw, &sc->chanctx_work);
846 }
847
848 static void ath_chanctx_offchan_switch(struct ath_softc *sc,
849 struct ieee80211_channel *chan)
850 {
851 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
852 struct cfg80211_chan_def chandef;
853
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);
857
858 ath_chanctx_switch(sc, &sc->offchannel.chan, &chandef);
859 }
860
861 static struct ath_chanctx *ath_chanctx_get_oper_chan(struct ath_softc *sc,
862 bool active)
863 {
864 struct ath_chanctx *ctx;
865
866 ath_for_each_chanctx(sc, ctx) {
867 if (!ctx->assigned || list_empty(&ctx->vifs))
868 continue;
869 if (active && !ctx->active)
870 continue;
871
872 if (ctx->switch_after_beacon)
873 return ctx;
874 }
875
876 return &sc->chanctx[0];
877 }
878
879 static void
880 ath_scan_next_channel(struct ath_softc *sc)
881 {
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;
885
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,
891 req->n_channels);
892
893 sc->offchannel.state = ATH_OFFCHANNEL_IDLE;
894 ath_chanctx_switch(sc, ath_chanctx_get_oper_chan(sc, false),
895 NULL);
896 return;
897 }
898
899 ath_dbg(common, CHAN_CTX,
900 "Moving offchannel state to ATH_OFFCHANNEL_PROBE_SEND, scan_idx: %d\n",
901 sc->offchannel.scan_idx);
902
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;
906
907 ath_chanctx_offchan_switch(sc, chan);
908 }
909
910 void ath_offchannel_next(struct ath_softc *sc)
911 {
912 struct ieee80211_vif *vif;
913
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);
925 } else {
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);
930
931 ath_chanctx_switch(sc, ath_chanctx_get_oper_chan(sc, false),
932 NULL);
933 sc->offchannel.state = ATH_OFFCHANNEL_IDLE;
934 if (sc->ps_idle)
935 ath_cancel_work(sc);
936 }
937 }
938
939 void ath_roc_complete(struct ath_softc *sc, enum ath_roc_complete_reason reason)
940 {
941 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
942
943 sc->offchannel.roc_vif = NULL;
944 sc->offchannel.roc_chan = NULL;
945
946 switch (reason) {
947 case ATH_ROC_COMPLETE_ABORT:
948 ath_dbg(common, CHAN_CTX, "RoC aborted\n");
949 ieee80211_remain_on_channel_expired(sc->hw);
950 break;
951 case ATH_ROC_COMPLETE_EXPIRE:
952 ath_dbg(common, CHAN_CTX, "RoC expired\n");
953 ieee80211_remain_on_channel_expired(sc->hw);
954 break;
955 case ATH_ROC_COMPLETE_CANCEL:
956 ath_dbg(common, CHAN_CTX, "RoC canceled\n");
957 break;
958 }
959
960 ath_offchannel_next(sc);
961 ath9k_ps_restore(sc);
962 }
963
964 void ath_scan_complete(struct ath_softc *sc, bool abort)
965 {
966 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
967 struct cfg80211_scan_info info = {
968 .aborted = abort,
969 };
970
971 if (abort)
972 ath_dbg(common, CHAN_CTX, "HW scan aborted\n");
973 else
974 ath_dbg(common, CHAN_CTX, "HW scan complete\n");
975
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);
987 }
988
989 static void ath_scan_send_probe(struct ath_softc *sc,
990 struct cfg80211_ssid *ssid)
991 {
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 = {};
995 struct sk_buff *skb;
996 struct ieee80211_tx_info *info;
997 int band = sc->offchannel.chan.chandef.chan->band;
998
999 skb = ieee80211_probereq_get(sc->hw, vif->addr,
1000 ssid->ssid, ssid->ssid_len, req->ie_len);
1001 if (!skb)
1002 return;
1003
1004 info = IEEE80211_SKB_CB(skb);
1005 if (req->no_cck)
1006 info->flags |= IEEE80211_TX_CTL_NO_CCK_RATE;
1007
1008 if (req->ie_len)
1009 skb_put_data(skb, req->ie, req->ie_len);
1010
1011 skb_set_queue_mapping(skb, IEEE80211_AC_VO);
1012
1013 if (!ieee80211_tx_prepare_skb(sc->hw, vif, skb, band, NULL))
1014 goto error;
1015
1016 txctl.txq = sc->tx.txq_map[IEEE80211_AC_VO];
1017 if (ath_tx_start(sc->hw, skb, &txctl))
1018 goto error;
1019
1020 return;
1021
1022 error:
1023 ieee80211_free_txskb(sc->hw, skb);
1024 }
1025
1026 static void ath_scan_channel_start(struct ath_softc *sc)
1027 {
1028 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1029 struct cfg80211_scan_request *req = sc->offchannel.scan_req;
1030 int i;
1031
1032 if (!(sc->cur_chan->chandef.chan->flags & IEEE80211_CHAN_NO_IR) &&
1033 req->n_ssids) {
1034 for (i = 0; i < req->n_ssids; i++)
1035 ath_scan_send_probe(sc, &req->ssids[i]);
1036
1037 }
1038
1039 ath_dbg(common, CHAN_CTX,
1040 "Moving offchannel state to ATH_OFFCHANNEL_PROBE_WAIT\n");
1041
1042 sc->offchannel.state = ATH_OFFCHANNEL_PROBE_WAIT;
1043 mod_timer(&sc->offchannel.timer, jiffies + sc->offchannel.duration);
1044 }
1045
1046 static void ath_chanctx_timer(struct timer_list *t)
1047 {
1048 struct ath_softc *sc = from_timer(sc, t, sched.timer);
1049 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1050
1051 ath_dbg(common, CHAN_CTX,
1052 "Channel context timer invoked\n");
1053
1054 ath_chanctx_event(sc, NULL, ATH_CHANCTX_EVENT_TSF_TIMER);
1055 }
1056
1057 static void ath_offchannel_timer(struct timer_list *t)
1058 {
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);
1062
1063 ath_dbg(common, CHAN_CTX, "%s: offchannel state: %s\n",
1064 __func__, offchannel_state_string(sc->offchannel.state));
1065
1066 switch (sc->offchannel.state) {
1067 case ATH_OFFCHANNEL_PROBE_WAIT:
1068 if (!sc->offchannel.scan_req)
1069 return;
1070
1071 /* get first active channel context */
1072 ctx = ath_chanctx_get_oper_chan(sc, true);
1073 if (ctx->active) {
1074 ath_dbg(common, CHAN_CTX,
1075 "Switch to oper/active context, "
1076 "move offchannel state to ATH_OFFCHANNEL_SUSPEND\n");
1077
1078 sc->offchannel.state = ATH_OFFCHANNEL_SUSPEND;
1079 ath_chanctx_switch(sc, ctx, NULL);
1080 mod_timer(&sc->offchannel.timer, jiffies + HZ / 10);
1081 break;
1082 }
1083 /* fall through */
1084 case ATH_OFFCHANNEL_SUSPEND:
1085 if (!sc->offchannel.scan_req)
1086 return;
1087
1088 ath_scan_next_channel(sc);
1089 break;
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);
1094 break;
1095 default:
1096 break;
1097 }
1098 }
1099
1100 static bool
1101 ath_chanctx_send_vif_ps_frame(struct ath_softc *sc, struct ath_vif *avp,
1102 bool powersave)
1103 {
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;
1110
1111 switch (vif->type) {
1112 case NL80211_IFTYPE_STATION:
1113 if (!avp->assoc)
1114 return false;
1115
1116 skb = ieee80211_nullfunc_get(sc->hw, vif, false);
1117 if (!skb)
1118 return false;
1119
1120 nullfunc = (struct ieee80211_hdr_3addr *) skb->data;
1121 if (powersave)
1122 nullfunc->frame_control |=
1123 cpu_to_le16(IEEE80211_FCTL_PM);
1124
1125 skb->priority = 7;
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);
1129 return false;
1130 }
1131 break;
1132 default:
1133 return false;
1134 }
1135
1136 memset(&txctl, 0, sizeof(txctl));
1137 txctl.txq = sc->tx.txq_map[IEEE80211_AC_VO];
1138 txctl.sta = sta;
1139 if (ath_tx_start(sc->hw, skb, &txctl)) {
1140 ieee80211_free_txskb(sc->hw, skb);
1141 return false;
1142 }
1143
1144 return true;
1145 }
1146
1147 static bool
1148 ath_chanctx_send_ps_frame(struct ath_softc *sc, bool powersave)
1149 {
1150 struct ath_vif *avp;
1151 bool sent = false;
1152
1153 rcu_read_lock();
1154 list_for_each_entry(avp, &sc->cur_chan->vifs, list) {
1155 if (ath_chanctx_send_vif_ps_frame(sc, avp, powersave))
1156 sent = true;
1157 }
1158 rcu_read_unlock();
1159
1160 return sent;
1161 }
1162
1163 static bool ath_chanctx_defer_switch(struct ath_softc *sc)
1164 {
1165 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1166
1167 if (sc->cur_chan == &sc->offchannel.chan)
1168 return false;
1169
1170 switch (sc->sched.state) {
1171 case ATH_CHANCTX_STATE_SWITCH:
1172 return false;
1173 case ATH_CHANCTX_STATE_IDLE:
1174 if (!sc->cur_chan->switch_after_beacon)
1175 return false;
1176
1177 ath_dbg(common, CHAN_CTX,
1178 "Defer switch, set chanctx state to WAIT_FOR_BEACON\n");
1179
1180 sc->sched.state = ATH_CHANCTX_STATE_WAIT_FOR_BEACON;
1181 break;
1182 default:
1183 break;
1184 }
1185
1186 return true;
1187 }
1188
1189 static void ath_offchannel_channel_change(struct ath_softc *sc)
1190 {
1191 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1192
1193 ath_dbg(common, CHAN_CTX, "%s: offchannel state: %s\n",
1194 __func__, offchannel_state_string(sc->offchannel.state));
1195
1196 switch (sc->offchannel.state) {
1197 case ATH_OFFCHANNEL_PROBE_SEND:
1198 if (!sc->offchannel.scan_req)
1199 return;
1200
1201 if (sc->cur_chan->chandef.chan !=
1202 sc->offchannel.chan.chandef.chan)
1203 return;
1204
1205 ath_scan_channel_start(sc);
1206 break;
1207 case ATH_OFFCHANNEL_IDLE:
1208 if (!sc->offchannel.scan_req)
1209 return;
1210
1211 ath_scan_complete(sc, false);
1212 break;
1213 case ATH_OFFCHANNEL_ROC_START:
1214 if (sc->cur_chan != &sc->offchannel.chan)
1215 break;
1216
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);
1221 break;
1222 case ATH_OFFCHANNEL_ROC_DONE:
1223 break;
1224 default:
1225 break;
1226 }
1227 }
1228
1229 void ath_chanctx_set_next(struct ath_softc *sc, bool force)
1230 {
1231 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1232 struct ath_chanctx *old_ctx;
1233 struct timespec64 ts;
1234 bool measure_time = false;
1235 bool send_ps = false;
1236 bool queues_stopped = false;
1237
1238 spin_lock_bh(&sc->chan_lock);
1239 if (!sc->next_chan) {
1240 spin_unlock_bh(&sc->chan_lock);
1241 return;
1242 }
1243
1244 if (!force && ath_chanctx_defer_switch(sc)) {
1245 spin_unlock_bh(&sc->chan_lock);
1246 return;
1247 }
1248
1249 ath_dbg(common, CHAN_CTX,
1250 "%s: current: %d MHz, next: %d MHz\n",
1251 __func__,
1252 sc->cur_chan->chandef.center_freq1,
1253 sc->next_chan->chandef.center_freq1);
1254
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);
1261
1262 if (sc->next_chan == &sc->offchannel.chan) {
1263 ktime_get_raw_ts64(&ts);
1264 measure_time = true;
1265 }
1266
1267 ath9k_chanctx_stop_queues(sc, sc->cur_chan);
1268 queues_stopped = true;
1269
1270 __ath9k_flush(sc->hw, ~0, true, false, false);
1271
1272 if (ath_chanctx_send_ps_frame(sc, true))
1273 __ath9k_flush(sc->hw, BIT(IEEE80211_AC_VO),
1274 false, false, false);
1275
1276 send_ps = true;
1277 spin_lock_bh(&sc->chan_lock);
1278
1279 if (sc->cur_chan != &sc->offchannel.chan) {
1280 ktime_get_raw_ts64(&sc->cur_chan->tsf_ts);
1281 sc->cur_chan->tsf_val = ath9k_hw_gettsf64(sc->sc_ah);
1282 }
1283 }
1284 old_ctx = sc->cur_chan;
1285 sc->cur_chan = sc->next_chan;
1286 sc->cur_chan->stopped = false;
1287 sc->next_chan = NULL;
1288
1289 if (!sc->sched.offchannel_pending)
1290 sc->sched.offchannel_duration = 0;
1291
1292 if (sc->sched.state != ATH_CHANCTX_STATE_FORCE_ACTIVE)
1293 sc->sched.state = ATH_CHANCTX_STATE_IDLE;
1294
1295 spin_unlock_bh(&sc->chan_lock);
1296
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);
1304 if (measure_time)
1305 sc->sched.channel_switch_time =
1306 ath9k_hw_get_tsf_offset(&ts, NULL);
1307 /*
1308 * A reset will ensure that all queues are woken up,
1309 * so there is no need to awaken them again.
1310 */
1311 goto out;
1312 }
1313
1314 if (queues_stopped)
1315 ath9k_chanctx_wake_queues(sc, old_ctx);
1316 out:
1317 if (send_ps)
1318 ath_chanctx_send_ps_frame(sc, false);
1319
1320 ath_offchannel_channel_change(sc);
1321 ath_chanctx_event(sc, NULL, ATH_CHANCTX_EVENT_SWITCH);
1322 }
1323
1324 static void ath_chanctx_work(struct work_struct *work)
1325 {
1326 struct ath_softc *sc = container_of(work, struct ath_softc,
1327 chanctx_work);
1328 mutex_lock(&sc->mutex);
1329 ath_chanctx_set_next(sc, false);
1330 mutex_unlock(&sc->mutex);
1331 }
1332
1333 void ath9k_offchannel_init(struct ath_softc *sc)
1334 {
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;
1339 int i;
1340
1341 sband = &common->sbands[NL80211_BAND_2GHZ];
1342 if (!sband->n_channels)
1343 sband = &common->sbands[NL80211_BAND_5GHZ];
1344
1345 chan = &sband->channels[0];
1346
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);
1351
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);
1356 }
1357
1358 sc->offchannel.chan.offchannel = true;
1359 }
1360
1361 void ath9k_init_channel_context(struct ath_softc *sc)
1362 {
1363 INIT_WORK(&sc->chanctx_work, ath_chanctx_work);
1364
1365 timer_setup(&sc->offchannel.timer, ath_offchannel_timer, 0);
1366 timer_setup(&sc->sched.timer, ath_chanctx_timer, 0);
1367
1368 init_completion(&sc->go_beacon);
1369 }
1370
1371 void ath9k_deinit_channel_context(struct ath_softc *sc)
1372 {
1373 cancel_work_sync(&sc->chanctx_work);
1374 }
1375
1376 bool ath9k_is_chanctx_enabled(void)
1377 {
1378 return (ath9k_use_chanctx == 1);
1379 }
1380
1381 /********************/
1382 /* Queue management */
1383 /********************/
1384
1385 void ath9k_chanctx_stop_queues(struct ath_softc *sc, struct ath_chanctx *ctx)
1386 {
1387 struct ath_hw *ah = sc->sc_ah;
1388 int i;
1389
1390 if (ctx == &sc->offchannel.chan) {
1391 ieee80211_stop_queue(sc->hw,
1392 sc->hw->offchannel_tx_hw_queue);
1393 } else {
1394 for (i = 0; i < IEEE80211_NUM_ACS; i++)
1395 ieee80211_stop_queue(sc->hw,
1396 ctx->hw_queue_base + i);
1397 }
1398
1399 if (ah->opmode == NL80211_IFTYPE_AP)
1400 ieee80211_stop_queue(sc->hw, sc->hw->queues - 2);
1401 }
1402
1403
1404 void ath9k_chanctx_wake_queues(struct ath_softc *sc, struct ath_chanctx *ctx)
1405 {
1406 struct ath_hw *ah = sc->sc_ah;
1407 int i;
1408
1409 if (ctx == &sc->offchannel.chan) {
1410 ieee80211_wake_queue(sc->hw,
1411 sc->hw->offchannel_tx_hw_queue);
1412 } else {
1413 for (i = 0; i < IEEE80211_NUM_ACS; i++)
1414 ieee80211_wake_queue(sc->hw,
1415 ctx->hw_queue_base + i);
1416 }
1417
1418 if (ah->opmode == NL80211_IFTYPE_AP)
1419 ieee80211_wake_queue(sc->hw, sc->hw->queues - 2);
1420 }
1421
1422 /*****************/
1423 /* P2P Powersave */
1424 /*****************/
1425
1426 static void ath9k_update_p2p_ps_timer(struct ath_softc *sc, struct ath_vif *avp)
1427 {
1428 struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1429 struct ath_hw *ah = sc->sc_ah;
1430 u32 tsf, target_tsf;
1431
1432 if (!avp || !avp->noa.has_next_tsf)
1433 return;
1434
1435 ath9k_hw_gen_timer_stop(ah, sc->p2p_ps_timer);
1436
1437 tsf = ath9k_hw_gettsf32(sc->sc_ah);
1438
1439 target_tsf = avp->noa.next_tsf;
1440 if (!avp->noa.absent)
1441 target_tsf -= ATH_P2P_PS_STOP_TIME;
1442 else
1443 target_tsf += ATH_P2P_PS_STOP_TIME;
1444
1445 if (target_tsf - tsf < ATH_P2P_PS_STOP_TIME)
1446 target_tsf = tsf + ATH_P2P_PS_STOP_TIME;
1447
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);
1451
1452 ath9k_hw_gen_timer_start(ah, sc->p2p_ps_timer, target_tsf, 1000000);
1453 }
1454
1455 static void ath9k_update_p2p_ps(struct ath_softc *sc, struct ieee80211_vif *vif)
1456 {
1457 struct ath_vif *avp = (void *)vif->drv_priv;
1458 u32 tsf;
1459
1460 if (!sc->p2p_ps_timer)
1461 return;
1462
1463 if (vif->type != NL80211_IFTYPE_STATION)
1464 return;
1465
1466 sc->p2p_ps_vif = avp;
1467
1468 if (sc->ps_flags & PS_BEACON_SYNC)
1469 return;
1470
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);
1474 }
1475
1476 static u8 ath9k_get_ctwin(struct ath_softc *sc, struct ath_vif *avp)
1477 {
1478 struct ath_beacon_config *cur_conf = &sc->cur_chan->beacon;
1479 u8 switch_time, ctwin;
1480
1481 /*
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.
1487 */
1488 switch_time = cur_conf->beacon_interval / 4;
1489
1490 ctwin = avp->vif->bss_conf.p2p_noa_attr.oppps_ctwindow;
1491 if (ctwin && (ctwin < switch_time))
1492 return ctwin;
1493
1494 if (switch_time < P2P_DEFAULT_CTWIN)
1495 return 0;
1496
1497 return P2P_DEFAULT_CTWIN;
1498 }
1499
1500 void ath9k_beacon_add_noa(struct ath_softc *sc, struct ath_vif *avp,
1501 struct sk_buff *skb)
1502 {
1503 static const u8 noa_ie_hdr[] = {
1504 WLAN_EID_VENDOR_SPECIFIC, /* type */
1505 0, /* length */
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 */
1511 };
1512
1513 struct ieee80211_p2p_noa_attr *noa;
1514 int noa_len, noa_desc, i = 0;
1515 u8 *hdr;
1516
1517 if (!avp->offchannel_duration && !avp->noa_duration)
1518 return;
1519
1520 noa_desc = !!avp->offchannel_duration + !!avp->noa_duration;
1521 noa_len = 2 + sizeof(struct ieee80211_p2p_noa_desc) * noa_desc;
1522
1523 hdr = skb_put_data(skb, noa_ie_hdr, sizeof(noa_ie_hdr));
1524 hdr[1] = sizeof(noa_ie_hdr) + noa_len - 2;
1525 hdr[7] = noa_len;
1526
1527 noa = skb_put_zero(skb, noa_len);
1528
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);
1533
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);
1539 } else {
1540 noa->desc[i].count = 1;
1541 }
1542
1543 noa->desc[i].start_time = cpu_to_le32(avp->noa_start);
1544 noa->desc[i].duration = cpu_to_le32(avp->noa_duration);
1545 i++;
1546 }
1547
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);
1552 }
1553 }
1554
1555 void ath9k_p2p_ps_timer(void *priv)
1556 {
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;
1562 u32 tsf;
1563
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);
1567
1568 if (!avp || avp->chanctx != sc->cur_chan)
1569 return;
1570
1571 tsf = ath9k_hw_gettsf32(sc->sc_ah);
1572 if (!avp->noa.absent)
1573 tsf += ATH_P2P_PS_STOP_TIME;
1574 else
1575 tsf -= ATH_P2P_PS_STOP_TIME;
1576
1577 if (!avp->noa.has_next_tsf ||
1578 avp->noa.next_tsf - tsf > BIT(31))
1579 ieee80211_update_p2p_noa(&avp->noa, tsf);
1580
1581 ath9k_update_p2p_ps_timer(sc, avp);
1582
1583 rcu_read_lock();
1584
1585 vif = avp->vif;
1586 sta = ieee80211_find_sta(vif, avp->bssid);
1587 if (!sta)
1588 goto out;
1589
1590 an = (void *) sta->drv_priv;
1591 if (an->sleeping == !!avp->noa.absent)
1592 goto out;
1593
1594 an->sleeping = avp->noa.absent;
1595 if (an->sleeping)
1596 ath_tx_aggr_sleep(sta, sc, an);
1597 else
1598 ath_tx_aggr_wakeup(sc, an);
1599
1600 out:
1601 rcu_read_unlock();
1602 }
1603
1604 void ath9k_p2p_bss_info_changed(struct ath_softc *sc,
1605 struct ieee80211_vif *vif)
1606 {
1607 unsigned long flags;
1608
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);
1614 }
1615
1616 void ath9k_p2p_beacon_sync(struct ath_softc *sc)
1617 {
1618 if (sc->p2p_ps_vif)
1619 ath9k_update_p2p_ps(sc, sc->p2p_ps_vif->vif);
1620 }
1621
1622 void ath9k_p2p_remove_vif(struct ath_softc *sc,
1623 struct ieee80211_vif *vif)
1624 {
1625 struct ath_vif *avp = (void *)vif->drv_priv;
1626
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);
1631 }
1632 spin_unlock_bh(&sc->sc_pcu_lock);
1633 }
1634
1635 int ath9k_init_p2p(struct ath_softc *sc)
1636 {
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)
1640 return -ENOMEM;
1641
1642 return 0;
1643 }
1644
1645 void ath9k_deinit_p2p(struct ath_softc *sc)
1646 {
1647 if (sc->p2p_ps_timer)
1648 ath_gen_timer_free(sc->sc_ah, sc->p2p_ps_timer);
1649 }
1650
1651 #endif /* CONFIG_ATH9K_CHANNEL_CONTEXT */
Linux with added FPC-III support