2 * This file contains helper code to handle channel
3 * settings and keeping track of what is possible at
6 * Copyright 2009 Johannes Berg <johannes@sipsolutions.net>
7 * Copyright 2013-2014 Intel Mobile Communications GmbH
10 #include <linux/export.h>
11 #include <net/cfg80211.h>
15 void cfg80211_chandef_create(struct cfg80211_chan_def
*chandef
,
16 struct ieee80211_channel
*chan
,
17 enum nl80211_channel_type chan_type
)
23 chandef
->center_freq2
= 0;
26 case NL80211_CHAN_NO_HT
:
27 chandef
->width
= NL80211_CHAN_WIDTH_20_NOHT
;
28 chandef
->center_freq1
= chan
->center_freq
;
30 case NL80211_CHAN_HT20
:
31 chandef
->width
= NL80211_CHAN_WIDTH_20
;
32 chandef
->center_freq1
= chan
->center_freq
;
34 case NL80211_CHAN_HT40PLUS
:
35 chandef
->width
= NL80211_CHAN_WIDTH_40
;
36 chandef
->center_freq1
= chan
->center_freq
+ 10;
38 case NL80211_CHAN_HT40MINUS
:
39 chandef
->width
= NL80211_CHAN_WIDTH_40
;
40 chandef
->center_freq1
= chan
->center_freq
- 10;
46 EXPORT_SYMBOL(cfg80211_chandef_create
);
48 bool cfg80211_chandef_valid(const struct cfg80211_chan_def
*chandef
)
55 control_freq
= chandef
->chan
->center_freq
;
57 switch (chandef
->width
) {
58 case NL80211_CHAN_WIDTH_5
:
59 case NL80211_CHAN_WIDTH_10
:
60 case NL80211_CHAN_WIDTH_20
:
61 case NL80211_CHAN_WIDTH_20_NOHT
:
62 if (chandef
->center_freq1
!= control_freq
)
64 if (chandef
->center_freq2
)
67 case NL80211_CHAN_WIDTH_40
:
68 if (chandef
->center_freq1
!= control_freq
+ 10 &&
69 chandef
->center_freq1
!= control_freq
- 10)
71 if (chandef
->center_freq2
)
74 case NL80211_CHAN_WIDTH_80P80
:
75 if (chandef
->center_freq1
!= control_freq
+ 30 &&
76 chandef
->center_freq1
!= control_freq
+ 10 &&
77 chandef
->center_freq1
!= control_freq
- 10 &&
78 chandef
->center_freq1
!= control_freq
- 30)
80 if (!chandef
->center_freq2
)
82 /* adjacent is not allowed -- that's a 160 MHz channel */
83 if (chandef
->center_freq1
- chandef
->center_freq2
== 80 ||
84 chandef
->center_freq2
- chandef
->center_freq1
== 80)
87 case NL80211_CHAN_WIDTH_80
:
88 if (chandef
->center_freq1
!= control_freq
+ 30 &&
89 chandef
->center_freq1
!= control_freq
+ 10 &&
90 chandef
->center_freq1
!= control_freq
- 10 &&
91 chandef
->center_freq1
!= control_freq
- 30)
93 if (chandef
->center_freq2
)
96 case NL80211_CHAN_WIDTH_160
:
97 if (chandef
->center_freq1
!= control_freq
+ 70 &&
98 chandef
->center_freq1
!= control_freq
+ 50 &&
99 chandef
->center_freq1
!= control_freq
+ 30 &&
100 chandef
->center_freq1
!= control_freq
+ 10 &&
101 chandef
->center_freq1
!= control_freq
- 10 &&
102 chandef
->center_freq1
!= control_freq
- 30 &&
103 chandef
->center_freq1
!= control_freq
- 50 &&
104 chandef
->center_freq1
!= control_freq
- 70)
106 if (chandef
->center_freq2
)
115 EXPORT_SYMBOL(cfg80211_chandef_valid
);
117 static void chandef_primary_freqs(const struct cfg80211_chan_def
*c
,
118 u32
*pri40
, u32
*pri80
)
123 case NL80211_CHAN_WIDTH_40
:
124 *pri40
= c
->center_freq1
;
127 case NL80211_CHAN_WIDTH_80
:
128 case NL80211_CHAN_WIDTH_80P80
:
129 *pri80
= c
->center_freq1
;
131 tmp
= (30 + c
->chan
->center_freq
- c
->center_freq1
)/20;
135 *pri40
= c
->center_freq1
- 20 + 40 * tmp
;
137 case NL80211_CHAN_WIDTH_160
:
139 tmp
= (70 + c
->chan
->center_freq
- c
->center_freq1
)/20;
143 *pri40
= c
->center_freq1
- 60 + 40 * tmp
;
146 *pri80
= c
->center_freq1
- 40 + 80 * tmp
;
153 static int cfg80211_chandef_get_width(const struct cfg80211_chan_def
*c
)
158 case NL80211_CHAN_WIDTH_5
:
161 case NL80211_CHAN_WIDTH_10
:
164 case NL80211_CHAN_WIDTH_20
:
165 case NL80211_CHAN_WIDTH_20_NOHT
:
168 case NL80211_CHAN_WIDTH_40
:
171 case NL80211_CHAN_WIDTH_80P80
:
172 case NL80211_CHAN_WIDTH_80
:
175 case NL80211_CHAN_WIDTH_160
:
185 const struct cfg80211_chan_def
*
186 cfg80211_chandef_compatible(const struct cfg80211_chan_def
*c1
,
187 const struct cfg80211_chan_def
*c2
)
189 u32 c1_pri40
, c1_pri80
, c2_pri40
, c2_pri80
;
191 /* If they are identical, return */
192 if (cfg80211_chandef_identical(c1
, c2
))
195 /* otherwise, must have same control channel */
196 if (c1
->chan
!= c2
->chan
)
200 * If they have the same width, but aren't identical,
201 * then they can't be compatible.
203 if (c1
->width
== c2
->width
)
207 * can't be compatible if one of them is 5 or 10 MHz,
208 * but they don't have the same width.
210 if (c1
->width
== NL80211_CHAN_WIDTH_5
||
211 c1
->width
== NL80211_CHAN_WIDTH_10
||
212 c2
->width
== NL80211_CHAN_WIDTH_5
||
213 c2
->width
== NL80211_CHAN_WIDTH_10
)
216 if (c1
->width
== NL80211_CHAN_WIDTH_20_NOHT
||
217 c1
->width
== NL80211_CHAN_WIDTH_20
)
220 if (c2
->width
== NL80211_CHAN_WIDTH_20_NOHT
||
221 c2
->width
== NL80211_CHAN_WIDTH_20
)
224 chandef_primary_freqs(c1
, &c1_pri40
, &c1_pri80
);
225 chandef_primary_freqs(c2
, &c2_pri40
, &c2_pri80
);
227 if (c1_pri40
!= c2_pri40
)
230 WARN_ON(!c1_pri80
&& !c2_pri80
);
231 if (c1_pri80
&& c2_pri80
&& c1_pri80
!= c2_pri80
)
234 if (c1
->width
> c2
->width
)
238 EXPORT_SYMBOL(cfg80211_chandef_compatible
);
240 static void cfg80211_set_chans_dfs_state(struct wiphy
*wiphy
, u32 center_freq
,
242 enum nl80211_dfs_state dfs_state
)
244 struct ieee80211_channel
*c
;
247 for (freq
= center_freq
- bandwidth
/2 + 10;
248 freq
<= center_freq
+ bandwidth
/2 - 10;
250 c
= ieee80211_get_channel(wiphy
, freq
);
251 if (!c
|| !(c
->flags
& IEEE80211_CHAN_RADAR
))
254 c
->dfs_state
= dfs_state
;
255 c
->dfs_state_entered
= jiffies
;
259 void cfg80211_set_dfs_state(struct wiphy
*wiphy
,
260 const struct cfg80211_chan_def
*chandef
,
261 enum nl80211_dfs_state dfs_state
)
265 if (WARN_ON(!cfg80211_chandef_valid(chandef
)))
268 width
= cfg80211_chandef_get_width(chandef
);
272 cfg80211_set_chans_dfs_state(wiphy
, chandef
->center_freq1
,
275 if (!chandef
->center_freq2
)
277 cfg80211_set_chans_dfs_state(wiphy
, chandef
->center_freq2
,
281 static u32
cfg80211_get_start_freq(u32 center_freq
,
287 start_freq
= center_freq
;
289 start_freq
= center_freq
- bandwidth
/2 + 10;
294 static u32
cfg80211_get_end_freq(u32 center_freq
,
300 end_freq
= center_freq
;
302 end_freq
= center_freq
+ bandwidth
/2 - 10;
307 static int cfg80211_get_chans_dfs_required(struct wiphy
*wiphy
,
311 struct ieee80211_channel
*c
;
312 u32 freq
, start_freq
, end_freq
;
314 start_freq
= cfg80211_get_start_freq(center_freq
, bandwidth
);
315 end_freq
= cfg80211_get_end_freq(center_freq
, bandwidth
);
317 for (freq
= start_freq
; freq
<= end_freq
; freq
+= 20) {
318 c
= ieee80211_get_channel(wiphy
, freq
);
322 if (c
->flags
& IEEE80211_CHAN_RADAR
)
329 int cfg80211_chandef_dfs_required(struct wiphy
*wiphy
,
330 const struct cfg80211_chan_def
*chandef
,
331 enum nl80211_iftype iftype
)
336 if (WARN_ON(!cfg80211_chandef_valid(chandef
)))
340 case NL80211_IFTYPE_ADHOC
:
341 case NL80211_IFTYPE_AP
:
342 case NL80211_IFTYPE_P2P_GO
:
343 case NL80211_IFTYPE_MESH_POINT
:
344 width
= cfg80211_chandef_get_width(chandef
);
348 ret
= cfg80211_get_chans_dfs_required(wiphy
,
349 chandef
->center_freq1
,
354 return BIT(chandef
->width
);
356 if (!chandef
->center_freq2
)
359 ret
= cfg80211_get_chans_dfs_required(wiphy
,
360 chandef
->center_freq2
,
365 return BIT(chandef
->width
);
368 case NL80211_IFTYPE_STATION
:
369 case NL80211_IFTYPE_OCB
:
370 case NL80211_IFTYPE_P2P_CLIENT
:
371 case NL80211_IFTYPE_MONITOR
:
372 case NL80211_IFTYPE_AP_VLAN
:
373 case NL80211_IFTYPE_WDS
:
374 case NL80211_IFTYPE_P2P_DEVICE
:
376 case NL80211_IFTYPE_UNSPECIFIED
:
377 case NUM_NL80211_IFTYPES
:
383 EXPORT_SYMBOL(cfg80211_chandef_dfs_required
);
385 static int cfg80211_get_chans_dfs_usable(struct wiphy
*wiphy
,
389 struct ieee80211_channel
*c
;
390 u32 freq
, start_freq
, end_freq
;
393 start_freq
= cfg80211_get_start_freq(center_freq
, bandwidth
);
394 end_freq
= cfg80211_get_end_freq(center_freq
, bandwidth
);
397 * Check entire range of channels for the bandwidth.
398 * Check all channels are DFS channels (DFS_USABLE or
399 * DFS_AVAILABLE). Return number of usable channels
400 * (require CAC). Allow DFS and non-DFS channel mix.
402 for (freq
= start_freq
; freq
<= end_freq
; freq
+= 20) {
403 c
= ieee80211_get_channel(wiphy
, freq
);
407 if (c
->flags
& IEEE80211_CHAN_DISABLED
)
410 if (c
->flags
& IEEE80211_CHAN_RADAR
) {
411 if (c
->dfs_state
== NL80211_DFS_UNAVAILABLE
)
414 if (c
->dfs_state
== NL80211_DFS_USABLE
)
422 bool cfg80211_chandef_dfs_usable(struct wiphy
*wiphy
,
423 const struct cfg80211_chan_def
*chandef
)
428 if (WARN_ON(!cfg80211_chandef_valid(chandef
)))
431 width
= cfg80211_chandef_get_width(chandef
);
435 r1
= cfg80211_get_chans_dfs_usable(wiphy
, chandef
->center_freq1
,
441 switch (chandef
->width
) {
442 case NL80211_CHAN_WIDTH_80P80
:
443 WARN_ON(!chandef
->center_freq2
);
444 r2
= cfg80211_get_chans_dfs_usable(wiphy
,
445 chandef
->center_freq2
,
451 WARN_ON(chandef
->center_freq2
);
455 return (r1
+ r2
> 0);
459 static bool cfg80211_get_chans_dfs_available(struct wiphy
*wiphy
,
463 struct ieee80211_channel
*c
;
464 u32 freq
, start_freq
, end_freq
;
466 start_freq
= cfg80211_get_start_freq(center_freq
, bandwidth
);
467 end_freq
= cfg80211_get_end_freq(center_freq
, bandwidth
);
470 * Check entire range of channels for the bandwidth.
471 * If any channel in between is disabled or has not
472 * had gone through CAC return false
474 for (freq
= start_freq
; freq
<= end_freq
; freq
+= 20) {
475 c
= ieee80211_get_channel(wiphy
, freq
);
479 if (c
->flags
& IEEE80211_CHAN_DISABLED
)
482 if ((c
->flags
& IEEE80211_CHAN_RADAR
) &&
483 (c
->dfs_state
!= NL80211_DFS_AVAILABLE
))
490 static bool cfg80211_chandef_dfs_available(struct wiphy
*wiphy
,
491 const struct cfg80211_chan_def
*chandef
)
496 if (WARN_ON(!cfg80211_chandef_valid(chandef
)))
499 width
= cfg80211_chandef_get_width(chandef
);
503 r
= cfg80211_get_chans_dfs_available(wiphy
, chandef
->center_freq1
,
506 /* If any of channels unavailable for cf1 just return */
510 switch (chandef
->width
) {
511 case NL80211_CHAN_WIDTH_80P80
:
512 WARN_ON(!chandef
->center_freq2
);
513 r
= cfg80211_get_chans_dfs_available(wiphy
,
514 chandef
->center_freq2
,
517 WARN_ON(chandef
->center_freq2
);
524 static unsigned int cfg80211_get_chans_dfs_cac_time(struct wiphy
*wiphy
,
528 struct ieee80211_channel
*c
;
529 u32 start_freq
, end_freq
, freq
;
530 unsigned int dfs_cac_ms
= 0;
532 start_freq
= cfg80211_get_start_freq(center_freq
, bandwidth
);
533 end_freq
= cfg80211_get_end_freq(center_freq
, bandwidth
);
535 for (freq
= start_freq
; freq
<= end_freq
; freq
+= 20) {
536 c
= ieee80211_get_channel(wiphy
, freq
);
540 if (c
->flags
& IEEE80211_CHAN_DISABLED
)
543 if (!(c
->flags
& IEEE80211_CHAN_RADAR
))
546 if (c
->dfs_cac_ms
> dfs_cac_ms
)
547 dfs_cac_ms
= c
->dfs_cac_ms
;
554 cfg80211_chandef_dfs_cac_time(struct wiphy
*wiphy
,
555 const struct cfg80211_chan_def
*chandef
)
558 unsigned int t1
= 0, t2
= 0;
560 if (WARN_ON(!cfg80211_chandef_valid(chandef
)))
563 width
= cfg80211_chandef_get_width(chandef
);
567 t1
= cfg80211_get_chans_dfs_cac_time(wiphy
,
568 chandef
->center_freq1
,
571 if (!chandef
->center_freq2
)
574 t2
= cfg80211_get_chans_dfs_cac_time(wiphy
,
575 chandef
->center_freq2
,
581 static bool cfg80211_secondary_chans_ok(struct wiphy
*wiphy
,
582 u32 center_freq
, u32 bandwidth
,
583 u32 prohibited_flags
)
585 struct ieee80211_channel
*c
;
586 u32 freq
, start_freq
, end_freq
;
588 start_freq
= cfg80211_get_start_freq(center_freq
, bandwidth
);
589 end_freq
= cfg80211_get_end_freq(center_freq
, bandwidth
);
591 for (freq
= start_freq
; freq
<= end_freq
; freq
+= 20) {
592 c
= ieee80211_get_channel(wiphy
, freq
);
593 if (!c
|| c
->flags
& prohibited_flags
)
600 bool cfg80211_chandef_usable(struct wiphy
*wiphy
,
601 const struct cfg80211_chan_def
*chandef
,
602 u32 prohibited_flags
)
604 struct ieee80211_sta_ht_cap
*ht_cap
;
605 struct ieee80211_sta_vht_cap
*vht_cap
;
606 u32 width
, control_freq
;
608 if (WARN_ON(!cfg80211_chandef_valid(chandef
)))
611 ht_cap
= &wiphy
->bands
[chandef
->chan
->band
]->ht_cap
;
612 vht_cap
= &wiphy
->bands
[chandef
->chan
->band
]->vht_cap
;
614 control_freq
= chandef
->chan
->center_freq
;
616 switch (chandef
->width
) {
617 case NL80211_CHAN_WIDTH_5
:
620 case NL80211_CHAN_WIDTH_10
:
621 prohibited_flags
|= IEEE80211_CHAN_NO_10MHZ
;
624 case NL80211_CHAN_WIDTH_20
:
625 if (!ht_cap
->ht_supported
)
627 case NL80211_CHAN_WIDTH_20_NOHT
:
628 prohibited_flags
|= IEEE80211_CHAN_NO_20MHZ
;
631 case NL80211_CHAN_WIDTH_40
:
633 if (!ht_cap
->ht_supported
)
635 if (!(ht_cap
->cap
& IEEE80211_HT_CAP_SUP_WIDTH_20_40
) ||
636 ht_cap
->cap
& IEEE80211_HT_CAP_40MHZ_INTOLERANT
)
638 if (chandef
->center_freq1
< control_freq
&&
639 chandef
->chan
->flags
& IEEE80211_CHAN_NO_HT40MINUS
)
641 if (chandef
->center_freq1
> control_freq
&&
642 chandef
->chan
->flags
& IEEE80211_CHAN_NO_HT40PLUS
)
645 case NL80211_CHAN_WIDTH_80P80
:
646 if (!(vht_cap
->cap
& IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ
))
648 case NL80211_CHAN_WIDTH_80
:
649 if (!vht_cap
->vht_supported
)
651 prohibited_flags
|= IEEE80211_CHAN_NO_80MHZ
;
654 case NL80211_CHAN_WIDTH_160
:
655 if (!vht_cap
->vht_supported
)
657 if (!(vht_cap
->cap
& IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ
))
659 prohibited_flags
|= IEEE80211_CHAN_NO_160MHZ
;
668 * TODO: What if there are only certain 80/160/80+80 MHz channels
669 * allowed by the driver, or only certain combinations?
670 * For 40 MHz the driver can set the NO_HT40 flags, but for
671 * 80/160 MHz and in particular 80+80 MHz this isn't really
672 * feasible and we only have NO_80MHZ/NO_160MHZ so far but
673 * no way to cover 80+80 MHz or more complex restrictions.
674 * Note that such restrictions also need to be advertised to
675 * userspace, for example for P2P channel selection.
679 prohibited_flags
|= IEEE80211_CHAN_NO_OFDM
;
681 /* 5 and 10 MHz are only defined for the OFDM PHY */
683 prohibited_flags
|= IEEE80211_CHAN_NO_OFDM
;
686 if (!cfg80211_secondary_chans_ok(wiphy
, chandef
->center_freq1
,
687 width
, prohibited_flags
))
690 if (!chandef
->center_freq2
)
692 return cfg80211_secondary_chans_ok(wiphy
, chandef
->center_freq2
,
693 width
, prohibited_flags
);
695 EXPORT_SYMBOL(cfg80211_chandef_usable
);
698 * For GO only, check if the channel can be used under permissive conditions
699 * mandated by the some regulatory bodies, i.e., the channel is marked with
700 * IEEE80211_CHAN_GO_CONCURRENT and there is an additional station interface
701 * associated to an AP on the same channel or on the same UNII band
702 * (assuming that the AP is an authorized master).
703 * In addition allow the GO to operate on a channel on which indoor operation is
704 * allowed, iff we are currently operating in an indoor environment.
706 static bool cfg80211_go_permissive_chan(struct cfg80211_registered_device
*rdev
,
707 struct ieee80211_channel
*chan
)
709 struct wireless_dev
*wdev_iter
;
710 struct wiphy
*wiphy
= wiphy_idx_to_wiphy(rdev
->wiphy_idx
);
714 if (!config_enabled(CONFIG_CFG80211_REG_RELAX_NO_IR
) ||
715 !(wiphy
->regulatory_flags
& REGULATORY_ENABLE_RELAX_NO_IR
))
718 if (regulatory_indoor_allowed() &&
719 (chan
->flags
& IEEE80211_CHAN_INDOOR_ONLY
))
722 if (!(chan
->flags
& IEEE80211_CHAN_GO_CONCURRENT
))
726 * Generally, it is possible to rely on another device/driver to allow
727 * the GO concurrent relaxation, however, since the device can further
728 * enforce the relaxation (by doing a similar verifications as this),
729 * and thus fail the GO instantiation, consider only the interfaces of
730 * the current registered device.
732 list_for_each_entry(wdev_iter
, &rdev
->wdev_list
, list
) {
733 struct ieee80211_channel
*other_chan
= NULL
;
736 if (wdev_iter
->iftype
!= NL80211_IFTYPE_STATION
||
737 !netif_running(wdev_iter
->netdev
))
740 wdev_lock(wdev_iter
);
741 if (wdev_iter
->current_bss
)
742 other_chan
= wdev_iter
->current_bss
->pub
.channel
;
743 wdev_unlock(wdev_iter
);
748 if (chan
== other_chan
)
751 if (chan
->band
!= IEEE80211_BAND_5GHZ
)
754 r1
= cfg80211_get_unii(chan
->center_freq
);
755 r2
= cfg80211_get_unii(other_chan
->center_freq
);
757 if (r1
!= -EINVAL
&& r1
== r2
) {
759 * At some locations channels 149-165 are considered a
760 * bundle, but at other locations, e.g., Indonesia,
761 * channels 149-161 are considered a bundle while
762 * channel 165 is left out and considered to be in a
763 * different bundle. Thus, in case that there is a
764 * station interface connected to an AP on channel 165,
765 * it is assumed that channels 149-161 are allowed for
766 * GO operations. However, having a station interface
767 * connected to an AP on channels 149-161, does not
768 * allow GO operation on channel 165.
770 if (chan
->center_freq
== 5825 &&
771 other_chan
->center_freq
!= 5825)
780 bool cfg80211_reg_can_beacon(struct wiphy
*wiphy
,
781 struct cfg80211_chan_def
*chandef
,
782 enum nl80211_iftype iftype
)
784 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
786 u32 prohibited_flags
= IEEE80211_CHAN_DISABLED
|
787 IEEE80211_CHAN_RADAR
;
789 trace_cfg80211_reg_can_beacon(wiphy
, chandef
, iftype
);
792 * Under certain conditions suggested by the some regulatory bodies
793 * a GO can operate on channels marked with IEEE80211_NO_IR
794 * so set this flag only if such relaxations are not enabled and
795 * the conditions are not met.
797 if (iftype
!= NL80211_IFTYPE_P2P_GO
||
798 !cfg80211_go_permissive_chan(rdev
, chandef
->chan
))
799 prohibited_flags
|= IEEE80211_CHAN_NO_IR
;
801 if (cfg80211_chandef_dfs_required(wiphy
, chandef
, iftype
) > 0 &&
802 cfg80211_chandef_dfs_available(wiphy
, chandef
)) {
803 /* We can skip IEEE80211_CHAN_NO_IR if chandef dfs available */
804 prohibited_flags
= IEEE80211_CHAN_DISABLED
;
807 res
= cfg80211_chandef_usable(wiphy
, chandef
, prohibited_flags
);
809 trace_cfg80211_return_bool(res
);
812 EXPORT_SYMBOL(cfg80211_reg_can_beacon
);
814 int cfg80211_set_monitor_channel(struct cfg80211_registered_device
*rdev
,
815 struct cfg80211_chan_def
*chandef
)
817 if (!rdev
->ops
->set_monitor_channel
)
819 if (!cfg80211_has_monitors_only(rdev
))
822 return rdev_set_monitor_channel(rdev
, chandef
);
826 cfg80211_get_chan_state(struct wireless_dev
*wdev
,
827 struct ieee80211_channel
**chan
,
828 enum cfg80211_chan_mode
*chanmode
,
834 *chanmode
= CHAN_MODE_UNDEFINED
;
836 ASSERT_WDEV_LOCK(wdev
);
838 if (wdev
->netdev
&& !netif_running(wdev
->netdev
))
841 switch (wdev
->iftype
) {
842 case NL80211_IFTYPE_ADHOC
:
843 if (wdev
->current_bss
) {
844 *chan
= wdev
->current_bss
->pub
.channel
;
845 *chanmode
= (wdev
->ibss_fixed
&&
846 !wdev
->ibss_dfs_possible
)
848 : CHAN_MODE_EXCLUSIVE
;
850 /* consider worst-case - IBSS can try to return to the
851 * original user-specified channel as creator */
852 if (wdev
->ibss_dfs_possible
)
853 *radar_detect
|= BIT(wdev
->chandef
.width
);
857 case NL80211_IFTYPE_STATION
:
858 case NL80211_IFTYPE_P2P_CLIENT
:
859 if (wdev
->current_bss
) {
860 *chan
= wdev
->current_bss
->pub
.channel
;
861 *chanmode
= CHAN_MODE_SHARED
;
865 case NL80211_IFTYPE_AP
:
866 case NL80211_IFTYPE_P2P_GO
:
867 if (wdev
->cac_started
) {
868 *chan
= wdev
->chandef
.chan
;
869 *chanmode
= CHAN_MODE_SHARED
;
870 *radar_detect
|= BIT(wdev
->chandef
.width
);
871 } else if (wdev
->beacon_interval
) {
872 *chan
= wdev
->chandef
.chan
;
873 *chanmode
= CHAN_MODE_SHARED
;
875 ret
= cfg80211_chandef_dfs_required(wdev
->wiphy
,
880 *radar_detect
|= BIT(wdev
->chandef
.width
);
883 case NL80211_IFTYPE_MESH_POINT
:
884 if (wdev
->mesh_id_len
) {
885 *chan
= wdev
->chandef
.chan
;
886 *chanmode
= CHAN_MODE_SHARED
;
888 ret
= cfg80211_chandef_dfs_required(wdev
->wiphy
,
893 *radar_detect
|= BIT(wdev
->chandef
.width
);
896 case NL80211_IFTYPE_OCB
:
897 if (wdev
->chandef
.chan
) {
898 *chan
= wdev
->chandef
.chan
;
899 *chanmode
= CHAN_MODE_SHARED
;
903 case NL80211_IFTYPE_MONITOR
:
904 case NL80211_IFTYPE_AP_VLAN
:
905 case NL80211_IFTYPE_WDS
:
906 case NL80211_IFTYPE_P2P_DEVICE
:
907 /* these interface types don't really have a channel */
909 case NL80211_IFTYPE_UNSPECIFIED
:
910 case NUM_NL80211_IFTYPES
: