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-2024 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 = (struct cfg80211_chan_def) {
31	.chan = chan,
32	.freq1_offset = chan->freq_offset,
33	};
34
35	switch (chan_type) {
36	case NL80211_CHAN_NO_HT:
37	chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
38	chandef->center_freq1 = chan->center_freq;
39	break;
40	case NL80211_CHAN_HT20:
41	chandef->width = NL80211_CHAN_WIDTH_20;
42	chandef->center_freq1 = chan->center_freq;
43	break;
44	case NL80211_CHAN_HT40PLUS:
45	chandef->width = NL80211_CHAN_WIDTH_40;
46	chandef->center_freq1 = chan->center_freq + 10;
47	break;
48	case NL80211_CHAN_HT40MINUS:
49	chandef->width = NL80211_CHAN_WIDTH_40;
50	chandef->center_freq1 = chan->center_freq - 10;
51	break;
52	default:
53	WARN_ON(1);
54	}
55	}
56	EXPORT_SYMBOL(cfg80211_chandef_create);
57
58	struct cfg80211_per_bw_puncturing_values {
59	u8 len;
60	const u16 *valid_values;
61	};
62
63	static const u16 puncturing_values_80mhz[] = {
64	0x8, 0x4, 0x2, 0x1
65	};
66
67	static const u16 puncturing_values_160mhz[] = {
68	0x80, 0x40, 0x20, 0x10, 0x8, 0x4, 0x2, 0x1, 0xc0, 0x30, 0xc, 0x3
69	};
70
71	static const u16 puncturing_values_320mhz[] = {
72	0xc000, 0x3000, 0xc00, 0x300, 0xc0, 0x30, 0xc, 0x3, 0xf000, 0xf00,
73	0xf0, 0xf, 0xfc00, 0xf300, 0xf0c0, 0xf030, 0xf00c, 0xf003, 0xc00f,
74	0x300f, 0xc0f, 0x30f, 0xcf, 0x3f
75	};
76
77	#define CFG80211_PER_BW_VALID_PUNCTURING_VALUES(_bw) \
78	{ \
79	.len = ARRAY_SIZE(puncturing_values_ ## _bw ## mhz), \
80	.valid_values = puncturing_values_ ## _bw ## mhz \
81	}
82
83	static const struct cfg80211_per_bw_puncturing_values per_bw_puncturing[] = {
84	CFG80211_PER_BW_VALID_PUNCTURING_VALUES(80),
85	CFG80211_PER_BW_VALID_PUNCTURING_VALUES(160),
86	CFG80211_PER_BW_VALID_PUNCTURING_VALUES(320)
87	};
88
89	static bool valid_puncturing_bitmap(const struct cfg80211_chan_def *chandef)
90	{
91	u32 idx, i, start_freq, primary_center = chandef->chan->center_freq;
92
93	switch (chandef->width) {
94	case NL80211_CHAN_WIDTH_80:
95	idx = 0;
96	start_freq = chandef->center_freq1 - 40;
97	break;
98	case NL80211_CHAN_WIDTH_160:
99	idx = 1;
100	start_freq = chandef->center_freq1 - 80;
101	break;
102	case NL80211_CHAN_WIDTH_320:
103	idx = 2;
104	start_freq = chandef->center_freq1 - 160;
105	break;
106	default:
107	return chandef->punctured == 0;
108	}
109
110	if (!chandef->punctured)
111	return true;
112
113	/* check if primary channel is punctured */
114	if (chandef->punctured & (u16)BIT((primary_center - start_freq) / 20))
115	return false;
116
117	for (i = 0; i < per_bw_puncturing[idx].len; i++) {
118	if (per_bw_puncturing[idx].valid_values[i] == chandef->punctured)
119	return true;
120	}
121
122	return false;
123	}
124
125	static bool cfg80211_edmg_chandef_valid(const struct cfg80211_chan_def *chandef)
126	{
127	int max_contiguous = 0;
128	int num_of_enabled = 0;
129	int contiguous = 0;
130	int i;
131
132	if (!chandef->edmg.channels || !chandef->edmg.bw_config)
133	return false;
134
135	if (!cfg80211_valid_60g_freq(freq: chandef->chan->center_freq))
136	return false;
137
138	for (i = 0; i < 6; i++) {
139	if (chandef->edmg.channels & BIT(i)) {
140	contiguous++;
141	num_of_enabled++;
142	} else {
143	contiguous = 0;
144	}
145
146	max_contiguous = max(contiguous, max_contiguous);
147	}
148	/* basic verification of edmg configuration according to
149	* IEEE P802.11ay/D4.0 section 9.4.2.251
150	*/
151	/* check bw_config against contiguous edmg channels */
152	switch (chandef->edmg.bw_config) {
153	case IEEE80211_EDMG_BW_CONFIG_4:
154	case IEEE80211_EDMG_BW_CONFIG_8:
155	case IEEE80211_EDMG_BW_CONFIG_12:
156	if (max_contiguous < 1)
157	return false;
158	break;
159	case IEEE80211_EDMG_BW_CONFIG_5:
160	case IEEE80211_EDMG_BW_CONFIG_9:
161	case IEEE80211_EDMG_BW_CONFIG_13:
162	if (max_contiguous < 2)
163	return false;
164	break;
165	case IEEE80211_EDMG_BW_CONFIG_6:
166	case IEEE80211_EDMG_BW_CONFIG_10:
167	case IEEE80211_EDMG_BW_CONFIG_14:
168	if (max_contiguous < 3)
169	return false;
170	break;
171	case IEEE80211_EDMG_BW_CONFIG_7:
172	case IEEE80211_EDMG_BW_CONFIG_11:
173	case IEEE80211_EDMG_BW_CONFIG_15:
174	if (max_contiguous < 4)
175	return false;
176	break;
177
178	default:
179	return false;
180	}
181
182	/* check bw_config against aggregated (non contiguous) edmg channels */
183	switch (chandef->edmg.bw_config) {
184	case IEEE80211_EDMG_BW_CONFIG_4:
185	case IEEE80211_EDMG_BW_CONFIG_5:
186	case IEEE80211_EDMG_BW_CONFIG_6:
187	case IEEE80211_EDMG_BW_CONFIG_7:
188	break;
189	case IEEE80211_EDMG_BW_CONFIG_8:
190	case IEEE80211_EDMG_BW_CONFIG_9:
191	case IEEE80211_EDMG_BW_CONFIG_10:
192	case IEEE80211_EDMG_BW_CONFIG_11:
193	if (num_of_enabled < 2)
194	return false;
195	break;
196	case IEEE80211_EDMG_BW_CONFIG_12:
197	case IEEE80211_EDMG_BW_CONFIG_13:
198	case IEEE80211_EDMG_BW_CONFIG_14:
199	case IEEE80211_EDMG_BW_CONFIG_15:
200	if (num_of_enabled < 4 || max_contiguous < 2)
201	return false;
202	break;
203	default:
204	return false;
205	}
206
207	return true;
208	}
209
210	int nl80211_chan_width_to_mhz(enum nl80211_chan_width chan_width)
211	{
212	int mhz;
213
214	switch (chan_width) {
215	case NL80211_CHAN_WIDTH_1:
216	mhz = 1;
217	break;
218	case NL80211_CHAN_WIDTH_2:
219	mhz = 2;
220	break;
221	case NL80211_CHAN_WIDTH_4:
222	mhz = 4;
223	break;
224	case NL80211_CHAN_WIDTH_8:
225	mhz = 8;
226	break;
227	case NL80211_CHAN_WIDTH_16:
228	mhz = 16;
229	break;
230	case NL80211_CHAN_WIDTH_5:
231	mhz = 5;
232	break;
233	case NL80211_CHAN_WIDTH_10:
234	mhz = 10;
235	break;
236	case NL80211_CHAN_WIDTH_20:
237	case NL80211_CHAN_WIDTH_20_NOHT:
238	mhz = 20;
239	break;
240	case NL80211_CHAN_WIDTH_40:
241	mhz = 40;
242	break;
243	case NL80211_CHAN_WIDTH_80P80:
244	case NL80211_CHAN_WIDTH_80:
245	mhz = 80;
246	break;
247	case NL80211_CHAN_WIDTH_160:
248	mhz = 160;
249	break;
250	case NL80211_CHAN_WIDTH_320:
251	mhz = 320;
252	break;
253	default:
254	WARN_ON_ONCE(1);
255	return -1;
256	}
257	return mhz;
258	}
259	EXPORT_SYMBOL(nl80211_chan_width_to_mhz);
260
261	static int cfg80211_chandef_get_width(const struct cfg80211_chan_def *c)
262	{
263	return nl80211_chan_width_to_mhz(c->width);
264	}
265
266	bool cfg80211_chandef_valid(const struct cfg80211_chan_def *chandef)
267	{
268	u32 control_freq, oper_freq;
269	int oper_width, control_width;
270
271	if (!chandef->chan)
272	return false;
273
274	if (chandef->freq1_offset >= 1000)
275	return false;
276
277	control_freq = chandef->chan->center_freq;
278
279	switch (chandef->width) {
280	case NL80211_CHAN_WIDTH_5:
281	case NL80211_CHAN_WIDTH_10:
282	case NL80211_CHAN_WIDTH_20:
283	case NL80211_CHAN_WIDTH_20_NOHT:
284	if (ieee80211_chandef_to_khz(chandef) !=
285	ieee80211_channel_to_khz(chan: chandef->chan))
286	return false;
287	if (chandef->center_freq2)
288	return false;
289	break;
290	case NL80211_CHAN_WIDTH_1:
291	case NL80211_CHAN_WIDTH_2:
292	case NL80211_CHAN_WIDTH_4:
293	case NL80211_CHAN_WIDTH_8:
294	case NL80211_CHAN_WIDTH_16:
295	if (chandef->chan->band != NL80211_BAND_S1GHZ)
296	return false;
297
298	control_freq = ieee80211_channel_to_khz(chan: chandef->chan);
299	oper_freq = ieee80211_chandef_to_khz(chandef);
300	control_width = nl80211_chan_width_to_mhz(
301	ieee80211_s1g_channel_width(
302	chan: chandef->chan));
303	oper_width = cfg80211_chandef_get_width(c: chandef);
304
305	if (oper_width < 0 || control_width < 0)
306	return false;
307	if (chandef->center_freq2)
308	return false;
309
310	if (control_freq + MHZ_TO_KHZ(control_width) / 2 >
311	oper_freq + MHZ_TO_KHZ(oper_width) / 2)
312	return false;
313
314	if (control_freq - MHZ_TO_KHZ(control_width) / 2 <
315	oper_freq - MHZ_TO_KHZ(oper_width) / 2)
316	return false;
317	break;
318	case NL80211_CHAN_WIDTH_80P80:
319	if (!chandef->center_freq2)
320	return false;
321	/* adjacent is not allowed -- that's a 160 MHz channel */
322	if (chandef->center_freq1 - chandef->center_freq2 == 80 ||
323	chandef->center_freq2 - chandef->center_freq1 == 80)
324	return false;
325	break;
326	default:
327	if (chandef->center_freq2)
328	return false;
329	break;
330	}
331
332	switch (chandef->width) {
333	case NL80211_CHAN_WIDTH_5:
334	case NL80211_CHAN_WIDTH_10:
335	case NL80211_CHAN_WIDTH_20:
336	case NL80211_CHAN_WIDTH_20_NOHT:
337	case NL80211_CHAN_WIDTH_1:
338	case NL80211_CHAN_WIDTH_2:
339	case NL80211_CHAN_WIDTH_4:
340	case NL80211_CHAN_WIDTH_8:
341	case NL80211_CHAN_WIDTH_16:
342	/* all checked above */
343	break;
344	case NL80211_CHAN_WIDTH_320:
345	if (chandef->center_freq1 == control_freq + 150 ||
346	chandef->center_freq1 == control_freq + 130 ||
347	chandef->center_freq1 == control_freq + 110 ||
348	chandef->center_freq1 == control_freq + 90 ||
349	chandef->center_freq1 == control_freq - 90 ||
350	chandef->center_freq1 == control_freq - 110 ||
351	chandef->center_freq1 == control_freq - 130 ||
352	chandef->center_freq1 == control_freq - 150)
353	break;
354	fallthrough;
355	case NL80211_CHAN_WIDTH_160:
356	if (chandef->center_freq1 == control_freq + 70 ||
357	chandef->center_freq1 == control_freq + 50 ||
358	chandef->center_freq1 == control_freq - 50 ||
359	chandef->center_freq1 == control_freq - 70)
360	break;
361	fallthrough;
362	case NL80211_CHAN_WIDTH_80P80:
363	case NL80211_CHAN_WIDTH_80:
364	if (chandef->center_freq1 == control_freq + 30 ||
365	chandef->center_freq1 == control_freq - 30)
366	break;
367	fallthrough;
368	case NL80211_CHAN_WIDTH_40:
369	if (chandef->center_freq1 == control_freq + 10 ||
370	chandef->center_freq1 == control_freq - 10)
371	break;
372	fallthrough;
373	default:
374	return false;
375	}
376
377	/* channel 14 is only for IEEE 802.11b */
378	if (chandef->center_freq1 == 2484 &&
379	chandef->width != NL80211_CHAN_WIDTH_20_NOHT)
380	return false;
381
382	if (cfg80211_chandef_is_edmg(chandef) &&
383	!cfg80211_edmg_chandef_valid(chandef))
384	return false;
385
386	return valid_puncturing_bitmap(chandef);
387	}
388	EXPORT_SYMBOL(cfg80211_chandef_valid);
389
390	int cfg80211_chandef_primary(const struct cfg80211_chan_def *c,
391	enum nl80211_chan_width primary_chan_width,
392	u16 *punctured)
393	{
394	int pri_width = nl80211_chan_width_to_mhz(primary_chan_width);
395	int width = cfg80211_chandef_get_width(c);
396	u32 control = c->chan->center_freq;
397	u32 center = c->center_freq1;
398	u16 _punct = 0;
399
400	if (WARN_ON_ONCE(pri_width < 0 || width < 0))
401	return -1;
402
403	/* not intended to be called this way, can't determine */
404	if (WARN_ON_ONCE(pri_width > width))
405	return -1;
406
407	if (!punctured)
408	punctured = &_punct;
409
410	*punctured = c->punctured;
411
412	while (width > pri_width) {
413	unsigned int bits_to_drop = width / 20 / 2;
414
415	if (control > center) {
416	center += width / 4;
417	*punctured >>= bits_to_drop;
418	} else {
419	center -= width / 4;
420	*punctured &= (1 << bits_to_drop) - 1;
421	}
422	width /= 2;
423	}
424
425	return center;
426	}
427	EXPORT_SYMBOL(cfg80211_chandef_primary);
428
429	static const struct cfg80211_chan_def *
430	check_chandef_primary_compat(const struct cfg80211_chan_def *c1,
431	const struct cfg80211_chan_def *c2,
432	enum nl80211_chan_width primary_chan_width)
433	{
434	u16 punct_c1 = 0, punct_c2 = 0;
435
436	/* check primary is compatible -> error if not */
437	if (cfg80211_chandef_primary(c1, primary_chan_width, &punct_c1) !=
438	cfg80211_chandef_primary(c2, primary_chan_width, &punct_c2))
439	return ERR_PTR(error: -EINVAL);
440
441	if (punct_c1 != punct_c2)
442	return ERR_PTR(error: -EINVAL);
443
444	/* assumes c1 is smaller width, if that was just checked -> done */
445	if (c1->width == primary_chan_width)
446	return c2;
447
448	/* otherwise continue checking the next width */
449	return NULL;
450	}
451
452	static const struct cfg80211_chan_def *
453	_cfg80211_chandef_compatible(const struct cfg80211_chan_def *c1,
454	const struct cfg80211_chan_def *c2)
455	{
456	const struct cfg80211_chan_def *ret;
457
458	/* If they are identical, return */
459	if (cfg80211_chandef_identical(chandef1: c1, chandef2: c2))
460	return c2;
461
462	/* otherwise, must have same control channel */
463	if (c1->chan != c2->chan)
464	return NULL;
465
466	/*
467	* If they have the same width, but aren't identical,
468	* then they can't be compatible.
469	*/
470	if (c1->width == c2->width)
471	return NULL;
472
473	/*
474	* can't be compatible if one of them is 5/10 MHz or S1G
475	* but they don't have the same width.
476	*/
477	#define NARROW_OR_S1G(width) ((width) == NL80211_CHAN_WIDTH_5 || \
478	(width) == NL80211_CHAN_WIDTH_10 || \
479	(width) == NL80211_CHAN_WIDTH_1 || \
480	(width) == NL80211_CHAN_WIDTH_2 || \
481	(width) == NL80211_CHAN_WIDTH_4 || \
482	(width) == NL80211_CHAN_WIDTH_8 || \
483	(width) == NL80211_CHAN_WIDTH_16)
484
485	if (NARROW_OR_S1G(c1->width) || NARROW_OR_S1G(c2->width))
486	return NULL;
487
488	/*
489	* Make sure that c1 is always the narrower one, so that later
490	* we either return NULL or c2 and don't have to check both
491	* directions.
492	*/
493	if (c1->width > c2->width)
494	swap(c1, c2);
495
496	/*
497	* No further checks needed if the "narrower" one is only 20 MHz.
498	* Here "narrower" includes being a 20 MHz non-HT channel vs. a
499	* 20 MHz HT (or later) one.
500	*/
501	if (c1->width <= NL80211_CHAN_WIDTH_20)
502	return c2;
503
504	ret = check_chandef_primary_compat(c1, c2, primary_chan_width: NL80211_CHAN_WIDTH_40);
505	if (ret)
506	return ret;
507
508	ret = check_chandef_primary_compat(c1, c2, primary_chan_width: NL80211_CHAN_WIDTH_80);
509	if (ret)
510	return ret;
511
512	/*
513	* If c1 is 80+80, then c2 is 160 or higher, but that cannot
514	* match. If c2 was also 80+80 it was already either accepted
515	* or rejected above (identical or not, respectively.)
516	*/
517	if (c1->width == NL80211_CHAN_WIDTH_80P80)
518	return NULL;
519
520	ret = check_chandef_primary_compat(c1, c2, primary_chan_width: NL80211_CHAN_WIDTH_160);
521	if (ret)
522	return ret;
523
524	/*
525	* Getting here would mean they're both wider than 160, have the
526	* same primary 160, but are not identical - this cannot happen
527	* since they must be 320 (no wider chandefs exist, at least yet.)
528	*/
529	WARN_ON_ONCE(1);
530
531	return NULL;
532	}
533
534	const struct cfg80211_chan_def *
535	cfg80211_chandef_compatible(const struct cfg80211_chan_def *c1,
536	const struct cfg80211_chan_def *c2)
537	{
538	const struct cfg80211_chan_def *ret;
539
540	ret = _cfg80211_chandef_compatible(c1, c2);
541	if (IS_ERR(ptr: ret))
542	return NULL;
543	return ret;
544	}
545	EXPORT_SYMBOL(cfg80211_chandef_compatible);
546
547	static void cfg80211_set_chans_dfs_state(struct wiphy *wiphy, u32 center_freq,
548	u32 bandwidth,
549	enum nl80211_dfs_state dfs_state)
550	{
551	struct ieee80211_channel *c;
552	u32 freq;
553
554	for (freq = center_freq - bandwidth/2 + 10;
555	freq <= center_freq + bandwidth/2 - 10;
556	freq += 20) {
557	c = ieee80211_get_channel(wiphy, freq);
558	if (!c || !(c->flags & IEEE80211_CHAN_RADAR))
559	continue;
560
561	c->dfs_state = dfs_state;
562	c->dfs_state_entered = jiffies;
563	}
564	}
565
566	void cfg80211_set_dfs_state(struct wiphy *wiphy,
567	const struct cfg80211_chan_def *chandef,
568	enum nl80211_dfs_state dfs_state)
569	{
570	int width;
571
572	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
573	return;
574
575	width = cfg80211_chandef_get_width(c: chandef);
576	if (width < 0)
577	return;
578
579	cfg80211_set_chans_dfs_state(wiphy, center_freq: chandef->center_freq1,
580	bandwidth: width, dfs_state);
581
582	if (!chandef->center_freq2)
583	return;
584	cfg80211_set_chans_dfs_state(wiphy, center_freq: chandef->center_freq2,
585	bandwidth: width, dfs_state);
586	}
587
588	static u32 cfg80211_get_start_freq(u32 center_freq,
589	u32 bandwidth)
590	{
591	u32 start_freq;
592
593	bandwidth = MHZ_TO_KHZ(bandwidth);
594	if (bandwidth <= MHZ_TO_KHZ(20))
595	start_freq = center_freq;
596	else
597	start_freq = center_freq - bandwidth / 2 + MHZ_TO_KHZ(10);
598
599	return start_freq;
600	}
601
602	static u32 cfg80211_get_end_freq(u32 center_freq,
603	u32 bandwidth)
604	{
605	u32 end_freq;
606
607	bandwidth = MHZ_TO_KHZ(bandwidth);
608	if (bandwidth <= MHZ_TO_KHZ(20))
609	end_freq = center_freq;
610	else
611	end_freq = center_freq + bandwidth / 2 - MHZ_TO_KHZ(10);
612
613	return end_freq;
614	}
615
616	static bool
617	cfg80211_dfs_permissive_check_wdev(struct cfg80211_registered_device *rdev,
618	enum nl80211_iftype iftype,
619	struct wireless_dev *wdev,
620	struct ieee80211_channel *chan)
621	{
622	unsigned int link_id;
623
624	for_each_valid_link(wdev, link_id) {
625	struct ieee80211_channel *other_chan = NULL;
626	struct cfg80211_chan_def chandef = {};
627	int ret;
628
629	/* In order to avoid daisy chaining only allow BSS STA */
630	if (wdev->iftype != NL80211_IFTYPE_STATION ||
631	!wdev->links[link_id].client.current_bss)
632	continue;
633
634	other_chan =
635	wdev->links[link_id].client.current_bss->pub.channel;
636
637	if (!other_chan)
638	continue;
639
640	if (chan == other_chan)
641	return true;
642
643	/* continue if we can't get the channel */
644	ret = rdev_get_channel(rdev, wdev, link_id, chandef: &chandef);
645	if (ret)
646	continue;
647
648	if (cfg80211_is_sub_chan(chandef: &chandef, chan, primary_only: false))
649	return true;
650	}
651
652	return false;
653	}
654
655	/*
656	* Check if P2P GO is allowed to operate on a DFS channel
657	*/
658	static bool cfg80211_dfs_permissive_chan(struct wiphy *wiphy,
659	enum nl80211_iftype iftype,
660	struct ieee80211_channel *chan)
661	{
662	struct wireless_dev *wdev;
663	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
664
665	lockdep_assert_held(&rdev->wiphy.mtx);
666
667	if (!wiphy_ext_feature_isset(wiphy: &rdev->wiphy,
668	ftidx: NL80211_EXT_FEATURE_DFS_CONCURRENT) ||
669	!(chan->flags & IEEE80211_CHAN_DFS_CONCURRENT))
670	return false;
671
672	/* only valid for P2P GO */
673	if (iftype != NL80211_IFTYPE_P2P_GO)
674	return false;
675
676	/*
677	* Allow only if there's a concurrent BSS
678	*/
679	list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
680	bool ret = cfg80211_dfs_permissive_check_wdev(rdev, iftype,
681	wdev, chan);
682	if (ret)
683	return ret;
684	}
685
686	return false;
687	}
688
689	static int cfg80211_get_chans_dfs_required(struct wiphy *wiphy,
690	u32 center_freq,
691	u32 bandwidth,
692	enum nl80211_iftype iftype)
693	{
694	struct ieee80211_channel *c;
695	u32 freq, start_freq, end_freq;
696
697	start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
698	end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
699
700	for (freq = start_freq; freq <= end_freq; freq += MHZ_TO_KHZ(20)) {
701	c = ieee80211_get_channel_khz(wiphy, freq);
702	if (!c)
703	return -EINVAL;
704
705	if (c->flags & IEEE80211_CHAN_RADAR &&
706	!cfg80211_dfs_permissive_chan(wiphy, iftype, chan: c))
707	return 1;
708	}
709
710	return 0;
711	}
712
713
714	int cfg80211_chandef_dfs_required(struct wiphy *wiphy,
715	const struct cfg80211_chan_def *chandef,
716	enum nl80211_iftype iftype)
717	{
718	int width;
719	int ret;
720
721	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
722	return -EINVAL;
723
724	switch (iftype) {
725	case NL80211_IFTYPE_ADHOC:
726	case NL80211_IFTYPE_AP:
727	case NL80211_IFTYPE_P2P_GO:
728	case NL80211_IFTYPE_MESH_POINT:
729	width = cfg80211_chandef_get_width(c: chandef);
730	if (width < 0)
731	return -EINVAL;
732
733	ret = cfg80211_get_chans_dfs_required(wiphy,
734	center_freq: ieee80211_chandef_to_khz(chandef),
735	bandwidth: width, iftype);
736	if (ret < 0)
737	return ret;
738	else if (ret > 0)
739	return BIT(chandef->width);
740
741	if (!chandef->center_freq2)
742	return 0;
743
744	ret = cfg80211_get_chans_dfs_required(wiphy,
745	MHZ_TO_KHZ(chandef->center_freq2),
746	bandwidth: width, iftype);
747	if (ret < 0)
748	return ret;
749	else if (ret > 0)
750	return BIT(chandef->width);
751
752	break;
753	case NL80211_IFTYPE_STATION:
754	case NL80211_IFTYPE_OCB:
755	case NL80211_IFTYPE_P2P_CLIENT:
756	case NL80211_IFTYPE_MONITOR:
757	case NL80211_IFTYPE_AP_VLAN:
758	case NL80211_IFTYPE_P2P_DEVICE:
759	case NL80211_IFTYPE_NAN:
760	break;
761	case NL80211_IFTYPE_WDS:
762	case NL80211_IFTYPE_UNSPECIFIED:
763	case NUM_NL80211_IFTYPES:
764	WARN_ON(1);
765	}
766
767	return 0;
768	}
769	EXPORT_SYMBOL(cfg80211_chandef_dfs_required);
770
771	static int cfg80211_get_chans_dfs_usable(struct wiphy *wiphy,
772	u32 center_freq,
773	u32 bandwidth)
774	{
775	struct ieee80211_channel *c;
776	u32 freq, start_freq, end_freq;
777	int count = 0;
778
779	start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
780	end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
781
782	/*
783	* Check entire range of channels for the bandwidth.
784	* Check all channels are DFS channels (DFS_USABLE or
785	* DFS_AVAILABLE). Return number of usable channels
786	* (require CAC). Allow DFS and non-DFS channel mix.
787	*/
788	for (freq = start_freq; freq <= end_freq; freq += MHZ_TO_KHZ(20)) {
789	c = ieee80211_get_channel_khz(wiphy, freq);
790	if (!c)
791	return -EINVAL;
792
793	if (c->flags & IEEE80211_CHAN_DISABLED)
794	return -EINVAL;
795
796	if (c->flags & IEEE80211_CHAN_RADAR) {
797	if (c->dfs_state == NL80211_DFS_UNAVAILABLE)
798	return -EINVAL;
799
800	if (c->dfs_state == NL80211_DFS_USABLE)
801	count++;
802	}
803	}
804
805	return count;
806	}
807
808	bool cfg80211_chandef_dfs_usable(struct wiphy *wiphy,
809	const struct cfg80211_chan_def *chandef)
810	{
811	int width;
812	int r1, r2 = 0;
813
814	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
815	return false;
816
817	width = cfg80211_chandef_get_width(c: chandef);
818	if (width < 0)
819	return false;
820
821	r1 = cfg80211_get_chans_dfs_usable(wiphy,
822	MHZ_TO_KHZ(chandef->center_freq1),
823	bandwidth: width);
824
825	if (r1 < 0)
826	return false;
827
828	switch (chandef->width) {
829	case NL80211_CHAN_WIDTH_80P80:
830	WARN_ON(!chandef->center_freq2);
831	r2 = cfg80211_get_chans_dfs_usable(wiphy,
832	MHZ_TO_KHZ(chandef->center_freq2),
833	bandwidth: width);
834	if (r2 < 0)
835	return false;
836	break;
837	default:
838	WARN_ON(chandef->center_freq2);
839	break;
840	}
841
842	return (r1 + r2 > 0);
843	}
844	EXPORT_SYMBOL(cfg80211_chandef_dfs_usable);
845
846	/*
847	* Checks if center frequency of chan falls with in the bandwidth
848	* range of chandef.
849	*/
850	bool cfg80211_is_sub_chan(struct cfg80211_chan_def *chandef,
851	struct ieee80211_channel *chan,
852	bool primary_only)
853	{
854	int width;
855	u32 freq;
856
857	if (!chandef->chan)
858	return false;
859
860	if (chandef->chan->center_freq == chan->center_freq)
861	return true;
862
863	if (primary_only)
864	return false;
865
866	width = cfg80211_chandef_get_width(c: chandef);
867	if (width <= 20)
868	return false;
869
870	for (freq = chandef->center_freq1 - width / 2 + 10;
871	freq <= chandef->center_freq1 + width / 2 - 10; freq += 20) {
872	if (chan->center_freq == freq)
873	return true;
874	}
875
876	if (!chandef->center_freq2)
877	return false;
878
879	for (freq = chandef->center_freq2 - width / 2 + 10;
880	freq <= chandef->center_freq2 + width / 2 - 10; freq += 20) {
881	if (chan->center_freq == freq)
882	return true;
883	}
884
885	return false;
886	}
887
888	bool cfg80211_beaconing_iface_active(struct wireless_dev *wdev)
889	{
890	unsigned int link;
891
892	lockdep_assert_wiphy(wdev->wiphy);
893
894	switch (wdev->iftype) {
895	case NL80211_IFTYPE_AP:
896	case NL80211_IFTYPE_P2P_GO:
897	for_each_valid_link(wdev, link) {
898	if (wdev->links[link].ap.beacon_interval)
899	return true;
900	}
901	break;
902	case NL80211_IFTYPE_ADHOC:
903	if (wdev->u.ibss.ssid_len)
904	return true;
905	break;
906	case NL80211_IFTYPE_MESH_POINT:
907	if (wdev->u.mesh.id_len)
908	return true;
909	break;
910	case NL80211_IFTYPE_STATION:
911	case NL80211_IFTYPE_OCB:
912	case NL80211_IFTYPE_P2P_CLIENT:
913	case NL80211_IFTYPE_MONITOR:
914	case NL80211_IFTYPE_AP_VLAN:
915	case NL80211_IFTYPE_P2P_DEVICE:
916	/* Can NAN type be considered as beaconing interface? */
917	case NL80211_IFTYPE_NAN:
918	break;
919	case NL80211_IFTYPE_UNSPECIFIED:
920	case NL80211_IFTYPE_WDS:
921	case NUM_NL80211_IFTYPES:
922	WARN_ON(1);
923	}
924
925	return false;
926	}
927
928	bool cfg80211_wdev_on_sub_chan(struct wireless_dev *wdev,
929	struct ieee80211_channel *chan,
930	bool primary_only)
931	{
932	unsigned int link;
933
934	switch (wdev->iftype) {
935	case NL80211_IFTYPE_AP:
936	case NL80211_IFTYPE_P2P_GO:
937	for_each_valid_link(wdev, link) {
938	if (cfg80211_is_sub_chan(chandef: &wdev->links[link].ap.chandef,
939	chan, primary_only))
940	return true;
941	}
942	break;
943	case NL80211_IFTYPE_ADHOC:
944	return cfg80211_is_sub_chan(chandef: &wdev->u.ibss.chandef, chan,
945	primary_only);
946	case NL80211_IFTYPE_MESH_POINT:
947	return cfg80211_is_sub_chan(chandef: &wdev->u.mesh.chandef, chan,
948	primary_only);
949	default:
950	break;
951	}
952
953	return false;
954	}
955
956	static bool cfg80211_is_wiphy_oper_chan(struct wiphy *wiphy,
957	struct ieee80211_channel *chan)
958	{
959	struct wireless_dev *wdev;
960
961	lockdep_assert_wiphy(wiphy);
962
963	list_for_each_entry(wdev, &wiphy->wdev_list, list) {
964	if (!cfg80211_beaconing_iface_active(wdev))
965	continue;
966
967	if (cfg80211_wdev_on_sub_chan(wdev, chan, primary_only: false))
968	return true;
969	}
970
971	return false;
972	}
973
974	static bool
975	cfg80211_offchan_chain_is_active(struct cfg80211_registered_device *rdev,
976	struct ieee80211_channel *channel)
977	{
978	if (!rdev->background_radar_wdev)
979	return false;
980
981	if (!cfg80211_chandef_valid(&rdev->background_radar_chandef))
982	return false;
983
984	return cfg80211_is_sub_chan(chandef: &rdev->background_radar_chandef, chan: channel,
985	primary_only: false);
986	}
987
988	bool cfg80211_any_wiphy_oper_chan(struct wiphy *wiphy,
989	struct ieee80211_channel *chan)
990	{
991	struct cfg80211_registered_device *rdev;
992
993	ASSERT_RTNL();
994
995	if (!(chan->flags & IEEE80211_CHAN_RADAR))
996	return false;
997
998	for_each_rdev(rdev) {
999	bool found;
1000
1001	if (!reg_dfs_domain_same(wiphy1: wiphy, wiphy2: &rdev->wiphy))
1002	continue;
1003
1004	wiphy_lock(wiphy: &rdev->wiphy);
1005	found = cfg80211_is_wiphy_oper_chan(wiphy: &rdev->wiphy, chan) ||
1006	cfg80211_offchan_chain_is_active(rdev, channel: chan);
1007	wiphy_unlock(wiphy: &rdev->wiphy);
1008
1009	if (found)
1010	return true;
1011	}
1012
1013	return false;
1014	}
1015
1016	static bool cfg80211_get_chans_dfs_available(struct wiphy *wiphy,
1017	u32 center_freq,
1018	u32 bandwidth)
1019	{
1020	struct ieee80211_channel *c;
1021	u32 freq, start_freq, end_freq;
1022	bool dfs_offload;
1023
1024	dfs_offload = wiphy_ext_feature_isset(wiphy,
1025	ftidx: NL80211_EXT_FEATURE_DFS_OFFLOAD);
1026
1027	start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
1028	end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
1029
1030	/*
1031	* Check entire range of channels for the bandwidth.
1032	* If any channel in between is disabled or has not
1033	* had gone through CAC return false
1034	*/
1035	for (freq = start_freq; freq <= end_freq; freq += MHZ_TO_KHZ(20)) {
1036	c = ieee80211_get_channel_khz(wiphy, freq);
1037	if (!c)
1038	return false;
1039
1040	if (c->flags & IEEE80211_CHAN_DISABLED)
1041	return false;
1042
1043	if ((c->flags & IEEE80211_CHAN_RADAR) &&
1044	(c->dfs_state != NL80211_DFS_AVAILABLE) &&
1045	!(c->dfs_state == NL80211_DFS_USABLE && dfs_offload))
1046	return false;
1047	}
1048
1049	return true;
1050	}
1051
1052	static bool cfg80211_chandef_dfs_available(struct wiphy *wiphy,
1053	const struct cfg80211_chan_def *chandef)
1054	{
1055	int width;
1056	int r;
1057
1058	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
1059	return false;
1060
1061	width = cfg80211_chandef_get_width(c: chandef);
1062	if (width < 0)
1063	return false;
1064
1065	r = cfg80211_get_chans_dfs_available(wiphy,
1066	MHZ_TO_KHZ(chandef->center_freq1),
1067	bandwidth: width);
1068
1069	/* If any of channels unavailable for cf1 just return */
1070	if (!r)
1071	return r;
1072
1073	switch (chandef->width) {
1074	case NL80211_CHAN_WIDTH_80P80:
1075	WARN_ON(!chandef->center_freq2);
1076	r = cfg80211_get_chans_dfs_available(wiphy,
1077	MHZ_TO_KHZ(chandef->center_freq2),
1078	bandwidth: width);
1079	break;
1080	default:
1081	WARN_ON(chandef->center_freq2);
1082	break;
1083	}
1084
1085	return r;
1086	}
1087
1088	static unsigned int cfg80211_get_chans_dfs_cac_time(struct wiphy *wiphy,
1089	u32 center_freq,
1090	u32 bandwidth)
1091	{
1092	struct ieee80211_channel *c;
1093	u32 start_freq, end_freq, freq;
1094	unsigned int dfs_cac_ms = 0;
1095
1096	start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
1097	end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
1098
1099	for (freq = start_freq; freq <= end_freq; freq += MHZ_TO_KHZ(20)) {
1100	c = ieee80211_get_channel_khz(wiphy, freq);
1101	if (!c)
1102	return 0;
1103
1104	if (c->flags & IEEE80211_CHAN_DISABLED)
1105	return 0;
1106
1107	if (!(c->flags & IEEE80211_CHAN_RADAR))
1108	continue;
1109
1110	if (c->dfs_cac_ms > dfs_cac_ms)
1111	dfs_cac_ms = c->dfs_cac_ms;
1112	}
1113
1114	return dfs_cac_ms;
1115	}
1116
1117	unsigned int
1118	cfg80211_chandef_dfs_cac_time(struct wiphy *wiphy,
1119	const struct cfg80211_chan_def *chandef)
1120	{
1121	int width;
1122	unsigned int t1 = 0, t2 = 0;
1123
1124	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
1125	return 0;
1126
1127	width = cfg80211_chandef_get_width(c: chandef);
1128	if (width < 0)
1129	return 0;
1130
1131	t1 = cfg80211_get_chans_dfs_cac_time(wiphy,
1132	MHZ_TO_KHZ(chandef->center_freq1),
1133	bandwidth: width);
1134
1135	if (!chandef->center_freq2)
1136	return t1;
1137
1138	t2 = cfg80211_get_chans_dfs_cac_time(wiphy,
1139	MHZ_TO_KHZ(chandef->center_freq2),
1140	bandwidth: width);
1141
1142	return max(t1, t2);
1143	}
1144	EXPORT_SYMBOL(cfg80211_chandef_dfs_cac_time);
1145
1146	static bool cfg80211_secondary_chans_ok(struct wiphy *wiphy,
1147	u32 center_freq, u32 bandwidth,
1148	u32 prohibited_flags, bool monitor)
1149	{
1150	struct ieee80211_channel *c;
1151	u32 freq, start_freq, end_freq;
1152
1153	start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
1154	end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
1155
1156	for (freq = start_freq; freq <= end_freq; freq += MHZ_TO_KHZ(20)) {
1157	c = ieee80211_get_channel_khz(wiphy, freq);
1158	if (!c)
1159	return false;
1160	if (monitor && c->flags & IEEE80211_CHAN_CAN_MONITOR)
1161	continue;
1162	if (c->flags & prohibited_flags)
1163	return false;
1164	}
1165
1166	return true;
1167	}
1168
1169	/* check if the operating channels are valid and supported */
1170	static bool cfg80211_edmg_usable(struct wiphy *wiphy, u8 edmg_channels,
1171	enum ieee80211_edmg_bw_config edmg_bw_config,
1172	int primary_channel,
1173	struct ieee80211_edmg *edmg_cap)
1174	{
1175	struct ieee80211_channel *chan;
1176	int i, freq;
1177	int channels_counter = 0;
1178
1179	if (!edmg_channels && !edmg_bw_config)
1180	return true;
1181
1182	if ((!edmg_channels && edmg_bw_config) ||
1183	(edmg_channels && !edmg_bw_config))
1184	return false;
1185
1186	if (!(edmg_channels & BIT(primary_channel - 1)))
1187	return false;
1188
1189	/* 60GHz channels 1..6 */
1190	for (i = 0; i < 6; i++) {
1191	if (!(edmg_channels & BIT(i)))
1192	continue;
1193
1194	if (!(edmg_cap->channels & BIT(i)))
1195	return false;
1196
1197	channels_counter++;
1198
1199	freq = ieee80211_channel_to_frequency(chan: i + 1,
1200	band: NL80211_BAND_60GHZ);
1201	chan = ieee80211_get_channel(wiphy, freq);
1202	if (!chan || chan->flags & IEEE80211_CHAN_DISABLED)
1203	return false;
1204	}
1205
1206	/* IEEE802.11 allows max 4 channels */
1207	if (channels_counter > 4)
1208	return false;
1209
1210	/* check bw_config is a subset of what driver supports
1211	* (see IEEE P802.11ay/D4.0 section 9.4.2.251, Table 13)
1212	*/
1213	if ((edmg_bw_config % 4) > (edmg_cap->bw_config % 4))
1214	return false;
1215
1216	if (edmg_bw_config > edmg_cap->bw_config)
1217	return false;
1218
1219	return true;
1220	}
1221
1222	bool _cfg80211_chandef_usable(struct wiphy *wiphy,
1223	const struct cfg80211_chan_def *chandef,
1224	u32 prohibited_flags, bool monitor)
1225	{
1226	struct ieee80211_sta_ht_cap *ht_cap;
1227	struct ieee80211_sta_vht_cap *vht_cap;
1228	struct ieee80211_edmg *edmg_cap;
1229	u32 width, control_freq, cap;
1230	bool ext_nss_cap, support_80_80 = false, support_320 = false;
1231	const struct ieee80211_sband_iftype_data *iftd;
1232	struct ieee80211_supported_band *sband;
1233	int i;
1234
1235	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
1236	return false;
1237
1238	ht_cap = &wiphy->bands[chandef->chan->band]->ht_cap;
1239	vht_cap = &wiphy->bands[chandef->chan->band]->vht_cap;
1240	edmg_cap = &wiphy->bands[chandef->chan->band]->edmg_cap;
1241	ext_nss_cap = __le16_to_cpu(vht_cap->vht_mcs.tx_highest) &
1242	IEEE80211_VHT_EXT_NSS_BW_CAPABLE;
1243
1244	if (edmg_cap->channels &&
1245	!cfg80211_edmg_usable(wiphy,
1246	edmg_channels: chandef->edmg.channels,
1247	edmg_bw_config: chandef->edmg.bw_config,
1248	primary_channel: chandef->chan->hw_value,
1249	edmg_cap))
1250	return false;
1251
1252	control_freq = chandef->chan->center_freq;
1253
1254	switch (chandef->width) {
1255	case NL80211_CHAN_WIDTH_1:
1256	width = 1;
1257	break;
1258	case NL80211_CHAN_WIDTH_2:
1259	width = 2;
1260	break;
1261	case NL80211_CHAN_WIDTH_4:
1262	width = 4;
1263	break;
1264	case NL80211_CHAN_WIDTH_8:
1265	width = 8;
1266	break;
1267	case NL80211_CHAN_WIDTH_16:
1268	width = 16;
1269	break;
1270	case NL80211_CHAN_WIDTH_5:
1271	width = 5;
1272	break;
1273	case NL80211_CHAN_WIDTH_10:
1274	prohibited_flags |= IEEE80211_CHAN_NO_10MHZ;
1275	width = 10;
1276	break;
1277	case NL80211_CHAN_WIDTH_20:
1278	if (!ht_cap->ht_supported &&
1279	chandef->chan->band != NL80211_BAND_6GHZ)
1280	return false;
1281	fallthrough;
1282	case NL80211_CHAN_WIDTH_20_NOHT:
1283	prohibited_flags |= IEEE80211_CHAN_NO_20MHZ;
1284	width = 20;
1285	break;
1286	case NL80211_CHAN_WIDTH_40:
1287	width = 40;
1288	if (chandef->chan->band == NL80211_BAND_6GHZ)
1289	break;
1290	if (!ht_cap->ht_supported)
1291	return false;
1292	if (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) ||
1293	ht_cap->cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT)
1294	return false;
1295	if (chandef->center_freq1 < control_freq &&
1296	chandef->chan->flags & IEEE80211_CHAN_NO_HT40MINUS)
1297	return false;
1298	if (chandef->center_freq1 > control_freq &&
1299	chandef->chan->flags & IEEE80211_CHAN_NO_HT40PLUS)
1300	return false;
1301	break;
1302	case NL80211_CHAN_WIDTH_80P80:
1303	cap = vht_cap->cap;
1304	support_80_80 =
1305	(cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ) ||
1306	(cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ &&
1307	cap & IEEE80211_VHT_CAP_EXT_NSS_BW_MASK) ||
1308	(ext_nss_cap &&
1309	u32_get_bits(v: cap, IEEE80211_VHT_CAP_EXT_NSS_BW_MASK) > 1);
1310	if (chandef->chan->band != NL80211_BAND_6GHZ && !support_80_80)
1311	return false;
1312	fallthrough;
1313	case NL80211_CHAN_WIDTH_80:
1314	prohibited_flags |= IEEE80211_CHAN_NO_80MHZ;
1315	width = 80;
1316	if (chandef->chan->band == NL80211_BAND_6GHZ)
1317	break;
1318	if (!vht_cap->vht_supported)
1319	return false;
1320	break;
1321	case NL80211_CHAN_WIDTH_160:
1322	prohibited_flags |= IEEE80211_CHAN_NO_160MHZ;
1323	width = 160;
1324	if (chandef->chan->band == NL80211_BAND_6GHZ)
1325	break;
1326	if (!vht_cap->vht_supported)
1327	return false;
1328	cap = vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK;
1329	if (cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ &&
1330	cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ &&
1331	!(ext_nss_cap &&
1332	(vht_cap->cap & IEEE80211_VHT_CAP_EXT_NSS_BW_MASK)))
1333	return false;
1334	break;
1335	case NL80211_CHAN_WIDTH_320:
1336	prohibited_flags |= IEEE80211_CHAN_NO_320MHZ;
1337	width = 320;
1338
1339	if (chandef->chan->band != NL80211_BAND_6GHZ)
1340	return false;
1341
1342	sband = wiphy->bands[NL80211_BAND_6GHZ];
1343	if (!sband)
1344	return false;
1345
1346	for_each_sband_iftype_data(sband, i, iftd) {
1347	if (!iftd->eht_cap.has_eht)
1348	continue;
1349
1350	if (iftd->eht_cap.eht_cap_elem.phy_cap_info[0] &
1351	IEEE80211_EHT_PHY_CAP0_320MHZ_IN_6GHZ) {
1352	support_320 = true;
1353	break;
1354	}
1355	}
1356
1357	if (!support_320)
1358	return false;
1359	break;
1360	default:
1361	WARN_ON_ONCE(1);
1362	return false;
1363	}
1364
1365	/*
1366	* TODO: What if there are only certain 80/160/80+80 MHz channels
1367	* allowed by the driver, or only certain combinations?
1368	* For 40 MHz the driver can set the NO_HT40 flags, but for
1369	* 80/160 MHz and in particular 80+80 MHz this isn't really
1370	* feasible and we only have NO_80MHZ/NO_160MHZ so far but
1371	* no way to cover 80+80 MHz or more complex restrictions.
1372	* Note that such restrictions also need to be advertised to
1373	* userspace, for example for P2P channel selection.
1374	*/
1375
1376	if (width > 20)
1377	prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
1378
1379	/* 5 and 10 MHz are only defined for the OFDM PHY */
1380	if (width < 20)
1381	prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
1382
1383
1384	if (!cfg80211_secondary_chans_ok(wiphy,
1385	center_freq: ieee80211_chandef_to_khz(chandef),
1386	bandwidth: width, prohibited_flags, monitor))
1387	return false;
1388
1389	if (!chandef->center_freq2)
1390	return true;
1391	return cfg80211_secondary_chans_ok(wiphy,
1392	MHZ_TO_KHZ(chandef->center_freq2),
1393	bandwidth: width, prohibited_flags, monitor);
1394	}
1395
1396	bool cfg80211_chandef_usable(struct wiphy *wiphy,
1397	const struct cfg80211_chan_def *chandef,
1398	u32 prohibited_flags)
1399	{
1400	return _cfg80211_chandef_usable(wiphy, chandef, prohibited_flags,
1401	monitor: false);
1402	}
1403	EXPORT_SYMBOL(cfg80211_chandef_usable);
1404
1405	static bool cfg80211_ir_permissive_check_wdev(enum nl80211_iftype iftype,
1406	struct wireless_dev *wdev,
1407	struct ieee80211_channel *chan)
1408	{
1409	struct ieee80211_channel *other_chan = NULL;
1410	unsigned int link_id;
1411	int r1, r2;
1412
1413	for_each_valid_link(wdev, link_id) {
1414	if (wdev->iftype == NL80211_IFTYPE_STATION &&
1415	wdev->links[link_id].client.current_bss)
1416	other_chan = wdev->links[link_id].client.current_bss->pub.channel;
1417
1418	/*
1419	* If a GO already operates on the same GO_CONCURRENT channel,
1420	* this one (maybe the same one) can beacon as well. We allow
1421	* the operation even if the station we relied on with
1422	* GO_CONCURRENT is disconnected now. But then we must make sure
1423	* we're not outdoor on an indoor-only channel.
1424	*/
1425	if (iftype == NL80211_IFTYPE_P2P_GO &&
1426	wdev->iftype == NL80211_IFTYPE_P2P_GO &&
1427	wdev->links[link_id].ap.beacon_interval &&
1428	!(chan->flags & IEEE80211_CHAN_INDOOR_ONLY))
1429	other_chan = wdev->links[link_id].ap.chandef.chan;
1430
1431	if (!other_chan)
1432	continue;
1433
1434	if (chan == other_chan)
1435	return true;
1436
1437	if (chan->band != NL80211_BAND_5GHZ &&
1438	chan->band != NL80211_BAND_6GHZ)
1439	continue;
1440
1441	r1 = cfg80211_get_unii(freq: chan->center_freq);
1442	r2 = cfg80211_get_unii(freq: other_chan->center_freq);
1443
1444	if (r1 != -EINVAL && r1 == r2) {
1445	/*
1446	* At some locations channels 149-165 are considered a
1447	* bundle, but at other locations, e.g., Indonesia,
1448	* channels 149-161 are considered a bundle while
1449	* channel 165 is left out and considered to be in a
1450	* different bundle. Thus, in case that there is a
1451	* station interface connected to an AP on channel 165,
1452	* it is assumed that channels 149-161 are allowed for
1453	* GO operations. However, having a station interface
1454	* connected to an AP on channels 149-161, does not
1455	* allow GO operation on channel 165.
1456	*/
1457	if (chan->center_freq == 5825 &&
1458	other_chan->center_freq != 5825)
1459	continue;
1460	return true;
1461	}
1462	}
1463
1464	return false;
1465	}
1466
1467	/*
1468	* Check if the channel can be used under permissive conditions mandated by
1469	* some regulatory bodies, i.e., the channel is marked with
1470	* IEEE80211_CHAN_IR_CONCURRENT and there is an additional station interface
1471	* associated to an AP on the same channel or on the same UNII band
1472	* (assuming that the AP is an authorized master).
1473	* In addition allow operation on a channel on which indoor operation is
1474	* allowed, iff we are currently operating in an indoor environment.
1475	*/
1476	static bool cfg80211_ir_permissive_chan(struct wiphy *wiphy,
1477	enum nl80211_iftype iftype,
1478	struct ieee80211_channel *chan)
1479	{
1480	struct wireless_dev *wdev;
1481	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1482
1483	lockdep_assert_held(&rdev->wiphy.mtx);
1484
1485	if (!IS_ENABLED(CONFIG_CFG80211_REG_RELAX_NO_IR) ||
1486	!(wiphy->regulatory_flags & REGULATORY_ENABLE_RELAX_NO_IR))
1487	return false;
1488
1489	/* only valid for GO and TDLS off-channel (station/p2p-CL) */
1490	if (iftype != NL80211_IFTYPE_P2P_GO &&
1491	iftype != NL80211_IFTYPE_STATION &&
1492	iftype != NL80211_IFTYPE_P2P_CLIENT)
1493	return false;
1494
1495	if (regulatory_indoor_allowed() &&
1496	(chan->flags & IEEE80211_CHAN_INDOOR_ONLY))
1497	return true;
1498
1499	if (!(chan->flags & IEEE80211_CHAN_IR_CONCURRENT))
1500	return false;
1501
1502	/*
1503	* Generally, it is possible to rely on another device/driver to allow
1504	* the IR concurrent relaxation, however, since the device can further
1505	* enforce the relaxation (by doing a similar verifications as this),
1506	* and thus fail the GO instantiation, consider only the interfaces of
1507	* the current registered device.
1508	*/
1509	list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
1510	bool ret;
1511
1512	ret = cfg80211_ir_permissive_check_wdev(iftype, wdev, chan);
1513	if (ret)
1514	return ret;
1515	}
1516
1517	return false;
1518	}
1519
1520	static bool _cfg80211_reg_can_beacon(struct wiphy *wiphy,
1521	struct cfg80211_chan_def *chandef,
1522	enum nl80211_iftype iftype,
1523	bool check_no_ir)
1524	{
1525	bool res;
1526	u32 prohibited_flags = IEEE80211_CHAN_DISABLED;
1527	int dfs_required;
1528
1529	trace_cfg80211_reg_can_beacon(wiphy, chandef, iftype, check_no_ir);
1530
1531	if (check_no_ir)
1532	prohibited_flags |= IEEE80211_CHAN_NO_IR;
1533
1534	dfs_required = cfg80211_chandef_dfs_required(wiphy, chandef, iftype);
1535	if (dfs_required != 0)
1536	prohibited_flags |= IEEE80211_CHAN_RADAR;
1537
1538	if (dfs_required > 0 &&
1539	cfg80211_chandef_dfs_available(wiphy, chandef)) {
1540	/* We can skip IEEE80211_CHAN_NO_IR if chandef dfs available */
1541	prohibited_flags = IEEE80211_CHAN_DISABLED;
1542	}
1543
1544	res = cfg80211_chandef_usable(wiphy, chandef, prohibited_flags);
1545
1546	trace_cfg80211_return_bool(ret: res);
1547	return res;
1548	}
1549
1550	bool cfg80211_reg_can_beacon(struct wiphy *wiphy,
1551	struct cfg80211_chan_def *chandef,
1552	enum nl80211_iftype iftype)
1553	{
1554	return _cfg80211_reg_can_beacon(wiphy, chandef, iftype, check_no_ir: true);
1555	}
1556	EXPORT_SYMBOL(cfg80211_reg_can_beacon);
1557
1558	bool cfg80211_reg_can_beacon_relax(struct wiphy *wiphy,
1559	struct cfg80211_chan_def *chandef,
1560	enum nl80211_iftype iftype)
1561	{
1562	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1563	bool check_no_ir;
1564
1565	lockdep_assert_held(&rdev->wiphy.mtx);
1566
1567	/*
1568	* Under certain conditions suggested by some regulatory bodies a
1569	* GO/STA can IR on channels marked with IEEE80211_NO_IR. Set this flag
1570	* only if such relaxations are not enabled and the conditions are not
1571	* met.
1572	*/
1573	check_no_ir = !cfg80211_ir_permissive_chan(wiphy, iftype,
1574	chan: chandef->chan);
1575
1576	return _cfg80211_reg_can_beacon(wiphy, chandef, iftype, check_no_ir);
1577	}
1578	EXPORT_SYMBOL(cfg80211_reg_can_beacon_relax);
1579
1580	int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev,
1581	struct cfg80211_chan_def *chandef)
1582	{
1583	if (!rdev->ops->set_monitor_channel)
1584	return -EOPNOTSUPP;
1585	if (!cfg80211_has_monitors_only(rdev))
1586	return -EBUSY;
1587
1588	return rdev_set_monitor_channel(rdev, chandef);
1589	}
1590
1591	bool cfg80211_any_usable_channels(struct wiphy *wiphy,
1592	unsigned long sband_mask,
1593	u32 prohibited_flags)
1594	{
1595	int idx;
1596
1597	prohibited_flags |= IEEE80211_CHAN_DISABLED;
1598
1599	for_each_set_bit(idx, &sband_mask, NUM_NL80211_BANDS) {
1600	struct ieee80211_supported_band *sband = wiphy->bands[idx];
1601	int chanidx;
1602
1603	if (!sband)
1604	continue;
1605
1606	for (chanidx = 0; chanidx < sband->n_channels; chanidx++) {
1607	struct ieee80211_channel *chan;
1608
1609	chan = &sband->channels[chanidx];
1610
1611	if (chan->flags & prohibited_flags)
1612	continue;
1613
1614	return true;
1615	}
1616	}
1617
1618	return false;
1619	}
1620	EXPORT_SYMBOL(cfg80211_any_usable_channels);
1621
1622	struct cfg80211_chan_def *wdev_chandef(struct wireless_dev *wdev,
1623	unsigned int link_id)
1624	{
1625	lockdep_assert_wiphy(wdev->wiphy);
1626
1627	WARN_ON(wdev->valid_links && !(wdev->valid_links & BIT(link_id)));
1628	WARN_ON(!wdev->valid_links && link_id > 0);
1629
1630	switch (wdev->iftype) {
1631	case NL80211_IFTYPE_MESH_POINT:
1632	return &wdev->u.mesh.chandef;
1633	case NL80211_IFTYPE_ADHOC:
1634	return &wdev->u.ibss.chandef;
1635	case NL80211_IFTYPE_OCB:
1636	return &wdev->u.ocb.chandef;
1637	case NL80211_IFTYPE_AP:
1638	case NL80211_IFTYPE_P2P_GO:
1639	return &wdev->links[link_id].ap.chandef;
1640	default:
1641	return NULL;
1642	}
1643	}
1644	EXPORT_SYMBOL(wdev_chandef);
1645