xref: /openbmc/linux/net/wireless/chan.c (revision 413d6ed3) 
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * This file contains helper code to handle channel
4  * settings and keeping track of what is possible at
5  * any point in time.
6  *
7  * Copyright 2009	Johannes Berg <johannes@sipsolutions.net>
8  * Copyright 2013-2014  Intel Mobile Communications GmbH
9  * Copyright 2018-2020	Intel Corporation
10  */
11 
12 #include <linux/export.h>
13 #include <linux/bitfield.h>
14 #include <net/cfg80211.h>
15 #include "core.h"
16 #include "rdev-ops.h"
17 
18 static bool cfg80211_valid_60g_freq(u32 freq)
19 {
20 	return freq >= 58320 && freq <= 70200;
21 }
22 
23 void cfg80211_chandef_create(struct cfg80211_chan_def *chandef,
24 			     struct ieee80211_channel *chan,
25 			     enum nl80211_channel_type chan_type)
26 {
27 	if (WARN_ON(!chan))
28 		return;
29 
30 	chandef->chan = chan;
31 	chandef->freq1_offset = chan->freq_offset;
32 	chandef->center_freq2 = 0;
33 	chandef->edmg.bw_config = 0;
34 	chandef->edmg.channels = 0;
35 
36 	switch (chan_type) {
37 	case NL80211_CHAN_NO_HT:
38 		chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
39 		chandef->center_freq1 = chan->center_freq;
40 		break;
41 	case NL80211_CHAN_HT20:
42 		chandef->width = NL80211_CHAN_WIDTH_20;
43 		chandef->center_freq1 = chan->center_freq;
44 		break;
45 	case NL80211_CHAN_HT40PLUS:
46 		chandef->width = NL80211_CHAN_WIDTH_40;
47 		chandef->center_freq1 = chan->center_freq + 10;
48 		break;
49 	case NL80211_CHAN_HT40MINUS:
50 		chandef->width = NL80211_CHAN_WIDTH_40;
51 		chandef->center_freq1 = chan->center_freq - 10;
52 		break;
53 	default:
54 		WARN_ON(1);
55 	}
56 }
57 EXPORT_SYMBOL(cfg80211_chandef_create);
58 
59 static bool cfg80211_edmg_chandef_valid(const struct cfg80211_chan_def *chandef)
60 {
61 	int max_contiguous = 0;
62 	int num_of_enabled = 0;
63 	int contiguous = 0;
64 	int i;
65 
66 	if (!chandef->edmg.channels || !chandef->edmg.bw_config)
67 		return false;
68 
69 	if (!cfg80211_valid_60g_freq(chandef->chan->center_freq))
70 		return false;
71 
72 	for (i = 0; i < 6; i++) {
73 		if (chandef->edmg.channels & BIT(i)) {
74 			contiguous++;
75 			num_of_enabled++;
76 		} else {
77 			contiguous = 0;
78 		}
79 
80 		max_contiguous = max(contiguous, max_contiguous);
81 	}
82 	/* basic verification of edmg configuration according to
83 	 * IEEE P802.11ay/D4.0 section 9.4.2.251
84 	 */
85 	/* check bw_config against contiguous edmg channels */
86 	switch (chandef->edmg.bw_config) {
87 	case IEEE80211_EDMG_BW_CONFIG_4:
88 	case IEEE80211_EDMG_BW_CONFIG_8:
89 	case IEEE80211_EDMG_BW_CONFIG_12:
90 		if (max_contiguous < 1)
91 			return false;
92 		break;
93 	case IEEE80211_EDMG_BW_CONFIG_5:
94 	case IEEE80211_EDMG_BW_CONFIG_9:
95 	case IEEE80211_EDMG_BW_CONFIG_13:
96 		if (max_contiguous < 2)
97 			return false;
98 		break;
99 	case IEEE80211_EDMG_BW_CONFIG_6:
100 	case IEEE80211_EDMG_BW_CONFIG_10:
101 	case IEEE80211_EDMG_BW_CONFIG_14:
102 		if (max_contiguous < 3)
103 			return false;
104 		break;
105 	case IEEE80211_EDMG_BW_CONFIG_7:
106 	case IEEE80211_EDMG_BW_CONFIG_11:
107 	case IEEE80211_EDMG_BW_CONFIG_15:
108 		if (max_contiguous < 4)
109 			return false;
110 		break;
111 
112 	default:
113 		return false;
114 	}
115 
116 	/* check bw_config against aggregated (non contiguous) edmg channels */
117 	switch (chandef->edmg.bw_config) {
118 	case IEEE80211_EDMG_BW_CONFIG_4:
119 	case IEEE80211_EDMG_BW_CONFIG_5:
120 	case IEEE80211_EDMG_BW_CONFIG_6:
121 	case IEEE80211_EDMG_BW_CONFIG_7:
122 		break;
123 	case IEEE80211_EDMG_BW_CONFIG_8:
124 	case IEEE80211_EDMG_BW_CONFIG_9:
125 	case IEEE80211_EDMG_BW_CONFIG_10:
126 	case IEEE80211_EDMG_BW_CONFIG_11:
127 		if (num_of_enabled < 2)
128 			return false;
129 		break;
130 	case IEEE80211_EDMG_BW_CONFIG_12:
131 	case IEEE80211_EDMG_BW_CONFIG_13:
132 	case IEEE80211_EDMG_BW_CONFIG_14:
133 	case IEEE80211_EDMG_BW_CONFIG_15:
134 		if (num_of_enabled < 4 || max_contiguous < 2)
135 			return false;
136 		break;
137 	default:
138 		return false;
139 	}
140 
141 	return true;
142 }
143 
144 static int nl80211_chan_width_to_mhz(enum nl80211_chan_width chan_width)
145 {
146 	int mhz;
147 
148 	switch (chan_width) {
149 	case NL80211_CHAN_WIDTH_1:
150 		mhz = 1;
151 		break;
152 	case NL80211_CHAN_WIDTH_2:
153 		mhz = 2;
154 		break;
155 	case NL80211_CHAN_WIDTH_4:
156 		mhz = 4;
157 		break;
158 	case NL80211_CHAN_WIDTH_8:
159 		mhz = 8;
160 		break;
161 	case NL80211_CHAN_WIDTH_16:
162 		mhz = 16;
163 		break;
164 	case NL80211_CHAN_WIDTH_5:
165 		mhz = 5;
166 		break;
167 	case NL80211_CHAN_WIDTH_10:
168 		mhz = 10;
169 		break;
170 	case NL80211_CHAN_WIDTH_20:
171 	case NL80211_CHAN_WIDTH_20_NOHT:
172 		mhz = 20;
173 		break;
174 	case NL80211_CHAN_WIDTH_40:
175 		mhz = 40;
176 		break;
177 	case NL80211_CHAN_WIDTH_80P80:
178 	case NL80211_CHAN_WIDTH_80:
179 		mhz = 80;
180 		break;
181 	case NL80211_CHAN_WIDTH_160:
182 		mhz = 160;
183 		break;
184 	default:
185 		WARN_ON_ONCE(1);
186 		return -1;
187 	}
188 	return mhz;
189 }
190 
191 static int cfg80211_chandef_get_width(const struct cfg80211_chan_def *c)
192 {
193 	return nl80211_chan_width_to_mhz(c->width);
194 }
195 
196 bool cfg80211_chandef_valid(const struct cfg80211_chan_def *chandef)
197 {
198 	u32 control_freq, oper_freq;
199 	int oper_width, control_width;
200 
201 	if (!chandef->chan)
202 		return false;
203 
204 	if (chandef->freq1_offset >= 1000)
205 		return false;
206 
207 	control_freq = chandef->chan->center_freq;
208 
209 	switch (chandef->width) {
210 	case NL80211_CHAN_WIDTH_5:
211 	case NL80211_CHAN_WIDTH_10:
212 	case NL80211_CHAN_WIDTH_20:
213 	case NL80211_CHAN_WIDTH_20_NOHT:
214 		if (ieee80211_chandef_to_khz(chandef) !=
215 		    ieee80211_channel_to_khz(chandef->chan))
216 			return false;
217 		if (chandef->center_freq2)
218 			return false;
219 		break;
220 	case NL80211_CHAN_WIDTH_1:
221 	case NL80211_CHAN_WIDTH_2:
222 	case NL80211_CHAN_WIDTH_4:
223 	case NL80211_CHAN_WIDTH_8:
224 	case NL80211_CHAN_WIDTH_16:
225 		if (chandef->chan->band != NL80211_BAND_S1GHZ)
226 			return false;
227 
228 		control_freq = ieee80211_channel_to_khz(chandef->chan);
229 		oper_freq = ieee80211_chandef_to_khz(chandef);
230 		control_width = nl80211_chan_width_to_mhz(
231 					ieee80211_s1g_channel_width(
232 								chandef->chan));
233 		oper_width = cfg80211_chandef_get_width(chandef);
234 
235 		if (oper_width < 0 || control_width < 0)
236 			return false;
237 		if (chandef->center_freq2)
238 			return false;
239 
240 		if (control_freq + MHZ_TO_KHZ(control_width) / 2 >
241 		    oper_freq + MHZ_TO_KHZ(oper_width) / 2)
242 			return false;
243 
244 		if (control_freq - MHZ_TO_KHZ(control_width) / 2 <
245 		    oper_freq - MHZ_TO_KHZ(oper_width) / 2)
246 			return false;
247 		break;
248 	case NL80211_CHAN_WIDTH_40:
249 		if (chandef->center_freq1 != control_freq + 10 &&
250 		    chandef->center_freq1 != control_freq - 10)
251 			return false;
252 		if (chandef->center_freq2)
253 			return false;
254 		break;
255 	case NL80211_CHAN_WIDTH_80P80:
256 		if (chandef->center_freq1 != control_freq + 30 &&
257 		    chandef->center_freq1 != control_freq + 10 &&
258 		    chandef->center_freq1 != control_freq - 10 &&
259 		    chandef->center_freq1 != control_freq - 30)
260 			return false;
261 		if (!chandef->center_freq2)
262 			return false;
263 		/* adjacent is not allowed -- that's a 160 MHz channel */
264 		if (chandef->center_freq1 - chandef->center_freq2 == 80 ||
265 		    chandef->center_freq2 - chandef->center_freq1 == 80)
266 			return false;
267 		break;
268 	case NL80211_CHAN_WIDTH_80:
269 		if (chandef->center_freq1 != control_freq + 30 &&
270 		    chandef->center_freq1 != control_freq + 10 &&
271 		    chandef->center_freq1 != control_freq - 10 &&
272 		    chandef->center_freq1 != control_freq - 30)
273 			return false;
274 		if (chandef->center_freq2)
275 			return false;
276 		break;
277 	case NL80211_CHAN_WIDTH_160:
278 		if (chandef->center_freq1 != control_freq + 70 &&
279 		    chandef->center_freq1 != control_freq + 50 &&
280 		    chandef->center_freq1 != control_freq + 30 &&
281 		    chandef->center_freq1 != control_freq + 10 &&
282 		    chandef->center_freq1 != control_freq - 10 &&
283 		    chandef->center_freq1 != control_freq - 30 &&
284 		    chandef->center_freq1 != control_freq - 50 &&
285 		    chandef->center_freq1 != control_freq - 70)
286 			return false;
287 		if (chandef->center_freq2)
288 			return false;
289 		break;
290 	default:
291 		return false;
292 	}
293 
294 	/* channel 14 is only for IEEE 802.11b */
295 	if (chandef->center_freq1 == 2484 &&
296 	    chandef->width != NL80211_CHAN_WIDTH_20_NOHT)
297 		return false;
298 
299 	if (cfg80211_chandef_is_edmg(chandef) &&
300 	    !cfg80211_edmg_chandef_valid(chandef))
301 		return false;
302 
303 	return true;
304 }
305 EXPORT_SYMBOL(cfg80211_chandef_valid);
306 
307 static void chandef_primary_freqs(const struct cfg80211_chan_def *c,
308 				  u32 *pri40, u32 *pri80)
309 {
310 	int tmp;
311 
312 	switch (c->width) {
313 	case NL80211_CHAN_WIDTH_40:
314 		*pri40 = c->center_freq1;
315 		*pri80 = 0;
316 		break;
317 	case NL80211_CHAN_WIDTH_80:
318 	case NL80211_CHAN_WIDTH_80P80:
319 		*pri80 = c->center_freq1;
320 		/* n_P20 */
321 		tmp = (30 + c->chan->center_freq - c->center_freq1)/20;
322 		/* n_P40 */
323 		tmp /= 2;
324 		/* freq_P40 */
325 		*pri40 = c->center_freq1 - 20 + 40 * tmp;
326 		break;
327 	case NL80211_CHAN_WIDTH_160:
328 		/* n_P20 */
329 		tmp = (70 + c->chan->center_freq - c->center_freq1)/20;
330 		/* n_P40 */
331 		tmp /= 2;
332 		/* freq_P40 */
333 		*pri40 = c->center_freq1 - 60 + 40 * tmp;
334 		/* n_P80 */
335 		tmp /= 2;
336 		*pri80 = c->center_freq1 - 40 + 80 * tmp;
337 		break;
338 	default:
339 		WARN_ON_ONCE(1);
340 	}
341 }
342 
343 const struct cfg80211_chan_def *
344 cfg80211_chandef_compatible(const struct cfg80211_chan_def *c1,
345 			    const struct cfg80211_chan_def *c2)
346 {
347 	u32 c1_pri40, c1_pri80, c2_pri40, c2_pri80;
348 
349 	/* If they are identical, return */
350 	if (cfg80211_chandef_identical(c1, c2))
351 		return c1;
352 
353 	/* otherwise, must have same control channel */
354 	if (c1->chan != c2->chan)
355 		return NULL;
356 
357 	/*
358 	 * If they have the same width, but aren't identical,
359 	 * then they can't be compatible.
360 	 */
361 	if (c1->width == c2->width)
362 		return NULL;
363 
364 	/*
365 	 * can't be compatible if one of them is 5 or 10 MHz,
366 	 * but they don't have the same width.
367 	 */
368 	if (c1->width == NL80211_CHAN_WIDTH_5 ||
369 	    c1->width == NL80211_CHAN_WIDTH_10 ||
370 	    c2->width == NL80211_CHAN_WIDTH_5 ||
371 	    c2->width == NL80211_CHAN_WIDTH_10)
372 		return NULL;
373 
374 	if (c1->width == NL80211_CHAN_WIDTH_20_NOHT ||
375 	    c1->width == NL80211_CHAN_WIDTH_20)
376 		return c2;
377 
378 	if (c2->width == NL80211_CHAN_WIDTH_20_NOHT ||
379 	    c2->width == NL80211_CHAN_WIDTH_20)
380 		return c1;
381 
382 	chandef_primary_freqs(c1, &c1_pri40, &c1_pri80);
383 	chandef_primary_freqs(c2, &c2_pri40, &c2_pri80);
384 
385 	if (c1_pri40 != c2_pri40)
386 		return NULL;
387 
388 	WARN_ON(!c1_pri80 && !c2_pri80);
389 	if (c1_pri80 && c2_pri80 && c1_pri80 != c2_pri80)
390 		return NULL;
391 
392 	if (c1->width > c2->width)
393 		return c1;
394 	return c2;
395 }
396 EXPORT_SYMBOL(cfg80211_chandef_compatible);
397 
398 static void cfg80211_set_chans_dfs_state(struct wiphy *wiphy, u32 center_freq,
399 					 u32 bandwidth,
400 					 enum nl80211_dfs_state dfs_state)
401 {
402 	struct ieee80211_channel *c;
403 	u32 freq;
404 
405 	for (freq = center_freq - bandwidth/2 + 10;
406 	     freq <= center_freq + bandwidth/2 - 10;
407 	     freq += 20) {
408 		c = ieee80211_get_channel(wiphy, freq);
409 		if (!c || !(c->flags & IEEE80211_CHAN_RADAR))
410 			continue;
411 
412 		c->dfs_state = dfs_state;
413 		c->dfs_state_entered = jiffies;
414 	}
415 }
416 
417 void cfg80211_set_dfs_state(struct wiphy *wiphy,
418 			    const struct cfg80211_chan_def *chandef,
419 			    enum nl80211_dfs_state dfs_state)
420 {
421 	int width;
422 
423 	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
424 		return;
425 
426 	width = cfg80211_chandef_get_width(chandef);
427 	if (width < 0)
428 		return;
429 
430 	cfg80211_set_chans_dfs_state(wiphy, chandef->center_freq1,
431 				     width, dfs_state);
432 
433 	if (!chandef->center_freq2)
434 		return;
435 	cfg80211_set_chans_dfs_state(wiphy, chandef->center_freq2,
436 				     width, dfs_state);
437 }
438 
439 static u32 cfg80211_get_start_freq(u32 center_freq,
440 				   u32 bandwidth)
441 {
442 	u32 start_freq;
443 
444 	bandwidth = MHZ_TO_KHZ(bandwidth);
445 	if (bandwidth <= MHZ_TO_KHZ(20))
446 		start_freq = center_freq;
447 	else
448 		start_freq = center_freq - bandwidth / 2 + MHZ_TO_KHZ(10);
449 
450 	return start_freq;
451 }
452 
453 static u32 cfg80211_get_end_freq(u32 center_freq,
454 				 u32 bandwidth)
455 {
456 	u32 end_freq;
457 
458 	bandwidth = MHZ_TO_KHZ(bandwidth);
459 	if (bandwidth <= MHZ_TO_KHZ(20))
460 		end_freq = center_freq;
461 	else
462 		end_freq = center_freq + bandwidth / 2 - MHZ_TO_KHZ(10);
463 
464 	return end_freq;
465 }
466 
467 static int cfg80211_get_chans_dfs_required(struct wiphy *wiphy,
468 					    u32 center_freq,
469 					    u32 bandwidth)
470 {
471 	struct ieee80211_channel *c;
472 	u32 freq, start_freq, end_freq;
473 
474 	start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
475 	end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
476 
477 	for (freq = start_freq; freq <= end_freq; freq += MHZ_TO_KHZ(20)) {
478 		c = ieee80211_get_channel_khz(wiphy, freq);
479 		if (!c)
480 			return -EINVAL;
481 
482 		if (c->flags & IEEE80211_CHAN_RADAR)
483 			return 1;
484 	}
485 	return 0;
486 }
487 
488 
489 int cfg80211_chandef_dfs_required(struct wiphy *wiphy,
490 				  const struct cfg80211_chan_def *chandef,
491 				  enum nl80211_iftype iftype)
492 {
493 	int width;
494 	int ret;
495 
496 	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
497 		return -EINVAL;
498 
499 	switch (iftype) {
500 	case NL80211_IFTYPE_ADHOC:
501 	case NL80211_IFTYPE_AP:
502 	case NL80211_IFTYPE_P2P_GO:
503 	case NL80211_IFTYPE_MESH_POINT:
504 		width = cfg80211_chandef_get_width(chandef);
505 		if (width < 0)
506 			return -EINVAL;
507 
508 		ret = cfg80211_get_chans_dfs_required(wiphy,
509 					ieee80211_chandef_to_khz(chandef),
510 					width);
511 		if (ret < 0)
512 			return ret;
513 		else if (ret > 0)
514 			return BIT(chandef->width);
515 
516 		if (!chandef->center_freq2)
517 			return 0;
518 
519 		ret = cfg80211_get_chans_dfs_required(wiphy,
520 					MHZ_TO_KHZ(chandef->center_freq2),
521 					width);
522 		if (ret < 0)
523 			return ret;
524 		else if (ret > 0)
525 			return BIT(chandef->width);
526 
527 		break;
528 	case NL80211_IFTYPE_STATION:
529 	case NL80211_IFTYPE_OCB:
530 	case NL80211_IFTYPE_P2P_CLIENT:
531 	case NL80211_IFTYPE_MONITOR:
532 	case NL80211_IFTYPE_AP_VLAN:
533 	case NL80211_IFTYPE_P2P_DEVICE:
534 	case NL80211_IFTYPE_NAN:
535 		break;
536 	case NL80211_IFTYPE_WDS:
537 	case NL80211_IFTYPE_UNSPECIFIED:
538 	case NUM_NL80211_IFTYPES:
539 		WARN_ON(1);
540 	}
541 
542 	return 0;
543 }
544 EXPORT_SYMBOL(cfg80211_chandef_dfs_required);
545 
546 static int cfg80211_get_chans_dfs_usable(struct wiphy *wiphy,
547 					 u32 center_freq,
548 					 u32 bandwidth)
549 {
550 	struct ieee80211_channel *c;
551 	u32 freq, start_freq, end_freq;
552 	int count = 0;
553 
554 	start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
555 	end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
556 
557 	/*
558 	 * Check entire range of channels for the bandwidth.
559 	 * Check all channels are DFS channels (DFS_USABLE or
560 	 * DFS_AVAILABLE). Return number of usable channels
561 	 * (require CAC). Allow DFS and non-DFS channel mix.
562 	 */
563 	for (freq = start_freq; freq <= end_freq; freq += MHZ_TO_KHZ(20)) {
564 		c = ieee80211_get_channel_khz(wiphy, freq);
565 		if (!c)
566 			return -EINVAL;
567 
568 		if (c->flags & IEEE80211_CHAN_DISABLED)
569 			return -EINVAL;
570 
571 		if (c->flags & IEEE80211_CHAN_RADAR) {
572 			if (c->dfs_state == NL80211_DFS_UNAVAILABLE)
573 				return -EINVAL;
574 
575 			if (c->dfs_state == NL80211_DFS_USABLE)
576 				count++;
577 		}
578 	}
579 
580 	return count;
581 }
582 
583 bool cfg80211_chandef_dfs_usable(struct wiphy *wiphy,
584 				 const struct cfg80211_chan_def *chandef)
585 {
586 	int width;
587 	int r1, r2 = 0;
588 
589 	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
590 		return false;
591 
592 	width = cfg80211_chandef_get_width(chandef);
593 	if (width < 0)
594 		return false;
595 
596 	r1 = cfg80211_get_chans_dfs_usable(wiphy,
597 					   MHZ_TO_KHZ(chandef->center_freq1),
598 					   width);
599 
600 	if (r1 < 0)
601 		return false;
602 
603 	switch (chandef->width) {
604 	case NL80211_CHAN_WIDTH_80P80:
605 		WARN_ON(!chandef->center_freq2);
606 		r2 = cfg80211_get_chans_dfs_usable(wiphy,
607 					MHZ_TO_KHZ(chandef->center_freq2),
608 					width);
609 		if (r2 < 0)
610 			return false;
611 		break;
612 	default:
613 		WARN_ON(chandef->center_freq2);
614 		break;
615 	}
616 
617 	return (r1 + r2 > 0);
618 }
619 
620 /*
621  * Checks if center frequency of chan falls with in the bandwidth
622  * range of chandef.
623  */
624 bool cfg80211_is_sub_chan(struct cfg80211_chan_def *chandef,
625 			  struct ieee80211_channel *chan)
626 {
627 	int width;
628 	u32 freq;
629 
630 	if (chandef->chan->center_freq == chan->center_freq)
631 		return true;
632 
633 	width = cfg80211_chandef_get_width(chandef);
634 	if (width <= 20)
635 		return false;
636 
637 	for (freq = chandef->center_freq1 - width / 2 + 10;
638 	     freq <= chandef->center_freq1 + width / 2 - 10; freq += 20) {
639 		if (chan->center_freq == freq)
640 			return true;
641 	}
642 
643 	if (!chandef->center_freq2)
644 		return false;
645 
646 	for (freq = chandef->center_freq2 - width / 2 + 10;
647 	     freq <= chandef->center_freq2 + width / 2 - 10; freq += 20) {
648 		if (chan->center_freq == freq)
649 			return true;
650 	}
651 
652 	return false;
653 }
654 
655 bool cfg80211_beaconing_iface_active(struct wireless_dev *wdev)
656 {
657 	bool active = false;
658 
659 	ASSERT_WDEV_LOCK(wdev);
660 
661 	if (!wdev->chandef.chan)
662 		return false;
663 
664 	switch (wdev->iftype) {
665 	case NL80211_IFTYPE_AP:
666 	case NL80211_IFTYPE_P2P_GO:
667 		active = wdev->beacon_interval != 0;
668 		break;
669 	case NL80211_IFTYPE_ADHOC:
670 		active = wdev->ssid_len != 0;
671 		break;
672 	case NL80211_IFTYPE_MESH_POINT:
673 		active = wdev->mesh_id_len != 0;
674 		break;
675 	case NL80211_IFTYPE_STATION:
676 	case NL80211_IFTYPE_OCB:
677 	case NL80211_IFTYPE_P2P_CLIENT:
678 	case NL80211_IFTYPE_MONITOR:
679 	case NL80211_IFTYPE_AP_VLAN:
680 	case NL80211_IFTYPE_P2P_DEVICE:
681 	/* Can NAN type be considered as beaconing interface? */
682 	case NL80211_IFTYPE_NAN:
683 		break;
684 	case NL80211_IFTYPE_UNSPECIFIED:
685 	case NL80211_IFTYPE_WDS:
686 	case NUM_NL80211_IFTYPES:
687 		WARN_ON(1);
688 	}
689 
690 	return active;
691 }
692 
693 static bool cfg80211_is_wiphy_oper_chan(struct wiphy *wiphy,
694 					struct ieee80211_channel *chan)
695 {
696 	struct wireless_dev *wdev;
697 
698 	list_for_each_entry(wdev, &wiphy->wdev_list, list) {
699 		wdev_lock(wdev);
700 		if (!cfg80211_beaconing_iface_active(wdev)) {
701 			wdev_unlock(wdev);
702 			continue;
703 		}
704 
705 		if (cfg80211_is_sub_chan(&wdev->chandef, chan)) {
706 			wdev_unlock(wdev);
707 			return true;
708 		}
709 		wdev_unlock(wdev);
710 	}
711 
712 	return false;
713 }
714 
715 bool cfg80211_any_wiphy_oper_chan(struct wiphy *wiphy,
716 				  struct ieee80211_channel *chan)
717 {
718 	struct cfg80211_registered_device *rdev;
719 
720 	ASSERT_RTNL();
721 
722 	if (!(chan->flags & IEEE80211_CHAN_RADAR))
723 		return false;
724 
725 	list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
726 		if (!reg_dfs_domain_same(wiphy, &rdev->wiphy))
727 			continue;
728 
729 		if (cfg80211_is_wiphy_oper_chan(&rdev->wiphy, chan))
730 			return true;
731 	}
732 
733 	return false;
734 }
735 
736 static bool cfg80211_get_chans_dfs_available(struct wiphy *wiphy,
737 					     u32 center_freq,
738 					     u32 bandwidth)
739 {
740 	struct ieee80211_channel *c;
741 	u32 freq, start_freq, end_freq;
742 	bool dfs_offload;
743 
744 	dfs_offload = wiphy_ext_feature_isset(wiphy,
745 					      NL80211_EXT_FEATURE_DFS_OFFLOAD);
746 
747 	start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
748 	end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
749 
750 	/*
751 	 * Check entire range of channels for the bandwidth.
752 	 * If any channel in between is disabled or has not
753 	 * had gone through CAC return false
754 	 */
755 	for (freq = start_freq; freq <= end_freq; freq += MHZ_TO_KHZ(20)) {
756 		c = ieee80211_get_channel_khz(wiphy, freq);
757 		if (!c)
758 			return false;
759 
760 		if (c->flags & IEEE80211_CHAN_DISABLED)
761 			return false;
762 
763 		if ((c->flags & IEEE80211_CHAN_RADAR) &&
764 		    (c->dfs_state != NL80211_DFS_AVAILABLE) &&
765 		    !(c->dfs_state == NL80211_DFS_USABLE && dfs_offload))
766 			return false;
767 	}
768 
769 	return true;
770 }
771 
772 static bool cfg80211_chandef_dfs_available(struct wiphy *wiphy,
773 				const struct cfg80211_chan_def *chandef)
774 {
775 	int width;
776 	int r;
777 
778 	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
779 		return false;
780 
781 	width = cfg80211_chandef_get_width(chandef);
782 	if (width < 0)
783 		return false;
784 
785 	r = cfg80211_get_chans_dfs_available(wiphy,
786 					     MHZ_TO_KHZ(chandef->center_freq1),
787 					     width);
788 
789 	/* If any of channels unavailable for cf1 just return */
790 	if (!r)
791 		return r;
792 
793 	switch (chandef->width) {
794 	case NL80211_CHAN_WIDTH_80P80:
795 		WARN_ON(!chandef->center_freq2);
796 		r = cfg80211_get_chans_dfs_available(wiphy,
797 					MHZ_TO_KHZ(chandef->center_freq2),
798 					width);
799 		break;
800 	default:
801 		WARN_ON(chandef->center_freq2);
802 		break;
803 	}
804 
805 	return r;
806 }
807 
808 static unsigned int cfg80211_get_chans_dfs_cac_time(struct wiphy *wiphy,
809 						    u32 center_freq,
810 						    u32 bandwidth)
811 {
812 	struct ieee80211_channel *c;
813 	u32 start_freq, end_freq, freq;
814 	unsigned int dfs_cac_ms = 0;
815 
816 	start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
817 	end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
818 
819 	for (freq = start_freq; freq <= end_freq; freq += MHZ_TO_KHZ(20)) {
820 		c = ieee80211_get_channel_khz(wiphy, freq);
821 		if (!c)
822 			return 0;
823 
824 		if (c->flags & IEEE80211_CHAN_DISABLED)
825 			return 0;
826 
827 		if (!(c->flags & IEEE80211_CHAN_RADAR))
828 			continue;
829 
830 		if (c->dfs_cac_ms > dfs_cac_ms)
831 			dfs_cac_ms = c->dfs_cac_ms;
832 	}
833 
834 	return dfs_cac_ms;
835 }
836 
837 unsigned int
838 cfg80211_chandef_dfs_cac_time(struct wiphy *wiphy,
839 			      const struct cfg80211_chan_def *chandef)
840 {
841 	int width;
842 	unsigned int t1 = 0, t2 = 0;
843 
844 	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
845 		return 0;
846 
847 	width = cfg80211_chandef_get_width(chandef);
848 	if (width < 0)
849 		return 0;
850 
851 	t1 = cfg80211_get_chans_dfs_cac_time(wiphy,
852 					     MHZ_TO_KHZ(chandef->center_freq1),
853 					     width);
854 
855 	if (!chandef->center_freq2)
856 		return t1;
857 
858 	t2 = cfg80211_get_chans_dfs_cac_time(wiphy,
859 					     MHZ_TO_KHZ(chandef->center_freq2),
860 					     width);
861 
862 	return max(t1, t2);
863 }
864 
865 static bool cfg80211_secondary_chans_ok(struct wiphy *wiphy,
866 					u32 center_freq, u32 bandwidth,
867 					u32 prohibited_flags)
868 {
869 	struct ieee80211_channel *c;
870 	u32 freq, start_freq, end_freq;
871 
872 	start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
873 	end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
874 
875 	for (freq = start_freq; freq <= end_freq; freq += MHZ_TO_KHZ(20)) {
876 		c = ieee80211_get_channel_khz(wiphy, freq);
877 		if (!c || c->flags & prohibited_flags)
878 			return false;
879 	}
880 
881 	return true;
882 }
883 
884 /* check if the operating channels are valid and supported */
885 static bool cfg80211_edmg_usable(struct wiphy *wiphy, u8 edmg_channels,
886 				 enum ieee80211_edmg_bw_config edmg_bw_config,
887 				 int primary_channel,
888 				 struct ieee80211_edmg *edmg_cap)
889 {
890 	struct ieee80211_channel *chan;
891 	int i, freq;
892 	int channels_counter = 0;
893 
894 	if (!edmg_channels && !edmg_bw_config)
895 		return true;
896 
897 	if ((!edmg_channels && edmg_bw_config) ||
898 	    (edmg_channels && !edmg_bw_config))
899 		return false;
900 
901 	if (!(edmg_channels & BIT(primary_channel - 1)))
902 		return false;
903 
904 	/* 60GHz channels 1..6 */
905 	for (i = 0; i < 6; i++) {
906 		if (!(edmg_channels & BIT(i)))
907 			continue;
908 
909 		if (!(edmg_cap->channels & BIT(i)))
910 			return false;
911 
912 		channels_counter++;
913 
914 		freq = ieee80211_channel_to_frequency(i + 1,
915 						      NL80211_BAND_60GHZ);
916 		chan = ieee80211_get_channel(wiphy, freq);
917 		if (!chan || chan->flags & IEEE80211_CHAN_DISABLED)
918 			return false;
919 	}
920 
921 	/* IEEE802.11 allows max 4 channels */
922 	if (channels_counter > 4)
923 		return false;
924 
925 	/* check bw_config is a subset of what driver supports
926 	 * (see IEEE P802.11ay/D4.0 section 9.4.2.251, Table 13)
927 	 */
928 	if ((edmg_bw_config % 4) > (edmg_cap->bw_config % 4))
929 		return false;
930 
931 	if (edmg_bw_config > edmg_cap->bw_config)
932 		return false;
933 
934 	return true;
935 }
936 
937 bool cfg80211_chandef_usable(struct wiphy *wiphy,
938 			     const struct cfg80211_chan_def *chandef,
939 			     u32 prohibited_flags)
940 {
941 	struct ieee80211_sta_ht_cap *ht_cap;
942 	struct ieee80211_sta_vht_cap *vht_cap;
943 	struct ieee80211_edmg *edmg_cap;
944 	u32 width, control_freq, cap;
945 	bool support_80_80 = false;
946 
947 	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
948 		return false;
949 
950 	ht_cap = &wiphy->bands[chandef->chan->band]->ht_cap;
951 	vht_cap = &wiphy->bands[chandef->chan->band]->vht_cap;
952 	edmg_cap = &wiphy->bands[chandef->chan->band]->edmg_cap;
953 
954 	if (edmg_cap->channels &&
955 	    !cfg80211_edmg_usable(wiphy,
956 				  chandef->edmg.channels,
957 				  chandef->edmg.bw_config,
958 				  chandef->chan->hw_value,
959 				  edmg_cap))
960 		return false;
961 
962 	control_freq = chandef->chan->center_freq;
963 
964 	switch (chandef->width) {
965 	case NL80211_CHAN_WIDTH_1:
966 		width = 1;
967 		break;
968 	case NL80211_CHAN_WIDTH_2:
969 		width = 2;
970 		break;
971 	case NL80211_CHAN_WIDTH_4:
972 		width = 4;
973 		break;
974 	case NL80211_CHAN_WIDTH_8:
975 		width = 8;
976 		break;
977 	case NL80211_CHAN_WIDTH_16:
978 		width = 16;
979 		break;
980 	case NL80211_CHAN_WIDTH_5:
981 		width = 5;
982 		break;
983 	case NL80211_CHAN_WIDTH_10:
984 		prohibited_flags |= IEEE80211_CHAN_NO_10MHZ;
985 		width = 10;
986 		break;
987 	case NL80211_CHAN_WIDTH_20:
988 		if (!ht_cap->ht_supported &&
989 		    chandef->chan->band != NL80211_BAND_6GHZ)
990 			return false;
991 		fallthrough;
992 	case NL80211_CHAN_WIDTH_20_NOHT:
993 		prohibited_flags |= IEEE80211_CHAN_NO_20MHZ;
994 		width = 20;
995 		break;
996 	case NL80211_CHAN_WIDTH_40:
997 		width = 40;
998 		if (chandef->chan->band == NL80211_BAND_6GHZ)
999 			break;
1000 		if (!ht_cap->ht_supported)
1001 			return false;
1002 		if (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) ||
1003 		    ht_cap->cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT)
1004 			return false;
1005 		if (chandef->center_freq1 < control_freq &&
1006 		    chandef->chan->flags & IEEE80211_CHAN_NO_HT40MINUS)
1007 			return false;
1008 		if (chandef->center_freq1 > control_freq &&
1009 		    chandef->chan->flags & IEEE80211_CHAN_NO_HT40PLUS)
1010 			return false;
1011 		break;
1012 	case NL80211_CHAN_WIDTH_80P80:
1013 		cap = vht_cap->cap;
1014 		support_80_80 =
1015 			(cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ) ||
1016 			(cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ &&
1017 			 cap & IEEE80211_VHT_CAP_EXT_NSS_BW_MASK) ||
1018 			u32_get_bits(cap, IEEE80211_VHT_CAP_EXT_NSS_BW_MASK) > 1;
1019 		if (chandef->chan->band != NL80211_BAND_6GHZ && !support_80_80)
1020 			return false;
1021 		fallthrough;
1022 	case NL80211_CHAN_WIDTH_80:
1023 		prohibited_flags |= IEEE80211_CHAN_NO_80MHZ;
1024 		width = 80;
1025 		if (chandef->chan->band == NL80211_BAND_6GHZ)
1026 			break;
1027 		if (!vht_cap->vht_supported)
1028 			return false;
1029 		break;
1030 	case NL80211_CHAN_WIDTH_160:
1031 		prohibited_flags |= IEEE80211_CHAN_NO_160MHZ;
1032 		width = 160;
1033 		if (chandef->chan->band == NL80211_BAND_6GHZ)
1034 			break;
1035 		if (!vht_cap->vht_supported)
1036 			return false;
1037 		cap = vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK;
1038 		if (cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ &&
1039 		    cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ &&
1040 		    !(vht_cap->cap & IEEE80211_VHT_CAP_EXT_NSS_BW_MASK))
1041 			return false;
1042 		break;
1043 	default:
1044 		WARN_ON_ONCE(1);
1045 		return false;
1046 	}
1047 
1048 	/*
1049 	 * TODO: What if there are only certain 80/160/80+80 MHz channels
1050 	 *	 allowed by the driver, or only certain combinations?
1051 	 *	 For 40 MHz the driver can set the NO_HT40 flags, but for
1052 	 *	 80/160 MHz and in particular 80+80 MHz this isn't really
1053 	 *	 feasible and we only have NO_80MHZ/NO_160MHZ so far but
1054 	 *	 no way to cover 80+80 MHz or more complex restrictions.
1055 	 *	 Note that such restrictions also need to be advertised to
1056 	 *	 userspace, for example for P2P channel selection.
1057 	 */
1058 
1059 	if (width > 20)
1060 		prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
1061 
1062 	/* 5 and 10 MHz are only defined for the OFDM PHY */
1063 	if (width < 20)
1064 		prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
1065 
1066 
1067 	if (!cfg80211_secondary_chans_ok(wiphy,
1068 					 ieee80211_chandef_to_khz(chandef),
1069 					 width, prohibited_flags))
1070 		return false;
1071 
1072 	if (!chandef->center_freq2)
1073 		return true;
1074 	return cfg80211_secondary_chans_ok(wiphy,
1075 					   MHZ_TO_KHZ(chandef->center_freq2),
1076 					   width, prohibited_flags);
1077 }
1078 EXPORT_SYMBOL(cfg80211_chandef_usable);
1079 
1080 /*
1081  * Check if the channel can be used under permissive conditions mandated by
1082  * some regulatory bodies, i.e., the channel is marked with
1083  * IEEE80211_CHAN_IR_CONCURRENT and there is an additional station interface
1084  * associated to an AP on the same channel or on the same UNII band
1085  * (assuming that the AP is an authorized master).
1086  * In addition allow operation on a channel on which indoor operation is
1087  * allowed, iff we are currently operating in an indoor environment.
1088  */
1089 static bool cfg80211_ir_permissive_chan(struct wiphy *wiphy,
1090 					enum nl80211_iftype iftype,
1091 					struct ieee80211_channel *chan)
1092 {
1093 	struct wireless_dev *wdev;
1094 	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1095 
1096 	lockdep_assert_held(&rdev->wiphy.mtx);
1097 
1098 	if (!IS_ENABLED(CONFIG_CFG80211_REG_RELAX_NO_IR) ||
1099 	    !(wiphy->regulatory_flags & REGULATORY_ENABLE_RELAX_NO_IR))
1100 		return false;
1101 
1102 	/* only valid for GO and TDLS off-channel (station/p2p-CL) */
1103 	if (iftype != NL80211_IFTYPE_P2P_GO &&
1104 	    iftype != NL80211_IFTYPE_STATION &&
1105 	    iftype != NL80211_IFTYPE_P2P_CLIENT)
1106 		return false;
1107 
1108 	if (regulatory_indoor_allowed() &&
1109 	    (chan->flags & IEEE80211_CHAN_INDOOR_ONLY))
1110 		return true;
1111 
1112 	if (!(chan->flags & IEEE80211_CHAN_IR_CONCURRENT))
1113 		return false;
1114 
1115 	/*
1116 	 * Generally, it is possible to rely on another device/driver to allow
1117 	 * the IR concurrent relaxation, however, since the device can further
1118 	 * enforce the relaxation (by doing a similar verifications as this),
1119 	 * and thus fail the GO instantiation, consider only the interfaces of
1120 	 * the current registered device.
1121 	 */
1122 	list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
1123 		struct ieee80211_channel *other_chan = NULL;
1124 		int r1, r2;
1125 
1126 		wdev_lock(wdev);
1127 		if (wdev->iftype == NL80211_IFTYPE_STATION &&
1128 		    wdev->current_bss)
1129 			other_chan = wdev->current_bss->pub.channel;
1130 
1131 		/*
1132 		 * If a GO already operates on the same GO_CONCURRENT channel,
1133 		 * this one (maybe the same one) can beacon as well. We allow
1134 		 * the operation even if the station we relied on with
1135 		 * GO_CONCURRENT is disconnected now. But then we must make sure
1136 		 * we're not outdoor on an indoor-only channel.
1137 		 */
1138 		if (iftype == NL80211_IFTYPE_P2P_GO &&
1139 		    wdev->iftype == NL80211_IFTYPE_P2P_GO &&
1140 		    wdev->beacon_interval &&
1141 		    !(chan->flags & IEEE80211_CHAN_INDOOR_ONLY))
1142 			other_chan = wdev->chandef.chan;
1143 		wdev_unlock(wdev);
1144 
1145 		if (!other_chan)
1146 			continue;
1147 
1148 		if (chan == other_chan)
1149 			return true;
1150 
1151 		if (chan->band != NL80211_BAND_5GHZ &&
1152 		    chan->band != NL80211_BAND_6GHZ)
1153 			continue;
1154 
1155 		r1 = cfg80211_get_unii(chan->center_freq);
1156 		r2 = cfg80211_get_unii(other_chan->center_freq);
1157 
1158 		if (r1 != -EINVAL && r1 == r2) {
1159 			/*
1160 			 * At some locations channels 149-165 are considered a
1161 			 * bundle, but at other locations, e.g., Indonesia,
1162 			 * channels 149-161 are considered a bundle while
1163 			 * channel 165 is left out and considered to be in a
1164 			 * different bundle. Thus, in case that there is a
1165 			 * station interface connected to an AP on channel 165,
1166 			 * it is assumed that channels 149-161 are allowed for
1167 			 * GO operations. However, having a station interface
1168 			 * connected to an AP on channels 149-161, does not
1169 			 * allow GO operation on channel 165.
1170 			 */
1171 			if (chan->center_freq == 5825 &&
1172 			    other_chan->center_freq != 5825)
1173 				continue;
1174 			return true;
1175 		}
1176 	}
1177 
1178 	return false;
1179 }
1180 
1181 static bool _cfg80211_reg_can_beacon(struct wiphy *wiphy,
1182 				     struct cfg80211_chan_def *chandef,
1183 				     enum nl80211_iftype iftype,
1184 				     bool check_no_ir)
1185 {
1186 	bool res;
1187 	u32 prohibited_flags = IEEE80211_CHAN_DISABLED |
1188 			       IEEE80211_CHAN_RADAR;
1189 
1190 	trace_cfg80211_reg_can_beacon(wiphy, chandef, iftype, check_no_ir);
1191 
1192 	if (check_no_ir)
1193 		prohibited_flags |= IEEE80211_CHAN_NO_IR;
1194 
1195 	if (cfg80211_chandef_dfs_required(wiphy, chandef, iftype) > 0 &&
1196 	    cfg80211_chandef_dfs_available(wiphy, chandef)) {
1197 		/* We can skip IEEE80211_CHAN_NO_IR if chandef dfs available */
1198 		prohibited_flags = IEEE80211_CHAN_DISABLED;
1199 	}
1200 
1201 	res = cfg80211_chandef_usable(wiphy, chandef, prohibited_flags);
1202 
1203 	trace_cfg80211_return_bool(res);
1204 	return res;
1205 }
1206 
1207 bool cfg80211_reg_can_beacon(struct wiphy *wiphy,
1208 			     struct cfg80211_chan_def *chandef,
1209 			     enum nl80211_iftype iftype)
1210 {
1211 	return _cfg80211_reg_can_beacon(wiphy, chandef, iftype, true);
1212 }
1213 EXPORT_SYMBOL(cfg80211_reg_can_beacon);
1214 
1215 bool cfg80211_reg_can_beacon_relax(struct wiphy *wiphy,
1216 				   struct cfg80211_chan_def *chandef,
1217 				   enum nl80211_iftype iftype)
1218 {
1219 	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1220 	bool check_no_ir;
1221 
1222 	lockdep_assert_held(&rdev->wiphy.mtx);
1223 
1224 	/*
1225 	 * Under certain conditions suggested by some regulatory bodies a
1226 	 * GO/STA can IR on channels marked with IEEE80211_NO_IR. Set this flag
1227 	 * only if such relaxations are not enabled and the conditions are not
1228 	 * met.
1229 	 */
1230 	check_no_ir = !cfg80211_ir_permissive_chan(wiphy, iftype,
1231 						   chandef->chan);
1232 
1233 	return _cfg80211_reg_can_beacon(wiphy, chandef, iftype, check_no_ir);
1234 }
1235 EXPORT_SYMBOL(cfg80211_reg_can_beacon_relax);
1236 
1237 int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev,
1238 				 struct cfg80211_chan_def *chandef)
1239 {
1240 	if (!rdev->ops->set_monitor_channel)
1241 		return -EOPNOTSUPP;
1242 	if (!cfg80211_has_monitors_only(rdev))
1243 		return -EBUSY;
1244 
1245 	return rdev_set_monitor_channel(rdev, chandef);
1246 }
1247 
1248 void
1249 cfg80211_get_chan_state(struct wireless_dev *wdev,
1250 		        struct ieee80211_channel **chan,
1251 		        enum cfg80211_chan_mode *chanmode,
1252 		        u8 *radar_detect)
1253 {
1254 	int ret;
1255 
1256 	*chan = NULL;
1257 	*chanmode = CHAN_MODE_UNDEFINED;
1258 
1259 	ASSERT_WDEV_LOCK(wdev);
1260 
1261 	if (wdev->netdev && !netif_running(wdev->netdev))
1262 		return;
1263 
1264 	switch (wdev->iftype) {
1265 	case NL80211_IFTYPE_ADHOC:
1266 		if (wdev->current_bss) {
1267 			*chan = wdev->current_bss->pub.channel;
1268 			*chanmode = (wdev->ibss_fixed &&
1269 				     !wdev->ibss_dfs_possible)
1270 				  ? CHAN_MODE_SHARED
1271 				  : CHAN_MODE_EXCLUSIVE;
1272 
1273 			/* consider worst-case - IBSS can try to return to the
1274 			 * original user-specified channel as creator */
1275 			if (wdev->ibss_dfs_possible)
1276 				*radar_detect |= BIT(wdev->chandef.width);
1277 			return;
1278 		}
1279 		break;
1280 	case NL80211_IFTYPE_STATION:
1281 	case NL80211_IFTYPE_P2P_CLIENT:
1282 		if (wdev->current_bss) {
1283 			*chan = wdev->current_bss->pub.channel;
1284 			*chanmode = CHAN_MODE_SHARED;
1285 			return;
1286 		}
1287 		break;
1288 	case NL80211_IFTYPE_AP:
1289 	case NL80211_IFTYPE_P2P_GO:
1290 		if (wdev->cac_started) {
1291 			*chan = wdev->chandef.chan;
1292 			*chanmode = CHAN_MODE_SHARED;
1293 			*radar_detect |= BIT(wdev->chandef.width);
1294 		} else if (wdev->beacon_interval) {
1295 			*chan = wdev->chandef.chan;
1296 			*chanmode = CHAN_MODE_SHARED;
1297 
1298 			ret = cfg80211_chandef_dfs_required(wdev->wiphy,
1299 							    &wdev->chandef,
1300 							    wdev->iftype);
1301 			WARN_ON(ret < 0);
1302 			if (ret > 0)
1303 				*radar_detect |= BIT(wdev->chandef.width);
1304 		}
1305 		return;
1306 	case NL80211_IFTYPE_MESH_POINT:
1307 		if (wdev->mesh_id_len) {
1308 			*chan = wdev->chandef.chan;
1309 			*chanmode = CHAN_MODE_SHARED;
1310 
1311 			ret = cfg80211_chandef_dfs_required(wdev->wiphy,
1312 							    &wdev->chandef,
1313 							    wdev->iftype);
1314 			WARN_ON(ret < 0);
1315 			if (ret > 0)
1316 				*radar_detect |= BIT(wdev->chandef.width);
1317 		}
1318 		return;
1319 	case NL80211_IFTYPE_OCB:
1320 		if (wdev->chandef.chan) {
1321 			*chan = wdev->chandef.chan;
1322 			*chanmode = CHAN_MODE_SHARED;
1323 			return;
1324 		}
1325 		break;
1326 	case NL80211_IFTYPE_MONITOR:
1327 	case NL80211_IFTYPE_AP_VLAN:
1328 	case NL80211_IFTYPE_P2P_DEVICE:
1329 	case NL80211_IFTYPE_NAN:
1330 		/* these interface types don't really have a channel */
1331 		return;
1332 	case NL80211_IFTYPE_UNSPECIFIED:
1333 	case NL80211_IFTYPE_WDS:
1334 	case NUM_NL80211_IFTYPES:
1335 		WARN_ON(1);
1336 	}
1337 }
1338