1 // SPDX-License-Identifier: GPL-2.0
3 * This file contains helper code to handle channel
4 * settings and keeping track of what is possible at
7 * Copyright 2009 Johannes Berg <johannes@sipsolutions.net>
8 * Copyright 2013-2014 Intel Mobile Communications GmbH
9 * Copyright 2018 Intel Corporation
12 #include <linux/export.h>
13 #include <net/cfg80211.h>
17 static bool cfg80211_valid_60g_freq(u32 freq)
19 return freq >= 58320 && freq <= 70200;
22 void cfg80211_chandef_create(struct cfg80211_chan_def *chandef,
23 struct ieee80211_channel *chan,
24 enum nl80211_channel_type chan_type)
30 chandef->center_freq2 = 0;
31 chandef->edmg.bw_config = 0;
32 chandef->edmg.channels = 0;
35 case NL80211_CHAN_NO_HT:
36 chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
37 chandef->center_freq1 = chan->center_freq;
39 case NL80211_CHAN_HT20:
40 chandef->width = NL80211_CHAN_WIDTH_20;
41 chandef->center_freq1 = chan->center_freq;
43 case NL80211_CHAN_HT40PLUS:
44 chandef->width = NL80211_CHAN_WIDTH_40;
45 chandef->center_freq1 = chan->center_freq + 10;
47 case NL80211_CHAN_HT40MINUS:
48 chandef->width = NL80211_CHAN_WIDTH_40;
49 chandef->center_freq1 = chan->center_freq - 10;
55 EXPORT_SYMBOL(cfg80211_chandef_create);
57 static bool cfg80211_edmg_chandef_valid(const struct cfg80211_chan_def *chandef)
59 int max_contiguous = 0;
60 int num_of_enabled = 0;
64 if (!chandef->edmg.channels || !chandef->edmg.bw_config)
67 if (!cfg80211_valid_60g_freq(chandef->chan->center_freq))
70 for (i = 0; i < 6; i++) {
71 if (chandef->edmg.channels & BIT(i)) {
78 max_contiguous = max(contiguous, max_contiguous);
80 /* basic verification of edmg configuration according to
81 * IEEE P802.11ay/D4.0 section 9.4.2.251
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)
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)
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)
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)
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:
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)
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)
142 bool cfg80211_chandef_valid(const struct cfg80211_chan_def *chandef)
149 control_freq = chandef->chan->center_freq;
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)
158 if (chandef->center_freq2)
161 case NL80211_CHAN_WIDTH_40:
162 if (chandef->center_freq1 != control_freq + 10 &&
163 chandef->center_freq1 != control_freq - 10)
165 if (chandef->center_freq2)
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)
174 if (!chandef->center_freq2)
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)
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)
187 if (chandef->center_freq2)
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)
200 if (chandef->center_freq2)
207 if (cfg80211_chandef_is_edmg(chandef) &&
208 !cfg80211_edmg_chandef_valid(chandef))
213 EXPORT_SYMBOL(cfg80211_chandef_valid);
215 static void chandef_primary_freqs(const struct cfg80211_chan_def *c,
216 u32 *pri40, u32 *pri80)
221 case NL80211_CHAN_WIDTH_40:
222 *pri40 = c->center_freq1;
225 case NL80211_CHAN_WIDTH_80:
226 case NL80211_CHAN_WIDTH_80P80:
227 *pri80 = c->center_freq1;
229 tmp = (30 + c->chan->center_freq - c->center_freq1)/20;
233 *pri40 = c->center_freq1 - 20 + 40 * tmp;
235 case NL80211_CHAN_WIDTH_160:
237 tmp = (70 + c->chan->center_freq - c->center_freq1)/20;
241 *pri40 = c->center_freq1 - 60 + 40 * tmp;
244 *pri80 = c->center_freq1 - 40 + 80 * tmp;
251 static int cfg80211_chandef_get_width(const struct cfg80211_chan_def *c)
256 case NL80211_CHAN_WIDTH_5:
259 case NL80211_CHAN_WIDTH_10:
262 case NL80211_CHAN_WIDTH_20:
263 case NL80211_CHAN_WIDTH_20_NOHT:
266 case NL80211_CHAN_WIDTH_40:
269 case NL80211_CHAN_WIDTH_80P80:
270 case NL80211_CHAN_WIDTH_80:
273 case NL80211_CHAN_WIDTH_160:
283 const struct cfg80211_chan_def *
284 cfg80211_chandef_compatible(const struct cfg80211_chan_def *c1,
285 const struct cfg80211_chan_def *c2)
287 u32 c1_pri40, c1_pri80, c2_pri40, c2_pri80;
289 /* If they are identical, return */
290 if (cfg80211_chandef_identical(c1, c2))
293 /* otherwise, must have same control channel */
294 if (c1->chan != c2->chan)
298 * If they have the same width, but aren't identical,
299 * then they can't be compatible.
301 if (c1->width == c2->width)
305 * can't be compatible if one of them is 5 or 10 MHz,
306 * but they don't have the same width.
308 if (c1->width == NL80211_CHAN_WIDTH_5 ||
309 c1->width == NL80211_CHAN_WIDTH_10 ||
310 c2->width == NL80211_CHAN_WIDTH_5 ||
311 c2->width == NL80211_CHAN_WIDTH_10)
314 if (c1->width == NL80211_CHAN_WIDTH_20_NOHT ||
315 c1->width == NL80211_CHAN_WIDTH_20)
318 if (c2->width == NL80211_CHAN_WIDTH_20_NOHT ||
319 c2->width == NL80211_CHAN_WIDTH_20)
322 chandef_primary_freqs(c1, &c1_pri40, &c1_pri80);
323 chandef_primary_freqs(c2, &c2_pri40, &c2_pri80);
325 if (c1_pri40 != c2_pri40)
328 WARN_ON(!c1_pri80 && !c2_pri80);
329 if (c1_pri80 && c2_pri80 && c1_pri80 != c2_pri80)
332 if (c1->width > c2->width)
336 EXPORT_SYMBOL(cfg80211_chandef_compatible);
338 static void cfg80211_set_chans_dfs_state(struct wiphy *wiphy, u32 center_freq,
340 enum nl80211_dfs_state dfs_state)
342 struct ieee80211_channel *c;
345 for (freq = center_freq - bandwidth/2 + 10;
346 freq <= center_freq + bandwidth/2 - 10;
348 c = ieee80211_get_channel(wiphy, freq);
349 if (!c || !(c->flags & IEEE80211_CHAN_RADAR))
352 c->dfs_state = dfs_state;
353 c->dfs_state_entered = jiffies;
357 void cfg80211_set_dfs_state(struct wiphy *wiphy,
358 const struct cfg80211_chan_def *chandef,
359 enum nl80211_dfs_state dfs_state)
363 if (WARN_ON(!cfg80211_chandef_valid(chandef)))
366 width = cfg80211_chandef_get_width(chandef);
370 cfg80211_set_chans_dfs_state(wiphy, chandef->center_freq1,
373 if (!chandef->center_freq2)
375 cfg80211_set_chans_dfs_state(wiphy, chandef->center_freq2,
379 static u32 cfg80211_get_start_freq(u32 center_freq,
385 start_freq = center_freq;
387 start_freq = center_freq - bandwidth/2 + 10;
392 static u32 cfg80211_get_end_freq(u32 center_freq,
398 end_freq = center_freq;
400 end_freq = center_freq + bandwidth/2 - 10;
405 static int cfg80211_get_chans_dfs_required(struct wiphy *wiphy,
409 struct ieee80211_channel *c;
410 u32 freq, start_freq, end_freq;
412 start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
413 end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
415 for (freq = start_freq; freq <= end_freq; freq += 20) {
416 c = ieee80211_get_channel(wiphy, freq);
420 if (c->flags & IEEE80211_CHAN_RADAR)
427 int cfg80211_chandef_dfs_required(struct wiphy *wiphy,
428 const struct cfg80211_chan_def *chandef,
429 enum nl80211_iftype iftype)
434 if (WARN_ON(!cfg80211_chandef_valid(chandef)))
438 case NL80211_IFTYPE_ADHOC:
439 case NL80211_IFTYPE_AP:
440 case NL80211_IFTYPE_P2P_GO:
441 case NL80211_IFTYPE_MESH_POINT:
442 width = cfg80211_chandef_get_width(chandef);
446 ret = cfg80211_get_chans_dfs_required(wiphy,
447 chandef->center_freq1,
452 return BIT(chandef->width);
454 if (!chandef->center_freq2)
457 ret = cfg80211_get_chans_dfs_required(wiphy,
458 chandef->center_freq2,
463 return BIT(chandef->width);
466 case NL80211_IFTYPE_STATION:
467 case NL80211_IFTYPE_OCB:
468 case NL80211_IFTYPE_P2P_CLIENT:
469 case NL80211_IFTYPE_MONITOR:
470 case NL80211_IFTYPE_AP_VLAN:
471 case NL80211_IFTYPE_WDS:
472 case NL80211_IFTYPE_P2P_DEVICE:
473 case NL80211_IFTYPE_NAN:
475 case NL80211_IFTYPE_UNSPECIFIED:
476 case NUM_NL80211_IFTYPES:
482 EXPORT_SYMBOL(cfg80211_chandef_dfs_required);
484 static int cfg80211_get_chans_dfs_usable(struct wiphy *wiphy,
488 struct ieee80211_channel *c;
489 u32 freq, start_freq, end_freq;
492 start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
493 end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
496 * Check entire range of channels for the bandwidth.
497 * Check all channels are DFS channels (DFS_USABLE or
498 * DFS_AVAILABLE). Return number of usable channels
499 * (require CAC). Allow DFS and non-DFS channel mix.
501 for (freq = start_freq; freq <= end_freq; freq += 20) {
502 c = ieee80211_get_channel(wiphy, freq);
506 if (c->flags & IEEE80211_CHAN_DISABLED)
509 if (c->flags & IEEE80211_CHAN_RADAR) {
510 if (c->dfs_state == NL80211_DFS_UNAVAILABLE)
513 if (c->dfs_state == NL80211_DFS_USABLE)
521 bool cfg80211_chandef_dfs_usable(struct wiphy *wiphy,
522 const struct cfg80211_chan_def *chandef)
527 if (WARN_ON(!cfg80211_chandef_valid(chandef)))
530 width = cfg80211_chandef_get_width(chandef);
534 r1 = cfg80211_get_chans_dfs_usable(wiphy, chandef->center_freq1,
540 switch (chandef->width) {
541 case NL80211_CHAN_WIDTH_80P80:
542 WARN_ON(!chandef->center_freq2);
543 r2 = cfg80211_get_chans_dfs_usable(wiphy,
544 chandef->center_freq2,
550 WARN_ON(chandef->center_freq2);
554 return (r1 + r2 > 0);
558 * Checks if center frequency of chan falls with in the bandwidth
561 bool cfg80211_is_sub_chan(struct cfg80211_chan_def *chandef,
562 struct ieee80211_channel *chan)
567 if (chandef->chan->center_freq == chan->center_freq)
570 width = cfg80211_chandef_get_width(chandef);
574 for (freq = chandef->center_freq1 - width / 2 + 10;
575 freq <= chandef->center_freq1 + width / 2 - 10; freq += 20) {
576 if (chan->center_freq == freq)
580 if (!chandef->center_freq2)
583 for (freq = chandef->center_freq2 - width / 2 + 10;
584 freq <= chandef->center_freq2 + width / 2 - 10; freq += 20) {
585 if (chan->center_freq == freq)
592 bool cfg80211_beaconing_iface_active(struct wireless_dev *wdev)
596 ASSERT_WDEV_LOCK(wdev);
598 if (!wdev->chandef.chan)
601 switch (wdev->iftype) {
602 case NL80211_IFTYPE_AP:
603 case NL80211_IFTYPE_P2P_GO:
604 active = wdev->beacon_interval != 0;
606 case NL80211_IFTYPE_ADHOC:
607 active = wdev->ssid_len != 0;
609 case NL80211_IFTYPE_MESH_POINT:
610 active = wdev->mesh_id_len != 0;
612 case NL80211_IFTYPE_STATION:
613 case NL80211_IFTYPE_OCB:
614 case NL80211_IFTYPE_P2P_CLIENT:
615 case NL80211_IFTYPE_MONITOR:
616 case NL80211_IFTYPE_AP_VLAN:
617 case NL80211_IFTYPE_WDS:
618 case NL80211_IFTYPE_P2P_DEVICE:
619 /* Can NAN type be considered as beaconing interface? */
620 case NL80211_IFTYPE_NAN:
622 case NL80211_IFTYPE_UNSPECIFIED:
623 case NUM_NL80211_IFTYPES:
630 static bool cfg80211_is_wiphy_oper_chan(struct wiphy *wiphy,
631 struct ieee80211_channel *chan)
633 struct wireless_dev *wdev;
635 list_for_each_entry(wdev, &wiphy->wdev_list, list) {
637 if (!cfg80211_beaconing_iface_active(wdev)) {
642 if (cfg80211_is_sub_chan(&wdev->chandef, chan)) {
652 bool cfg80211_any_wiphy_oper_chan(struct wiphy *wiphy,
653 struct ieee80211_channel *chan)
655 struct cfg80211_registered_device *rdev;
659 if (!(chan->flags & IEEE80211_CHAN_RADAR))
662 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
663 if (!reg_dfs_domain_same(wiphy, &rdev->wiphy))
666 if (cfg80211_is_wiphy_oper_chan(&rdev->wiphy, chan))
673 static bool cfg80211_get_chans_dfs_available(struct wiphy *wiphy,
677 struct ieee80211_channel *c;
678 u32 freq, start_freq, end_freq;
681 dfs_offload = wiphy_ext_feature_isset(wiphy,
682 NL80211_EXT_FEATURE_DFS_OFFLOAD);
684 start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
685 end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
688 * Check entire range of channels for the bandwidth.
689 * If any channel in between is disabled or has not
690 * had gone through CAC return false
692 for (freq = start_freq; freq <= end_freq; freq += 20) {
693 c = ieee80211_get_channel(wiphy, freq);
697 if (c->flags & IEEE80211_CHAN_DISABLED)
700 if ((c->flags & IEEE80211_CHAN_RADAR) &&
701 (c->dfs_state != NL80211_DFS_AVAILABLE) &&
702 !(c->dfs_state == NL80211_DFS_USABLE && dfs_offload))
709 static bool cfg80211_chandef_dfs_available(struct wiphy *wiphy,
710 const struct cfg80211_chan_def *chandef)
715 if (WARN_ON(!cfg80211_chandef_valid(chandef)))
718 width = cfg80211_chandef_get_width(chandef);
722 r = cfg80211_get_chans_dfs_available(wiphy, chandef->center_freq1,
725 /* If any of channels unavailable for cf1 just return */
729 switch (chandef->width) {
730 case NL80211_CHAN_WIDTH_80P80:
731 WARN_ON(!chandef->center_freq2);
732 r = cfg80211_get_chans_dfs_available(wiphy,
733 chandef->center_freq2,
737 WARN_ON(chandef->center_freq2);
744 static unsigned int cfg80211_get_chans_dfs_cac_time(struct wiphy *wiphy,
748 struct ieee80211_channel *c;
749 u32 start_freq, end_freq, freq;
750 unsigned int dfs_cac_ms = 0;
752 start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
753 end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
755 for (freq = start_freq; freq <= end_freq; freq += 20) {
756 c = ieee80211_get_channel(wiphy, freq);
760 if (c->flags & IEEE80211_CHAN_DISABLED)
763 if (!(c->flags & IEEE80211_CHAN_RADAR))
766 if (c->dfs_cac_ms > dfs_cac_ms)
767 dfs_cac_ms = c->dfs_cac_ms;
774 cfg80211_chandef_dfs_cac_time(struct wiphy *wiphy,
775 const struct cfg80211_chan_def *chandef)
778 unsigned int t1 = 0, t2 = 0;
780 if (WARN_ON(!cfg80211_chandef_valid(chandef)))
783 width = cfg80211_chandef_get_width(chandef);
787 t1 = cfg80211_get_chans_dfs_cac_time(wiphy,
788 chandef->center_freq1,
791 if (!chandef->center_freq2)
794 t2 = cfg80211_get_chans_dfs_cac_time(wiphy,
795 chandef->center_freq2,
801 static bool cfg80211_secondary_chans_ok(struct wiphy *wiphy,
802 u32 center_freq, u32 bandwidth,
803 u32 prohibited_flags)
805 struct ieee80211_channel *c;
806 u32 freq, start_freq, end_freq;
808 start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
809 end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
811 for (freq = start_freq; freq <= end_freq; freq += 20) {
812 c = ieee80211_get_channel(wiphy, freq);
813 if (!c || c->flags & prohibited_flags)
820 /* check if the operating channels are valid and supported */
821 static bool cfg80211_edmg_usable(struct wiphy *wiphy, u8 edmg_channels,
822 enum ieee80211_edmg_bw_config edmg_bw_config,
824 struct ieee80211_edmg *edmg_cap)
826 struct ieee80211_channel *chan;
828 int channels_counter = 0;
830 if (!edmg_channels && !edmg_bw_config)
833 if ((!edmg_channels && edmg_bw_config) ||
834 (edmg_channels && !edmg_bw_config))
837 if (!(edmg_channels & BIT(primary_channel - 1)))
840 /* 60GHz channels 1..6 */
841 for (i = 0; i < 6; i++) {
842 if (!(edmg_channels & BIT(i)))
845 if (!(edmg_cap->channels & BIT(i)))
850 freq = ieee80211_channel_to_frequency(i + 1,
852 chan = ieee80211_get_channel(wiphy, freq);
853 if (!chan || chan->flags & IEEE80211_CHAN_DISABLED)
857 /* IEEE802.11 allows max 4 channels */
858 if (channels_counter > 4)
861 /* check bw_config is a subset of what driver supports
862 * (see IEEE P802.11ay/D4.0 section 9.4.2.251, Table 13)
864 if ((edmg_bw_config % 4) > (edmg_cap->bw_config % 4))
867 if (edmg_bw_config > edmg_cap->bw_config)
873 bool cfg80211_chandef_usable(struct wiphy *wiphy,
874 const struct cfg80211_chan_def *chandef,
875 u32 prohibited_flags)
877 struct ieee80211_sta_ht_cap *ht_cap;
878 struct ieee80211_sta_vht_cap *vht_cap;
879 struct ieee80211_edmg *edmg_cap;
880 u32 width, control_freq, cap;
882 if (WARN_ON(!cfg80211_chandef_valid(chandef)))
885 ht_cap = &wiphy->bands[chandef->chan->band]->ht_cap;
886 vht_cap = &wiphy->bands[chandef->chan->band]->vht_cap;
887 edmg_cap = &wiphy->bands[chandef->chan->band]->edmg_cap;
889 if (edmg_cap->channels &&
890 !cfg80211_edmg_usable(wiphy,
891 chandef->edmg.channels,
892 chandef->edmg.bw_config,
893 chandef->chan->hw_value,
897 control_freq = chandef->chan->center_freq;
899 switch (chandef->width) {
900 case NL80211_CHAN_WIDTH_5:
903 case NL80211_CHAN_WIDTH_10:
904 prohibited_flags |= IEEE80211_CHAN_NO_10MHZ;
907 case NL80211_CHAN_WIDTH_20:
908 if (!ht_cap->ht_supported)
911 case NL80211_CHAN_WIDTH_20_NOHT:
912 prohibited_flags |= IEEE80211_CHAN_NO_20MHZ;
915 case NL80211_CHAN_WIDTH_40:
917 if (!ht_cap->ht_supported)
919 if (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) ||
920 ht_cap->cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT)
922 if (chandef->center_freq1 < control_freq &&
923 chandef->chan->flags & IEEE80211_CHAN_NO_HT40MINUS)
925 if (chandef->center_freq1 > control_freq &&
926 chandef->chan->flags & IEEE80211_CHAN_NO_HT40PLUS)
929 case NL80211_CHAN_WIDTH_80P80:
930 cap = vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK;
931 if (cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ)
934 case NL80211_CHAN_WIDTH_80:
935 if (!vht_cap->vht_supported)
937 prohibited_flags |= IEEE80211_CHAN_NO_80MHZ;
940 case NL80211_CHAN_WIDTH_160:
941 if (!vht_cap->vht_supported)
943 cap = vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK;
944 if (cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ &&
945 cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ)
947 prohibited_flags |= IEEE80211_CHAN_NO_160MHZ;
956 * TODO: What if there are only certain 80/160/80+80 MHz channels
957 * allowed by the driver, or only certain combinations?
958 * For 40 MHz the driver can set the NO_HT40 flags, but for
959 * 80/160 MHz and in particular 80+80 MHz this isn't really
960 * feasible and we only have NO_80MHZ/NO_160MHZ so far but
961 * no way to cover 80+80 MHz or more complex restrictions.
962 * Note that such restrictions also need to be advertised to
963 * userspace, for example for P2P channel selection.
967 prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
969 /* 5 and 10 MHz are only defined for the OFDM PHY */
971 prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
974 if (!cfg80211_secondary_chans_ok(wiphy, chandef->center_freq1,
975 width, prohibited_flags))
978 if (!chandef->center_freq2)
980 return cfg80211_secondary_chans_ok(wiphy, chandef->center_freq2,
981 width, prohibited_flags);
983 EXPORT_SYMBOL(cfg80211_chandef_usable);
986 * Check if the channel can be used under permissive conditions mandated by
987 * some regulatory bodies, i.e., the channel is marked with
988 * IEEE80211_CHAN_IR_CONCURRENT and there is an additional station interface
989 * associated to an AP on the same channel or on the same UNII band
990 * (assuming that the AP is an authorized master).
991 * In addition allow operation on a channel on which indoor operation is
992 * allowed, iff we are currently operating in an indoor environment.
994 static bool cfg80211_ir_permissive_chan(struct wiphy *wiphy,
995 enum nl80211_iftype iftype,
996 struct ieee80211_channel *chan)
998 struct wireless_dev *wdev;
999 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1003 if (!IS_ENABLED(CONFIG_CFG80211_REG_RELAX_NO_IR) ||
1004 !(wiphy->regulatory_flags & REGULATORY_ENABLE_RELAX_NO_IR))
1007 /* only valid for GO and TDLS off-channel (station/p2p-CL) */
1008 if (iftype != NL80211_IFTYPE_P2P_GO &&
1009 iftype != NL80211_IFTYPE_STATION &&
1010 iftype != NL80211_IFTYPE_P2P_CLIENT)
1013 if (regulatory_indoor_allowed() &&
1014 (chan->flags & IEEE80211_CHAN_INDOOR_ONLY))
1017 if (!(chan->flags & IEEE80211_CHAN_IR_CONCURRENT))
1021 * Generally, it is possible to rely on another device/driver to allow
1022 * the IR concurrent relaxation, however, since the device can further
1023 * enforce the relaxation (by doing a similar verifications as this),
1024 * and thus fail the GO instantiation, consider only the interfaces of
1025 * the current registered device.
1027 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
1028 struct ieee80211_channel *other_chan = NULL;
1032 if (wdev->iftype == NL80211_IFTYPE_STATION &&
1034 other_chan = wdev->current_bss->pub.channel;
1037 * If a GO already operates on the same GO_CONCURRENT channel,
1038 * this one (maybe the same one) can beacon as well. We allow
1039 * the operation even if the station we relied on with
1040 * GO_CONCURRENT is disconnected now. But then we must make sure
1041 * we're not outdoor on an indoor-only channel.
1043 if (iftype == NL80211_IFTYPE_P2P_GO &&
1044 wdev->iftype == NL80211_IFTYPE_P2P_GO &&
1045 wdev->beacon_interval &&
1046 !(chan->flags & IEEE80211_CHAN_INDOOR_ONLY))
1047 other_chan = wdev->chandef.chan;
1053 if (chan == other_chan)
1056 if (chan->band != NL80211_BAND_5GHZ &&
1057 chan->band != NL80211_BAND_6GHZ)
1060 r1 = cfg80211_get_unii(chan->center_freq);
1061 r2 = cfg80211_get_unii(other_chan->center_freq);
1063 if (r1 != -EINVAL && r1 == r2) {
1065 * At some locations channels 149-165 are considered a
1066 * bundle, but at other locations, e.g., Indonesia,
1067 * channels 149-161 are considered a bundle while
1068 * channel 165 is left out and considered to be in a
1069 * different bundle. Thus, in case that there is a
1070 * station interface connected to an AP on channel 165,
1071 * it is assumed that channels 149-161 are allowed for
1072 * GO operations. However, having a station interface
1073 * connected to an AP on channels 149-161, does not
1074 * allow GO operation on channel 165.
1076 if (chan->center_freq == 5825 &&
1077 other_chan->center_freq != 5825)
1086 static bool _cfg80211_reg_can_beacon(struct wiphy *wiphy,
1087 struct cfg80211_chan_def *chandef,
1088 enum nl80211_iftype iftype,
1092 u32 prohibited_flags = IEEE80211_CHAN_DISABLED |
1093 IEEE80211_CHAN_RADAR;
1095 trace_cfg80211_reg_can_beacon(wiphy, chandef, iftype, check_no_ir);
1098 prohibited_flags |= IEEE80211_CHAN_NO_IR;
1100 if (cfg80211_chandef_dfs_required(wiphy, chandef, iftype) > 0 &&
1101 cfg80211_chandef_dfs_available(wiphy, chandef)) {
1102 /* We can skip IEEE80211_CHAN_NO_IR if chandef dfs available */
1103 prohibited_flags = IEEE80211_CHAN_DISABLED;
1106 res = cfg80211_chandef_usable(wiphy, chandef, prohibited_flags);
1108 trace_cfg80211_return_bool(res);
1112 bool cfg80211_reg_can_beacon(struct wiphy *wiphy,
1113 struct cfg80211_chan_def *chandef,
1114 enum nl80211_iftype iftype)
1116 return _cfg80211_reg_can_beacon(wiphy, chandef, iftype, true);
1118 EXPORT_SYMBOL(cfg80211_reg_can_beacon);
1120 bool cfg80211_reg_can_beacon_relax(struct wiphy *wiphy,
1121 struct cfg80211_chan_def *chandef,
1122 enum nl80211_iftype iftype)
1129 * Under certain conditions suggested by some regulatory bodies a
1130 * GO/STA can IR on channels marked with IEEE80211_NO_IR. Set this flag
1131 * only if such relaxations are not enabled and the conditions are not
1134 check_no_ir = !cfg80211_ir_permissive_chan(wiphy, iftype,
1137 return _cfg80211_reg_can_beacon(wiphy, chandef, iftype, check_no_ir);
1139 EXPORT_SYMBOL(cfg80211_reg_can_beacon_relax);
1141 int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev,
1142 struct cfg80211_chan_def *chandef)
1144 if (!rdev->ops->set_monitor_channel)
1146 if (!cfg80211_has_monitors_only(rdev))
1149 return rdev_set_monitor_channel(rdev, chandef);
1153 cfg80211_get_chan_state(struct wireless_dev *wdev,
1154 struct ieee80211_channel **chan,
1155 enum cfg80211_chan_mode *chanmode,
1161 *chanmode = CHAN_MODE_UNDEFINED;
1163 ASSERT_WDEV_LOCK(wdev);
1165 if (wdev->netdev && !netif_running(wdev->netdev))
1168 switch (wdev->iftype) {
1169 case NL80211_IFTYPE_ADHOC:
1170 if (wdev->current_bss) {
1171 *chan = wdev->current_bss->pub.channel;
1172 *chanmode = (wdev->ibss_fixed &&
1173 !wdev->ibss_dfs_possible)
1175 : CHAN_MODE_EXCLUSIVE;
1177 /* consider worst-case - IBSS can try to return to the
1178 * original user-specified channel as creator */
1179 if (wdev->ibss_dfs_possible)
1180 *radar_detect |= BIT(wdev->chandef.width);
1184 case NL80211_IFTYPE_STATION:
1185 case NL80211_IFTYPE_P2P_CLIENT:
1186 if (wdev->current_bss) {
1187 *chan = wdev->current_bss->pub.channel;
1188 *chanmode = CHAN_MODE_SHARED;
1192 case NL80211_IFTYPE_AP:
1193 case NL80211_IFTYPE_P2P_GO:
1194 if (wdev->cac_started) {
1195 *chan = wdev->chandef.chan;
1196 *chanmode = CHAN_MODE_SHARED;
1197 *radar_detect |= BIT(wdev->chandef.width);
1198 } else if (wdev->beacon_interval) {
1199 *chan = wdev->chandef.chan;
1200 *chanmode = CHAN_MODE_SHARED;
1202 ret = cfg80211_chandef_dfs_required(wdev->wiphy,
1207 *radar_detect |= BIT(wdev->chandef.width);
1210 case NL80211_IFTYPE_MESH_POINT:
1211 if (wdev->mesh_id_len) {
1212 *chan = wdev->chandef.chan;
1213 *chanmode = CHAN_MODE_SHARED;
1215 ret = cfg80211_chandef_dfs_required(wdev->wiphy,
1220 *radar_detect |= BIT(wdev->chandef.width);
1223 case NL80211_IFTYPE_OCB:
1224 if (wdev->chandef.chan) {
1225 *chan = wdev->chandef.chan;
1226 *chanmode = CHAN_MODE_SHARED;
1230 case NL80211_IFTYPE_MONITOR:
1231 case NL80211_IFTYPE_AP_VLAN:
1232 case NL80211_IFTYPE_WDS:
1233 case NL80211_IFTYPE_P2P_DEVICE:
1234 case NL80211_IFTYPE_NAN:
1235 /* these interface types don't really have a channel */
1237 case NL80211_IFTYPE_UNSPECIFIED:
1238 case NUM_NL80211_IFTYPES: