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