xref: /openbmc/linux/net/wireless/chan.c (revision e2ad626f) 
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-2022	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 			  bool primary_only)
677 {
678 	int width;
679 	u32 freq;
680 
681 	if (!chandef->chan)
682 		return false;
683 
684 	if (chandef->chan->center_freq == chan->center_freq)
685 		return true;
686 
687 	if (primary_only)
688 		return false;
689 
690 	width = cfg80211_chandef_get_width(chandef);
691 	if (width <= 20)
692 		return false;
693 
694 	for (freq = chandef->center_freq1 - width / 2 + 10;
695 	     freq <= chandef->center_freq1 + width / 2 - 10; freq += 20) {
696 		if (chan->center_freq == freq)
697 			return true;
698 	}
699 
700 	if (!chandef->center_freq2)
701 		return false;
702 
703 	for (freq = chandef->center_freq2 - width / 2 + 10;
704 	     freq <= chandef->center_freq2 + width / 2 - 10; freq += 20) {
705 		if (chan->center_freq == freq)
706 			return true;
707 	}
708 
709 	return false;
710 }
711 
712 bool cfg80211_beaconing_iface_active(struct wireless_dev *wdev)
713 {
714 	unsigned int link;
715 
716 	ASSERT_WDEV_LOCK(wdev);
717 
718 	switch (wdev->iftype) {
719 	case NL80211_IFTYPE_AP:
720 	case NL80211_IFTYPE_P2P_GO:
721 		for_each_valid_link(wdev, link) {
722 			if (wdev->links[link].ap.beacon_interval)
723 				return true;
724 		}
725 		break;
726 	case NL80211_IFTYPE_ADHOC:
727 		if (wdev->u.ibss.ssid_len)
728 			return true;
729 		break;
730 	case NL80211_IFTYPE_MESH_POINT:
731 		if (wdev->u.mesh.id_len)
732 			return true;
733 		break;
734 	case NL80211_IFTYPE_STATION:
735 	case NL80211_IFTYPE_OCB:
736 	case NL80211_IFTYPE_P2P_CLIENT:
737 	case NL80211_IFTYPE_MONITOR:
738 	case NL80211_IFTYPE_AP_VLAN:
739 	case NL80211_IFTYPE_P2P_DEVICE:
740 	/* Can NAN type be considered as beaconing interface? */
741 	case NL80211_IFTYPE_NAN:
742 		break;
743 	case NL80211_IFTYPE_UNSPECIFIED:
744 	case NL80211_IFTYPE_WDS:
745 	case NUM_NL80211_IFTYPES:
746 		WARN_ON(1);
747 	}
748 
749 	return false;
750 }
751 
752 bool cfg80211_wdev_on_sub_chan(struct wireless_dev *wdev,
753 			       struct ieee80211_channel *chan,
754 			       bool primary_only)
755 {
756 	unsigned int link;
757 
758 	switch (wdev->iftype) {
759 	case NL80211_IFTYPE_AP:
760 	case NL80211_IFTYPE_P2P_GO:
761 		for_each_valid_link(wdev, link) {
762 			if (cfg80211_is_sub_chan(&wdev->links[link].ap.chandef,
763 						 chan, primary_only))
764 				return true;
765 		}
766 		break;
767 	case NL80211_IFTYPE_ADHOC:
768 		return cfg80211_is_sub_chan(&wdev->u.ibss.chandef, chan,
769 					    primary_only);
770 	case NL80211_IFTYPE_MESH_POINT:
771 		return cfg80211_is_sub_chan(&wdev->u.mesh.chandef, chan,
772 					    primary_only);
773 	default:
774 		break;
775 	}
776 
777 	return false;
778 }
779 
780 static bool cfg80211_is_wiphy_oper_chan(struct wiphy *wiphy,
781 					struct ieee80211_channel *chan)
782 {
783 	struct wireless_dev *wdev;
784 
785 	list_for_each_entry(wdev, &wiphy->wdev_list, list) {
786 		wdev_lock(wdev);
787 		if (!cfg80211_beaconing_iface_active(wdev)) {
788 			wdev_unlock(wdev);
789 			continue;
790 		}
791 
792 		if (cfg80211_wdev_on_sub_chan(wdev, chan, false)) {
793 			wdev_unlock(wdev);
794 			return true;
795 		}
796 		wdev_unlock(wdev);
797 	}
798 
799 	return false;
800 }
801 
802 static bool
803 cfg80211_offchan_chain_is_active(struct cfg80211_registered_device *rdev,
804 				 struct ieee80211_channel *channel)
805 {
806 	if (!rdev->background_radar_wdev)
807 		return false;
808 
809 	if (!cfg80211_chandef_valid(&rdev->background_radar_chandef))
810 		return false;
811 
812 	return cfg80211_is_sub_chan(&rdev->background_radar_chandef, channel,
813 				    false);
814 }
815 
816 bool cfg80211_any_wiphy_oper_chan(struct wiphy *wiphy,
817 				  struct ieee80211_channel *chan)
818 {
819 	struct cfg80211_registered_device *rdev;
820 
821 	ASSERT_RTNL();
822 
823 	if (!(chan->flags & IEEE80211_CHAN_RADAR))
824 		return false;
825 
826 	list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
827 		if (!reg_dfs_domain_same(wiphy, &rdev->wiphy))
828 			continue;
829 
830 		if (cfg80211_is_wiphy_oper_chan(&rdev->wiphy, chan))
831 			return true;
832 
833 		if (cfg80211_offchan_chain_is_active(rdev, chan))
834 			return true;
835 	}
836 
837 	return false;
838 }
839 
840 static bool cfg80211_get_chans_dfs_available(struct wiphy *wiphy,
841 					     u32 center_freq,
842 					     u32 bandwidth)
843 {
844 	struct ieee80211_channel *c;
845 	u32 freq, start_freq, end_freq;
846 	bool dfs_offload;
847 
848 	dfs_offload = wiphy_ext_feature_isset(wiphy,
849 					      NL80211_EXT_FEATURE_DFS_OFFLOAD);
850 
851 	start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
852 	end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
853 
854 	/*
855 	 * Check entire range of channels for the bandwidth.
856 	 * If any channel in between is disabled or has not
857 	 * had gone through CAC return false
858 	 */
859 	for (freq = start_freq; freq <= end_freq; freq += MHZ_TO_KHZ(20)) {
860 		c = ieee80211_get_channel_khz(wiphy, freq);
861 		if (!c)
862 			return false;
863 
864 		if (c->flags & IEEE80211_CHAN_DISABLED)
865 			return false;
866 
867 		if ((c->flags & IEEE80211_CHAN_RADAR) &&
868 		    (c->dfs_state != NL80211_DFS_AVAILABLE) &&
869 		    !(c->dfs_state == NL80211_DFS_USABLE && dfs_offload))
870 			return false;
871 	}
872 
873 	return true;
874 }
875 
876 static bool cfg80211_chandef_dfs_available(struct wiphy *wiphy,
877 				const struct cfg80211_chan_def *chandef)
878 {
879 	int width;
880 	int r;
881 
882 	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
883 		return false;
884 
885 	width = cfg80211_chandef_get_width(chandef);
886 	if (width < 0)
887 		return false;
888 
889 	r = cfg80211_get_chans_dfs_available(wiphy,
890 					     MHZ_TO_KHZ(chandef->center_freq1),
891 					     width);
892 
893 	/* If any of channels unavailable for cf1 just return */
894 	if (!r)
895 		return r;
896 
897 	switch (chandef->width) {
898 	case NL80211_CHAN_WIDTH_80P80:
899 		WARN_ON(!chandef->center_freq2);
900 		r = cfg80211_get_chans_dfs_available(wiphy,
901 					MHZ_TO_KHZ(chandef->center_freq2),
902 					width);
903 		break;
904 	default:
905 		WARN_ON(chandef->center_freq2);
906 		break;
907 	}
908 
909 	return r;
910 }
911 
912 static unsigned int cfg80211_get_chans_dfs_cac_time(struct wiphy *wiphy,
913 						    u32 center_freq,
914 						    u32 bandwidth)
915 {
916 	struct ieee80211_channel *c;
917 	u32 start_freq, end_freq, freq;
918 	unsigned int dfs_cac_ms = 0;
919 
920 	start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
921 	end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
922 
923 	for (freq = start_freq; freq <= end_freq; freq += MHZ_TO_KHZ(20)) {
924 		c = ieee80211_get_channel_khz(wiphy, freq);
925 		if (!c)
926 			return 0;
927 
928 		if (c->flags & IEEE80211_CHAN_DISABLED)
929 			return 0;
930 
931 		if (!(c->flags & IEEE80211_CHAN_RADAR))
932 			continue;
933 
934 		if (c->dfs_cac_ms > dfs_cac_ms)
935 			dfs_cac_ms = c->dfs_cac_ms;
936 	}
937 
938 	return dfs_cac_ms;
939 }
940 
941 unsigned int
942 cfg80211_chandef_dfs_cac_time(struct wiphy *wiphy,
943 			      const struct cfg80211_chan_def *chandef)
944 {
945 	int width;
946 	unsigned int t1 = 0, t2 = 0;
947 
948 	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
949 		return 0;
950 
951 	width = cfg80211_chandef_get_width(chandef);
952 	if (width < 0)
953 		return 0;
954 
955 	t1 = cfg80211_get_chans_dfs_cac_time(wiphy,
956 					     MHZ_TO_KHZ(chandef->center_freq1),
957 					     width);
958 
959 	if (!chandef->center_freq2)
960 		return t1;
961 
962 	t2 = cfg80211_get_chans_dfs_cac_time(wiphy,
963 					     MHZ_TO_KHZ(chandef->center_freq2),
964 					     width);
965 
966 	return max(t1, t2);
967 }
968 
969 static bool cfg80211_secondary_chans_ok(struct wiphy *wiphy,
970 					u32 center_freq, u32 bandwidth,
971 					u32 prohibited_flags)
972 {
973 	struct ieee80211_channel *c;
974 	u32 freq, start_freq, end_freq;
975 
976 	start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
977 	end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
978 
979 	for (freq = start_freq; freq <= end_freq; freq += MHZ_TO_KHZ(20)) {
980 		c = ieee80211_get_channel_khz(wiphy, freq);
981 		if (!c || c->flags & prohibited_flags)
982 			return false;
983 	}
984 
985 	return true;
986 }
987 
988 /* check if the operating channels are valid and supported */
989 static bool cfg80211_edmg_usable(struct wiphy *wiphy, u8 edmg_channels,
990 				 enum ieee80211_edmg_bw_config edmg_bw_config,
991 				 int primary_channel,
992 				 struct ieee80211_edmg *edmg_cap)
993 {
994 	struct ieee80211_channel *chan;
995 	int i, freq;
996 	int channels_counter = 0;
997 
998 	if (!edmg_channels && !edmg_bw_config)
999 		return true;
1000 
1001 	if ((!edmg_channels && edmg_bw_config) ||
1002 	    (edmg_channels && !edmg_bw_config))
1003 		return false;
1004 
1005 	if (!(edmg_channels & BIT(primary_channel - 1)))
1006 		return false;
1007 
1008 	/* 60GHz channels 1..6 */
1009 	for (i = 0; i < 6; i++) {
1010 		if (!(edmg_channels & BIT(i)))
1011 			continue;
1012 
1013 		if (!(edmg_cap->channels & BIT(i)))
1014 			return false;
1015 
1016 		channels_counter++;
1017 
1018 		freq = ieee80211_channel_to_frequency(i + 1,
1019 						      NL80211_BAND_60GHZ);
1020 		chan = ieee80211_get_channel(wiphy, freq);
1021 		if (!chan || chan->flags & IEEE80211_CHAN_DISABLED)
1022 			return false;
1023 	}
1024 
1025 	/* IEEE802.11 allows max 4 channels */
1026 	if (channels_counter > 4)
1027 		return false;
1028 
1029 	/* check bw_config is a subset of what driver supports
1030 	 * (see IEEE P802.11ay/D4.0 section 9.4.2.251, Table 13)
1031 	 */
1032 	if ((edmg_bw_config % 4) > (edmg_cap->bw_config % 4))
1033 		return false;
1034 
1035 	if (edmg_bw_config > edmg_cap->bw_config)
1036 		return false;
1037 
1038 	return true;
1039 }
1040 
1041 bool cfg80211_chandef_usable(struct wiphy *wiphy,
1042 			     const struct cfg80211_chan_def *chandef,
1043 			     u32 prohibited_flags)
1044 {
1045 	struct ieee80211_sta_ht_cap *ht_cap;
1046 	struct ieee80211_sta_vht_cap *vht_cap;
1047 	struct ieee80211_edmg *edmg_cap;
1048 	u32 width, control_freq, cap;
1049 	bool ext_nss_cap, support_80_80 = false, support_320 = false;
1050 	const struct ieee80211_sband_iftype_data *iftd;
1051 	struct ieee80211_supported_band *sband;
1052 	int i;
1053 
1054 	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
1055 		return false;
1056 
1057 	ht_cap = &wiphy->bands[chandef->chan->band]->ht_cap;
1058 	vht_cap = &wiphy->bands[chandef->chan->band]->vht_cap;
1059 	edmg_cap = &wiphy->bands[chandef->chan->band]->edmg_cap;
1060 	ext_nss_cap = __le16_to_cpu(vht_cap->vht_mcs.tx_highest) &
1061 			IEEE80211_VHT_EXT_NSS_BW_CAPABLE;
1062 
1063 	if (edmg_cap->channels &&
1064 	    !cfg80211_edmg_usable(wiphy,
1065 				  chandef->edmg.channels,
1066 				  chandef->edmg.bw_config,
1067 				  chandef->chan->hw_value,
1068 				  edmg_cap))
1069 		return false;
1070 
1071 	control_freq = chandef->chan->center_freq;
1072 
1073 	switch (chandef->width) {
1074 	case NL80211_CHAN_WIDTH_1:
1075 		width = 1;
1076 		break;
1077 	case NL80211_CHAN_WIDTH_2:
1078 		width = 2;
1079 		break;
1080 	case NL80211_CHAN_WIDTH_4:
1081 		width = 4;
1082 		break;
1083 	case NL80211_CHAN_WIDTH_8:
1084 		width = 8;
1085 		break;
1086 	case NL80211_CHAN_WIDTH_16:
1087 		width = 16;
1088 		break;
1089 	case NL80211_CHAN_WIDTH_5:
1090 		width = 5;
1091 		break;
1092 	case NL80211_CHAN_WIDTH_10:
1093 		prohibited_flags |= IEEE80211_CHAN_NO_10MHZ;
1094 		width = 10;
1095 		break;
1096 	case NL80211_CHAN_WIDTH_20:
1097 		if (!ht_cap->ht_supported &&
1098 		    chandef->chan->band != NL80211_BAND_6GHZ)
1099 			return false;
1100 		fallthrough;
1101 	case NL80211_CHAN_WIDTH_20_NOHT:
1102 		prohibited_flags |= IEEE80211_CHAN_NO_20MHZ;
1103 		width = 20;
1104 		break;
1105 	case NL80211_CHAN_WIDTH_40:
1106 		width = 40;
1107 		if (chandef->chan->band == NL80211_BAND_6GHZ)
1108 			break;
1109 		if (!ht_cap->ht_supported)
1110 			return false;
1111 		if (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) ||
1112 		    ht_cap->cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT)
1113 			return false;
1114 		if (chandef->center_freq1 < control_freq &&
1115 		    chandef->chan->flags & IEEE80211_CHAN_NO_HT40MINUS)
1116 			return false;
1117 		if (chandef->center_freq1 > control_freq &&
1118 		    chandef->chan->flags & IEEE80211_CHAN_NO_HT40PLUS)
1119 			return false;
1120 		break;
1121 	case NL80211_CHAN_WIDTH_80P80:
1122 		cap = vht_cap->cap;
1123 		support_80_80 =
1124 			(cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ) ||
1125 			(cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ &&
1126 			 cap & IEEE80211_VHT_CAP_EXT_NSS_BW_MASK) ||
1127 			(ext_nss_cap &&
1128 			 u32_get_bits(cap, IEEE80211_VHT_CAP_EXT_NSS_BW_MASK) > 1);
1129 		if (chandef->chan->band != NL80211_BAND_6GHZ && !support_80_80)
1130 			return false;
1131 		fallthrough;
1132 	case NL80211_CHAN_WIDTH_80:
1133 		prohibited_flags |= IEEE80211_CHAN_NO_80MHZ;
1134 		width = 80;
1135 		if (chandef->chan->band == NL80211_BAND_6GHZ)
1136 			break;
1137 		if (!vht_cap->vht_supported)
1138 			return false;
1139 		break;
1140 	case NL80211_CHAN_WIDTH_160:
1141 		prohibited_flags |= IEEE80211_CHAN_NO_160MHZ;
1142 		width = 160;
1143 		if (chandef->chan->band == NL80211_BAND_6GHZ)
1144 			break;
1145 		if (!vht_cap->vht_supported)
1146 			return false;
1147 		cap = vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK;
1148 		if (cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ &&
1149 		    cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ &&
1150 		    !(ext_nss_cap &&
1151 		      (vht_cap->cap & IEEE80211_VHT_CAP_EXT_NSS_BW_MASK)))
1152 			return false;
1153 		break;
1154 	case NL80211_CHAN_WIDTH_320:
1155 		prohibited_flags |= IEEE80211_CHAN_NO_320MHZ;
1156 		width = 320;
1157 
1158 		if (chandef->chan->band != NL80211_BAND_6GHZ)
1159 			return false;
1160 
1161 		sband = wiphy->bands[NL80211_BAND_6GHZ];
1162 		if (!sband)
1163 			return false;
1164 
1165 		for (i = 0; i < sband->n_iftype_data; i++) {
1166 			iftd = &sband->iftype_data[i];
1167 			if (!iftd->eht_cap.has_eht)
1168 				continue;
1169 
1170 			if (iftd->eht_cap.eht_cap_elem.phy_cap_info[0] &
1171 			    IEEE80211_EHT_PHY_CAP0_320MHZ_IN_6GHZ) {
1172 				support_320 = true;
1173 				break;
1174 			}
1175 		}
1176 
1177 		if (!support_320)
1178 			return false;
1179 		break;
1180 	default:
1181 		WARN_ON_ONCE(1);
1182 		return false;
1183 	}
1184 
1185 	/*
1186 	 * TODO: What if there are only certain 80/160/80+80 MHz channels
1187 	 *	 allowed by the driver, or only certain combinations?
1188 	 *	 For 40 MHz the driver can set the NO_HT40 flags, but for
1189 	 *	 80/160 MHz and in particular 80+80 MHz this isn't really
1190 	 *	 feasible and we only have NO_80MHZ/NO_160MHZ so far but
1191 	 *	 no way to cover 80+80 MHz or more complex restrictions.
1192 	 *	 Note that such restrictions also need to be advertised to
1193 	 *	 userspace, for example for P2P channel selection.
1194 	 */
1195 
1196 	if (width > 20)
1197 		prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
1198 
1199 	/* 5 and 10 MHz are only defined for the OFDM PHY */
1200 	if (width < 20)
1201 		prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
1202 
1203 
1204 	if (!cfg80211_secondary_chans_ok(wiphy,
1205 					 ieee80211_chandef_to_khz(chandef),
1206 					 width, prohibited_flags))
1207 		return false;
1208 
1209 	if (!chandef->center_freq2)
1210 		return true;
1211 	return cfg80211_secondary_chans_ok(wiphy,
1212 					   MHZ_TO_KHZ(chandef->center_freq2),
1213 					   width, prohibited_flags);
1214 }
1215 EXPORT_SYMBOL(cfg80211_chandef_usable);
1216 
1217 static bool cfg80211_ir_permissive_check_wdev(enum nl80211_iftype iftype,
1218 					      struct wireless_dev *wdev,
1219 					      struct ieee80211_channel *chan)
1220 {
1221 	struct ieee80211_channel *other_chan = NULL;
1222 	unsigned int link_id;
1223 	int r1, r2;
1224 
1225 	for_each_valid_link(wdev, link_id) {
1226 		if (wdev->iftype == NL80211_IFTYPE_STATION &&
1227 		    wdev->links[link_id].client.current_bss)
1228 			other_chan = wdev->links[link_id].client.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->links[link_id].ap.beacon_interval &&
1240 		    !(chan->flags & IEEE80211_CHAN_INDOOR_ONLY))
1241 			other_chan = wdev->links[link_id].ap.chandef.chan;
1242 
1243 		if (!other_chan)
1244 			continue;
1245 
1246 		if (chan == other_chan)
1247 			return true;
1248 
1249 		if (chan->band != NL80211_BAND_5GHZ &&
1250 		    chan->band != NL80211_BAND_6GHZ)
1251 			continue;
1252 
1253 		r1 = cfg80211_get_unii(chan->center_freq);
1254 		r2 = cfg80211_get_unii(other_chan->center_freq);
1255 
1256 		if (r1 != -EINVAL && r1 == r2) {
1257 			/*
1258 			 * At some locations channels 149-165 are considered a
1259 			 * bundle, but at other locations, e.g., Indonesia,
1260 			 * channels 149-161 are considered a bundle while
1261 			 * channel 165 is left out and considered to be in a
1262 			 * different bundle. Thus, in case that there is a
1263 			 * station interface connected to an AP on channel 165,
1264 			 * it is assumed that channels 149-161 are allowed for
1265 			 * GO operations. However, having a station interface
1266 			 * connected to an AP on channels 149-161, does not
1267 			 * allow GO operation on channel 165.
1268 			 */
1269 			if (chan->center_freq == 5825 &&
1270 			    other_chan->center_freq != 5825)
1271 				continue;
1272 			return true;
1273 		}
1274 	}
1275 
1276 	return false;
1277 }
1278 
1279 /*
1280  * Check if the channel can be used under permissive conditions mandated by
1281  * some regulatory bodies, i.e., the channel is marked with
1282  * IEEE80211_CHAN_IR_CONCURRENT and there is an additional station interface
1283  * associated to an AP on the same channel or on the same UNII band
1284  * (assuming that the AP is an authorized master).
1285  * In addition allow operation on a channel on which indoor operation is
1286  * allowed, iff we are currently operating in an indoor environment.
1287  */
1288 static bool cfg80211_ir_permissive_chan(struct wiphy *wiphy,
1289 					enum nl80211_iftype iftype,
1290 					struct ieee80211_channel *chan)
1291 {
1292 	struct wireless_dev *wdev;
1293 	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1294 
1295 	lockdep_assert_held(&rdev->wiphy.mtx);
1296 
1297 	if (!IS_ENABLED(CONFIG_CFG80211_REG_RELAX_NO_IR) ||
1298 	    !(wiphy->regulatory_flags & REGULATORY_ENABLE_RELAX_NO_IR))
1299 		return false;
1300 
1301 	/* only valid for GO and TDLS off-channel (station/p2p-CL) */
1302 	if (iftype != NL80211_IFTYPE_P2P_GO &&
1303 	    iftype != NL80211_IFTYPE_STATION &&
1304 	    iftype != NL80211_IFTYPE_P2P_CLIENT)
1305 		return false;
1306 
1307 	if (regulatory_indoor_allowed() &&
1308 	    (chan->flags & IEEE80211_CHAN_INDOOR_ONLY))
1309 		return true;
1310 
1311 	if (!(chan->flags & IEEE80211_CHAN_IR_CONCURRENT))
1312 		return false;
1313 
1314 	/*
1315 	 * Generally, it is possible to rely on another device/driver to allow
1316 	 * the IR concurrent relaxation, however, since the device can further
1317 	 * enforce the relaxation (by doing a similar verifications as this),
1318 	 * and thus fail the GO instantiation, consider only the interfaces of
1319 	 * the current registered device.
1320 	 */
1321 	list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
1322 		bool ret;
1323 
1324 		wdev_lock(wdev);
1325 		ret = cfg80211_ir_permissive_check_wdev(iftype, wdev, chan);
1326 		wdev_unlock(wdev);
1327 
1328 		if (ret)
1329 			return ret;
1330 	}
1331 
1332 	return false;
1333 }
1334 
1335 static bool _cfg80211_reg_can_beacon(struct wiphy *wiphy,
1336 				     struct cfg80211_chan_def *chandef,
1337 				     enum nl80211_iftype iftype,
1338 				     bool check_no_ir)
1339 {
1340 	bool res;
1341 	u32 prohibited_flags = IEEE80211_CHAN_DISABLED |
1342 			       IEEE80211_CHAN_RADAR;
1343 
1344 	trace_cfg80211_reg_can_beacon(wiphy, chandef, iftype, check_no_ir);
1345 
1346 	if (check_no_ir)
1347 		prohibited_flags |= IEEE80211_CHAN_NO_IR;
1348 
1349 	if (cfg80211_chandef_dfs_required(wiphy, chandef, iftype) > 0 &&
1350 	    cfg80211_chandef_dfs_available(wiphy, chandef)) {
1351 		/* We can skip IEEE80211_CHAN_NO_IR if chandef dfs available */
1352 		prohibited_flags = IEEE80211_CHAN_DISABLED;
1353 	}
1354 
1355 	res = cfg80211_chandef_usable(wiphy, chandef, prohibited_flags);
1356 
1357 	trace_cfg80211_return_bool(res);
1358 	return res;
1359 }
1360 
1361 bool cfg80211_reg_can_beacon(struct wiphy *wiphy,
1362 			     struct cfg80211_chan_def *chandef,
1363 			     enum nl80211_iftype iftype)
1364 {
1365 	return _cfg80211_reg_can_beacon(wiphy, chandef, iftype, true);
1366 }
1367 EXPORT_SYMBOL(cfg80211_reg_can_beacon);
1368 
1369 bool cfg80211_reg_can_beacon_relax(struct wiphy *wiphy,
1370 				   struct cfg80211_chan_def *chandef,
1371 				   enum nl80211_iftype iftype)
1372 {
1373 	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1374 	bool check_no_ir;
1375 
1376 	lockdep_assert_held(&rdev->wiphy.mtx);
1377 
1378 	/*
1379 	 * Under certain conditions suggested by some regulatory bodies a
1380 	 * GO/STA can IR on channels marked with IEEE80211_NO_IR. Set this flag
1381 	 * only if such relaxations are not enabled and the conditions are not
1382 	 * met.
1383 	 */
1384 	check_no_ir = !cfg80211_ir_permissive_chan(wiphy, iftype,
1385 						   chandef->chan);
1386 
1387 	return _cfg80211_reg_can_beacon(wiphy, chandef, iftype, check_no_ir);
1388 }
1389 EXPORT_SYMBOL(cfg80211_reg_can_beacon_relax);
1390 
1391 int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev,
1392 				 struct cfg80211_chan_def *chandef)
1393 {
1394 	if (!rdev->ops->set_monitor_channel)
1395 		return -EOPNOTSUPP;
1396 	if (!cfg80211_has_monitors_only(rdev))
1397 		return -EBUSY;
1398 
1399 	return rdev_set_monitor_channel(rdev, chandef);
1400 }
1401 
1402 bool cfg80211_any_usable_channels(struct wiphy *wiphy,
1403 				  unsigned long sband_mask,
1404 				  u32 prohibited_flags)
1405 {
1406 	int idx;
1407 
1408 	prohibited_flags |= IEEE80211_CHAN_DISABLED;
1409 
1410 	for_each_set_bit(idx, &sband_mask, NUM_NL80211_BANDS) {
1411 		struct ieee80211_supported_band *sband = wiphy->bands[idx];
1412 		int chanidx;
1413 
1414 		if (!sband)
1415 			continue;
1416 
1417 		for (chanidx = 0; chanidx < sband->n_channels; chanidx++) {
1418 			struct ieee80211_channel *chan;
1419 
1420 			chan = &sband->channels[chanidx];
1421 
1422 			if (chan->flags & prohibited_flags)
1423 				continue;
1424 
1425 			return true;
1426 		}
1427 	}
1428 
1429 	return false;
1430 }
1431 EXPORT_SYMBOL(cfg80211_any_usable_channels);
1432 
1433 struct cfg80211_chan_def *wdev_chandef(struct wireless_dev *wdev,
1434 				       unsigned int link_id)
1435 {
1436 	/*
1437 	 * We need to sort out the locking here - in some cases
1438 	 * where we get here we really just don't care (yet)
1439 	 * about the valid links, but in others we do. But we
1440 	 * get here with various driver cases, so we cannot
1441 	 * easily require the wdev mutex.
1442 	 */
1443 	if (link_id || wdev->valid_links & BIT(0)) {
1444 		ASSERT_WDEV_LOCK(wdev);
1445 		WARN_ON(!(wdev->valid_links & BIT(link_id)));
1446 	}
1447 
1448 	switch (wdev->iftype) {
1449 	case NL80211_IFTYPE_MESH_POINT:
1450 		return &wdev->u.mesh.chandef;
1451 	case NL80211_IFTYPE_ADHOC:
1452 		return &wdev->u.ibss.chandef;
1453 	case NL80211_IFTYPE_OCB:
1454 		return &wdev->u.ocb.chandef;
1455 	case NL80211_IFTYPE_AP:
1456 	case NL80211_IFTYPE_P2P_GO:
1457 		return &wdev->links[link_id].ap.chandef;
1458 	default:
1459 		return NULL;
1460 	}
1461 }
1462 EXPORT_SYMBOL(wdev_chandef);
1463 
1464 struct cfg80211_per_bw_puncturing_values {
1465 	u8 len;
1466 	const u16 *valid_values;
1467 };
1468 
1469 static const u16 puncturing_values_80mhz[] = {
1470 	0x8, 0x4, 0x2, 0x1
1471 };
1472 
1473 static const u16 puncturing_values_160mhz[] = {
1474 	 0x80, 0x40, 0x20, 0x10, 0x8, 0x4, 0x2, 0x1, 0xc0, 0x30, 0xc, 0x3
1475 };
1476 
1477 static const u16 puncturing_values_320mhz[] = {
1478 	0xc000, 0x3000, 0xc00, 0x300, 0xc0, 0x30, 0xc, 0x3, 0xf000, 0xf00,
1479 	0xf0, 0xf, 0xfc00, 0xf300, 0xf0c0, 0xf030, 0xf00c, 0xf003, 0xc00f,
1480 	0x300f, 0xc0f, 0x30f, 0xcf, 0x3f
1481 };
1482 
1483 #define CFG80211_PER_BW_VALID_PUNCTURING_VALUES(_bw) \
1484 	{ \
1485 		.len = ARRAY_SIZE(puncturing_values_ ## _bw ## mhz), \
1486 		.valid_values = puncturing_values_ ## _bw ## mhz \
1487 	}
1488 
1489 static const struct cfg80211_per_bw_puncturing_values per_bw_puncturing[] = {
1490 	CFG80211_PER_BW_VALID_PUNCTURING_VALUES(80),
1491 	CFG80211_PER_BW_VALID_PUNCTURING_VALUES(160),
1492 	CFG80211_PER_BW_VALID_PUNCTURING_VALUES(320)
1493 };
1494 
1495 bool cfg80211_valid_disable_subchannel_bitmap(u16 *bitmap,
1496 					      const struct cfg80211_chan_def *chandef)
1497 {
1498 	u32 idx, i, start_freq;
1499 
1500 	switch (chandef->width) {
1501 	case NL80211_CHAN_WIDTH_80:
1502 		idx = 0;
1503 		start_freq = chandef->center_freq1 - 40;
1504 		break;
1505 	case NL80211_CHAN_WIDTH_160:
1506 		idx = 1;
1507 		start_freq = chandef->center_freq1 - 80;
1508 		break;
1509 	case NL80211_CHAN_WIDTH_320:
1510 		idx = 2;
1511 		start_freq = chandef->center_freq1 - 160;
1512 		break;
1513 	default:
1514 		*bitmap = 0;
1515 		break;
1516 	}
1517 
1518 	if (!*bitmap)
1519 		return true;
1520 
1521 	/* check if primary channel is punctured */
1522 	if (*bitmap & (u16)BIT((chandef->chan->center_freq - start_freq) / 20))
1523 		return false;
1524 
1525 	for (i = 0; i < per_bw_puncturing[idx].len; i++)
1526 		if (per_bw_puncturing[idx].valid_values[i] == *bitmap)
1527 			return true;
1528 
1529 	return false;
1530 }
1531 EXPORT_SYMBOL(cfg80211_valid_disable_subchannel_bitmap);
1532