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