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