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