xref: /openbmc/linux/net/wireless/chan.c (revision ed84ef1c) 
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-2021	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 ext_nss_cap, 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 	ext_nss_cap = __le16_to_cpu(vht_cap->vht_mcs.tx_highest) &
954 			IEEE80211_VHT_EXT_NSS_BW_CAPABLE;
955 
956 	if (edmg_cap->channels &&
957 	    !cfg80211_edmg_usable(wiphy,
958 				  chandef->edmg.channels,
959 				  chandef->edmg.bw_config,
960 				  chandef->chan->hw_value,
961 				  edmg_cap))
962 		return false;
963 
964 	control_freq = chandef->chan->center_freq;
965 
966 	switch (chandef->width) {
967 	case NL80211_CHAN_WIDTH_1:
968 		width = 1;
969 		break;
970 	case NL80211_CHAN_WIDTH_2:
971 		width = 2;
972 		break;
973 	case NL80211_CHAN_WIDTH_4:
974 		width = 4;
975 		break;
976 	case NL80211_CHAN_WIDTH_8:
977 		width = 8;
978 		break;
979 	case NL80211_CHAN_WIDTH_16:
980 		width = 16;
981 		break;
982 	case NL80211_CHAN_WIDTH_5:
983 		width = 5;
984 		break;
985 	case NL80211_CHAN_WIDTH_10:
986 		prohibited_flags |= IEEE80211_CHAN_NO_10MHZ;
987 		width = 10;
988 		break;
989 	case NL80211_CHAN_WIDTH_20:
990 		if (!ht_cap->ht_supported &&
991 		    chandef->chan->band != NL80211_BAND_6GHZ)
992 			return false;
993 		fallthrough;
994 	case NL80211_CHAN_WIDTH_20_NOHT:
995 		prohibited_flags |= IEEE80211_CHAN_NO_20MHZ;
996 		width = 20;
997 		break;
998 	case NL80211_CHAN_WIDTH_40:
999 		width = 40;
1000 		if (chandef->chan->band == NL80211_BAND_6GHZ)
1001 			break;
1002 		if (!ht_cap->ht_supported)
1003 			return false;
1004 		if (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) ||
1005 		    ht_cap->cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT)
1006 			return false;
1007 		if (chandef->center_freq1 < control_freq &&
1008 		    chandef->chan->flags & IEEE80211_CHAN_NO_HT40MINUS)
1009 			return false;
1010 		if (chandef->center_freq1 > control_freq &&
1011 		    chandef->chan->flags & IEEE80211_CHAN_NO_HT40PLUS)
1012 			return false;
1013 		break;
1014 	case NL80211_CHAN_WIDTH_80P80:
1015 		cap = vht_cap->cap;
1016 		support_80_80 =
1017 			(cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ) ||
1018 			(cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ &&
1019 			 cap & IEEE80211_VHT_CAP_EXT_NSS_BW_MASK) ||
1020 			(ext_nss_cap &&
1021 			 u32_get_bits(cap, IEEE80211_VHT_CAP_EXT_NSS_BW_MASK) > 1);
1022 		if (chandef->chan->band != NL80211_BAND_6GHZ && !support_80_80)
1023 			return false;
1024 		fallthrough;
1025 	case NL80211_CHAN_WIDTH_80:
1026 		prohibited_flags |= IEEE80211_CHAN_NO_80MHZ;
1027 		width = 80;
1028 		if (chandef->chan->band == NL80211_BAND_6GHZ)
1029 			break;
1030 		if (!vht_cap->vht_supported)
1031 			return false;
1032 		break;
1033 	case NL80211_CHAN_WIDTH_160:
1034 		prohibited_flags |= IEEE80211_CHAN_NO_160MHZ;
1035 		width = 160;
1036 		if (chandef->chan->band == NL80211_BAND_6GHZ)
1037 			break;
1038 		if (!vht_cap->vht_supported)
1039 			return false;
1040 		cap = vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK;
1041 		if (cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ &&
1042 		    cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ &&
1043 		    !(ext_nss_cap &&
1044 		      (vht_cap->cap & IEEE80211_VHT_CAP_EXT_NSS_BW_MASK)))
1045 			return false;
1046 		break;
1047 	default:
1048 		WARN_ON_ONCE(1);
1049 		return false;
1050 	}
1051 
1052 	/*
1053 	 * TODO: What if there are only certain 80/160/80+80 MHz channels
1054 	 *	 allowed by the driver, or only certain combinations?
1055 	 *	 For 40 MHz the driver can set the NO_HT40 flags, but for
1056 	 *	 80/160 MHz and in particular 80+80 MHz this isn't really
1057 	 *	 feasible and we only have NO_80MHZ/NO_160MHZ so far but
1058 	 *	 no way to cover 80+80 MHz or more complex restrictions.
1059 	 *	 Note that such restrictions also need to be advertised to
1060 	 *	 userspace, for example for P2P channel selection.
1061 	 */
1062 
1063 	if (width > 20)
1064 		prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
1065 
1066 	/* 5 and 10 MHz are only defined for the OFDM PHY */
1067 	if (width < 20)
1068 		prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
1069 
1070 
1071 	if (!cfg80211_secondary_chans_ok(wiphy,
1072 					 ieee80211_chandef_to_khz(chandef),
1073 					 width, prohibited_flags))
1074 		return false;
1075 
1076 	if (!chandef->center_freq2)
1077 		return true;
1078 	return cfg80211_secondary_chans_ok(wiphy,
1079 					   MHZ_TO_KHZ(chandef->center_freq2),
1080 					   width, prohibited_flags);
1081 }
1082 EXPORT_SYMBOL(cfg80211_chandef_usable);
1083 
1084 /*
1085  * Check if the channel can be used under permissive conditions mandated by
1086  * some regulatory bodies, i.e., the channel is marked with
1087  * IEEE80211_CHAN_IR_CONCURRENT and there is an additional station interface
1088  * associated to an AP on the same channel or on the same UNII band
1089  * (assuming that the AP is an authorized master).
1090  * In addition allow operation on a channel on which indoor operation is
1091  * allowed, iff we are currently operating in an indoor environment.
1092  */
1093 static bool cfg80211_ir_permissive_chan(struct wiphy *wiphy,
1094 					enum nl80211_iftype iftype,
1095 					struct ieee80211_channel *chan)
1096 {
1097 	struct wireless_dev *wdev;
1098 	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1099 
1100 	lockdep_assert_held(&rdev->wiphy.mtx);
1101 
1102 	if (!IS_ENABLED(CONFIG_CFG80211_REG_RELAX_NO_IR) ||
1103 	    !(wiphy->regulatory_flags & REGULATORY_ENABLE_RELAX_NO_IR))
1104 		return false;
1105 
1106 	/* only valid for GO and TDLS off-channel (station/p2p-CL) */
1107 	if (iftype != NL80211_IFTYPE_P2P_GO &&
1108 	    iftype != NL80211_IFTYPE_STATION &&
1109 	    iftype != NL80211_IFTYPE_P2P_CLIENT)
1110 		return false;
1111 
1112 	if (regulatory_indoor_allowed() &&
1113 	    (chan->flags & IEEE80211_CHAN_INDOOR_ONLY))
1114 		return true;
1115 
1116 	if (!(chan->flags & IEEE80211_CHAN_IR_CONCURRENT))
1117 		return false;
1118 
1119 	/*
1120 	 * Generally, it is possible to rely on another device/driver to allow
1121 	 * the IR concurrent relaxation, however, since the device can further
1122 	 * enforce the relaxation (by doing a similar verifications as this),
1123 	 * and thus fail the GO instantiation, consider only the interfaces of
1124 	 * the current registered device.
1125 	 */
1126 	list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
1127 		struct ieee80211_channel *other_chan = NULL;
1128 		int r1, r2;
1129 
1130 		wdev_lock(wdev);
1131 		if (wdev->iftype == NL80211_IFTYPE_STATION &&
1132 		    wdev->current_bss)
1133 			other_chan = wdev->current_bss->pub.channel;
1134 
1135 		/*
1136 		 * If a GO already operates on the same GO_CONCURRENT channel,
1137 		 * this one (maybe the same one) can beacon as well. We allow
1138 		 * the operation even if the station we relied on with
1139 		 * GO_CONCURRENT is disconnected now. But then we must make sure
1140 		 * we're not outdoor on an indoor-only channel.
1141 		 */
1142 		if (iftype == NL80211_IFTYPE_P2P_GO &&
1143 		    wdev->iftype == NL80211_IFTYPE_P2P_GO &&
1144 		    wdev->beacon_interval &&
1145 		    !(chan->flags & IEEE80211_CHAN_INDOOR_ONLY))
1146 			other_chan = wdev->chandef.chan;
1147 		wdev_unlock(wdev);
1148 
1149 		if (!other_chan)
1150 			continue;
1151 
1152 		if (chan == other_chan)
1153 			return true;
1154 
1155 		if (chan->band != NL80211_BAND_5GHZ &&
1156 		    chan->band != NL80211_BAND_6GHZ)
1157 			continue;
1158 
1159 		r1 = cfg80211_get_unii(chan->center_freq);
1160 		r2 = cfg80211_get_unii(other_chan->center_freq);
1161 
1162 		if (r1 != -EINVAL && r1 == r2) {
1163 			/*
1164 			 * At some locations channels 149-165 are considered a
1165 			 * bundle, but at other locations, e.g., Indonesia,
1166 			 * channels 149-161 are considered a bundle while
1167 			 * channel 165 is left out and considered to be in a
1168 			 * different bundle. Thus, in case that there is a
1169 			 * station interface connected to an AP on channel 165,
1170 			 * it is assumed that channels 149-161 are allowed for
1171 			 * GO operations. However, having a station interface
1172 			 * connected to an AP on channels 149-161, does not
1173 			 * allow GO operation on channel 165.
1174 			 */
1175 			if (chan->center_freq == 5825 &&
1176 			    other_chan->center_freq != 5825)
1177 				continue;
1178 			return true;
1179 		}
1180 	}
1181 
1182 	return false;
1183 }
1184 
1185 static bool _cfg80211_reg_can_beacon(struct wiphy *wiphy,
1186 				     struct cfg80211_chan_def *chandef,
1187 				     enum nl80211_iftype iftype,
1188 				     bool check_no_ir)
1189 {
1190 	bool res;
1191 	u32 prohibited_flags = IEEE80211_CHAN_DISABLED |
1192 			       IEEE80211_CHAN_RADAR;
1193 
1194 	trace_cfg80211_reg_can_beacon(wiphy, chandef, iftype, check_no_ir);
1195 
1196 	if (check_no_ir)
1197 		prohibited_flags |= IEEE80211_CHAN_NO_IR;
1198 
1199 	if (cfg80211_chandef_dfs_required(wiphy, chandef, iftype) > 0 &&
1200 	    cfg80211_chandef_dfs_available(wiphy, chandef)) {
1201 		/* We can skip IEEE80211_CHAN_NO_IR if chandef dfs available */
1202 		prohibited_flags = IEEE80211_CHAN_DISABLED;
1203 	}
1204 
1205 	res = cfg80211_chandef_usable(wiphy, chandef, prohibited_flags);
1206 
1207 	trace_cfg80211_return_bool(res);
1208 	return res;
1209 }
1210 
1211 bool cfg80211_reg_can_beacon(struct wiphy *wiphy,
1212 			     struct cfg80211_chan_def *chandef,
1213 			     enum nl80211_iftype iftype)
1214 {
1215 	return _cfg80211_reg_can_beacon(wiphy, chandef, iftype, true);
1216 }
1217 EXPORT_SYMBOL(cfg80211_reg_can_beacon);
1218 
1219 bool cfg80211_reg_can_beacon_relax(struct wiphy *wiphy,
1220 				   struct cfg80211_chan_def *chandef,
1221 				   enum nl80211_iftype iftype)
1222 {
1223 	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1224 	bool check_no_ir;
1225 
1226 	lockdep_assert_held(&rdev->wiphy.mtx);
1227 
1228 	/*
1229 	 * Under certain conditions suggested by some regulatory bodies a
1230 	 * GO/STA can IR on channels marked with IEEE80211_NO_IR. Set this flag
1231 	 * only if such relaxations are not enabled and the conditions are not
1232 	 * met.
1233 	 */
1234 	check_no_ir = !cfg80211_ir_permissive_chan(wiphy, iftype,
1235 						   chandef->chan);
1236 
1237 	return _cfg80211_reg_can_beacon(wiphy, chandef, iftype, check_no_ir);
1238 }
1239 EXPORT_SYMBOL(cfg80211_reg_can_beacon_relax);
1240 
1241 int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev,
1242 				 struct cfg80211_chan_def *chandef)
1243 {
1244 	if (!rdev->ops->set_monitor_channel)
1245 		return -EOPNOTSUPP;
1246 	if (!cfg80211_has_monitors_only(rdev))
1247 		return -EBUSY;
1248 
1249 	return rdev_set_monitor_channel(rdev, chandef);
1250 }
1251 
1252 void
1253 cfg80211_get_chan_state(struct wireless_dev *wdev,
1254 		        struct ieee80211_channel **chan,
1255 		        enum cfg80211_chan_mode *chanmode,
1256 		        u8 *radar_detect)
1257 {
1258 	int ret;
1259 
1260 	*chan = NULL;
1261 	*chanmode = CHAN_MODE_UNDEFINED;
1262 
1263 	ASSERT_WDEV_LOCK(wdev);
1264 
1265 	if (wdev->netdev && !netif_running(wdev->netdev))
1266 		return;
1267 
1268 	switch (wdev->iftype) {
1269 	case NL80211_IFTYPE_ADHOC:
1270 		if (wdev->current_bss) {
1271 			*chan = wdev->current_bss->pub.channel;
1272 			*chanmode = (wdev->ibss_fixed &&
1273 				     !wdev->ibss_dfs_possible)
1274 				  ? CHAN_MODE_SHARED
1275 				  : CHAN_MODE_EXCLUSIVE;
1276 
1277 			/* consider worst-case - IBSS can try to return to the
1278 			 * original user-specified channel as creator */
1279 			if (wdev->ibss_dfs_possible)
1280 				*radar_detect |= BIT(wdev->chandef.width);
1281 			return;
1282 		}
1283 		break;
1284 	case NL80211_IFTYPE_STATION:
1285 	case NL80211_IFTYPE_P2P_CLIENT:
1286 		if (wdev->current_bss) {
1287 			*chan = wdev->current_bss->pub.channel;
1288 			*chanmode = CHAN_MODE_SHARED;
1289 			return;
1290 		}
1291 		break;
1292 	case NL80211_IFTYPE_AP:
1293 	case NL80211_IFTYPE_P2P_GO:
1294 		if (wdev->cac_started) {
1295 			*chan = wdev->chandef.chan;
1296 			*chanmode = CHAN_MODE_SHARED;
1297 			*radar_detect |= BIT(wdev->chandef.width);
1298 		} else if (wdev->beacon_interval) {
1299 			*chan = wdev->chandef.chan;
1300 			*chanmode = CHAN_MODE_SHARED;
1301 
1302 			ret = cfg80211_chandef_dfs_required(wdev->wiphy,
1303 							    &wdev->chandef,
1304 							    wdev->iftype);
1305 			WARN_ON(ret < 0);
1306 			if (ret > 0)
1307 				*radar_detect |= BIT(wdev->chandef.width);
1308 		}
1309 		return;
1310 	case NL80211_IFTYPE_MESH_POINT:
1311 		if (wdev->mesh_id_len) {
1312 			*chan = wdev->chandef.chan;
1313 			*chanmode = CHAN_MODE_SHARED;
1314 
1315 			ret = cfg80211_chandef_dfs_required(wdev->wiphy,
1316 							    &wdev->chandef,
1317 							    wdev->iftype);
1318 			WARN_ON(ret < 0);
1319 			if (ret > 0)
1320 				*radar_detect |= BIT(wdev->chandef.width);
1321 		}
1322 		return;
1323 	case NL80211_IFTYPE_OCB:
1324 		if (wdev->chandef.chan) {
1325 			*chan = wdev->chandef.chan;
1326 			*chanmode = CHAN_MODE_SHARED;
1327 			return;
1328 		}
1329 		break;
1330 	case NL80211_IFTYPE_MONITOR:
1331 	case NL80211_IFTYPE_AP_VLAN:
1332 	case NL80211_IFTYPE_P2P_DEVICE:
1333 	case NL80211_IFTYPE_NAN:
1334 		/* these interface types don't really have a channel */
1335 		return;
1336 	case NL80211_IFTYPE_UNSPECIFIED:
1337 	case NL80211_IFTYPE_WDS:
1338 	case NUM_NL80211_IFTYPES:
1339 		WARN_ON(1);
1340 	}
1341 }
1342 
1343 bool cfg80211_any_usable_channels(struct wiphy *wiphy,
1344 				  unsigned long sband_mask,
1345 				  u32 prohibited_flags)
1346 {
1347 	int idx;
1348 
1349 	prohibited_flags |= IEEE80211_CHAN_DISABLED;
1350 
1351 	for_each_set_bit(idx, &sband_mask, NUM_NL80211_BANDS) {
1352 		struct ieee80211_supported_band *sband = wiphy->bands[idx];
1353 		int chanidx;
1354 
1355 		if (!sband)
1356 			continue;
1357 
1358 		for (chanidx = 0; chanidx < sband->n_channels; chanidx++) {
1359 			struct ieee80211_channel *chan;
1360 
1361 			chan = &sband->channels[chanidx];
1362 
1363 			if (chan->flags & prohibited_flags)
1364 				continue;
1365 
1366 			return true;
1367 		}
1368 	}
1369 
1370 	return false;
1371 }
1372 EXPORT_SYMBOL(cfg80211_any_usable_channels);
1373