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