2 * Copyright 2002-2005, Instant802 Networks, Inc.
3 * Copyright 2005-2006, Devicescape Software, Inc.
4 * Copyright 2007 Johannes Berg <johannes@sipsolutions.net>
5 * Copyright 2008-2011 Luis R. Rodriguez <mcgrof@qca.qualcomm.com>
6 * Copyright 2013-2014 Intel Mobile Communications GmbH
8 * Permission to use, copy, modify, and/or distribute this software for any
9 * purpose with or without fee is hereby granted, provided that the above
10 * copyright notice and this permission notice appear in all copies.
12 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
13 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
14 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
15 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
16 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
18 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
23 * DOC: Wireless regulatory infrastructure
25 * The usual implementation is for a driver to read a device EEPROM to
26 * determine which regulatory domain it should be operating under, then
27 * looking up the allowable channels in a driver-local table and finally
28 * registering those channels in the wiphy structure.
30 * Another set of compliance enforcement is for drivers to use their
31 * own compliance limits which can be stored on the EEPROM. The host
32 * driver or firmware may ensure these are used.
34 * In addition to all this we provide an extra layer of regulatory
35 * conformance. For drivers which do not have any regulatory
36 * information CRDA provides the complete regulatory solution.
37 * For others it provides a community effort on further restrictions
38 * to enhance compliance.
40 * Note: When number of rules --> infinity we will not be able to
41 * index on alpha2 any more, instead we'll probably have to
42 * rely on some SHA1 checksum of the regdomain for example.
46 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
48 #include <linux/kernel.h>
49 #include <linux/export.h>
50 #include <linux/slab.h>
51 #include <linux/list.h>
52 #include <linux/ctype.h>
53 #include <linux/nl80211.h>
54 #include <linux/platform_device.h>
55 #include <linux/moduleparam.h>
56 #include <net/cfg80211.h>
63 #ifdef CONFIG_CFG80211_REG_DEBUG
64 #define REG_DBG_PRINT(format, args...) \
65 printk(KERN_DEBUG pr_fmt(format), ##args)
67 #define REG_DBG_PRINT(args...)
71 * Grace period we give before making sure all current interfaces reside on
72 * channels allowed by the current regulatory domain.
74 #define REG_ENFORCE_GRACE_MS 60000
77 * enum reg_request_treatment - regulatory request treatment
79 * @REG_REQ_OK: continue processing the regulatory request
80 * @REG_REQ_IGNORE: ignore the regulatory request
81 * @REG_REQ_INTERSECT: the regulatory domain resulting from this request should
82 * be intersected with the current one.
83 * @REG_REQ_ALREADY_SET: the regulatory request will not change the current
84 * regulatory settings, and no further processing is required.
86 enum reg_request_treatment
{
93 static struct regulatory_request core_request_world
= {
94 .initiator
= NL80211_REGDOM_SET_BY_CORE
,
99 .country_ie_env
= ENVIRON_ANY
,
103 * Receipt of information from last regulatory request,
104 * protected by RTNL (and can be accessed with RCU protection)
106 static struct regulatory_request __rcu
*last_request
=
107 (void __force __rcu
*)&core_request_world
;
109 /* To trigger userspace events */
110 static struct platform_device
*reg_pdev
;
113 * Central wireless core regulatory domains, we only need two,
114 * the current one and a world regulatory domain in case we have no
115 * information to give us an alpha2.
116 * (protected by RTNL, can be read under RCU)
118 const struct ieee80211_regdomain __rcu
*cfg80211_regdomain
;
121 * Number of devices that registered to the core
122 * that support cellular base station regulatory hints
123 * (protected by RTNL)
125 static int reg_num_devs_support_basehint
;
128 * State variable indicating if the platform on which the devices
129 * are attached is operating in an indoor environment. The state variable
130 * is relevant for all registered devices.
132 static bool reg_is_indoor
;
133 static spinlock_t reg_indoor_lock
;
135 /* Used to track the userspace process controlling the indoor setting */
136 static u32 reg_is_indoor_portid
;
138 static void restore_regulatory_settings(bool reset_user
);
140 static const struct ieee80211_regdomain
*get_cfg80211_regdom(void)
142 return rtnl_dereference(cfg80211_regdomain
);
145 const struct ieee80211_regdomain
*get_wiphy_regdom(struct wiphy
*wiphy
)
147 return rtnl_dereference(wiphy
->regd
);
150 static const char *reg_dfs_region_str(enum nl80211_dfs_regions dfs_region
)
152 switch (dfs_region
) {
153 case NL80211_DFS_UNSET
:
155 case NL80211_DFS_FCC
:
157 case NL80211_DFS_ETSI
:
165 enum nl80211_dfs_regions
reg_get_dfs_region(struct wiphy
*wiphy
)
167 const struct ieee80211_regdomain
*regd
= NULL
;
168 const struct ieee80211_regdomain
*wiphy_regd
= NULL
;
170 regd
= get_cfg80211_regdom();
174 wiphy_regd
= get_wiphy_regdom(wiphy
);
178 if (wiphy_regd
->dfs_region
== regd
->dfs_region
)
181 REG_DBG_PRINT("%s: device specific dfs_region "
182 "(%s) disagrees with cfg80211's "
183 "central dfs_region (%s)\n",
184 dev_name(&wiphy
->dev
),
185 reg_dfs_region_str(wiphy_regd
->dfs_region
),
186 reg_dfs_region_str(regd
->dfs_region
));
189 return regd
->dfs_region
;
192 static void rcu_free_regdom(const struct ieee80211_regdomain
*r
)
196 kfree_rcu((struct ieee80211_regdomain
*)r
, rcu_head
);
199 static struct regulatory_request
*get_last_request(void)
201 return rcu_dereference_rtnl(last_request
);
204 /* Used to queue up regulatory hints */
205 static LIST_HEAD(reg_requests_list
);
206 static spinlock_t reg_requests_lock
;
208 /* Used to queue up beacon hints for review */
209 static LIST_HEAD(reg_pending_beacons
);
210 static spinlock_t reg_pending_beacons_lock
;
212 /* Used to keep track of processed beacon hints */
213 static LIST_HEAD(reg_beacon_list
);
216 struct list_head list
;
217 struct ieee80211_channel chan
;
220 static void reg_check_chans_work(struct work_struct
*work
);
221 static DECLARE_DELAYED_WORK(reg_check_chans
, reg_check_chans_work
);
223 static void reg_todo(struct work_struct
*work
);
224 static DECLARE_WORK(reg_work
, reg_todo
);
226 /* We keep a static world regulatory domain in case of the absence of CRDA */
227 static const struct ieee80211_regdomain world_regdom
= {
231 /* IEEE 802.11b/g, channels 1..11 */
232 REG_RULE(2412-10, 2462+10, 40, 6, 20, 0),
233 /* IEEE 802.11b/g, channels 12..13. */
234 REG_RULE(2467-10, 2472+10, 20, 6, 20,
235 NL80211_RRF_NO_IR
| NL80211_RRF_AUTO_BW
),
236 /* IEEE 802.11 channel 14 - Only JP enables
237 * this and for 802.11b only */
238 REG_RULE(2484-10, 2484+10, 20, 6, 20,
240 NL80211_RRF_NO_OFDM
),
241 /* IEEE 802.11a, channel 36..48 */
242 REG_RULE(5180-10, 5240+10, 80, 6, 20,
244 NL80211_RRF_AUTO_BW
),
246 /* IEEE 802.11a, channel 52..64 - DFS required */
247 REG_RULE(5260-10, 5320+10, 80, 6, 20,
249 NL80211_RRF_AUTO_BW
|
252 /* IEEE 802.11a, channel 100..144 - DFS required */
253 REG_RULE(5500-10, 5720+10, 160, 6, 20,
257 /* IEEE 802.11a, channel 149..165 */
258 REG_RULE(5745-10, 5825+10, 80, 6, 20,
261 /* IEEE 802.11ad (60GHz), channels 1..3 */
262 REG_RULE(56160+2160*1-1080, 56160+2160*3+1080, 2160, 0, 0, 0),
266 /* protected by RTNL */
267 static const struct ieee80211_regdomain
*cfg80211_world_regdom
=
270 static char *ieee80211_regdom
= "00";
271 static char user_alpha2
[2];
273 module_param(ieee80211_regdom
, charp
, 0444);
274 MODULE_PARM_DESC(ieee80211_regdom
, "IEEE 802.11 regulatory domain code");
276 static void reg_free_request(struct regulatory_request
*request
)
278 if (request
== &core_request_world
)
281 if (request
!= get_last_request())
285 static void reg_free_last_request(void)
287 struct regulatory_request
*lr
= get_last_request();
289 if (lr
!= &core_request_world
&& lr
)
290 kfree_rcu(lr
, rcu_head
);
293 static void reg_update_last_request(struct regulatory_request
*request
)
295 struct regulatory_request
*lr
;
297 lr
= get_last_request();
301 reg_free_last_request();
302 rcu_assign_pointer(last_request
, request
);
305 static void reset_regdomains(bool full_reset
,
306 const struct ieee80211_regdomain
*new_regdom
)
308 const struct ieee80211_regdomain
*r
;
312 r
= get_cfg80211_regdom();
314 /* avoid freeing static information or freeing something twice */
315 if (r
== cfg80211_world_regdom
)
317 if (cfg80211_world_regdom
== &world_regdom
)
318 cfg80211_world_regdom
= NULL
;
319 if (r
== &world_regdom
)
323 rcu_free_regdom(cfg80211_world_regdom
);
325 cfg80211_world_regdom
= &world_regdom
;
326 rcu_assign_pointer(cfg80211_regdomain
, new_regdom
);
331 reg_update_last_request(&core_request_world
);
335 * Dynamic world regulatory domain requested by the wireless
336 * core upon initialization
338 static void update_world_regdomain(const struct ieee80211_regdomain
*rd
)
340 struct regulatory_request
*lr
;
342 lr
= get_last_request();
346 reset_regdomains(false, rd
);
348 cfg80211_world_regdom
= rd
;
351 bool is_world_regdom(const char *alpha2
)
355 return alpha2
[0] == '0' && alpha2
[1] == '0';
358 static bool is_alpha2_set(const char *alpha2
)
362 return alpha2
[0] && alpha2
[1];
365 static bool is_unknown_alpha2(const char *alpha2
)
370 * Special case where regulatory domain was built by driver
371 * but a specific alpha2 cannot be determined
373 return alpha2
[0] == '9' && alpha2
[1] == '9';
376 static bool is_intersected_alpha2(const char *alpha2
)
381 * Special case where regulatory domain is the
382 * result of an intersection between two regulatory domain
385 return alpha2
[0] == '9' && alpha2
[1] == '8';
388 static bool is_an_alpha2(const char *alpha2
)
392 return isalpha(alpha2
[0]) && isalpha(alpha2
[1]);
395 static bool alpha2_equal(const char *alpha2_x
, const char *alpha2_y
)
397 if (!alpha2_x
|| !alpha2_y
)
399 return alpha2_x
[0] == alpha2_y
[0] && alpha2_x
[1] == alpha2_y
[1];
402 static bool regdom_changes(const char *alpha2
)
404 const struct ieee80211_regdomain
*r
= get_cfg80211_regdom();
408 return !alpha2_equal(r
->alpha2
, alpha2
);
412 * The NL80211_REGDOM_SET_BY_USER regdom alpha2 is cached, this lets
413 * you know if a valid regulatory hint with NL80211_REGDOM_SET_BY_USER
414 * has ever been issued.
416 static bool is_user_regdom_saved(void)
418 if (user_alpha2
[0] == '9' && user_alpha2
[1] == '7')
421 /* This would indicate a mistake on the design */
422 if (WARN(!is_world_regdom(user_alpha2
) && !is_an_alpha2(user_alpha2
),
423 "Unexpected user alpha2: %c%c\n",
424 user_alpha2
[0], user_alpha2
[1]))
430 static const struct ieee80211_regdomain
*
431 reg_copy_regd(const struct ieee80211_regdomain
*src_regd
)
433 struct ieee80211_regdomain
*regd
;
438 sizeof(struct ieee80211_regdomain
) +
439 src_regd
->n_reg_rules
* sizeof(struct ieee80211_reg_rule
);
441 regd
= kzalloc(size_of_regd
, GFP_KERNEL
);
443 return ERR_PTR(-ENOMEM
);
445 memcpy(regd
, src_regd
, sizeof(struct ieee80211_regdomain
));
447 for (i
= 0; i
< src_regd
->n_reg_rules
; i
++)
448 memcpy(®d
->reg_rules
[i
], &src_regd
->reg_rules
[i
],
449 sizeof(struct ieee80211_reg_rule
));
454 #ifdef CONFIG_CFG80211_INTERNAL_REGDB
455 struct reg_regdb_apply_request
{
456 struct list_head list
;
457 const struct ieee80211_regdomain
*regdom
;
460 static LIST_HEAD(reg_regdb_apply_list
);
461 static DEFINE_MUTEX(reg_regdb_apply_mutex
);
463 static void reg_regdb_apply(struct work_struct
*work
)
465 struct reg_regdb_apply_request
*request
;
469 mutex_lock(®_regdb_apply_mutex
);
470 while (!list_empty(®_regdb_apply_list
)) {
471 request
= list_first_entry(®_regdb_apply_list
,
472 struct reg_regdb_apply_request
,
474 list_del(&request
->list
);
476 set_regdom(request
->regdom
, REGD_SOURCE_INTERNAL_DB
);
479 mutex_unlock(®_regdb_apply_mutex
);
484 static DECLARE_WORK(reg_regdb_work
, reg_regdb_apply
);
486 static int reg_query_builtin(const char *alpha2
)
488 const struct ieee80211_regdomain
*regdom
= NULL
;
489 struct reg_regdb_apply_request
*request
;
492 for (i
= 0; i
< reg_regdb_size
; i
++) {
493 if (alpha2_equal(alpha2
, reg_regdb
[i
]->alpha2
)) {
494 regdom
= reg_regdb
[i
];
502 request
= kzalloc(sizeof(struct reg_regdb_apply_request
), GFP_KERNEL
);
506 request
->regdom
= reg_copy_regd(regdom
);
507 if (IS_ERR_OR_NULL(request
->regdom
)) {
512 mutex_lock(®_regdb_apply_mutex
);
513 list_add_tail(&request
->list
, ®_regdb_apply_list
);
514 mutex_unlock(®_regdb_apply_mutex
);
516 schedule_work(®_regdb_work
);
521 /* Feel free to add any other sanity checks here */
522 static void reg_regdb_size_check(void)
524 /* We should ideally BUILD_BUG_ON() but then random builds would fail */
525 WARN_ONCE(!reg_regdb_size
, "db.txt is empty, you should update it...");
528 static inline void reg_regdb_size_check(void) {}
529 static inline int reg_query_builtin(const char *alpha2
)
533 #endif /* CONFIG_CFG80211_INTERNAL_REGDB */
535 #ifdef CONFIG_CFG80211_CRDA_SUPPORT
536 /* Max number of consecutive attempts to communicate with CRDA */
537 #define REG_MAX_CRDA_TIMEOUTS 10
539 static u32 reg_crda_timeouts
;
541 static void crda_timeout_work(struct work_struct
*work
);
542 static DECLARE_DELAYED_WORK(crda_timeout
, crda_timeout_work
);
544 static void crda_timeout_work(struct work_struct
*work
)
546 REG_DBG_PRINT("Timeout while waiting for CRDA to reply, restoring regulatory settings\n");
549 restore_regulatory_settings(true);
553 static void cancel_crda_timeout(void)
555 cancel_delayed_work(&crda_timeout
);
558 static void cancel_crda_timeout_sync(void)
560 cancel_delayed_work_sync(&crda_timeout
);
563 static void reset_crda_timeouts(void)
565 reg_crda_timeouts
= 0;
569 * This lets us keep regulatory code which is updated on a regulatory
570 * basis in userspace.
572 static int call_crda(const char *alpha2
)
575 char *env
[] = { country
, NULL
};
578 snprintf(country
, sizeof(country
), "COUNTRY=%c%c",
579 alpha2
[0], alpha2
[1]);
581 if (reg_crda_timeouts
> REG_MAX_CRDA_TIMEOUTS
) {
582 pr_debug("Exceeded CRDA call max attempts. Not calling CRDA\n");
586 if (!is_world_regdom((char *) alpha2
))
587 pr_debug("Calling CRDA for country: %c%c\n",
588 alpha2
[0], alpha2
[1]);
590 pr_debug("Calling CRDA to update world regulatory domain\n");
592 ret
= kobject_uevent_env(®_pdev
->dev
.kobj
, KOBJ_CHANGE
, env
);
596 queue_delayed_work(system_power_efficient_wq
,
597 &crda_timeout
, msecs_to_jiffies(3142));
601 static inline void cancel_crda_timeout(void) {}
602 static inline void cancel_crda_timeout_sync(void) {}
603 static inline void reset_crda_timeouts(void) {}
604 static inline int call_crda(const char *alpha2
)
608 #endif /* CONFIG_CFG80211_CRDA_SUPPORT */
610 static bool reg_query_database(struct regulatory_request
*request
)
612 /* query internal regulatory database (if it exists) */
613 if (reg_query_builtin(request
->alpha2
) == 0)
616 if (call_crda(request
->alpha2
) == 0)
622 bool reg_is_valid_request(const char *alpha2
)
624 struct regulatory_request
*lr
= get_last_request();
626 if (!lr
|| lr
->processed
)
629 return alpha2_equal(lr
->alpha2
, alpha2
);
632 static const struct ieee80211_regdomain
*reg_get_regdomain(struct wiphy
*wiphy
)
634 struct regulatory_request
*lr
= get_last_request();
637 * Follow the driver's regulatory domain, if present, unless a country
638 * IE has been processed or a user wants to help complaince further
640 if (lr
->initiator
!= NL80211_REGDOM_SET_BY_COUNTRY_IE
&&
641 lr
->initiator
!= NL80211_REGDOM_SET_BY_USER
&&
643 return get_wiphy_regdom(wiphy
);
645 return get_cfg80211_regdom();
649 reg_get_max_bandwidth_from_range(const struct ieee80211_regdomain
*rd
,
650 const struct ieee80211_reg_rule
*rule
)
652 const struct ieee80211_freq_range
*freq_range
= &rule
->freq_range
;
653 const struct ieee80211_freq_range
*freq_range_tmp
;
654 const struct ieee80211_reg_rule
*tmp
;
655 u32 start_freq
, end_freq
, idx
, no
;
657 for (idx
= 0; idx
< rd
->n_reg_rules
; idx
++)
658 if (rule
== &rd
->reg_rules
[idx
])
661 if (idx
== rd
->n_reg_rules
)
668 tmp
= &rd
->reg_rules
[--no
];
669 freq_range_tmp
= &tmp
->freq_range
;
671 if (freq_range_tmp
->end_freq_khz
< freq_range
->start_freq_khz
)
674 freq_range
= freq_range_tmp
;
677 start_freq
= freq_range
->start_freq_khz
;
680 freq_range
= &rule
->freq_range
;
683 while (no
< rd
->n_reg_rules
- 1) {
684 tmp
= &rd
->reg_rules
[++no
];
685 freq_range_tmp
= &tmp
->freq_range
;
687 if (freq_range_tmp
->start_freq_khz
> freq_range
->end_freq_khz
)
690 freq_range
= freq_range_tmp
;
693 end_freq
= freq_range
->end_freq_khz
;
695 return end_freq
- start_freq
;
698 unsigned int reg_get_max_bandwidth(const struct ieee80211_regdomain
*rd
,
699 const struct ieee80211_reg_rule
*rule
)
701 unsigned int bw
= reg_get_max_bandwidth_from_range(rd
, rule
);
703 if (rule
->flags
& NL80211_RRF_NO_160MHZ
)
704 bw
= min_t(unsigned int, bw
, MHZ_TO_KHZ(80));
705 if (rule
->flags
& NL80211_RRF_NO_80MHZ
)
706 bw
= min_t(unsigned int, bw
, MHZ_TO_KHZ(40));
709 * HT40+/HT40- limits are handled per-channel. Only limit BW if both
712 if (rule
->flags
& NL80211_RRF_NO_HT40MINUS
&&
713 rule
->flags
& NL80211_RRF_NO_HT40PLUS
)
714 bw
= min_t(unsigned int, bw
, MHZ_TO_KHZ(20));
719 /* Sanity check on a regulatory rule */
720 static bool is_valid_reg_rule(const struct ieee80211_reg_rule
*rule
)
722 const struct ieee80211_freq_range
*freq_range
= &rule
->freq_range
;
725 if (freq_range
->start_freq_khz
<= 0 || freq_range
->end_freq_khz
<= 0)
728 if (freq_range
->start_freq_khz
> freq_range
->end_freq_khz
)
731 freq_diff
= freq_range
->end_freq_khz
- freq_range
->start_freq_khz
;
733 if (freq_range
->end_freq_khz
<= freq_range
->start_freq_khz
||
734 freq_range
->max_bandwidth_khz
> freq_diff
)
740 static bool is_valid_rd(const struct ieee80211_regdomain
*rd
)
742 const struct ieee80211_reg_rule
*reg_rule
= NULL
;
745 if (!rd
->n_reg_rules
)
748 if (WARN_ON(rd
->n_reg_rules
> NL80211_MAX_SUPP_REG_RULES
))
751 for (i
= 0; i
< rd
->n_reg_rules
; i
++) {
752 reg_rule
= &rd
->reg_rules
[i
];
753 if (!is_valid_reg_rule(reg_rule
))
760 static bool reg_does_bw_fit(const struct ieee80211_freq_range
*freq_range
,
761 u32 center_freq_khz
, u32 bw_khz
)
763 u32 start_freq_khz
, end_freq_khz
;
765 start_freq_khz
= center_freq_khz
- (bw_khz
/2);
766 end_freq_khz
= center_freq_khz
+ (bw_khz
/2);
768 if (start_freq_khz
>= freq_range
->start_freq_khz
&&
769 end_freq_khz
<= freq_range
->end_freq_khz
)
776 * freq_in_rule_band - tells us if a frequency is in a frequency band
777 * @freq_range: frequency rule we want to query
778 * @freq_khz: frequency we are inquiring about
780 * This lets us know if a specific frequency rule is or is not relevant to
781 * a specific frequency's band. Bands are device specific and artificial
782 * definitions (the "2.4 GHz band", the "5 GHz band" and the "60GHz band"),
783 * however it is safe for now to assume that a frequency rule should not be
784 * part of a frequency's band if the start freq or end freq are off by more
785 * than 2 GHz for the 2.4 and 5 GHz bands, and by more than 10 GHz for the
787 * This resolution can be lowered and should be considered as we add
788 * regulatory rule support for other "bands".
790 static bool freq_in_rule_band(const struct ieee80211_freq_range
*freq_range
,
793 #define ONE_GHZ_IN_KHZ 1000000
795 * From 802.11ad: directional multi-gigabit (DMG):
796 * Pertaining to operation in a frequency band containing a channel
797 * with the Channel starting frequency above 45 GHz.
799 u32 limit
= freq_khz
> 45 * ONE_GHZ_IN_KHZ
?
800 10 * ONE_GHZ_IN_KHZ
: 2 * ONE_GHZ_IN_KHZ
;
801 if (abs(freq_khz
- freq_range
->start_freq_khz
) <= limit
)
803 if (abs(freq_khz
- freq_range
->end_freq_khz
) <= limit
)
806 #undef ONE_GHZ_IN_KHZ
810 * Later on we can perhaps use the more restrictive DFS
811 * region but we don't have information for that yet so
812 * for now simply disallow conflicts.
814 static enum nl80211_dfs_regions
815 reg_intersect_dfs_region(const enum nl80211_dfs_regions dfs_region1
,
816 const enum nl80211_dfs_regions dfs_region2
)
818 if (dfs_region1
!= dfs_region2
)
819 return NL80211_DFS_UNSET
;
824 * Helper for regdom_intersect(), this does the real
825 * mathematical intersection fun
827 static int reg_rules_intersect(const struct ieee80211_regdomain
*rd1
,
828 const struct ieee80211_regdomain
*rd2
,
829 const struct ieee80211_reg_rule
*rule1
,
830 const struct ieee80211_reg_rule
*rule2
,
831 struct ieee80211_reg_rule
*intersected_rule
)
833 const struct ieee80211_freq_range
*freq_range1
, *freq_range2
;
834 struct ieee80211_freq_range
*freq_range
;
835 const struct ieee80211_power_rule
*power_rule1
, *power_rule2
;
836 struct ieee80211_power_rule
*power_rule
;
837 u32 freq_diff
, max_bandwidth1
, max_bandwidth2
;
839 freq_range1
= &rule1
->freq_range
;
840 freq_range2
= &rule2
->freq_range
;
841 freq_range
= &intersected_rule
->freq_range
;
843 power_rule1
= &rule1
->power_rule
;
844 power_rule2
= &rule2
->power_rule
;
845 power_rule
= &intersected_rule
->power_rule
;
847 freq_range
->start_freq_khz
= max(freq_range1
->start_freq_khz
,
848 freq_range2
->start_freq_khz
);
849 freq_range
->end_freq_khz
= min(freq_range1
->end_freq_khz
,
850 freq_range2
->end_freq_khz
);
852 max_bandwidth1
= freq_range1
->max_bandwidth_khz
;
853 max_bandwidth2
= freq_range2
->max_bandwidth_khz
;
855 if (rule1
->flags
& NL80211_RRF_AUTO_BW
)
856 max_bandwidth1
= reg_get_max_bandwidth(rd1
, rule1
);
857 if (rule2
->flags
& NL80211_RRF_AUTO_BW
)
858 max_bandwidth2
= reg_get_max_bandwidth(rd2
, rule2
);
860 freq_range
->max_bandwidth_khz
= min(max_bandwidth1
, max_bandwidth2
);
862 intersected_rule
->flags
= rule1
->flags
| rule2
->flags
;
865 * In case NL80211_RRF_AUTO_BW requested for both rules
866 * set AUTO_BW in intersected rule also. Next we will
867 * calculate BW correctly in handle_channel function.
868 * In other case remove AUTO_BW flag while we calculate
869 * maximum bandwidth correctly and auto calculation is
872 if ((rule1
->flags
& NL80211_RRF_AUTO_BW
) &&
873 (rule2
->flags
& NL80211_RRF_AUTO_BW
))
874 intersected_rule
->flags
|= NL80211_RRF_AUTO_BW
;
876 intersected_rule
->flags
&= ~NL80211_RRF_AUTO_BW
;
878 freq_diff
= freq_range
->end_freq_khz
- freq_range
->start_freq_khz
;
879 if (freq_range
->max_bandwidth_khz
> freq_diff
)
880 freq_range
->max_bandwidth_khz
= freq_diff
;
882 power_rule
->max_eirp
= min(power_rule1
->max_eirp
,
883 power_rule2
->max_eirp
);
884 power_rule
->max_antenna_gain
= min(power_rule1
->max_antenna_gain
,
885 power_rule2
->max_antenna_gain
);
887 intersected_rule
->dfs_cac_ms
= max(rule1
->dfs_cac_ms
,
890 if (!is_valid_reg_rule(intersected_rule
))
896 /* check whether old rule contains new rule */
897 static bool rule_contains(struct ieee80211_reg_rule
*r1
,
898 struct ieee80211_reg_rule
*r2
)
900 /* for simplicity, currently consider only same flags */
901 if (r1
->flags
!= r2
->flags
)
904 /* verify r1 is more restrictive */
905 if ((r1
->power_rule
.max_antenna_gain
>
906 r2
->power_rule
.max_antenna_gain
) ||
907 r1
->power_rule
.max_eirp
> r2
->power_rule
.max_eirp
)
910 /* make sure r2's range is contained within r1 */
911 if (r1
->freq_range
.start_freq_khz
> r2
->freq_range
.start_freq_khz
||
912 r1
->freq_range
.end_freq_khz
< r2
->freq_range
.end_freq_khz
)
915 /* and finally verify that r1.max_bw >= r2.max_bw */
916 if (r1
->freq_range
.max_bandwidth_khz
<
917 r2
->freq_range
.max_bandwidth_khz
)
923 /* add or extend current rules. do nothing if rule is already contained */
924 static void add_rule(struct ieee80211_reg_rule
*rule
,
925 struct ieee80211_reg_rule
*reg_rules
, u32
*n_rules
)
927 struct ieee80211_reg_rule
*tmp_rule
;
930 for (i
= 0; i
< *n_rules
; i
++) {
931 tmp_rule
= ®_rules
[i
];
932 /* rule is already contained - do nothing */
933 if (rule_contains(tmp_rule
, rule
))
936 /* extend rule if possible */
937 if (rule_contains(rule
, tmp_rule
)) {
938 memcpy(tmp_rule
, rule
, sizeof(*rule
));
943 memcpy(®_rules
[*n_rules
], rule
, sizeof(*rule
));
948 * regdom_intersect - do the intersection between two regulatory domains
949 * @rd1: first regulatory domain
950 * @rd2: second regulatory domain
952 * Use this function to get the intersection between two regulatory domains.
953 * Once completed we will mark the alpha2 for the rd as intersected, "98",
954 * as no one single alpha2 can represent this regulatory domain.
956 * Returns a pointer to the regulatory domain structure which will hold the
957 * resulting intersection of rules between rd1 and rd2. We will
958 * kzalloc() this structure for you.
960 static struct ieee80211_regdomain
*
961 regdom_intersect(const struct ieee80211_regdomain
*rd1
,
962 const struct ieee80211_regdomain
*rd2
)
966 unsigned int num_rules
= 0;
967 const struct ieee80211_reg_rule
*rule1
, *rule2
;
968 struct ieee80211_reg_rule intersected_rule
;
969 struct ieee80211_regdomain
*rd
;
975 * First we get a count of the rules we'll need, then we actually
976 * build them. This is to so we can malloc() and free() a
977 * regdomain once. The reason we use reg_rules_intersect() here
978 * is it will return -EINVAL if the rule computed makes no sense.
979 * All rules that do check out OK are valid.
982 for (x
= 0; x
< rd1
->n_reg_rules
; x
++) {
983 rule1
= &rd1
->reg_rules
[x
];
984 for (y
= 0; y
< rd2
->n_reg_rules
; y
++) {
985 rule2
= &rd2
->reg_rules
[y
];
986 if (!reg_rules_intersect(rd1
, rd2
, rule1
, rule2
,
995 size_of_regd
= sizeof(struct ieee80211_regdomain
) +
996 num_rules
* sizeof(struct ieee80211_reg_rule
);
998 rd
= kzalloc(size_of_regd
, GFP_KERNEL
);
1002 for (x
= 0; x
< rd1
->n_reg_rules
; x
++) {
1003 rule1
= &rd1
->reg_rules
[x
];
1004 for (y
= 0; y
< rd2
->n_reg_rules
; y
++) {
1005 rule2
= &rd2
->reg_rules
[y
];
1006 r
= reg_rules_intersect(rd1
, rd2
, rule1
, rule2
,
1009 * No need to memset here the intersected rule here as
1010 * we're not using the stack anymore
1015 add_rule(&intersected_rule
, rd
->reg_rules
,
1020 rd
->alpha2
[0] = '9';
1021 rd
->alpha2
[1] = '8';
1022 rd
->dfs_region
= reg_intersect_dfs_region(rd1
->dfs_region
,
1029 * XXX: add support for the rest of enum nl80211_reg_rule_flags, we may
1030 * want to just have the channel structure use these
1032 static u32
map_regdom_flags(u32 rd_flags
)
1034 u32 channel_flags
= 0;
1035 if (rd_flags
& NL80211_RRF_NO_IR_ALL
)
1036 channel_flags
|= IEEE80211_CHAN_NO_IR
;
1037 if (rd_flags
& NL80211_RRF_DFS
)
1038 channel_flags
|= IEEE80211_CHAN_RADAR
;
1039 if (rd_flags
& NL80211_RRF_NO_OFDM
)
1040 channel_flags
|= IEEE80211_CHAN_NO_OFDM
;
1041 if (rd_flags
& NL80211_RRF_NO_OUTDOOR
)
1042 channel_flags
|= IEEE80211_CHAN_INDOOR_ONLY
;
1043 if (rd_flags
& NL80211_RRF_IR_CONCURRENT
)
1044 channel_flags
|= IEEE80211_CHAN_IR_CONCURRENT
;
1045 if (rd_flags
& NL80211_RRF_NO_HT40MINUS
)
1046 channel_flags
|= IEEE80211_CHAN_NO_HT40MINUS
;
1047 if (rd_flags
& NL80211_RRF_NO_HT40PLUS
)
1048 channel_flags
|= IEEE80211_CHAN_NO_HT40PLUS
;
1049 if (rd_flags
& NL80211_RRF_NO_80MHZ
)
1050 channel_flags
|= IEEE80211_CHAN_NO_80MHZ
;
1051 if (rd_flags
& NL80211_RRF_NO_160MHZ
)
1052 channel_flags
|= IEEE80211_CHAN_NO_160MHZ
;
1053 return channel_flags
;
1056 static const struct ieee80211_reg_rule
*
1057 freq_reg_info_regd(u32 center_freq
,
1058 const struct ieee80211_regdomain
*regd
, u32 bw
)
1061 bool band_rule_found
= false;
1062 bool bw_fits
= false;
1065 return ERR_PTR(-EINVAL
);
1067 for (i
= 0; i
< regd
->n_reg_rules
; i
++) {
1068 const struct ieee80211_reg_rule
*rr
;
1069 const struct ieee80211_freq_range
*fr
= NULL
;
1071 rr
= ®d
->reg_rules
[i
];
1072 fr
= &rr
->freq_range
;
1075 * We only need to know if one frequency rule was
1076 * was in center_freq's band, that's enough, so lets
1077 * not overwrite it once found
1079 if (!band_rule_found
)
1080 band_rule_found
= freq_in_rule_band(fr
, center_freq
);
1082 bw_fits
= reg_does_bw_fit(fr
, center_freq
, bw
);
1084 if (band_rule_found
&& bw_fits
)
1088 if (!band_rule_found
)
1089 return ERR_PTR(-ERANGE
);
1091 return ERR_PTR(-EINVAL
);
1094 static const struct ieee80211_reg_rule
*
1095 __freq_reg_info(struct wiphy
*wiphy
, u32 center_freq
, u32 min_bw
)
1097 const struct ieee80211_regdomain
*regd
= reg_get_regdomain(wiphy
);
1098 const struct ieee80211_reg_rule
*reg_rule
= NULL
;
1101 for (bw
= MHZ_TO_KHZ(20); bw
>= min_bw
; bw
= bw
/ 2) {
1102 reg_rule
= freq_reg_info_regd(center_freq
, regd
, bw
);
1103 if (!IS_ERR(reg_rule
))
1110 const struct ieee80211_reg_rule
*freq_reg_info(struct wiphy
*wiphy
,
1113 return __freq_reg_info(wiphy
, center_freq
, MHZ_TO_KHZ(20));
1115 EXPORT_SYMBOL(freq_reg_info
);
1117 const char *reg_initiator_name(enum nl80211_reg_initiator initiator
)
1119 switch (initiator
) {
1120 case NL80211_REGDOM_SET_BY_CORE
:
1122 case NL80211_REGDOM_SET_BY_USER
:
1124 case NL80211_REGDOM_SET_BY_DRIVER
:
1126 case NL80211_REGDOM_SET_BY_COUNTRY_IE
:
1127 return "country IE";
1133 EXPORT_SYMBOL(reg_initiator_name
);
1135 static void chan_reg_rule_print_dbg(const struct ieee80211_regdomain
*regd
,
1136 struct ieee80211_channel
*chan
,
1137 const struct ieee80211_reg_rule
*reg_rule
)
1139 #ifdef CONFIG_CFG80211_REG_DEBUG
1140 const struct ieee80211_power_rule
*power_rule
;
1141 const struct ieee80211_freq_range
*freq_range
;
1142 char max_antenna_gain
[32], bw
[32];
1144 power_rule
= ®_rule
->power_rule
;
1145 freq_range
= ®_rule
->freq_range
;
1147 if (!power_rule
->max_antenna_gain
)
1148 snprintf(max_antenna_gain
, sizeof(max_antenna_gain
), "N/A");
1150 snprintf(max_antenna_gain
, sizeof(max_antenna_gain
), "%d mBi",
1151 power_rule
->max_antenna_gain
);
1153 if (reg_rule
->flags
& NL80211_RRF_AUTO_BW
)
1154 snprintf(bw
, sizeof(bw
), "%d KHz, %d KHz AUTO",
1155 freq_range
->max_bandwidth_khz
,
1156 reg_get_max_bandwidth(regd
, reg_rule
));
1158 snprintf(bw
, sizeof(bw
), "%d KHz",
1159 freq_range
->max_bandwidth_khz
);
1161 REG_DBG_PRINT("Updating information on frequency %d MHz with regulatory rule:\n",
1164 REG_DBG_PRINT("(%d KHz - %d KHz @ %s), (%s, %d mBm)\n",
1165 freq_range
->start_freq_khz
, freq_range
->end_freq_khz
,
1166 bw
, max_antenna_gain
,
1167 power_rule
->max_eirp
);
1171 static uint32_t reg_rule_to_chan_bw_flags(const struct ieee80211_regdomain
*regd
,
1172 const struct ieee80211_reg_rule
*reg_rule
,
1173 const struct ieee80211_channel
*chan
)
1175 const struct ieee80211_freq_range
*freq_range
= NULL
;
1176 u32 max_bandwidth_khz
, bw_flags
= 0;
1178 freq_range
= ®_rule
->freq_range
;
1180 max_bandwidth_khz
= freq_range
->max_bandwidth_khz
;
1181 /* Check if auto calculation requested */
1182 if (reg_rule
->flags
& NL80211_RRF_AUTO_BW
)
1183 max_bandwidth_khz
= reg_get_max_bandwidth(regd
, reg_rule
);
1185 /* If we get a reg_rule we can assume that at least 5Mhz fit */
1186 if (!reg_does_bw_fit(freq_range
, MHZ_TO_KHZ(chan
->center_freq
),
1188 bw_flags
|= IEEE80211_CHAN_NO_10MHZ
;
1189 if (!reg_does_bw_fit(freq_range
, MHZ_TO_KHZ(chan
->center_freq
),
1191 bw_flags
|= IEEE80211_CHAN_NO_20MHZ
;
1193 if (max_bandwidth_khz
< MHZ_TO_KHZ(10))
1194 bw_flags
|= IEEE80211_CHAN_NO_10MHZ
;
1195 if (max_bandwidth_khz
< MHZ_TO_KHZ(20))
1196 bw_flags
|= IEEE80211_CHAN_NO_20MHZ
;
1197 if (max_bandwidth_khz
< MHZ_TO_KHZ(40))
1198 bw_flags
|= IEEE80211_CHAN_NO_HT40
;
1199 if (max_bandwidth_khz
< MHZ_TO_KHZ(80))
1200 bw_flags
|= IEEE80211_CHAN_NO_80MHZ
;
1201 if (max_bandwidth_khz
< MHZ_TO_KHZ(160))
1202 bw_flags
|= IEEE80211_CHAN_NO_160MHZ
;
1207 * Note that right now we assume the desired channel bandwidth
1208 * is always 20 MHz for each individual channel (HT40 uses 20 MHz
1209 * per channel, the primary and the extension channel).
1211 static void handle_channel(struct wiphy
*wiphy
,
1212 enum nl80211_reg_initiator initiator
,
1213 struct ieee80211_channel
*chan
)
1215 u32 flags
, bw_flags
= 0;
1216 const struct ieee80211_reg_rule
*reg_rule
= NULL
;
1217 const struct ieee80211_power_rule
*power_rule
= NULL
;
1218 struct wiphy
*request_wiphy
= NULL
;
1219 struct regulatory_request
*lr
= get_last_request();
1220 const struct ieee80211_regdomain
*regd
;
1222 request_wiphy
= wiphy_idx_to_wiphy(lr
->wiphy_idx
);
1224 flags
= chan
->orig_flags
;
1226 reg_rule
= freq_reg_info(wiphy
, MHZ_TO_KHZ(chan
->center_freq
));
1227 if (IS_ERR(reg_rule
)) {
1229 * We will disable all channels that do not match our
1230 * received regulatory rule unless the hint is coming
1231 * from a Country IE and the Country IE had no information
1232 * about a band. The IEEE 802.11 spec allows for an AP
1233 * to send only a subset of the regulatory rules allowed,
1234 * so an AP in the US that only supports 2.4 GHz may only send
1235 * a country IE with information for the 2.4 GHz band
1236 * while 5 GHz is still supported.
1238 if (initiator
== NL80211_REGDOM_SET_BY_COUNTRY_IE
&&
1239 PTR_ERR(reg_rule
) == -ERANGE
)
1242 if (lr
->initiator
== NL80211_REGDOM_SET_BY_DRIVER
&&
1243 request_wiphy
&& request_wiphy
== wiphy
&&
1244 request_wiphy
->regulatory_flags
& REGULATORY_STRICT_REG
) {
1245 REG_DBG_PRINT("Disabling freq %d MHz for good\n",
1247 chan
->orig_flags
|= IEEE80211_CHAN_DISABLED
;
1248 chan
->flags
= chan
->orig_flags
;
1250 REG_DBG_PRINT("Disabling freq %d MHz\n",
1252 chan
->flags
|= IEEE80211_CHAN_DISABLED
;
1257 regd
= reg_get_regdomain(wiphy
);
1258 chan_reg_rule_print_dbg(regd
, chan
, reg_rule
);
1260 power_rule
= ®_rule
->power_rule
;
1261 bw_flags
= reg_rule_to_chan_bw_flags(regd
, reg_rule
, chan
);
1263 if (lr
->initiator
== NL80211_REGDOM_SET_BY_DRIVER
&&
1264 request_wiphy
&& request_wiphy
== wiphy
&&
1265 request_wiphy
->regulatory_flags
& REGULATORY_STRICT_REG
) {
1267 * This guarantees the driver's requested regulatory domain
1268 * will always be used as a base for further regulatory
1271 chan
->flags
= chan
->orig_flags
=
1272 map_regdom_flags(reg_rule
->flags
) | bw_flags
;
1273 chan
->max_antenna_gain
= chan
->orig_mag
=
1274 (int) MBI_TO_DBI(power_rule
->max_antenna_gain
);
1275 chan
->max_reg_power
= chan
->max_power
= chan
->orig_mpwr
=
1276 (int) MBM_TO_DBM(power_rule
->max_eirp
);
1278 if (chan
->flags
& IEEE80211_CHAN_RADAR
) {
1279 chan
->dfs_cac_ms
= IEEE80211_DFS_MIN_CAC_TIME_MS
;
1280 if (reg_rule
->dfs_cac_ms
)
1281 chan
->dfs_cac_ms
= reg_rule
->dfs_cac_ms
;
1287 chan
->dfs_state
= NL80211_DFS_USABLE
;
1288 chan
->dfs_state_entered
= jiffies
;
1290 chan
->beacon_found
= false;
1291 chan
->flags
= flags
| bw_flags
| map_regdom_flags(reg_rule
->flags
);
1292 chan
->max_antenna_gain
=
1293 min_t(int, chan
->orig_mag
,
1294 MBI_TO_DBI(power_rule
->max_antenna_gain
));
1295 chan
->max_reg_power
= (int) MBM_TO_DBM(power_rule
->max_eirp
);
1297 if (chan
->flags
& IEEE80211_CHAN_RADAR
) {
1298 if (reg_rule
->dfs_cac_ms
)
1299 chan
->dfs_cac_ms
= reg_rule
->dfs_cac_ms
;
1301 chan
->dfs_cac_ms
= IEEE80211_DFS_MIN_CAC_TIME_MS
;
1304 if (chan
->orig_mpwr
) {
1306 * Devices that use REGULATORY_COUNTRY_IE_FOLLOW_POWER
1307 * will always follow the passed country IE power settings.
1309 if (initiator
== NL80211_REGDOM_SET_BY_COUNTRY_IE
&&
1310 wiphy
->regulatory_flags
& REGULATORY_COUNTRY_IE_FOLLOW_POWER
)
1311 chan
->max_power
= chan
->max_reg_power
;
1313 chan
->max_power
= min(chan
->orig_mpwr
,
1314 chan
->max_reg_power
);
1316 chan
->max_power
= chan
->max_reg_power
;
1319 static void handle_band(struct wiphy
*wiphy
,
1320 enum nl80211_reg_initiator initiator
,
1321 struct ieee80211_supported_band
*sband
)
1328 for (i
= 0; i
< sband
->n_channels
; i
++)
1329 handle_channel(wiphy
, initiator
, &sband
->channels
[i
]);
1332 static bool reg_request_cell_base(struct regulatory_request
*request
)
1334 if (request
->initiator
!= NL80211_REGDOM_SET_BY_USER
)
1336 return request
->user_reg_hint_type
== NL80211_USER_REG_HINT_CELL_BASE
;
1339 bool reg_last_request_cell_base(void)
1341 return reg_request_cell_base(get_last_request());
1344 #ifdef CONFIG_CFG80211_REG_CELLULAR_HINTS
1345 /* Core specific check */
1346 static enum reg_request_treatment
1347 reg_ignore_cell_hint(struct regulatory_request
*pending_request
)
1349 struct regulatory_request
*lr
= get_last_request();
1351 if (!reg_num_devs_support_basehint
)
1352 return REG_REQ_IGNORE
;
1354 if (reg_request_cell_base(lr
) &&
1355 !regdom_changes(pending_request
->alpha2
))
1356 return REG_REQ_ALREADY_SET
;
1361 /* Device specific check */
1362 static bool reg_dev_ignore_cell_hint(struct wiphy
*wiphy
)
1364 return !(wiphy
->features
& NL80211_FEATURE_CELL_BASE_REG_HINTS
);
1367 static enum reg_request_treatment
1368 reg_ignore_cell_hint(struct regulatory_request
*pending_request
)
1370 return REG_REQ_IGNORE
;
1373 static bool reg_dev_ignore_cell_hint(struct wiphy
*wiphy
)
1379 static bool wiphy_strict_alpha2_regd(struct wiphy
*wiphy
)
1381 if (wiphy
->regulatory_flags
& REGULATORY_STRICT_REG
&&
1382 !(wiphy
->regulatory_flags
& REGULATORY_CUSTOM_REG
))
1387 static bool ignore_reg_update(struct wiphy
*wiphy
,
1388 enum nl80211_reg_initiator initiator
)
1390 struct regulatory_request
*lr
= get_last_request();
1392 if (wiphy
->regulatory_flags
& REGULATORY_WIPHY_SELF_MANAGED
)
1396 REG_DBG_PRINT("Ignoring regulatory request set by %s "
1397 "since last_request is not set\n",
1398 reg_initiator_name(initiator
));
1402 if (initiator
== NL80211_REGDOM_SET_BY_CORE
&&
1403 wiphy
->regulatory_flags
& REGULATORY_CUSTOM_REG
) {
1404 REG_DBG_PRINT("Ignoring regulatory request set by %s "
1405 "since the driver uses its own custom "
1406 "regulatory domain\n",
1407 reg_initiator_name(initiator
));
1412 * wiphy->regd will be set once the device has its own
1413 * desired regulatory domain set
1415 if (wiphy_strict_alpha2_regd(wiphy
) && !wiphy
->regd
&&
1416 initiator
!= NL80211_REGDOM_SET_BY_COUNTRY_IE
&&
1417 !is_world_regdom(lr
->alpha2
)) {
1418 REG_DBG_PRINT("Ignoring regulatory request set by %s "
1419 "since the driver requires its own regulatory "
1420 "domain to be set first\n",
1421 reg_initiator_name(initiator
));
1425 if (reg_request_cell_base(lr
))
1426 return reg_dev_ignore_cell_hint(wiphy
);
1431 static bool reg_is_world_roaming(struct wiphy
*wiphy
)
1433 const struct ieee80211_regdomain
*cr
= get_cfg80211_regdom();
1434 const struct ieee80211_regdomain
*wr
= get_wiphy_regdom(wiphy
);
1435 struct regulatory_request
*lr
= get_last_request();
1437 if (is_world_regdom(cr
->alpha2
) || (wr
&& is_world_regdom(wr
->alpha2
)))
1440 if (lr
&& lr
->initiator
!= NL80211_REGDOM_SET_BY_COUNTRY_IE
&&
1441 wiphy
->regulatory_flags
& REGULATORY_CUSTOM_REG
)
1447 static void handle_reg_beacon(struct wiphy
*wiphy
, unsigned int chan_idx
,
1448 struct reg_beacon
*reg_beacon
)
1450 struct ieee80211_supported_band
*sband
;
1451 struct ieee80211_channel
*chan
;
1452 bool channel_changed
= false;
1453 struct ieee80211_channel chan_before
;
1455 sband
= wiphy
->bands
[reg_beacon
->chan
.band
];
1456 chan
= &sband
->channels
[chan_idx
];
1458 if (likely(chan
->center_freq
!= reg_beacon
->chan
.center_freq
))
1461 if (chan
->beacon_found
)
1464 chan
->beacon_found
= true;
1466 if (!reg_is_world_roaming(wiphy
))
1469 if (wiphy
->regulatory_flags
& REGULATORY_DISABLE_BEACON_HINTS
)
1472 chan_before
.center_freq
= chan
->center_freq
;
1473 chan_before
.flags
= chan
->flags
;
1475 if (chan
->flags
& IEEE80211_CHAN_NO_IR
) {
1476 chan
->flags
&= ~IEEE80211_CHAN_NO_IR
;
1477 channel_changed
= true;
1480 if (channel_changed
)
1481 nl80211_send_beacon_hint_event(wiphy
, &chan_before
, chan
);
1485 * Called when a scan on a wiphy finds a beacon on
1488 static void wiphy_update_new_beacon(struct wiphy
*wiphy
,
1489 struct reg_beacon
*reg_beacon
)
1492 struct ieee80211_supported_band
*sband
;
1494 if (!wiphy
->bands
[reg_beacon
->chan
.band
])
1497 sband
= wiphy
->bands
[reg_beacon
->chan
.band
];
1499 for (i
= 0; i
< sband
->n_channels
; i
++)
1500 handle_reg_beacon(wiphy
, i
, reg_beacon
);
1504 * Called upon reg changes or a new wiphy is added
1506 static void wiphy_update_beacon_reg(struct wiphy
*wiphy
)
1509 struct ieee80211_supported_band
*sband
;
1510 struct reg_beacon
*reg_beacon
;
1512 list_for_each_entry(reg_beacon
, ®_beacon_list
, list
) {
1513 if (!wiphy
->bands
[reg_beacon
->chan
.band
])
1515 sband
= wiphy
->bands
[reg_beacon
->chan
.band
];
1516 for (i
= 0; i
< sband
->n_channels
; i
++)
1517 handle_reg_beacon(wiphy
, i
, reg_beacon
);
1521 /* Reap the advantages of previously found beacons */
1522 static void reg_process_beacons(struct wiphy
*wiphy
)
1525 * Means we are just firing up cfg80211, so no beacons would
1526 * have been processed yet.
1530 wiphy_update_beacon_reg(wiphy
);
1533 static bool is_ht40_allowed(struct ieee80211_channel
*chan
)
1537 if (chan
->flags
& IEEE80211_CHAN_DISABLED
)
1539 /* This would happen when regulatory rules disallow HT40 completely */
1540 if ((chan
->flags
& IEEE80211_CHAN_NO_HT40
) == IEEE80211_CHAN_NO_HT40
)
1545 static void reg_process_ht_flags_channel(struct wiphy
*wiphy
,
1546 struct ieee80211_channel
*channel
)
1548 struct ieee80211_supported_band
*sband
= wiphy
->bands
[channel
->band
];
1549 struct ieee80211_channel
*channel_before
= NULL
, *channel_after
= NULL
;
1552 if (!is_ht40_allowed(channel
)) {
1553 channel
->flags
|= IEEE80211_CHAN_NO_HT40
;
1558 * We need to ensure the extension channels exist to
1559 * be able to use HT40- or HT40+, this finds them (or not)
1561 for (i
= 0; i
< sband
->n_channels
; i
++) {
1562 struct ieee80211_channel
*c
= &sband
->channels
[i
];
1564 if (c
->center_freq
== (channel
->center_freq
- 20))
1566 if (c
->center_freq
== (channel
->center_freq
+ 20))
1571 * Please note that this assumes target bandwidth is 20 MHz,
1572 * if that ever changes we also need to change the below logic
1573 * to include that as well.
1575 if (!is_ht40_allowed(channel_before
))
1576 channel
->flags
|= IEEE80211_CHAN_NO_HT40MINUS
;
1578 channel
->flags
&= ~IEEE80211_CHAN_NO_HT40MINUS
;
1580 if (!is_ht40_allowed(channel_after
))
1581 channel
->flags
|= IEEE80211_CHAN_NO_HT40PLUS
;
1583 channel
->flags
&= ~IEEE80211_CHAN_NO_HT40PLUS
;
1586 static void reg_process_ht_flags_band(struct wiphy
*wiphy
,
1587 struct ieee80211_supported_band
*sband
)
1594 for (i
= 0; i
< sband
->n_channels
; i
++)
1595 reg_process_ht_flags_channel(wiphy
, &sband
->channels
[i
]);
1598 static void reg_process_ht_flags(struct wiphy
*wiphy
)
1600 enum ieee80211_band band
;
1605 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++)
1606 reg_process_ht_flags_band(wiphy
, wiphy
->bands
[band
]);
1609 static void reg_call_notifier(struct wiphy
*wiphy
,
1610 struct regulatory_request
*request
)
1612 if (wiphy
->reg_notifier
)
1613 wiphy
->reg_notifier(wiphy
, request
);
1616 static bool reg_wdev_chan_valid(struct wiphy
*wiphy
, struct wireless_dev
*wdev
)
1618 struct cfg80211_chan_def chandef
;
1619 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
1620 enum nl80211_iftype iftype
;
1623 iftype
= wdev
->iftype
;
1625 /* make sure the interface is active */
1626 if (!wdev
->netdev
|| !netif_running(wdev
->netdev
))
1627 goto wdev_inactive_unlock
;
1630 case NL80211_IFTYPE_AP
:
1631 case NL80211_IFTYPE_P2P_GO
:
1632 if (!wdev
->beacon_interval
)
1633 goto wdev_inactive_unlock
;
1634 chandef
= wdev
->chandef
;
1636 case NL80211_IFTYPE_ADHOC
:
1637 if (!wdev
->ssid_len
)
1638 goto wdev_inactive_unlock
;
1639 chandef
= wdev
->chandef
;
1641 case NL80211_IFTYPE_STATION
:
1642 case NL80211_IFTYPE_P2P_CLIENT
:
1643 if (!wdev
->current_bss
||
1644 !wdev
->current_bss
->pub
.channel
)
1645 goto wdev_inactive_unlock
;
1647 if (!rdev
->ops
->get_channel
||
1648 rdev_get_channel(rdev
, wdev
, &chandef
))
1649 cfg80211_chandef_create(&chandef
,
1650 wdev
->current_bss
->pub
.channel
,
1651 NL80211_CHAN_NO_HT
);
1653 case NL80211_IFTYPE_MONITOR
:
1654 case NL80211_IFTYPE_AP_VLAN
:
1655 case NL80211_IFTYPE_P2P_DEVICE
:
1656 /* no enforcement required */
1659 /* others not implemented for now */
1667 case NL80211_IFTYPE_AP
:
1668 case NL80211_IFTYPE_P2P_GO
:
1669 case NL80211_IFTYPE_ADHOC
:
1670 return cfg80211_reg_can_beacon_relax(wiphy
, &chandef
, iftype
);
1671 case NL80211_IFTYPE_STATION
:
1672 case NL80211_IFTYPE_P2P_CLIENT
:
1673 return cfg80211_chandef_usable(wiphy
, &chandef
,
1674 IEEE80211_CHAN_DISABLED
);
1681 wdev_inactive_unlock
:
1686 static void reg_leave_invalid_chans(struct wiphy
*wiphy
)
1688 struct wireless_dev
*wdev
;
1689 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
1693 list_for_each_entry(wdev
, &rdev
->wdev_list
, list
)
1694 if (!reg_wdev_chan_valid(wiphy
, wdev
))
1695 cfg80211_leave(rdev
, wdev
);
1698 static void reg_check_chans_work(struct work_struct
*work
)
1700 struct cfg80211_registered_device
*rdev
;
1702 REG_DBG_PRINT("Verifying active interfaces after reg change\n");
1705 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
)
1706 if (!(rdev
->wiphy
.regulatory_flags
&
1707 REGULATORY_IGNORE_STALE_KICKOFF
))
1708 reg_leave_invalid_chans(&rdev
->wiphy
);
1713 static void reg_check_channels(void)
1716 * Give usermode a chance to do something nicer (move to another
1717 * channel, orderly disconnection), before forcing a disconnection.
1719 mod_delayed_work(system_power_efficient_wq
,
1721 msecs_to_jiffies(REG_ENFORCE_GRACE_MS
));
1724 static void wiphy_update_regulatory(struct wiphy
*wiphy
,
1725 enum nl80211_reg_initiator initiator
)
1727 enum ieee80211_band band
;
1728 struct regulatory_request
*lr
= get_last_request();
1730 if (ignore_reg_update(wiphy
, initiator
)) {
1732 * Regulatory updates set by CORE are ignored for custom
1733 * regulatory cards. Let us notify the changes to the driver,
1734 * as some drivers used this to restore its orig_* reg domain.
1736 if (initiator
== NL80211_REGDOM_SET_BY_CORE
&&
1737 wiphy
->regulatory_flags
& REGULATORY_CUSTOM_REG
)
1738 reg_call_notifier(wiphy
, lr
);
1742 lr
->dfs_region
= get_cfg80211_regdom()->dfs_region
;
1744 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++)
1745 handle_band(wiphy
, initiator
, wiphy
->bands
[band
]);
1747 reg_process_beacons(wiphy
);
1748 reg_process_ht_flags(wiphy
);
1749 reg_call_notifier(wiphy
, lr
);
1752 static void update_all_wiphy_regulatory(enum nl80211_reg_initiator initiator
)
1754 struct cfg80211_registered_device
*rdev
;
1755 struct wiphy
*wiphy
;
1759 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
) {
1760 wiphy
= &rdev
->wiphy
;
1761 wiphy_update_regulatory(wiphy
, initiator
);
1764 reg_check_channels();
1767 static void handle_channel_custom(struct wiphy
*wiphy
,
1768 struct ieee80211_channel
*chan
,
1769 const struct ieee80211_regdomain
*regd
)
1772 const struct ieee80211_reg_rule
*reg_rule
= NULL
;
1773 const struct ieee80211_power_rule
*power_rule
= NULL
;
1776 for (bw
= MHZ_TO_KHZ(20); bw
>= MHZ_TO_KHZ(5); bw
= bw
/ 2) {
1777 reg_rule
= freq_reg_info_regd(MHZ_TO_KHZ(chan
->center_freq
),
1779 if (!IS_ERR(reg_rule
))
1783 if (IS_ERR(reg_rule
)) {
1784 REG_DBG_PRINT("Disabling freq %d MHz as custom regd has no rule that fits it\n",
1786 if (wiphy
->regulatory_flags
& REGULATORY_WIPHY_SELF_MANAGED
) {
1787 chan
->flags
|= IEEE80211_CHAN_DISABLED
;
1789 chan
->orig_flags
|= IEEE80211_CHAN_DISABLED
;
1790 chan
->flags
= chan
->orig_flags
;
1795 chan_reg_rule_print_dbg(regd
, chan
, reg_rule
);
1797 power_rule
= ®_rule
->power_rule
;
1798 bw_flags
= reg_rule_to_chan_bw_flags(regd
, reg_rule
, chan
);
1800 chan
->dfs_state_entered
= jiffies
;
1801 chan
->dfs_state
= NL80211_DFS_USABLE
;
1803 chan
->beacon_found
= false;
1805 if (wiphy
->regulatory_flags
& REGULATORY_WIPHY_SELF_MANAGED
)
1806 chan
->flags
= chan
->orig_flags
| bw_flags
|
1807 map_regdom_flags(reg_rule
->flags
);
1809 chan
->flags
|= map_regdom_flags(reg_rule
->flags
) | bw_flags
;
1811 chan
->max_antenna_gain
= (int) MBI_TO_DBI(power_rule
->max_antenna_gain
);
1812 chan
->max_reg_power
= chan
->max_power
=
1813 (int) MBM_TO_DBM(power_rule
->max_eirp
);
1815 if (chan
->flags
& IEEE80211_CHAN_RADAR
) {
1816 if (reg_rule
->dfs_cac_ms
)
1817 chan
->dfs_cac_ms
= reg_rule
->dfs_cac_ms
;
1819 chan
->dfs_cac_ms
= IEEE80211_DFS_MIN_CAC_TIME_MS
;
1822 chan
->max_power
= chan
->max_reg_power
;
1825 static void handle_band_custom(struct wiphy
*wiphy
,
1826 struct ieee80211_supported_band
*sband
,
1827 const struct ieee80211_regdomain
*regd
)
1834 for (i
= 0; i
< sband
->n_channels
; i
++)
1835 handle_channel_custom(wiphy
, &sband
->channels
[i
], regd
);
1838 /* Used by drivers prior to wiphy registration */
1839 void wiphy_apply_custom_regulatory(struct wiphy
*wiphy
,
1840 const struct ieee80211_regdomain
*regd
)
1842 enum ieee80211_band band
;
1843 unsigned int bands_set
= 0;
1845 WARN(!(wiphy
->regulatory_flags
& REGULATORY_CUSTOM_REG
),
1846 "wiphy should have REGULATORY_CUSTOM_REG\n");
1847 wiphy
->regulatory_flags
|= REGULATORY_CUSTOM_REG
;
1849 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
1850 if (!wiphy
->bands
[band
])
1852 handle_band_custom(wiphy
, wiphy
->bands
[band
], regd
);
1857 * no point in calling this if it won't have any effect
1858 * on your device's supported bands.
1860 WARN_ON(!bands_set
);
1862 EXPORT_SYMBOL(wiphy_apply_custom_regulatory
);
1864 static void reg_set_request_processed(void)
1866 bool need_more_processing
= false;
1867 struct regulatory_request
*lr
= get_last_request();
1869 lr
->processed
= true;
1871 spin_lock(®_requests_lock
);
1872 if (!list_empty(®_requests_list
))
1873 need_more_processing
= true;
1874 spin_unlock(®_requests_lock
);
1876 cancel_crda_timeout();
1878 if (need_more_processing
)
1879 schedule_work(®_work
);
1883 * reg_process_hint_core - process core regulatory requests
1884 * @pending_request: a pending core regulatory request
1886 * The wireless subsystem can use this function to process
1887 * a regulatory request issued by the regulatory core.
1889 static enum reg_request_treatment
1890 reg_process_hint_core(struct regulatory_request
*core_request
)
1892 if (reg_query_database(core_request
)) {
1893 core_request
->intersect
= false;
1894 core_request
->processed
= false;
1895 reg_update_last_request(core_request
);
1899 return REG_REQ_IGNORE
;
1902 static enum reg_request_treatment
1903 __reg_process_hint_user(struct regulatory_request
*user_request
)
1905 struct regulatory_request
*lr
= get_last_request();
1907 if (reg_request_cell_base(user_request
))
1908 return reg_ignore_cell_hint(user_request
);
1910 if (reg_request_cell_base(lr
))
1911 return REG_REQ_IGNORE
;
1913 if (lr
->initiator
== NL80211_REGDOM_SET_BY_COUNTRY_IE
)
1914 return REG_REQ_INTERSECT
;
1916 * If the user knows better the user should set the regdom
1917 * to their country before the IE is picked up
1919 if (lr
->initiator
== NL80211_REGDOM_SET_BY_USER
&&
1921 return REG_REQ_IGNORE
;
1923 * Process user requests only after previous user/driver/core
1924 * requests have been processed
1926 if ((lr
->initiator
== NL80211_REGDOM_SET_BY_CORE
||
1927 lr
->initiator
== NL80211_REGDOM_SET_BY_DRIVER
||
1928 lr
->initiator
== NL80211_REGDOM_SET_BY_USER
) &&
1929 regdom_changes(lr
->alpha2
))
1930 return REG_REQ_IGNORE
;
1932 if (!regdom_changes(user_request
->alpha2
))
1933 return REG_REQ_ALREADY_SET
;
1939 * reg_process_hint_user - process user regulatory requests
1940 * @user_request: a pending user regulatory request
1942 * The wireless subsystem can use this function to process
1943 * a regulatory request initiated by userspace.
1945 static enum reg_request_treatment
1946 reg_process_hint_user(struct regulatory_request
*user_request
)
1948 enum reg_request_treatment treatment
;
1950 treatment
= __reg_process_hint_user(user_request
);
1951 if (treatment
== REG_REQ_IGNORE
||
1952 treatment
== REG_REQ_ALREADY_SET
)
1953 return REG_REQ_IGNORE
;
1955 user_request
->intersect
= treatment
== REG_REQ_INTERSECT
;
1956 user_request
->processed
= false;
1958 if (reg_query_database(user_request
)) {
1959 reg_update_last_request(user_request
);
1960 user_alpha2
[0] = user_request
->alpha2
[0];
1961 user_alpha2
[1] = user_request
->alpha2
[1];
1965 return REG_REQ_IGNORE
;
1968 static enum reg_request_treatment
1969 __reg_process_hint_driver(struct regulatory_request
*driver_request
)
1971 struct regulatory_request
*lr
= get_last_request();
1973 if (lr
->initiator
== NL80211_REGDOM_SET_BY_CORE
) {
1974 if (regdom_changes(driver_request
->alpha2
))
1976 return REG_REQ_ALREADY_SET
;
1980 * This would happen if you unplug and plug your card
1981 * back in or if you add a new device for which the previously
1982 * loaded card also agrees on the regulatory domain.
1984 if (lr
->initiator
== NL80211_REGDOM_SET_BY_DRIVER
&&
1985 !regdom_changes(driver_request
->alpha2
))
1986 return REG_REQ_ALREADY_SET
;
1988 return REG_REQ_INTERSECT
;
1992 * reg_process_hint_driver - process driver regulatory requests
1993 * @driver_request: a pending driver regulatory request
1995 * The wireless subsystem can use this function to process
1996 * a regulatory request issued by an 802.11 driver.
1998 * Returns one of the different reg request treatment values.
2000 static enum reg_request_treatment
2001 reg_process_hint_driver(struct wiphy
*wiphy
,
2002 struct regulatory_request
*driver_request
)
2004 const struct ieee80211_regdomain
*regd
, *tmp
;
2005 enum reg_request_treatment treatment
;
2007 treatment
= __reg_process_hint_driver(driver_request
);
2009 switch (treatment
) {
2012 case REG_REQ_IGNORE
:
2013 return REG_REQ_IGNORE
;
2014 case REG_REQ_INTERSECT
:
2015 case REG_REQ_ALREADY_SET
:
2016 regd
= reg_copy_regd(get_cfg80211_regdom());
2018 return REG_REQ_IGNORE
;
2020 tmp
= get_wiphy_regdom(wiphy
);
2021 rcu_assign_pointer(wiphy
->regd
, regd
);
2022 rcu_free_regdom(tmp
);
2026 driver_request
->intersect
= treatment
== REG_REQ_INTERSECT
;
2027 driver_request
->processed
= false;
2030 * Since CRDA will not be called in this case as we already
2031 * have applied the requested regulatory domain before we just
2032 * inform userspace we have processed the request
2034 if (treatment
== REG_REQ_ALREADY_SET
) {
2035 nl80211_send_reg_change_event(driver_request
);
2036 reg_update_last_request(driver_request
);
2037 reg_set_request_processed();
2038 return REG_REQ_ALREADY_SET
;
2041 if (reg_query_database(driver_request
)) {
2042 reg_update_last_request(driver_request
);
2046 return REG_REQ_IGNORE
;
2049 static enum reg_request_treatment
2050 __reg_process_hint_country_ie(struct wiphy
*wiphy
,
2051 struct regulatory_request
*country_ie_request
)
2053 struct wiphy
*last_wiphy
= NULL
;
2054 struct regulatory_request
*lr
= get_last_request();
2056 if (reg_request_cell_base(lr
)) {
2057 /* Trust a Cell base station over the AP's country IE */
2058 if (regdom_changes(country_ie_request
->alpha2
))
2059 return REG_REQ_IGNORE
;
2060 return REG_REQ_ALREADY_SET
;
2062 if (wiphy
->regulatory_flags
& REGULATORY_COUNTRY_IE_IGNORE
)
2063 return REG_REQ_IGNORE
;
2066 if (unlikely(!is_an_alpha2(country_ie_request
->alpha2
)))
2069 if (lr
->initiator
!= NL80211_REGDOM_SET_BY_COUNTRY_IE
)
2072 last_wiphy
= wiphy_idx_to_wiphy(lr
->wiphy_idx
);
2074 if (last_wiphy
!= wiphy
) {
2076 * Two cards with two APs claiming different
2077 * Country IE alpha2s. We could
2078 * intersect them, but that seems unlikely
2079 * to be correct. Reject second one for now.
2081 if (regdom_changes(country_ie_request
->alpha2
))
2082 return REG_REQ_IGNORE
;
2083 return REG_REQ_ALREADY_SET
;
2086 if (regdom_changes(country_ie_request
->alpha2
))
2088 return REG_REQ_ALREADY_SET
;
2092 * reg_process_hint_country_ie - process regulatory requests from country IEs
2093 * @country_ie_request: a regulatory request from a country IE
2095 * The wireless subsystem can use this function to process
2096 * a regulatory request issued by a country Information Element.
2098 * Returns one of the different reg request treatment values.
2100 static enum reg_request_treatment
2101 reg_process_hint_country_ie(struct wiphy
*wiphy
,
2102 struct regulatory_request
*country_ie_request
)
2104 enum reg_request_treatment treatment
;
2106 treatment
= __reg_process_hint_country_ie(wiphy
, country_ie_request
);
2108 switch (treatment
) {
2111 case REG_REQ_IGNORE
:
2112 return REG_REQ_IGNORE
;
2113 case REG_REQ_ALREADY_SET
:
2114 reg_free_request(country_ie_request
);
2115 return REG_REQ_ALREADY_SET
;
2116 case REG_REQ_INTERSECT
:
2118 * This doesn't happen yet, not sure we
2119 * ever want to support it for this case.
2121 WARN_ONCE(1, "Unexpected intersection for country IEs");
2122 return REG_REQ_IGNORE
;
2125 country_ie_request
->intersect
= false;
2126 country_ie_request
->processed
= false;
2128 if (reg_query_database(country_ie_request
)) {
2129 reg_update_last_request(country_ie_request
);
2133 return REG_REQ_IGNORE
;
2136 /* This processes *all* regulatory hints */
2137 static void reg_process_hint(struct regulatory_request
*reg_request
)
2139 struct wiphy
*wiphy
= NULL
;
2140 enum reg_request_treatment treatment
;
2142 if (reg_request
->wiphy_idx
!= WIPHY_IDX_INVALID
)
2143 wiphy
= wiphy_idx_to_wiphy(reg_request
->wiphy_idx
);
2145 switch (reg_request
->initiator
) {
2146 case NL80211_REGDOM_SET_BY_CORE
:
2147 treatment
= reg_process_hint_core(reg_request
);
2149 case NL80211_REGDOM_SET_BY_USER
:
2150 treatment
= reg_process_hint_user(reg_request
);
2152 case NL80211_REGDOM_SET_BY_DRIVER
:
2155 treatment
= reg_process_hint_driver(wiphy
, reg_request
);
2157 case NL80211_REGDOM_SET_BY_COUNTRY_IE
:
2160 treatment
= reg_process_hint_country_ie(wiphy
, reg_request
);
2163 WARN(1, "invalid initiator %d\n", reg_request
->initiator
);
2167 if (treatment
== REG_REQ_IGNORE
)
2170 WARN(treatment
!= REG_REQ_OK
&& treatment
!= REG_REQ_ALREADY_SET
,
2171 "unexpected treatment value %d\n", treatment
);
2173 /* This is required so that the orig_* parameters are saved.
2174 * NOTE: treatment must be set for any case that reaches here!
2176 if (treatment
== REG_REQ_ALREADY_SET
&& wiphy
&&
2177 wiphy
->regulatory_flags
& REGULATORY_STRICT_REG
) {
2178 wiphy_update_regulatory(wiphy
, reg_request
->initiator
);
2179 reg_check_channels();
2185 reg_free_request(reg_request
);
2188 static bool reg_only_self_managed_wiphys(void)
2190 struct cfg80211_registered_device
*rdev
;
2191 struct wiphy
*wiphy
;
2192 bool self_managed_found
= false;
2196 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
) {
2197 wiphy
= &rdev
->wiphy
;
2198 if (wiphy
->regulatory_flags
& REGULATORY_WIPHY_SELF_MANAGED
)
2199 self_managed_found
= true;
2204 /* make sure at least one self-managed wiphy exists */
2205 return self_managed_found
;
2209 * Processes regulatory hints, this is all the NL80211_REGDOM_SET_BY_*
2210 * Regulatory hints come on a first come first serve basis and we
2211 * must process each one atomically.
2213 static void reg_process_pending_hints(void)
2215 struct regulatory_request
*reg_request
, *lr
;
2217 lr
= get_last_request();
2219 /* When last_request->processed becomes true this will be rescheduled */
2220 if (lr
&& !lr
->processed
) {
2221 reg_process_hint(lr
);
2225 spin_lock(®_requests_lock
);
2227 if (list_empty(®_requests_list
)) {
2228 spin_unlock(®_requests_lock
);
2232 reg_request
= list_first_entry(®_requests_list
,
2233 struct regulatory_request
,
2235 list_del_init(®_request
->list
);
2237 spin_unlock(®_requests_lock
);
2239 if (reg_only_self_managed_wiphys()) {
2240 reg_free_request(reg_request
);
2244 reg_process_hint(reg_request
);
2246 lr
= get_last_request();
2248 spin_lock(®_requests_lock
);
2249 if (!list_empty(®_requests_list
) && lr
&& lr
->processed
)
2250 schedule_work(®_work
);
2251 spin_unlock(®_requests_lock
);
2254 /* Processes beacon hints -- this has nothing to do with country IEs */
2255 static void reg_process_pending_beacon_hints(void)
2257 struct cfg80211_registered_device
*rdev
;
2258 struct reg_beacon
*pending_beacon
, *tmp
;
2260 /* This goes through the _pending_ beacon list */
2261 spin_lock_bh(®_pending_beacons_lock
);
2263 list_for_each_entry_safe(pending_beacon
, tmp
,
2264 ®_pending_beacons
, list
) {
2265 list_del_init(&pending_beacon
->list
);
2267 /* Applies the beacon hint to current wiphys */
2268 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
)
2269 wiphy_update_new_beacon(&rdev
->wiphy
, pending_beacon
);
2271 /* Remembers the beacon hint for new wiphys or reg changes */
2272 list_add_tail(&pending_beacon
->list
, ®_beacon_list
);
2275 spin_unlock_bh(®_pending_beacons_lock
);
2278 static void reg_process_self_managed_hints(void)
2280 struct cfg80211_registered_device
*rdev
;
2281 struct wiphy
*wiphy
;
2282 const struct ieee80211_regdomain
*tmp
;
2283 const struct ieee80211_regdomain
*regd
;
2284 enum ieee80211_band band
;
2285 struct regulatory_request request
= {};
2287 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
) {
2288 wiphy
= &rdev
->wiphy
;
2290 spin_lock(®_requests_lock
);
2291 regd
= rdev
->requested_regd
;
2292 rdev
->requested_regd
= NULL
;
2293 spin_unlock(®_requests_lock
);
2298 tmp
= get_wiphy_regdom(wiphy
);
2299 rcu_assign_pointer(wiphy
->regd
, regd
);
2300 rcu_free_regdom(tmp
);
2302 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++)
2303 handle_band_custom(wiphy
, wiphy
->bands
[band
], regd
);
2305 reg_process_ht_flags(wiphy
);
2307 request
.wiphy_idx
= get_wiphy_idx(wiphy
);
2308 request
.alpha2
[0] = regd
->alpha2
[0];
2309 request
.alpha2
[1] = regd
->alpha2
[1];
2310 request
.initiator
= NL80211_REGDOM_SET_BY_DRIVER
;
2312 nl80211_send_wiphy_reg_change_event(&request
);
2315 reg_check_channels();
2318 static void reg_todo(struct work_struct
*work
)
2321 reg_process_pending_hints();
2322 reg_process_pending_beacon_hints();
2323 reg_process_self_managed_hints();
2327 static void queue_regulatory_request(struct regulatory_request
*request
)
2329 request
->alpha2
[0] = toupper(request
->alpha2
[0]);
2330 request
->alpha2
[1] = toupper(request
->alpha2
[1]);
2332 spin_lock(®_requests_lock
);
2333 list_add_tail(&request
->list
, ®_requests_list
);
2334 spin_unlock(®_requests_lock
);
2336 schedule_work(®_work
);
2340 * Core regulatory hint -- happens during cfg80211_init()
2341 * and when we restore regulatory settings.
2343 static int regulatory_hint_core(const char *alpha2
)
2345 struct regulatory_request
*request
;
2347 request
= kzalloc(sizeof(struct regulatory_request
), GFP_KERNEL
);
2351 request
->alpha2
[0] = alpha2
[0];
2352 request
->alpha2
[1] = alpha2
[1];
2353 request
->initiator
= NL80211_REGDOM_SET_BY_CORE
;
2355 queue_regulatory_request(request
);
2361 int regulatory_hint_user(const char *alpha2
,
2362 enum nl80211_user_reg_hint_type user_reg_hint_type
)
2364 struct regulatory_request
*request
;
2366 if (WARN_ON(!alpha2
))
2369 request
= kzalloc(sizeof(struct regulatory_request
), GFP_KERNEL
);
2373 request
->wiphy_idx
= WIPHY_IDX_INVALID
;
2374 request
->alpha2
[0] = alpha2
[0];
2375 request
->alpha2
[1] = alpha2
[1];
2376 request
->initiator
= NL80211_REGDOM_SET_BY_USER
;
2377 request
->user_reg_hint_type
= user_reg_hint_type
;
2379 /* Allow calling CRDA again */
2380 reset_crda_timeouts();
2382 queue_regulatory_request(request
);
2387 int regulatory_hint_indoor(bool is_indoor
, u32 portid
)
2389 spin_lock(®_indoor_lock
);
2391 /* It is possible that more than one user space process is trying to
2392 * configure the indoor setting. To handle such cases, clear the indoor
2393 * setting in case that some process does not think that the device
2394 * is operating in an indoor environment. In addition, if a user space
2395 * process indicates that it is controlling the indoor setting, save its
2396 * portid, i.e., make it the owner.
2398 reg_is_indoor
= is_indoor
;
2399 if (reg_is_indoor
) {
2400 if (!reg_is_indoor_portid
)
2401 reg_is_indoor_portid
= portid
;
2403 reg_is_indoor_portid
= 0;
2406 spin_unlock(®_indoor_lock
);
2409 reg_check_channels();
2414 void regulatory_netlink_notify(u32 portid
)
2416 spin_lock(®_indoor_lock
);
2418 if (reg_is_indoor_portid
!= portid
) {
2419 spin_unlock(®_indoor_lock
);
2423 reg_is_indoor
= false;
2424 reg_is_indoor_portid
= 0;
2426 spin_unlock(®_indoor_lock
);
2428 reg_check_channels();
2432 int regulatory_hint(struct wiphy
*wiphy
, const char *alpha2
)
2434 struct regulatory_request
*request
;
2436 if (WARN_ON(!alpha2
|| !wiphy
))
2439 wiphy
->regulatory_flags
&= ~REGULATORY_CUSTOM_REG
;
2441 request
= kzalloc(sizeof(struct regulatory_request
), GFP_KERNEL
);
2445 request
->wiphy_idx
= get_wiphy_idx(wiphy
);
2447 request
->alpha2
[0] = alpha2
[0];
2448 request
->alpha2
[1] = alpha2
[1];
2449 request
->initiator
= NL80211_REGDOM_SET_BY_DRIVER
;
2451 /* Allow calling CRDA again */
2452 reset_crda_timeouts();
2454 queue_regulatory_request(request
);
2458 EXPORT_SYMBOL(regulatory_hint
);
2460 void regulatory_hint_country_ie(struct wiphy
*wiphy
, enum ieee80211_band band
,
2461 const u8
*country_ie
, u8 country_ie_len
)
2464 enum environment_cap env
= ENVIRON_ANY
;
2465 struct regulatory_request
*request
= NULL
, *lr
;
2467 /* IE len must be evenly divisible by 2 */
2468 if (country_ie_len
& 0x01)
2471 if (country_ie_len
< IEEE80211_COUNTRY_IE_MIN_LEN
)
2474 request
= kzalloc(sizeof(*request
), GFP_KERNEL
);
2478 alpha2
[0] = country_ie
[0];
2479 alpha2
[1] = country_ie
[1];
2481 if (country_ie
[2] == 'I')
2482 env
= ENVIRON_INDOOR
;
2483 else if (country_ie
[2] == 'O')
2484 env
= ENVIRON_OUTDOOR
;
2487 lr
= get_last_request();
2493 * We will run this only upon a successful connection on cfg80211.
2494 * We leave conflict resolution to the workqueue, where can hold
2497 if (lr
->initiator
== NL80211_REGDOM_SET_BY_COUNTRY_IE
&&
2498 lr
->wiphy_idx
!= WIPHY_IDX_INVALID
)
2501 request
->wiphy_idx
= get_wiphy_idx(wiphy
);
2502 request
->alpha2
[0] = alpha2
[0];
2503 request
->alpha2
[1] = alpha2
[1];
2504 request
->initiator
= NL80211_REGDOM_SET_BY_COUNTRY_IE
;
2505 request
->country_ie_env
= env
;
2507 /* Allow calling CRDA again */
2508 reset_crda_timeouts();
2510 queue_regulatory_request(request
);
2517 static void restore_alpha2(char *alpha2
, bool reset_user
)
2519 /* indicates there is no alpha2 to consider for restoration */
2523 /* The user setting has precedence over the module parameter */
2524 if (is_user_regdom_saved()) {
2525 /* Unless we're asked to ignore it and reset it */
2527 REG_DBG_PRINT("Restoring regulatory settings including user preference\n");
2528 user_alpha2
[0] = '9';
2529 user_alpha2
[1] = '7';
2532 * If we're ignoring user settings, we still need to
2533 * check the module parameter to ensure we put things
2534 * back as they were for a full restore.
2536 if (!is_world_regdom(ieee80211_regdom
)) {
2537 REG_DBG_PRINT("Keeping preference on module parameter ieee80211_regdom: %c%c\n",
2538 ieee80211_regdom
[0], ieee80211_regdom
[1]);
2539 alpha2
[0] = ieee80211_regdom
[0];
2540 alpha2
[1] = ieee80211_regdom
[1];
2543 REG_DBG_PRINT("Restoring regulatory settings while preserving user preference for: %c%c\n",
2544 user_alpha2
[0], user_alpha2
[1]);
2545 alpha2
[0] = user_alpha2
[0];
2546 alpha2
[1] = user_alpha2
[1];
2548 } else if (!is_world_regdom(ieee80211_regdom
)) {
2549 REG_DBG_PRINT("Keeping preference on module parameter ieee80211_regdom: %c%c\n",
2550 ieee80211_regdom
[0], ieee80211_regdom
[1]);
2551 alpha2
[0] = ieee80211_regdom
[0];
2552 alpha2
[1] = ieee80211_regdom
[1];
2554 REG_DBG_PRINT("Restoring regulatory settings\n");
2557 static void restore_custom_reg_settings(struct wiphy
*wiphy
)
2559 struct ieee80211_supported_band
*sband
;
2560 enum ieee80211_band band
;
2561 struct ieee80211_channel
*chan
;
2564 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
2565 sband
= wiphy
->bands
[band
];
2568 for (i
= 0; i
< sband
->n_channels
; i
++) {
2569 chan
= &sband
->channels
[i
];
2570 chan
->flags
= chan
->orig_flags
;
2571 chan
->max_antenna_gain
= chan
->orig_mag
;
2572 chan
->max_power
= chan
->orig_mpwr
;
2573 chan
->beacon_found
= false;
2579 * Restoring regulatory settings involves ingoring any
2580 * possibly stale country IE information and user regulatory
2581 * settings if so desired, this includes any beacon hints
2582 * learned as we could have traveled outside to another country
2583 * after disconnection. To restore regulatory settings we do
2584 * exactly what we did at bootup:
2586 * - send a core regulatory hint
2587 * - send a user regulatory hint if applicable
2589 * Device drivers that send a regulatory hint for a specific country
2590 * keep their own regulatory domain on wiphy->regd so that does does
2591 * not need to be remembered.
2593 static void restore_regulatory_settings(bool reset_user
)
2596 char world_alpha2
[2];
2597 struct reg_beacon
*reg_beacon
, *btmp
;
2598 LIST_HEAD(tmp_reg_req_list
);
2599 struct cfg80211_registered_device
*rdev
;
2604 * Clear the indoor setting in case that it is not controlled by user
2605 * space, as otherwise there is no guarantee that the device is still
2606 * operating in an indoor environment.
2608 spin_lock(®_indoor_lock
);
2609 if (reg_is_indoor
&& !reg_is_indoor_portid
) {
2610 reg_is_indoor
= false;
2611 reg_check_channels();
2613 spin_unlock(®_indoor_lock
);
2615 reset_regdomains(true, &world_regdom
);
2616 restore_alpha2(alpha2
, reset_user
);
2619 * If there's any pending requests we simply
2620 * stash them to a temporary pending queue and
2621 * add then after we've restored regulatory
2624 spin_lock(®_requests_lock
);
2625 list_splice_tail_init(®_requests_list
, &tmp_reg_req_list
);
2626 spin_unlock(®_requests_lock
);
2628 /* Clear beacon hints */
2629 spin_lock_bh(®_pending_beacons_lock
);
2630 list_for_each_entry_safe(reg_beacon
, btmp
, ®_pending_beacons
, list
) {
2631 list_del(®_beacon
->list
);
2634 spin_unlock_bh(®_pending_beacons_lock
);
2636 list_for_each_entry_safe(reg_beacon
, btmp
, ®_beacon_list
, list
) {
2637 list_del(®_beacon
->list
);
2641 /* First restore to the basic regulatory settings */
2642 world_alpha2
[0] = cfg80211_world_regdom
->alpha2
[0];
2643 world_alpha2
[1] = cfg80211_world_regdom
->alpha2
[1];
2645 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
) {
2646 if (rdev
->wiphy
.regulatory_flags
& REGULATORY_WIPHY_SELF_MANAGED
)
2648 if (rdev
->wiphy
.regulatory_flags
& REGULATORY_CUSTOM_REG
)
2649 restore_custom_reg_settings(&rdev
->wiphy
);
2652 regulatory_hint_core(world_alpha2
);
2655 * This restores the ieee80211_regdom module parameter
2656 * preference or the last user requested regulatory
2657 * settings, user regulatory settings takes precedence.
2659 if (is_an_alpha2(alpha2
))
2660 regulatory_hint_user(alpha2
, NL80211_USER_REG_HINT_USER
);
2662 spin_lock(®_requests_lock
);
2663 list_splice_tail_init(&tmp_reg_req_list
, ®_requests_list
);
2664 spin_unlock(®_requests_lock
);
2666 REG_DBG_PRINT("Kicking the queue\n");
2668 schedule_work(®_work
);
2671 void regulatory_hint_disconnect(void)
2673 REG_DBG_PRINT("All devices are disconnected, going to restore regulatory settings\n");
2674 restore_regulatory_settings(false);
2677 static bool freq_is_chan_12_13_14(u16 freq
)
2679 if (freq
== ieee80211_channel_to_frequency(12, IEEE80211_BAND_2GHZ
) ||
2680 freq
== ieee80211_channel_to_frequency(13, IEEE80211_BAND_2GHZ
) ||
2681 freq
== ieee80211_channel_to_frequency(14, IEEE80211_BAND_2GHZ
))
2686 static bool pending_reg_beacon(struct ieee80211_channel
*beacon_chan
)
2688 struct reg_beacon
*pending_beacon
;
2690 list_for_each_entry(pending_beacon
, ®_pending_beacons
, list
)
2691 if (beacon_chan
->center_freq
==
2692 pending_beacon
->chan
.center_freq
)
2697 int regulatory_hint_found_beacon(struct wiphy
*wiphy
,
2698 struct ieee80211_channel
*beacon_chan
,
2701 struct reg_beacon
*reg_beacon
;
2704 if (beacon_chan
->beacon_found
||
2705 beacon_chan
->flags
& IEEE80211_CHAN_RADAR
||
2706 (beacon_chan
->band
== IEEE80211_BAND_2GHZ
&&
2707 !freq_is_chan_12_13_14(beacon_chan
->center_freq
)))
2710 spin_lock_bh(®_pending_beacons_lock
);
2711 processing
= pending_reg_beacon(beacon_chan
);
2712 spin_unlock_bh(®_pending_beacons_lock
);
2717 reg_beacon
= kzalloc(sizeof(struct reg_beacon
), gfp
);
2721 REG_DBG_PRINT("Found new beacon on frequency: %d MHz (Ch %d) on %s\n",
2722 beacon_chan
->center_freq
,
2723 ieee80211_frequency_to_channel(beacon_chan
->center_freq
),
2726 memcpy(®_beacon
->chan
, beacon_chan
,
2727 sizeof(struct ieee80211_channel
));
2730 * Since we can be called from BH or and non-BH context
2731 * we must use spin_lock_bh()
2733 spin_lock_bh(®_pending_beacons_lock
);
2734 list_add_tail(®_beacon
->list
, ®_pending_beacons
);
2735 spin_unlock_bh(®_pending_beacons_lock
);
2737 schedule_work(®_work
);
2742 static void print_rd_rules(const struct ieee80211_regdomain
*rd
)
2745 const struct ieee80211_reg_rule
*reg_rule
= NULL
;
2746 const struct ieee80211_freq_range
*freq_range
= NULL
;
2747 const struct ieee80211_power_rule
*power_rule
= NULL
;
2748 char bw
[32], cac_time
[32];
2750 pr_debug(" (start_freq - end_freq @ bandwidth), (max_antenna_gain, max_eirp), (dfs_cac_time)\n");
2752 for (i
= 0; i
< rd
->n_reg_rules
; i
++) {
2753 reg_rule
= &rd
->reg_rules
[i
];
2754 freq_range
= ®_rule
->freq_range
;
2755 power_rule
= ®_rule
->power_rule
;
2757 if (reg_rule
->flags
& NL80211_RRF_AUTO_BW
)
2758 snprintf(bw
, sizeof(bw
), "%d KHz, %d KHz AUTO",
2759 freq_range
->max_bandwidth_khz
,
2760 reg_get_max_bandwidth(rd
, reg_rule
));
2762 snprintf(bw
, sizeof(bw
), "%d KHz",
2763 freq_range
->max_bandwidth_khz
);
2765 if (reg_rule
->flags
& NL80211_RRF_DFS
)
2766 scnprintf(cac_time
, sizeof(cac_time
), "%u s",
2767 reg_rule
->dfs_cac_ms
/1000);
2769 scnprintf(cac_time
, sizeof(cac_time
), "N/A");
2773 * There may not be documentation for max antenna gain
2774 * in certain regions
2776 if (power_rule
->max_antenna_gain
)
2777 pr_debug(" (%d KHz - %d KHz @ %s), (%d mBi, %d mBm), (%s)\n",
2778 freq_range
->start_freq_khz
,
2779 freq_range
->end_freq_khz
,
2781 power_rule
->max_antenna_gain
,
2782 power_rule
->max_eirp
,
2785 pr_debug(" (%d KHz - %d KHz @ %s), (N/A, %d mBm), (%s)\n",
2786 freq_range
->start_freq_khz
,
2787 freq_range
->end_freq_khz
,
2789 power_rule
->max_eirp
,
2794 bool reg_supported_dfs_region(enum nl80211_dfs_regions dfs_region
)
2796 switch (dfs_region
) {
2797 case NL80211_DFS_UNSET
:
2798 case NL80211_DFS_FCC
:
2799 case NL80211_DFS_ETSI
:
2800 case NL80211_DFS_JP
:
2803 REG_DBG_PRINT("Ignoring uknown DFS master region: %d\n",
2809 static void print_regdomain(const struct ieee80211_regdomain
*rd
)
2811 struct regulatory_request
*lr
= get_last_request();
2813 if (is_intersected_alpha2(rd
->alpha2
)) {
2814 if (lr
->initiator
== NL80211_REGDOM_SET_BY_COUNTRY_IE
) {
2815 struct cfg80211_registered_device
*rdev
;
2816 rdev
= cfg80211_rdev_by_wiphy_idx(lr
->wiphy_idx
);
2818 pr_debug("Current regulatory domain updated by AP to: %c%c\n",
2819 rdev
->country_ie_alpha2
[0],
2820 rdev
->country_ie_alpha2
[1]);
2822 pr_debug("Current regulatory domain intersected:\n");
2824 pr_debug("Current regulatory domain intersected:\n");
2825 } else if (is_world_regdom(rd
->alpha2
)) {
2826 pr_debug("World regulatory domain updated:\n");
2828 if (is_unknown_alpha2(rd
->alpha2
))
2829 pr_debug("Regulatory domain changed to driver built-in settings (unknown country)\n");
2831 if (reg_request_cell_base(lr
))
2832 pr_debug("Regulatory domain changed to country: %c%c by Cell Station\n",
2833 rd
->alpha2
[0], rd
->alpha2
[1]);
2835 pr_debug("Regulatory domain changed to country: %c%c\n",
2836 rd
->alpha2
[0], rd
->alpha2
[1]);
2840 pr_debug(" DFS Master region: %s", reg_dfs_region_str(rd
->dfs_region
));
2844 static void print_regdomain_info(const struct ieee80211_regdomain
*rd
)
2846 pr_debug("Regulatory domain: %c%c\n", rd
->alpha2
[0], rd
->alpha2
[1]);
2850 static int reg_set_rd_core(const struct ieee80211_regdomain
*rd
)
2852 if (!is_world_regdom(rd
->alpha2
))
2854 update_world_regdomain(rd
);
2858 static int reg_set_rd_user(const struct ieee80211_regdomain
*rd
,
2859 struct regulatory_request
*user_request
)
2861 const struct ieee80211_regdomain
*intersected_rd
= NULL
;
2863 if (!regdom_changes(rd
->alpha2
))
2866 if (!is_valid_rd(rd
)) {
2867 pr_err("Invalid regulatory domain detected: %c%c\n",
2868 rd
->alpha2
[0], rd
->alpha2
[1]);
2869 print_regdomain_info(rd
);
2873 if (!user_request
->intersect
) {
2874 reset_regdomains(false, rd
);
2878 intersected_rd
= regdom_intersect(rd
, get_cfg80211_regdom());
2879 if (!intersected_rd
)
2884 reset_regdomains(false, intersected_rd
);
2889 static int reg_set_rd_driver(const struct ieee80211_regdomain
*rd
,
2890 struct regulatory_request
*driver_request
)
2892 const struct ieee80211_regdomain
*regd
;
2893 const struct ieee80211_regdomain
*intersected_rd
= NULL
;
2894 const struct ieee80211_regdomain
*tmp
;
2895 struct wiphy
*request_wiphy
;
2897 if (is_world_regdom(rd
->alpha2
))
2900 if (!regdom_changes(rd
->alpha2
))
2903 if (!is_valid_rd(rd
)) {
2904 pr_err("Invalid regulatory domain detected: %c%c\n",
2905 rd
->alpha2
[0], rd
->alpha2
[1]);
2906 print_regdomain_info(rd
);
2910 request_wiphy
= wiphy_idx_to_wiphy(driver_request
->wiphy_idx
);
2914 if (!driver_request
->intersect
) {
2915 if (request_wiphy
->regd
)
2918 regd
= reg_copy_regd(rd
);
2920 return PTR_ERR(regd
);
2922 rcu_assign_pointer(request_wiphy
->regd
, regd
);
2923 reset_regdomains(false, rd
);
2927 intersected_rd
= regdom_intersect(rd
, get_cfg80211_regdom());
2928 if (!intersected_rd
)
2932 * We can trash what CRDA provided now.
2933 * However if a driver requested this specific regulatory
2934 * domain we keep it for its private use
2936 tmp
= get_wiphy_regdom(request_wiphy
);
2937 rcu_assign_pointer(request_wiphy
->regd
, rd
);
2938 rcu_free_regdom(tmp
);
2942 reset_regdomains(false, intersected_rd
);
2947 static int reg_set_rd_country_ie(const struct ieee80211_regdomain
*rd
,
2948 struct regulatory_request
*country_ie_request
)
2950 struct wiphy
*request_wiphy
;
2952 if (!is_alpha2_set(rd
->alpha2
) && !is_an_alpha2(rd
->alpha2
) &&
2953 !is_unknown_alpha2(rd
->alpha2
))
2957 * Lets only bother proceeding on the same alpha2 if the current
2958 * rd is non static (it means CRDA was present and was used last)
2959 * and the pending request came in from a country IE
2962 if (!is_valid_rd(rd
)) {
2963 pr_err("Invalid regulatory domain detected: %c%c\n",
2964 rd
->alpha2
[0], rd
->alpha2
[1]);
2965 print_regdomain_info(rd
);
2969 request_wiphy
= wiphy_idx_to_wiphy(country_ie_request
->wiphy_idx
);
2973 if (country_ie_request
->intersect
)
2976 reset_regdomains(false, rd
);
2981 * Use this call to set the current regulatory domain. Conflicts with
2982 * multiple drivers can be ironed out later. Caller must've already
2983 * kmalloc'd the rd structure.
2985 int set_regdom(const struct ieee80211_regdomain
*rd
,
2986 enum ieee80211_regd_source regd_src
)
2988 struct regulatory_request
*lr
;
2989 bool user_reset
= false;
2992 if (!reg_is_valid_request(rd
->alpha2
)) {
2997 if (regd_src
== REGD_SOURCE_CRDA
)
2998 reset_crda_timeouts();
3000 lr
= get_last_request();
3002 /* Note that this doesn't update the wiphys, this is done below */
3003 switch (lr
->initiator
) {
3004 case NL80211_REGDOM_SET_BY_CORE
:
3005 r
= reg_set_rd_core(rd
);
3007 case NL80211_REGDOM_SET_BY_USER
:
3008 r
= reg_set_rd_user(rd
, lr
);
3011 case NL80211_REGDOM_SET_BY_DRIVER
:
3012 r
= reg_set_rd_driver(rd
, lr
);
3014 case NL80211_REGDOM_SET_BY_COUNTRY_IE
:
3015 r
= reg_set_rd_country_ie(rd
, lr
);
3018 WARN(1, "invalid initiator %d\n", lr
->initiator
);
3026 reg_set_request_processed();
3029 /* Back to world regulatory in case of errors */
3030 restore_regulatory_settings(user_reset
);
3037 /* This would make this whole thing pointless */
3038 if (WARN_ON(!lr
->intersect
&& rd
!= get_cfg80211_regdom()))
3041 /* update all wiphys now with the new established regulatory domain */
3042 update_all_wiphy_regulatory(lr
->initiator
);
3044 print_regdomain(get_cfg80211_regdom());
3046 nl80211_send_reg_change_event(lr
);
3048 reg_set_request_processed();
3053 static int __regulatory_set_wiphy_regd(struct wiphy
*wiphy
,
3054 struct ieee80211_regdomain
*rd
)
3056 const struct ieee80211_regdomain
*regd
;
3057 const struct ieee80211_regdomain
*prev_regd
;
3058 struct cfg80211_registered_device
*rdev
;
3060 if (WARN_ON(!wiphy
|| !rd
))
3063 if (WARN(!(wiphy
->regulatory_flags
& REGULATORY_WIPHY_SELF_MANAGED
),
3064 "wiphy should have REGULATORY_WIPHY_SELF_MANAGED\n"))
3067 if (WARN(!is_valid_rd(rd
), "Invalid regulatory domain detected\n")) {
3068 print_regdomain_info(rd
);
3072 regd
= reg_copy_regd(rd
);
3074 return PTR_ERR(regd
);
3076 rdev
= wiphy_to_rdev(wiphy
);
3078 spin_lock(®_requests_lock
);
3079 prev_regd
= rdev
->requested_regd
;
3080 rdev
->requested_regd
= regd
;
3081 spin_unlock(®_requests_lock
);
3087 int regulatory_set_wiphy_regd(struct wiphy
*wiphy
,
3088 struct ieee80211_regdomain
*rd
)
3090 int ret
= __regulatory_set_wiphy_regd(wiphy
, rd
);
3095 schedule_work(®_work
);
3098 EXPORT_SYMBOL(regulatory_set_wiphy_regd
);
3100 int regulatory_set_wiphy_regd_sync_rtnl(struct wiphy
*wiphy
,
3101 struct ieee80211_regdomain
*rd
)
3107 ret
= __regulatory_set_wiphy_regd(wiphy
, rd
);
3111 /* process the request immediately */
3112 reg_process_self_managed_hints();
3115 EXPORT_SYMBOL(regulatory_set_wiphy_regd_sync_rtnl
);
3117 void wiphy_regulatory_register(struct wiphy
*wiphy
)
3119 struct regulatory_request
*lr
;
3121 /* self-managed devices ignore external hints */
3122 if (wiphy
->regulatory_flags
& REGULATORY_WIPHY_SELF_MANAGED
)
3123 wiphy
->regulatory_flags
|= REGULATORY_DISABLE_BEACON_HINTS
|
3124 REGULATORY_COUNTRY_IE_IGNORE
;
3126 if (!reg_dev_ignore_cell_hint(wiphy
))
3127 reg_num_devs_support_basehint
++;
3129 lr
= get_last_request();
3130 wiphy_update_regulatory(wiphy
, lr
->initiator
);
3133 void wiphy_regulatory_deregister(struct wiphy
*wiphy
)
3135 struct wiphy
*request_wiphy
= NULL
;
3136 struct regulatory_request
*lr
;
3138 lr
= get_last_request();
3140 if (!reg_dev_ignore_cell_hint(wiphy
))
3141 reg_num_devs_support_basehint
--;
3143 rcu_free_regdom(get_wiphy_regdom(wiphy
));
3144 RCU_INIT_POINTER(wiphy
->regd
, NULL
);
3147 request_wiphy
= wiphy_idx_to_wiphy(lr
->wiphy_idx
);
3149 if (!request_wiphy
|| request_wiphy
!= wiphy
)
3152 lr
->wiphy_idx
= WIPHY_IDX_INVALID
;
3153 lr
->country_ie_env
= ENVIRON_ANY
;
3157 * See http://www.fcc.gov/document/5-ghz-unlicensed-spectrum-unii, for
3158 * UNII band definitions
3160 int cfg80211_get_unii(int freq
)
3163 if (freq
>= 5150 && freq
<= 5250)
3167 if (freq
> 5250 && freq
<= 5350)
3171 if (freq
> 5350 && freq
<= 5470)
3175 if (freq
> 5470 && freq
<= 5725)
3179 if (freq
> 5725 && freq
<= 5825)
3185 bool regulatory_indoor_allowed(void)
3187 return reg_is_indoor
;
3190 int __init
regulatory_init(void)
3194 reg_pdev
= platform_device_register_simple("regulatory", 0, NULL
, 0);
3195 if (IS_ERR(reg_pdev
))
3196 return PTR_ERR(reg_pdev
);
3198 spin_lock_init(®_requests_lock
);
3199 spin_lock_init(®_pending_beacons_lock
);
3200 spin_lock_init(®_indoor_lock
);
3202 reg_regdb_size_check();
3204 rcu_assign_pointer(cfg80211_regdomain
, cfg80211_world_regdom
);
3206 user_alpha2
[0] = '9';
3207 user_alpha2
[1] = '7';
3209 /* We always try to get an update for the static regdomain */
3210 err
= regulatory_hint_core(cfg80211_world_regdom
->alpha2
);
3212 if (err
== -ENOMEM
) {
3213 platform_device_unregister(reg_pdev
);
3217 * N.B. kobject_uevent_env() can fail mainly for when we're out
3218 * memory which is handled and propagated appropriately above
3219 * but it can also fail during a netlink_broadcast() or during
3220 * early boot for call_usermodehelper(). For now treat these
3221 * errors as non-fatal.
3223 pr_err("kobject_uevent_env() was unable to call CRDA during init\n");
3227 * Finally, if the user set the module parameter treat it
3230 if (!is_world_regdom(ieee80211_regdom
))
3231 regulatory_hint_user(ieee80211_regdom
,
3232 NL80211_USER_REG_HINT_USER
);
3237 void regulatory_exit(void)
3239 struct regulatory_request
*reg_request
, *tmp
;
3240 struct reg_beacon
*reg_beacon
, *btmp
;
3242 cancel_work_sync(®_work
);
3243 cancel_crda_timeout_sync();
3244 cancel_delayed_work_sync(®_check_chans
);
3246 /* Lock to suppress warnings */
3248 reset_regdomains(true, NULL
);
3251 dev_set_uevent_suppress(®_pdev
->dev
, true);
3253 platform_device_unregister(reg_pdev
);
3255 list_for_each_entry_safe(reg_beacon
, btmp
, ®_pending_beacons
, list
) {
3256 list_del(®_beacon
->list
);
3260 list_for_each_entry_safe(reg_beacon
, btmp
, ®_beacon_list
, list
) {
3261 list_del(®_beacon
->list
);
3265 list_for_each_entry_safe(reg_request
, tmp
, ®_requests_list
, list
) {
3266 list_del(®_request
->list
);