cfg80211: Add support for 60GHz band channels 5 and 6
[linux-2.6-microblaze.git] / net / wireless / reg.c
1 /*
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
7  * Copyright      2017  Intel Deutschland GmbH
8  * Copyright (C) 2018 Intel Corporation
9  *
10  * Permission to use, copy, modify, and/or distribute this software for any
11  * purpose with or without fee is hereby granted, provided that the above
12  * copyright notice and this permission notice appear in all copies.
13  *
14  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
15  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
16  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
17  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
18  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
19  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
20  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
21  */
22
23
24 /**
25  * DOC: Wireless regulatory infrastructure
26  *
27  * The usual implementation is for a driver to read a device EEPROM to
28  * determine which regulatory domain it should be operating under, then
29  * looking up the allowable channels in a driver-local table and finally
30  * registering those channels in the wiphy structure.
31  *
32  * Another set of compliance enforcement is for drivers to use their
33  * own compliance limits which can be stored on the EEPROM. The host
34  * driver or firmware may ensure these are used.
35  *
36  * In addition to all this we provide an extra layer of regulatory
37  * conformance. For drivers which do not have any regulatory
38  * information CRDA provides the complete regulatory solution.
39  * For others it provides a community effort on further restrictions
40  * to enhance compliance.
41  *
42  * Note: When number of rules --> infinity we will not be able to
43  * index on alpha2 any more, instead we'll probably have to
44  * rely on some SHA1 checksum of the regdomain for example.
45  *
46  */
47
48 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
49
50 #include <linux/kernel.h>
51 #include <linux/export.h>
52 #include <linux/slab.h>
53 #include <linux/list.h>
54 #include <linux/ctype.h>
55 #include <linux/nl80211.h>
56 #include <linux/platform_device.h>
57 #include <linux/verification.h>
58 #include <linux/moduleparam.h>
59 #include <linux/firmware.h>
60 #include <net/cfg80211.h>
61 #include "core.h"
62 #include "reg.h"
63 #include "rdev-ops.h"
64 #include "nl80211.h"
65
66 /*
67  * Grace period we give before making sure all current interfaces reside on
68  * channels allowed by the current regulatory domain.
69  */
70 #define REG_ENFORCE_GRACE_MS 60000
71
72 /**
73  * enum reg_request_treatment - regulatory request treatment
74  *
75  * @REG_REQ_OK: continue processing the regulatory request
76  * @REG_REQ_IGNORE: ignore the regulatory request
77  * @REG_REQ_INTERSECT: the regulatory domain resulting from this request should
78  *      be intersected with the current one.
79  * @REG_REQ_ALREADY_SET: the regulatory request will not change the current
80  *      regulatory settings, and no further processing is required.
81  */
82 enum reg_request_treatment {
83         REG_REQ_OK,
84         REG_REQ_IGNORE,
85         REG_REQ_INTERSECT,
86         REG_REQ_ALREADY_SET,
87 };
88
89 static struct regulatory_request core_request_world = {
90         .initiator = NL80211_REGDOM_SET_BY_CORE,
91         .alpha2[0] = '0',
92         .alpha2[1] = '0',
93         .intersect = false,
94         .processed = true,
95         .country_ie_env = ENVIRON_ANY,
96 };
97
98 /*
99  * Receipt of information from last regulatory request,
100  * protected by RTNL (and can be accessed with RCU protection)
101  */
102 static struct regulatory_request __rcu *last_request =
103         (void __force __rcu *)&core_request_world;
104
105 /* To trigger userspace events and load firmware */
106 static struct platform_device *reg_pdev;
107
108 /*
109  * Central wireless core regulatory domains, we only need two,
110  * the current one and a world regulatory domain in case we have no
111  * information to give us an alpha2.
112  * (protected by RTNL, can be read under RCU)
113  */
114 const struct ieee80211_regdomain __rcu *cfg80211_regdomain;
115
116 /*
117  * Number of devices that registered to the core
118  * that support cellular base station regulatory hints
119  * (protected by RTNL)
120  */
121 static int reg_num_devs_support_basehint;
122
123 /*
124  * State variable indicating if the platform on which the devices
125  * are attached is operating in an indoor environment. The state variable
126  * is relevant for all registered devices.
127  */
128 static bool reg_is_indoor;
129 static spinlock_t reg_indoor_lock;
130
131 /* Used to track the userspace process controlling the indoor setting */
132 static u32 reg_is_indoor_portid;
133
134 static void restore_regulatory_settings(bool reset_user);
135
136 static const struct ieee80211_regdomain *get_cfg80211_regdom(void)
137 {
138         return rcu_dereference_rtnl(cfg80211_regdomain);
139 }
140
141 const struct ieee80211_regdomain *get_wiphy_regdom(struct wiphy *wiphy)
142 {
143         return rcu_dereference_rtnl(wiphy->regd);
144 }
145
146 static const char *reg_dfs_region_str(enum nl80211_dfs_regions dfs_region)
147 {
148         switch (dfs_region) {
149         case NL80211_DFS_UNSET:
150                 return "unset";
151         case NL80211_DFS_FCC:
152                 return "FCC";
153         case NL80211_DFS_ETSI:
154                 return "ETSI";
155         case NL80211_DFS_JP:
156                 return "JP";
157         }
158         return "Unknown";
159 }
160
161 enum nl80211_dfs_regions reg_get_dfs_region(struct wiphy *wiphy)
162 {
163         const struct ieee80211_regdomain *regd = NULL;
164         const struct ieee80211_regdomain *wiphy_regd = NULL;
165
166         regd = get_cfg80211_regdom();
167         if (!wiphy)
168                 goto out;
169
170         wiphy_regd = get_wiphy_regdom(wiphy);
171         if (!wiphy_regd)
172                 goto out;
173
174         if (wiphy_regd->dfs_region == regd->dfs_region)
175                 goto out;
176
177         pr_debug("%s: device specific dfs_region (%s) disagrees with cfg80211's central dfs_region (%s)\n",
178                  dev_name(&wiphy->dev),
179                  reg_dfs_region_str(wiphy_regd->dfs_region),
180                  reg_dfs_region_str(regd->dfs_region));
181
182 out:
183         return regd->dfs_region;
184 }
185
186 static void rcu_free_regdom(const struct ieee80211_regdomain *r)
187 {
188         if (!r)
189                 return;
190         kfree_rcu((struct ieee80211_regdomain *)r, rcu_head);
191 }
192
193 static struct regulatory_request *get_last_request(void)
194 {
195         return rcu_dereference_rtnl(last_request);
196 }
197
198 /* Used to queue up regulatory hints */
199 static LIST_HEAD(reg_requests_list);
200 static spinlock_t reg_requests_lock;
201
202 /* Used to queue up beacon hints for review */
203 static LIST_HEAD(reg_pending_beacons);
204 static spinlock_t reg_pending_beacons_lock;
205
206 /* Used to keep track of processed beacon hints */
207 static LIST_HEAD(reg_beacon_list);
208
209 struct reg_beacon {
210         struct list_head list;
211         struct ieee80211_channel chan;
212 };
213
214 static void reg_check_chans_work(struct work_struct *work);
215 static DECLARE_DELAYED_WORK(reg_check_chans, reg_check_chans_work);
216
217 static void reg_todo(struct work_struct *work);
218 static DECLARE_WORK(reg_work, reg_todo);
219
220 /* We keep a static world regulatory domain in case of the absence of CRDA */
221 static const struct ieee80211_regdomain world_regdom = {
222         .n_reg_rules = 8,
223         .alpha2 =  "00",
224         .reg_rules = {
225                 /* IEEE 802.11b/g, channels 1..11 */
226                 REG_RULE(2412-10, 2462+10, 40, 6, 20, 0),
227                 /* IEEE 802.11b/g, channels 12..13. */
228                 REG_RULE(2467-10, 2472+10, 20, 6, 20,
229                         NL80211_RRF_NO_IR | NL80211_RRF_AUTO_BW),
230                 /* IEEE 802.11 channel 14 - Only JP enables
231                  * this and for 802.11b only */
232                 REG_RULE(2484-10, 2484+10, 20, 6, 20,
233                         NL80211_RRF_NO_IR |
234                         NL80211_RRF_NO_OFDM),
235                 /* IEEE 802.11a, channel 36..48 */
236                 REG_RULE(5180-10, 5240+10, 80, 6, 20,
237                         NL80211_RRF_NO_IR |
238                         NL80211_RRF_AUTO_BW),
239
240                 /* IEEE 802.11a, channel 52..64 - DFS required */
241                 REG_RULE(5260-10, 5320+10, 80, 6, 20,
242                         NL80211_RRF_NO_IR |
243                         NL80211_RRF_AUTO_BW |
244                         NL80211_RRF_DFS),
245
246                 /* IEEE 802.11a, channel 100..144 - DFS required */
247                 REG_RULE(5500-10, 5720+10, 160, 6, 20,
248                         NL80211_RRF_NO_IR |
249                         NL80211_RRF_DFS),
250
251                 /* IEEE 802.11a, channel 149..165 */
252                 REG_RULE(5745-10, 5825+10, 80, 6, 20,
253                         NL80211_RRF_NO_IR),
254
255                 /* IEEE 802.11ad (60GHz), channels 1..3 */
256                 REG_RULE(56160+2160*1-1080, 56160+2160*3+1080, 2160, 0, 0, 0),
257         }
258 };
259
260 /* protected by RTNL */
261 static const struct ieee80211_regdomain *cfg80211_world_regdom =
262         &world_regdom;
263
264 static char *ieee80211_regdom = "00";
265 static char user_alpha2[2];
266
267 module_param(ieee80211_regdom, charp, 0444);
268 MODULE_PARM_DESC(ieee80211_regdom, "IEEE 802.11 regulatory domain code");
269
270 static void reg_free_request(struct regulatory_request *request)
271 {
272         if (request == &core_request_world)
273                 return;
274
275         if (request != get_last_request())
276                 kfree(request);
277 }
278
279 static void reg_free_last_request(void)
280 {
281         struct regulatory_request *lr = get_last_request();
282
283         if (lr != &core_request_world && lr)
284                 kfree_rcu(lr, rcu_head);
285 }
286
287 static void reg_update_last_request(struct regulatory_request *request)
288 {
289         struct regulatory_request *lr;
290
291         lr = get_last_request();
292         if (lr == request)
293                 return;
294
295         reg_free_last_request();
296         rcu_assign_pointer(last_request, request);
297 }
298
299 static void reset_regdomains(bool full_reset,
300                              const struct ieee80211_regdomain *new_regdom)
301 {
302         const struct ieee80211_regdomain *r;
303
304         ASSERT_RTNL();
305
306         r = get_cfg80211_regdom();
307
308         /* avoid freeing static information or freeing something twice */
309         if (r == cfg80211_world_regdom)
310                 r = NULL;
311         if (cfg80211_world_regdom == &world_regdom)
312                 cfg80211_world_regdom = NULL;
313         if (r == &world_regdom)
314                 r = NULL;
315
316         rcu_free_regdom(r);
317         rcu_free_regdom(cfg80211_world_regdom);
318
319         cfg80211_world_regdom = &world_regdom;
320         rcu_assign_pointer(cfg80211_regdomain, new_regdom);
321
322         if (!full_reset)
323                 return;
324
325         reg_update_last_request(&core_request_world);
326 }
327
328 /*
329  * Dynamic world regulatory domain requested by the wireless
330  * core upon initialization
331  */
332 static void update_world_regdomain(const struct ieee80211_regdomain *rd)
333 {
334         struct regulatory_request *lr;
335
336         lr = get_last_request();
337
338         WARN_ON(!lr);
339
340         reset_regdomains(false, rd);
341
342         cfg80211_world_regdom = rd;
343 }
344
345 bool is_world_regdom(const char *alpha2)
346 {
347         if (!alpha2)
348                 return false;
349         return alpha2[0] == '0' && alpha2[1] == '0';
350 }
351
352 static bool is_alpha2_set(const char *alpha2)
353 {
354         if (!alpha2)
355                 return false;
356         return alpha2[0] && alpha2[1];
357 }
358
359 static bool is_unknown_alpha2(const char *alpha2)
360 {
361         if (!alpha2)
362                 return false;
363         /*
364          * Special case where regulatory domain was built by driver
365          * but a specific alpha2 cannot be determined
366          */
367         return alpha2[0] == '9' && alpha2[1] == '9';
368 }
369
370 static bool is_intersected_alpha2(const char *alpha2)
371 {
372         if (!alpha2)
373                 return false;
374         /*
375          * Special case where regulatory domain is the
376          * result of an intersection between two regulatory domain
377          * structures
378          */
379         return alpha2[0] == '9' && alpha2[1] == '8';
380 }
381
382 static bool is_an_alpha2(const char *alpha2)
383 {
384         if (!alpha2)
385                 return false;
386         return isalpha(alpha2[0]) && isalpha(alpha2[1]);
387 }
388
389 static bool alpha2_equal(const char *alpha2_x, const char *alpha2_y)
390 {
391         if (!alpha2_x || !alpha2_y)
392                 return false;
393         return alpha2_x[0] == alpha2_y[0] && alpha2_x[1] == alpha2_y[1];
394 }
395
396 static bool regdom_changes(const char *alpha2)
397 {
398         const struct ieee80211_regdomain *r = get_cfg80211_regdom();
399
400         if (!r)
401                 return true;
402         return !alpha2_equal(r->alpha2, alpha2);
403 }
404
405 /*
406  * The NL80211_REGDOM_SET_BY_USER regdom alpha2 is cached, this lets
407  * you know if a valid regulatory hint with NL80211_REGDOM_SET_BY_USER
408  * has ever been issued.
409  */
410 static bool is_user_regdom_saved(void)
411 {
412         if (user_alpha2[0] == '9' && user_alpha2[1] == '7')
413                 return false;
414
415         /* This would indicate a mistake on the design */
416         if (WARN(!is_world_regdom(user_alpha2) && !is_an_alpha2(user_alpha2),
417                  "Unexpected user alpha2: %c%c\n",
418                  user_alpha2[0], user_alpha2[1]))
419                 return false;
420
421         return true;
422 }
423
424 static const struct ieee80211_regdomain *
425 reg_copy_regd(const struct ieee80211_regdomain *src_regd)
426 {
427         struct ieee80211_regdomain *regd;
428         int size_of_regd, size_of_wmms;
429         unsigned int i;
430         struct ieee80211_wmm_rule *d_wmm, *s_wmm;
431
432         size_of_regd =
433                 sizeof(struct ieee80211_regdomain) +
434                 src_regd->n_reg_rules * sizeof(struct ieee80211_reg_rule);
435         size_of_wmms = src_regd->n_wmm_rules *
436                 sizeof(struct ieee80211_wmm_rule);
437
438         regd = kzalloc(size_of_regd + size_of_wmms, GFP_KERNEL);
439         if (!regd)
440                 return ERR_PTR(-ENOMEM);
441
442         memcpy(regd, src_regd, sizeof(struct ieee80211_regdomain));
443
444         d_wmm = (struct ieee80211_wmm_rule *)((u8 *)regd + size_of_regd);
445         s_wmm = (struct ieee80211_wmm_rule *)((u8 *)src_regd + size_of_regd);
446         memcpy(d_wmm, s_wmm, size_of_wmms);
447
448         for (i = 0; i < src_regd->n_reg_rules; i++) {
449                 memcpy(&regd->reg_rules[i], &src_regd->reg_rules[i],
450                        sizeof(struct ieee80211_reg_rule));
451                 if (!src_regd->reg_rules[i].wmm_rule)
452                         continue;
453
454                 regd->reg_rules[i].wmm_rule = d_wmm +
455                         (src_regd->reg_rules[i].wmm_rule - s_wmm) /
456                         sizeof(struct ieee80211_wmm_rule);
457         }
458         return regd;
459 }
460
461 struct reg_regdb_apply_request {
462         struct list_head list;
463         const struct ieee80211_regdomain *regdom;
464 };
465
466 static LIST_HEAD(reg_regdb_apply_list);
467 static DEFINE_MUTEX(reg_regdb_apply_mutex);
468
469 static void reg_regdb_apply(struct work_struct *work)
470 {
471         struct reg_regdb_apply_request *request;
472
473         rtnl_lock();
474
475         mutex_lock(&reg_regdb_apply_mutex);
476         while (!list_empty(&reg_regdb_apply_list)) {
477                 request = list_first_entry(&reg_regdb_apply_list,
478                                            struct reg_regdb_apply_request,
479                                            list);
480                 list_del(&request->list);
481
482                 set_regdom(request->regdom, REGD_SOURCE_INTERNAL_DB);
483                 kfree(request);
484         }
485         mutex_unlock(&reg_regdb_apply_mutex);
486
487         rtnl_unlock();
488 }
489
490 static DECLARE_WORK(reg_regdb_work, reg_regdb_apply);
491
492 static int reg_schedule_apply(const struct ieee80211_regdomain *regdom)
493 {
494         struct reg_regdb_apply_request *request;
495
496         request = kzalloc(sizeof(struct reg_regdb_apply_request), GFP_KERNEL);
497         if (!request) {
498                 kfree(regdom);
499                 return -ENOMEM;
500         }
501
502         request->regdom = regdom;
503
504         mutex_lock(&reg_regdb_apply_mutex);
505         list_add_tail(&request->list, &reg_regdb_apply_list);
506         mutex_unlock(&reg_regdb_apply_mutex);
507
508         schedule_work(&reg_regdb_work);
509         return 0;
510 }
511
512 #ifdef CONFIG_CFG80211_CRDA_SUPPORT
513 /* Max number of consecutive attempts to communicate with CRDA  */
514 #define REG_MAX_CRDA_TIMEOUTS 10
515
516 static u32 reg_crda_timeouts;
517
518 static void crda_timeout_work(struct work_struct *work);
519 static DECLARE_DELAYED_WORK(crda_timeout, crda_timeout_work);
520
521 static void crda_timeout_work(struct work_struct *work)
522 {
523         pr_debug("Timeout while waiting for CRDA to reply, restoring regulatory settings\n");
524         rtnl_lock();
525         reg_crda_timeouts++;
526         restore_regulatory_settings(true);
527         rtnl_unlock();
528 }
529
530 static void cancel_crda_timeout(void)
531 {
532         cancel_delayed_work(&crda_timeout);
533 }
534
535 static void cancel_crda_timeout_sync(void)
536 {
537         cancel_delayed_work_sync(&crda_timeout);
538 }
539
540 static void reset_crda_timeouts(void)
541 {
542         reg_crda_timeouts = 0;
543 }
544
545 /*
546  * This lets us keep regulatory code which is updated on a regulatory
547  * basis in userspace.
548  */
549 static int call_crda(const char *alpha2)
550 {
551         char country[12];
552         char *env[] = { country, NULL };
553         int ret;
554
555         snprintf(country, sizeof(country), "COUNTRY=%c%c",
556                  alpha2[0], alpha2[1]);
557
558         if (reg_crda_timeouts > REG_MAX_CRDA_TIMEOUTS) {
559                 pr_debug("Exceeded CRDA call max attempts. Not calling CRDA\n");
560                 return -EINVAL;
561         }
562
563         if (!is_world_regdom((char *) alpha2))
564                 pr_debug("Calling CRDA for country: %c%c\n",
565                          alpha2[0], alpha2[1]);
566         else
567                 pr_debug("Calling CRDA to update world regulatory domain\n");
568
569         ret = kobject_uevent_env(&reg_pdev->dev.kobj, KOBJ_CHANGE, env);
570         if (ret)
571                 return ret;
572
573         queue_delayed_work(system_power_efficient_wq,
574                            &crda_timeout, msecs_to_jiffies(3142));
575         return 0;
576 }
577 #else
578 static inline void cancel_crda_timeout(void) {}
579 static inline void cancel_crda_timeout_sync(void) {}
580 static inline void reset_crda_timeouts(void) {}
581 static inline int call_crda(const char *alpha2)
582 {
583         return -ENODATA;
584 }
585 #endif /* CONFIG_CFG80211_CRDA_SUPPORT */
586
587 /* code to directly load a firmware database through request_firmware */
588 static const struct fwdb_header *regdb;
589
590 struct fwdb_country {
591         u8 alpha2[2];
592         __be16 coll_ptr;
593         /* this struct cannot be extended */
594 } __packed __aligned(4);
595
596 struct fwdb_collection {
597         u8 len;
598         u8 n_rules;
599         u8 dfs_region;
600         /* no optional data yet */
601         /* aligned to 2, then followed by __be16 array of rule pointers */
602 } __packed __aligned(4);
603
604 enum fwdb_flags {
605         FWDB_FLAG_NO_OFDM       = BIT(0),
606         FWDB_FLAG_NO_OUTDOOR    = BIT(1),
607         FWDB_FLAG_DFS           = BIT(2),
608         FWDB_FLAG_NO_IR         = BIT(3),
609         FWDB_FLAG_AUTO_BW       = BIT(4),
610 };
611
612 struct fwdb_wmm_ac {
613         u8 ecw;
614         u8 aifsn;
615         __be16 cot;
616 } __packed;
617
618 struct fwdb_wmm_rule {
619         struct fwdb_wmm_ac client[IEEE80211_NUM_ACS];
620         struct fwdb_wmm_ac ap[IEEE80211_NUM_ACS];
621 } __packed;
622
623 struct fwdb_rule {
624         u8 len;
625         u8 flags;
626         __be16 max_eirp;
627         __be32 start, end, max_bw;
628         /* start of optional data */
629         __be16 cac_timeout;
630         __be16 wmm_ptr;
631 } __packed __aligned(4);
632
633 #define FWDB_MAGIC 0x52474442
634 #define FWDB_VERSION 20
635
636 struct fwdb_header {
637         __be32 magic;
638         __be32 version;
639         struct fwdb_country country[];
640 } __packed __aligned(4);
641
642 static int ecw2cw(int ecw)
643 {
644         return (1 << ecw) - 1;
645 }
646
647 static bool valid_wmm(struct fwdb_wmm_rule *rule)
648 {
649         struct fwdb_wmm_ac *ac = (struct fwdb_wmm_ac *)rule;
650         int i;
651
652         for (i = 0; i < IEEE80211_NUM_ACS * 2; i++) {
653                 u16 cw_min = ecw2cw((ac[i].ecw & 0xf0) >> 4);
654                 u16 cw_max = ecw2cw(ac[i].ecw & 0x0f);
655                 u8 aifsn = ac[i].aifsn;
656
657                 if (cw_min >= cw_max)
658                         return false;
659
660                 if (aifsn < 1)
661                         return false;
662         }
663
664         return true;
665 }
666
667 static bool valid_rule(const u8 *data, unsigned int size, u16 rule_ptr)
668 {
669         struct fwdb_rule *rule = (void *)(data + (rule_ptr << 2));
670
671         if ((u8 *)rule + sizeof(rule->len) > data + size)
672                 return false;
673
674         /* mandatory fields */
675         if (rule->len < offsetofend(struct fwdb_rule, max_bw))
676                 return false;
677         if (rule->len >= offsetofend(struct fwdb_rule, wmm_ptr)) {
678                 u32 wmm_ptr = be16_to_cpu(rule->wmm_ptr) << 2;
679                 struct fwdb_wmm_rule *wmm;
680
681                 if (wmm_ptr + sizeof(struct fwdb_wmm_rule) > size)
682                         return false;
683
684                 wmm = (void *)(data + wmm_ptr);
685
686                 if (!valid_wmm(wmm))
687                         return false;
688         }
689         return true;
690 }
691
692 static bool valid_country(const u8 *data, unsigned int size,
693                           const struct fwdb_country *country)
694 {
695         unsigned int ptr = be16_to_cpu(country->coll_ptr) << 2;
696         struct fwdb_collection *coll = (void *)(data + ptr);
697         __be16 *rules_ptr;
698         unsigned int i;
699
700         /* make sure we can read len/n_rules */
701         if ((u8 *)coll + offsetofend(typeof(*coll), n_rules) > data + size)
702                 return false;
703
704         /* make sure base struct and all rules fit */
705         if ((u8 *)coll + ALIGN(coll->len, 2) +
706             (coll->n_rules * 2) > data + size)
707                 return false;
708
709         /* mandatory fields must exist */
710         if (coll->len < offsetofend(struct fwdb_collection, dfs_region))
711                 return false;
712
713         rules_ptr = (void *)((u8 *)coll + ALIGN(coll->len, 2));
714
715         for (i = 0; i < coll->n_rules; i++) {
716                 u16 rule_ptr = be16_to_cpu(rules_ptr[i]);
717
718                 if (!valid_rule(data, size, rule_ptr))
719                         return false;
720         }
721
722         return true;
723 }
724
725 #ifdef CONFIG_CFG80211_REQUIRE_SIGNED_REGDB
726 static struct key *builtin_regdb_keys;
727
728 static void __init load_keys_from_buffer(const u8 *p, unsigned int buflen)
729 {
730         const u8 *end = p + buflen;
731         size_t plen;
732         key_ref_t key;
733
734         while (p < end) {
735                 /* Each cert begins with an ASN.1 SEQUENCE tag and must be more
736                  * than 256 bytes in size.
737                  */
738                 if (end - p < 4)
739                         goto dodgy_cert;
740                 if (p[0] != 0x30 &&
741                     p[1] != 0x82)
742                         goto dodgy_cert;
743                 plen = (p[2] << 8) | p[3];
744                 plen += 4;
745                 if (plen > end - p)
746                         goto dodgy_cert;
747
748                 key = key_create_or_update(make_key_ref(builtin_regdb_keys, 1),
749                                            "asymmetric", NULL, p, plen,
750                                            ((KEY_POS_ALL & ~KEY_POS_SETATTR) |
751                                             KEY_USR_VIEW | KEY_USR_READ),
752                                            KEY_ALLOC_NOT_IN_QUOTA |
753                                            KEY_ALLOC_BUILT_IN |
754                                            KEY_ALLOC_BYPASS_RESTRICTION);
755                 if (IS_ERR(key)) {
756                         pr_err("Problem loading in-kernel X.509 certificate (%ld)\n",
757                                PTR_ERR(key));
758                 } else {
759                         pr_notice("Loaded X.509 cert '%s'\n",
760                                   key_ref_to_ptr(key)->description);
761                         key_ref_put(key);
762                 }
763                 p += plen;
764         }
765
766         return;
767
768 dodgy_cert:
769         pr_err("Problem parsing in-kernel X.509 certificate list\n");
770 }
771
772 static int __init load_builtin_regdb_keys(void)
773 {
774         builtin_regdb_keys =
775                 keyring_alloc(".builtin_regdb_keys",
776                               KUIDT_INIT(0), KGIDT_INIT(0), current_cred(),
777                               ((KEY_POS_ALL & ~KEY_POS_SETATTR) |
778                               KEY_USR_VIEW | KEY_USR_READ | KEY_USR_SEARCH),
779                               KEY_ALLOC_NOT_IN_QUOTA, NULL, NULL);
780         if (IS_ERR(builtin_regdb_keys))
781                 return PTR_ERR(builtin_regdb_keys);
782
783         pr_notice("Loading compiled-in X.509 certificates for regulatory database\n");
784
785 #ifdef CONFIG_CFG80211_USE_KERNEL_REGDB_KEYS
786         load_keys_from_buffer(shipped_regdb_certs, shipped_regdb_certs_len);
787 #endif
788 #ifdef CONFIG_CFG80211_EXTRA_REGDB_KEYDIR
789         if (CONFIG_CFG80211_EXTRA_REGDB_KEYDIR[0] != '\0')
790                 load_keys_from_buffer(extra_regdb_certs, extra_regdb_certs_len);
791 #endif
792
793         return 0;
794 }
795
796 static bool regdb_has_valid_signature(const u8 *data, unsigned int size)
797 {
798         const struct firmware *sig;
799         bool result;
800
801         if (request_firmware(&sig, "regulatory.db.p7s", &reg_pdev->dev))
802                 return false;
803
804         result = verify_pkcs7_signature(data, size, sig->data, sig->size,
805                                         builtin_regdb_keys,
806                                         VERIFYING_UNSPECIFIED_SIGNATURE,
807                                         NULL, NULL) == 0;
808
809         release_firmware(sig);
810
811         return result;
812 }
813
814 static void free_regdb_keyring(void)
815 {
816         key_put(builtin_regdb_keys);
817 }
818 #else
819 static int load_builtin_regdb_keys(void)
820 {
821         return 0;
822 }
823
824 static bool regdb_has_valid_signature(const u8 *data, unsigned int size)
825 {
826         return true;
827 }
828
829 static void free_regdb_keyring(void)
830 {
831 }
832 #endif /* CONFIG_CFG80211_REQUIRE_SIGNED_REGDB */
833
834 static bool valid_regdb(const u8 *data, unsigned int size)
835 {
836         const struct fwdb_header *hdr = (void *)data;
837         const struct fwdb_country *country;
838
839         if (size < sizeof(*hdr))
840                 return false;
841
842         if (hdr->magic != cpu_to_be32(FWDB_MAGIC))
843                 return false;
844
845         if (hdr->version != cpu_to_be32(FWDB_VERSION))
846                 return false;
847
848         if (!regdb_has_valid_signature(data, size))
849                 return false;
850
851         country = &hdr->country[0];
852         while ((u8 *)(country + 1) <= data + size) {
853                 if (!country->coll_ptr)
854                         break;
855                 if (!valid_country(data, size, country))
856                         return false;
857                 country++;
858         }
859
860         return true;
861 }
862
863 static void set_wmm_rule(struct ieee80211_wmm_rule *rule,
864                          struct fwdb_wmm_rule *wmm)
865 {
866         unsigned int i;
867
868         for (i = 0; i < IEEE80211_NUM_ACS; i++) {
869                 rule->client[i].cw_min =
870                         ecw2cw((wmm->client[i].ecw & 0xf0) >> 4);
871                 rule->client[i].cw_max = ecw2cw(wmm->client[i].ecw & 0x0f);
872                 rule->client[i].aifsn =  wmm->client[i].aifsn;
873                 rule->client[i].cot = 1000 * be16_to_cpu(wmm->client[i].cot);
874                 rule->ap[i].cw_min = ecw2cw((wmm->ap[i].ecw & 0xf0) >> 4);
875                 rule->ap[i].cw_max = ecw2cw(wmm->ap[i].ecw & 0x0f);
876                 rule->ap[i].aifsn = wmm->ap[i].aifsn;
877                 rule->ap[i].cot = 1000 * be16_to_cpu(wmm->ap[i].cot);
878         }
879 }
880
881 static int __regdb_query_wmm(const struct fwdb_header *db,
882                              const struct fwdb_country *country, int freq,
883                              u32 *dbptr, struct ieee80211_wmm_rule *rule)
884 {
885         unsigned int ptr = be16_to_cpu(country->coll_ptr) << 2;
886         struct fwdb_collection *coll = (void *)((u8 *)db + ptr);
887         int i;
888
889         for (i = 0; i < coll->n_rules; i++) {
890                 __be16 *rules_ptr = (void *)((u8 *)coll + ALIGN(coll->len, 2));
891                 unsigned int rule_ptr = be16_to_cpu(rules_ptr[i]) << 2;
892                 struct fwdb_rule *rrule = (void *)((u8 *)db + rule_ptr);
893                 struct fwdb_wmm_rule *wmm;
894                 unsigned int wmm_ptr;
895
896                 if (rrule->len < offsetofend(struct fwdb_rule, wmm_ptr))
897                         continue;
898
899                 if (freq >= KHZ_TO_MHZ(be32_to_cpu(rrule->start)) &&
900                     freq <= KHZ_TO_MHZ(be32_to_cpu(rrule->end))) {
901                         wmm_ptr = be16_to_cpu(rrule->wmm_ptr) << 2;
902                         wmm = (void *)((u8 *)db + wmm_ptr);
903                         set_wmm_rule(rule, wmm);
904                         if (dbptr)
905                                 *dbptr = wmm_ptr;
906                         return 0;
907                 }
908         }
909
910         return -ENODATA;
911 }
912
913 int reg_query_regdb_wmm(char *alpha2, int freq, u32 *dbptr,
914                         struct ieee80211_wmm_rule *rule)
915 {
916         const struct fwdb_header *hdr = regdb;
917         const struct fwdb_country *country;
918
919         if (!regdb)
920                 return -ENODATA;
921
922         if (IS_ERR(regdb))
923                 return PTR_ERR(regdb);
924
925         country = &hdr->country[0];
926         while (country->coll_ptr) {
927                 if (alpha2_equal(alpha2, country->alpha2))
928                         return __regdb_query_wmm(regdb, country, freq, dbptr,
929                                                  rule);
930
931                 country++;
932         }
933
934         return -ENODATA;
935 }
936 EXPORT_SYMBOL(reg_query_regdb_wmm);
937
938 struct wmm_ptrs {
939         struct ieee80211_wmm_rule *rule;
940         u32 ptr;
941 };
942
943 static struct ieee80211_wmm_rule *find_wmm_ptr(struct wmm_ptrs *wmm_ptrs,
944                                                u32 wmm_ptr, int n_wmms)
945 {
946         int i;
947
948         for (i = 0; i < n_wmms; i++) {
949                 if (wmm_ptrs[i].ptr == wmm_ptr)
950                         return wmm_ptrs[i].rule;
951         }
952         return NULL;
953 }
954
955 static int regdb_query_country(const struct fwdb_header *db,
956                                const struct fwdb_country *country)
957 {
958         unsigned int ptr = be16_to_cpu(country->coll_ptr) << 2;
959         struct fwdb_collection *coll = (void *)((u8 *)db + ptr);
960         struct ieee80211_regdomain *regdom;
961         struct ieee80211_regdomain *tmp_rd;
962         unsigned int size_of_regd, i, n_wmms = 0;
963         struct wmm_ptrs *wmm_ptrs;
964
965         size_of_regd = sizeof(struct ieee80211_regdomain) +
966                 coll->n_rules * sizeof(struct ieee80211_reg_rule);
967
968         regdom = kzalloc(size_of_regd, GFP_KERNEL);
969         if (!regdom)
970                 return -ENOMEM;
971
972         wmm_ptrs = kcalloc(coll->n_rules, sizeof(*wmm_ptrs), GFP_KERNEL);
973         if (!wmm_ptrs) {
974                 kfree(regdom);
975                 return -ENOMEM;
976         }
977
978         regdom->n_reg_rules = coll->n_rules;
979         regdom->alpha2[0] = country->alpha2[0];
980         regdom->alpha2[1] = country->alpha2[1];
981         regdom->dfs_region = coll->dfs_region;
982
983         for (i = 0; i < regdom->n_reg_rules; i++) {
984                 __be16 *rules_ptr = (void *)((u8 *)coll + ALIGN(coll->len, 2));
985                 unsigned int rule_ptr = be16_to_cpu(rules_ptr[i]) << 2;
986                 struct fwdb_rule *rule = (void *)((u8 *)db + rule_ptr);
987                 struct ieee80211_reg_rule *rrule = &regdom->reg_rules[i];
988
989                 rrule->freq_range.start_freq_khz = be32_to_cpu(rule->start);
990                 rrule->freq_range.end_freq_khz = be32_to_cpu(rule->end);
991                 rrule->freq_range.max_bandwidth_khz = be32_to_cpu(rule->max_bw);
992
993                 rrule->power_rule.max_antenna_gain = 0;
994                 rrule->power_rule.max_eirp = be16_to_cpu(rule->max_eirp);
995
996                 rrule->flags = 0;
997                 if (rule->flags & FWDB_FLAG_NO_OFDM)
998                         rrule->flags |= NL80211_RRF_NO_OFDM;
999                 if (rule->flags & FWDB_FLAG_NO_OUTDOOR)
1000                         rrule->flags |= NL80211_RRF_NO_OUTDOOR;
1001                 if (rule->flags & FWDB_FLAG_DFS)
1002                         rrule->flags |= NL80211_RRF_DFS;
1003                 if (rule->flags & FWDB_FLAG_NO_IR)
1004                         rrule->flags |= NL80211_RRF_NO_IR;
1005                 if (rule->flags & FWDB_FLAG_AUTO_BW)
1006                         rrule->flags |= NL80211_RRF_AUTO_BW;
1007
1008                 rrule->dfs_cac_ms = 0;
1009
1010                 /* handle optional data */
1011                 if (rule->len >= offsetofend(struct fwdb_rule, cac_timeout))
1012                         rrule->dfs_cac_ms =
1013                                 1000 * be16_to_cpu(rule->cac_timeout);
1014                 if (rule->len >= offsetofend(struct fwdb_rule, wmm_ptr)) {
1015                         u32 wmm_ptr = be16_to_cpu(rule->wmm_ptr) << 2;
1016                         struct ieee80211_wmm_rule *wmm_pos =
1017                                 find_wmm_ptr(wmm_ptrs, wmm_ptr, n_wmms);
1018                         struct fwdb_wmm_rule *wmm;
1019                         struct ieee80211_wmm_rule *wmm_rule;
1020
1021                         if (wmm_pos) {
1022                                 rrule->wmm_rule = wmm_pos;
1023                                 continue;
1024                         }
1025                         wmm = (void *)((u8 *)db + wmm_ptr);
1026                         tmp_rd = krealloc(regdom, size_of_regd + (n_wmms + 1) *
1027                                           sizeof(struct ieee80211_wmm_rule),
1028                                           GFP_KERNEL);
1029
1030                         if (!tmp_rd) {
1031                                 kfree(regdom);
1032                                 kfree(wmm_ptrs);
1033                                 return -ENOMEM;
1034                         }
1035                         regdom = tmp_rd;
1036
1037                         wmm_rule = (struct ieee80211_wmm_rule *)
1038                                 ((u8 *)regdom + size_of_regd + n_wmms *
1039                                 sizeof(struct ieee80211_wmm_rule));
1040
1041                         set_wmm_rule(wmm_rule, wmm);
1042                         wmm_ptrs[n_wmms].ptr = wmm_ptr;
1043                         wmm_ptrs[n_wmms++].rule = wmm_rule;
1044                 }
1045         }
1046         kfree(wmm_ptrs);
1047
1048         return reg_schedule_apply(regdom);
1049 }
1050
1051 static int query_regdb(const char *alpha2)
1052 {
1053         const struct fwdb_header *hdr = regdb;
1054         const struct fwdb_country *country;
1055
1056         ASSERT_RTNL();
1057
1058         if (IS_ERR(regdb))
1059                 return PTR_ERR(regdb);
1060
1061         country = &hdr->country[0];
1062         while (country->coll_ptr) {
1063                 if (alpha2_equal(alpha2, country->alpha2))
1064                         return regdb_query_country(regdb, country);
1065                 country++;
1066         }
1067
1068         return -ENODATA;
1069 }
1070
1071 static void regdb_fw_cb(const struct firmware *fw, void *context)
1072 {
1073         int set_error = 0;
1074         bool restore = true;
1075         void *db;
1076
1077         if (!fw) {
1078                 pr_info("failed to load regulatory.db\n");
1079                 set_error = -ENODATA;
1080         } else if (!valid_regdb(fw->data, fw->size)) {
1081                 pr_info("loaded regulatory.db is malformed or signature is missing/invalid\n");
1082                 set_error = -EINVAL;
1083         }
1084
1085         rtnl_lock();
1086         if (WARN_ON(regdb && !IS_ERR(regdb))) {
1087                 /* just restore and free new db */
1088         } else if (set_error) {
1089                 regdb = ERR_PTR(set_error);
1090         } else if (fw) {
1091                 db = kmemdup(fw->data, fw->size, GFP_KERNEL);
1092                 if (db) {
1093                         regdb = db;
1094                         restore = context && query_regdb(context);
1095                 } else {
1096                         restore = true;
1097                 }
1098         }
1099
1100         if (restore)
1101                 restore_regulatory_settings(true);
1102
1103         rtnl_unlock();
1104
1105         kfree(context);
1106
1107         release_firmware(fw);
1108 }
1109
1110 static int query_regdb_file(const char *alpha2)
1111 {
1112         ASSERT_RTNL();
1113
1114         if (regdb)
1115                 return query_regdb(alpha2);
1116
1117         alpha2 = kmemdup(alpha2, 2, GFP_KERNEL);
1118         if (!alpha2)
1119                 return -ENOMEM;
1120
1121         return request_firmware_nowait(THIS_MODULE, true, "regulatory.db",
1122                                        &reg_pdev->dev, GFP_KERNEL,
1123                                        (void *)alpha2, regdb_fw_cb);
1124 }
1125
1126 int reg_reload_regdb(void)
1127 {
1128         const struct firmware *fw;
1129         void *db;
1130         int err;
1131
1132         err = request_firmware(&fw, "regulatory.db", &reg_pdev->dev);
1133         if (err)
1134                 return err;
1135
1136         if (!valid_regdb(fw->data, fw->size)) {
1137                 err = -ENODATA;
1138                 goto out;
1139         }
1140
1141         db = kmemdup(fw->data, fw->size, GFP_KERNEL);
1142         if (!db) {
1143                 err = -ENOMEM;
1144                 goto out;
1145         }
1146
1147         rtnl_lock();
1148         if (!IS_ERR_OR_NULL(regdb))
1149                 kfree(regdb);
1150         regdb = db;
1151         rtnl_unlock();
1152
1153  out:
1154         release_firmware(fw);
1155         return err;
1156 }
1157
1158 static bool reg_query_database(struct regulatory_request *request)
1159 {
1160         if (query_regdb_file(request->alpha2) == 0)
1161                 return true;
1162
1163         if (call_crda(request->alpha2) == 0)
1164                 return true;
1165
1166         return false;
1167 }
1168
1169 bool reg_is_valid_request(const char *alpha2)
1170 {
1171         struct regulatory_request *lr = get_last_request();
1172
1173         if (!lr || lr->processed)
1174                 return false;
1175
1176         return alpha2_equal(lr->alpha2, alpha2);
1177 }
1178
1179 static const struct ieee80211_regdomain *reg_get_regdomain(struct wiphy *wiphy)
1180 {
1181         struct regulatory_request *lr = get_last_request();
1182
1183         /*
1184          * Follow the driver's regulatory domain, if present, unless a country
1185          * IE has been processed or a user wants to help complaince further
1186          */
1187         if (lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
1188             lr->initiator != NL80211_REGDOM_SET_BY_USER &&
1189             wiphy->regd)
1190                 return get_wiphy_regdom(wiphy);
1191
1192         return get_cfg80211_regdom();
1193 }
1194
1195 static unsigned int
1196 reg_get_max_bandwidth_from_range(const struct ieee80211_regdomain *rd,
1197                                  const struct ieee80211_reg_rule *rule)
1198 {
1199         const struct ieee80211_freq_range *freq_range = &rule->freq_range;
1200         const struct ieee80211_freq_range *freq_range_tmp;
1201         const struct ieee80211_reg_rule *tmp;
1202         u32 start_freq, end_freq, idx, no;
1203
1204         for (idx = 0; idx < rd->n_reg_rules; idx++)
1205                 if (rule == &rd->reg_rules[idx])
1206                         break;
1207
1208         if (idx == rd->n_reg_rules)
1209                 return 0;
1210
1211         /* get start_freq */
1212         no = idx;
1213
1214         while (no) {
1215                 tmp = &rd->reg_rules[--no];
1216                 freq_range_tmp = &tmp->freq_range;
1217
1218                 if (freq_range_tmp->end_freq_khz < freq_range->start_freq_khz)
1219                         break;
1220
1221                 freq_range = freq_range_tmp;
1222         }
1223
1224         start_freq = freq_range->start_freq_khz;
1225
1226         /* get end_freq */
1227         freq_range = &rule->freq_range;
1228         no = idx;
1229
1230         while (no < rd->n_reg_rules - 1) {
1231                 tmp = &rd->reg_rules[++no];
1232                 freq_range_tmp = &tmp->freq_range;
1233
1234                 if (freq_range_tmp->start_freq_khz > freq_range->end_freq_khz)
1235                         break;
1236
1237                 freq_range = freq_range_tmp;
1238         }
1239
1240         end_freq = freq_range->end_freq_khz;
1241
1242         return end_freq - start_freq;
1243 }
1244
1245 unsigned int reg_get_max_bandwidth(const struct ieee80211_regdomain *rd,
1246                                    const struct ieee80211_reg_rule *rule)
1247 {
1248         unsigned int bw = reg_get_max_bandwidth_from_range(rd, rule);
1249
1250         if (rule->flags & NL80211_RRF_NO_160MHZ)
1251                 bw = min_t(unsigned int, bw, MHZ_TO_KHZ(80));
1252         if (rule->flags & NL80211_RRF_NO_80MHZ)
1253                 bw = min_t(unsigned int, bw, MHZ_TO_KHZ(40));
1254
1255         /*
1256          * HT40+/HT40- limits are handled per-channel. Only limit BW if both
1257          * are not allowed.
1258          */
1259         if (rule->flags & NL80211_RRF_NO_HT40MINUS &&
1260             rule->flags & NL80211_RRF_NO_HT40PLUS)
1261                 bw = min_t(unsigned int, bw, MHZ_TO_KHZ(20));
1262
1263         return bw;
1264 }
1265
1266 /* Sanity check on a regulatory rule */
1267 static bool is_valid_reg_rule(const struct ieee80211_reg_rule *rule)
1268 {
1269         const struct ieee80211_freq_range *freq_range = &rule->freq_range;
1270         u32 freq_diff;
1271
1272         if (freq_range->start_freq_khz <= 0 || freq_range->end_freq_khz <= 0)
1273                 return false;
1274
1275         if (freq_range->start_freq_khz > freq_range->end_freq_khz)
1276                 return false;
1277
1278         freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
1279
1280         if (freq_range->end_freq_khz <= freq_range->start_freq_khz ||
1281             freq_range->max_bandwidth_khz > freq_diff)
1282                 return false;
1283
1284         return true;
1285 }
1286
1287 static bool is_valid_rd(const struct ieee80211_regdomain *rd)
1288 {
1289         const struct ieee80211_reg_rule *reg_rule = NULL;
1290         unsigned int i;
1291
1292         if (!rd->n_reg_rules)
1293                 return false;
1294
1295         if (WARN_ON(rd->n_reg_rules > NL80211_MAX_SUPP_REG_RULES))
1296                 return false;
1297
1298         for (i = 0; i < rd->n_reg_rules; i++) {
1299                 reg_rule = &rd->reg_rules[i];
1300                 if (!is_valid_reg_rule(reg_rule))
1301                         return false;
1302         }
1303
1304         return true;
1305 }
1306
1307 /**
1308  * freq_in_rule_band - tells us if a frequency is in a frequency band
1309  * @freq_range: frequency rule we want to query
1310  * @freq_khz: frequency we are inquiring about
1311  *
1312  * This lets us know if a specific frequency rule is or is not relevant to
1313  * a specific frequency's band. Bands are device specific and artificial
1314  * definitions (the "2.4 GHz band", the "5 GHz band" and the "60GHz band"),
1315  * however it is safe for now to assume that a frequency rule should not be
1316  * part of a frequency's band if the start freq or end freq are off by more
1317  * than 2 GHz for the 2.4 and 5 GHz bands, and by more than 10 GHz for the
1318  * 60 GHz band.
1319  * This resolution can be lowered and should be considered as we add
1320  * regulatory rule support for other "bands".
1321  **/
1322 static bool freq_in_rule_band(const struct ieee80211_freq_range *freq_range,
1323                               u32 freq_khz)
1324 {
1325 #define ONE_GHZ_IN_KHZ  1000000
1326         /*
1327          * From 802.11ad: directional multi-gigabit (DMG):
1328          * Pertaining to operation in a frequency band containing a channel
1329          * with the Channel starting frequency above 45 GHz.
1330          */
1331         u32 limit = freq_khz > 45 * ONE_GHZ_IN_KHZ ?
1332                         10 * ONE_GHZ_IN_KHZ : 2 * ONE_GHZ_IN_KHZ;
1333         if (abs(freq_khz - freq_range->start_freq_khz) <= limit)
1334                 return true;
1335         if (abs(freq_khz - freq_range->end_freq_khz) <= limit)
1336                 return true;
1337         return false;
1338 #undef ONE_GHZ_IN_KHZ
1339 }
1340
1341 /*
1342  * Later on we can perhaps use the more restrictive DFS
1343  * region but we don't have information for that yet so
1344  * for now simply disallow conflicts.
1345  */
1346 static enum nl80211_dfs_regions
1347 reg_intersect_dfs_region(const enum nl80211_dfs_regions dfs_region1,
1348                          const enum nl80211_dfs_regions dfs_region2)
1349 {
1350         if (dfs_region1 != dfs_region2)
1351                 return NL80211_DFS_UNSET;
1352         return dfs_region1;
1353 }
1354
1355 /*
1356  * Helper for regdom_intersect(), this does the real
1357  * mathematical intersection fun
1358  */
1359 static int reg_rules_intersect(const struct ieee80211_regdomain *rd1,
1360                                const struct ieee80211_regdomain *rd2,
1361                                const struct ieee80211_reg_rule *rule1,
1362                                const struct ieee80211_reg_rule *rule2,
1363                                struct ieee80211_reg_rule *intersected_rule)
1364 {
1365         const struct ieee80211_freq_range *freq_range1, *freq_range2;
1366         struct ieee80211_freq_range *freq_range;
1367         const struct ieee80211_power_rule *power_rule1, *power_rule2;
1368         struct ieee80211_power_rule *power_rule;
1369         u32 freq_diff, max_bandwidth1, max_bandwidth2;
1370
1371         freq_range1 = &rule1->freq_range;
1372         freq_range2 = &rule2->freq_range;
1373         freq_range = &intersected_rule->freq_range;
1374
1375         power_rule1 = &rule1->power_rule;
1376         power_rule2 = &rule2->power_rule;
1377         power_rule = &intersected_rule->power_rule;
1378
1379         freq_range->start_freq_khz = max(freq_range1->start_freq_khz,
1380                                          freq_range2->start_freq_khz);
1381         freq_range->end_freq_khz = min(freq_range1->end_freq_khz,
1382                                        freq_range2->end_freq_khz);
1383
1384         max_bandwidth1 = freq_range1->max_bandwidth_khz;
1385         max_bandwidth2 = freq_range2->max_bandwidth_khz;
1386
1387         if (rule1->flags & NL80211_RRF_AUTO_BW)
1388                 max_bandwidth1 = reg_get_max_bandwidth(rd1, rule1);
1389         if (rule2->flags & NL80211_RRF_AUTO_BW)
1390                 max_bandwidth2 = reg_get_max_bandwidth(rd2, rule2);
1391
1392         freq_range->max_bandwidth_khz = min(max_bandwidth1, max_bandwidth2);
1393
1394         intersected_rule->flags = rule1->flags | rule2->flags;
1395
1396         /*
1397          * In case NL80211_RRF_AUTO_BW requested for both rules
1398          * set AUTO_BW in intersected rule also. Next we will
1399          * calculate BW correctly in handle_channel function.
1400          * In other case remove AUTO_BW flag while we calculate
1401          * maximum bandwidth correctly and auto calculation is
1402          * not required.
1403          */
1404         if ((rule1->flags & NL80211_RRF_AUTO_BW) &&
1405             (rule2->flags & NL80211_RRF_AUTO_BW))
1406                 intersected_rule->flags |= NL80211_RRF_AUTO_BW;
1407         else
1408                 intersected_rule->flags &= ~NL80211_RRF_AUTO_BW;
1409
1410         freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
1411         if (freq_range->max_bandwidth_khz > freq_diff)
1412                 freq_range->max_bandwidth_khz = freq_diff;
1413
1414         power_rule->max_eirp = min(power_rule1->max_eirp,
1415                 power_rule2->max_eirp);
1416         power_rule->max_antenna_gain = min(power_rule1->max_antenna_gain,
1417                 power_rule2->max_antenna_gain);
1418
1419         intersected_rule->dfs_cac_ms = max(rule1->dfs_cac_ms,
1420                                            rule2->dfs_cac_ms);
1421
1422         if (!is_valid_reg_rule(intersected_rule))
1423                 return -EINVAL;
1424
1425         return 0;
1426 }
1427
1428 /* check whether old rule contains new rule */
1429 static bool rule_contains(struct ieee80211_reg_rule *r1,
1430                           struct ieee80211_reg_rule *r2)
1431 {
1432         /* for simplicity, currently consider only same flags */
1433         if (r1->flags != r2->flags)
1434                 return false;
1435
1436         /* verify r1 is more restrictive */
1437         if ((r1->power_rule.max_antenna_gain >
1438              r2->power_rule.max_antenna_gain) ||
1439             r1->power_rule.max_eirp > r2->power_rule.max_eirp)
1440                 return false;
1441
1442         /* make sure r2's range is contained within r1 */
1443         if (r1->freq_range.start_freq_khz > r2->freq_range.start_freq_khz ||
1444             r1->freq_range.end_freq_khz < r2->freq_range.end_freq_khz)
1445                 return false;
1446
1447         /* and finally verify that r1.max_bw >= r2.max_bw */
1448         if (r1->freq_range.max_bandwidth_khz <
1449             r2->freq_range.max_bandwidth_khz)
1450                 return false;
1451
1452         return true;
1453 }
1454
1455 /* add or extend current rules. do nothing if rule is already contained */
1456 static void add_rule(struct ieee80211_reg_rule *rule,
1457                      struct ieee80211_reg_rule *reg_rules, u32 *n_rules)
1458 {
1459         struct ieee80211_reg_rule *tmp_rule;
1460         int i;
1461
1462         for (i = 0; i < *n_rules; i++) {
1463                 tmp_rule = &reg_rules[i];
1464                 /* rule is already contained - do nothing */
1465                 if (rule_contains(tmp_rule, rule))
1466                         return;
1467
1468                 /* extend rule if possible */
1469                 if (rule_contains(rule, tmp_rule)) {
1470                         memcpy(tmp_rule, rule, sizeof(*rule));
1471                         return;
1472                 }
1473         }
1474
1475         memcpy(&reg_rules[*n_rules], rule, sizeof(*rule));
1476         (*n_rules)++;
1477 }
1478
1479 /**
1480  * regdom_intersect - do the intersection between two regulatory domains
1481  * @rd1: first regulatory domain
1482  * @rd2: second regulatory domain
1483  *
1484  * Use this function to get the intersection between two regulatory domains.
1485  * Once completed we will mark the alpha2 for the rd as intersected, "98",
1486  * as no one single alpha2 can represent this regulatory domain.
1487  *
1488  * Returns a pointer to the regulatory domain structure which will hold the
1489  * resulting intersection of rules between rd1 and rd2. We will
1490  * kzalloc() this structure for you.
1491  */
1492 static struct ieee80211_regdomain *
1493 regdom_intersect(const struct ieee80211_regdomain *rd1,
1494                  const struct ieee80211_regdomain *rd2)
1495 {
1496         int r, size_of_regd;
1497         unsigned int x, y;
1498         unsigned int num_rules = 0;
1499         const struct ieee80211_reg_rule *rule1, *rule2;
1500         struct ieee80211_reg_rule intersected_rule;
1501         struct ieee80211_regdomain *rd;
1502
1503         if (!rd1 || !rd2)
1504                 return NULL;
1505
1506         /*
1507          * First we get a count of the rules we'll need, then we actually
1508          * build them. This is to so we can malloc() and free() a
1509          * regdomain once. The reason we use reg_rules_intersect() here
1510          * is it will return -EINVAL if the rule computed makes no sense.
1511          * All rules that do check out OK are valid.
1512          */
1513
1514         for (x = 0; x < rd1->n_reg_rules; x++) {
1515                 rule1 = &rd1->reg_rules[x];
1516                 for (y = 0; y < rd2->n_reg_rules; y++) {
1517                         rule2 = &rd2->reg_rules[y];
1518                         if (!reg_rules_intersect(rd1, rd2, rule1, rule2,
1519                                                  &intersected_rule))
1520                                 num_rules++;
1521                 }
1522         }
1523
1524         if (!num_rules)
1525                 return NULL;
1526
1527         size_of_regd = sizeof(struct ieee80211_regdomain) +
1528                        num_rules * sizeof(struct ieee80211_reg_rule);
1529
1530         rd = kzalloc(size_of_regd, GFP_KERNEL);
1531         if (!rd)
1532                 return NULL;
1533
1534         for (x = 0; x < rd1->n_reg_rules; x++) {
1535                 rule1 = &rd1->reg_rules[x];
1536                 for (y = 0; y < rd2->n_reg_rules; y++) {
1537                         rule2 = &rd2->reg_rules[y];
1538                         r = reg_rules_intersect(rd1, rd2, rule1, rule2,
1539                                                 &intersected_rule);
1540                         /*
1541                          * No need to memset here the intersected rule here as
1542                          * we're not using the stack anymore
1543                          */
1544                         if (r)
1545                                 continue;
1546
1547                         add_rule(&intersected_rule, rd->reg_rules,
1548                                  &rd->n_reg_rules);
1549                 }
1550         }
1551
1552         rd->alpha2[0] = '9';
1553         rd->alpha2[1] = '8';
1554         rd->dfs_region = reg_intersect_dfs_region(rd1->dfs_region,
1555                                                   rd2->dfs_region);
1556
1557         return rd;
1558 }
1559
1560 /*
1561  * XXX: add support for the rest of enum nl80211_reg_rule_flags, we may
1562  * want to just have the channel structure use these
1563  */
1564 static u32 map_regdom_flags(u32 rd_flags)
1565 {
1566         u32 channel_flags = 0;
1567         if (rd_flags & NL80211_RRF_NO_IR_ALL)
1568                 channel_flags |= IEEE80211_CHAN_NO_IR;
1569         if (rd_flags & NL80211_RRF_DFS)
1570                 channel_flags |= IEEE80211_CHAN_RADAR;
1571         if (rd_flags & NL80211_RRF_NO_OFDM)
1572                 channel_flags |= IEEE80211_CHAN_NO_OFDM;
1573         if (rd_flags & NL80211_RRF_NO_OUTDOOR)
1574                 channel_flags |= IEEE80211_CHAN_INDOOR_ONLY;
1575         if (rd_flags & NL80211_RRF_IR_CONCURRENT)
1576                 channel_flags |= IEEE80211_CHAN_IR_CONCURRENT;
1577         if (rd_flags & NL80211_RRF_NO_HT40MINUS)
1578                 channel_flags |= IEEE80211_CHAN_NO_HT40MINUS;
1579         if (rd_flags & NL80211_RRF_NO_HT40PLUS)
1580                 channel_flags |= IEEE80211_CHAN_NO_HT40PLUS;
1581         if (rd_flags & NL80211_RRF_NO_80MHZ)
1582                 channel_flags |= IEEE80211_CHAN_NO_80MHZ;
1583         if (rd_flags & NL80211_RRF_NO_160MHZ)
1584                 channel_flags |= IEEE80211_CHAN_NO_160MHZ;
1585         return channel_flags;
1586 }
1587
1588 static const struct ieee80211_reg_rule *
1589 freq_reg_info_regd(u32 center_freq,
1590                    const struct ieee80211_regdomain *regd, u32 bw)
1591 {
1592         int i;
1593         bool band_rule_found = false;
1594         bool bw_fits = false;
1595
1596         if (!regd)
1597                 return ERR_PTR(-EINVAL);
1598
1599         for (i = 0; i < regd->n_reg_rules; i++) {
1600                 const struct ieee80211_reg_rule *rr;
1601                 const struct ieee80211_freq_range *fr = NULL;
1602
1603                 rr = &regd->reg_rules[i];
1604                 fr = &rr->freq_range;
1605
1606                 /*
1607                  * We only need to know if one frequency rule was
1608                  * was in center_freq's band, that's enough, so lets
1609                  * not overwrite it once found
1610                  */
1611                 if (!band_rule_found)
1612                         band_rule_found = freq_in_rule_band(fr, center_freq);
1613
1614                 bw_fits = cfg80211_does_bw_fit_range(fr, center_freq, bw);
1615
1616                 if (band_rule_found && bw_fits)
1617                         return rr;
1618         }
1619
1620         if (!band_rule_found)
1621                 return ERR_PTR(-ERANGE);
1622
1623         return ERR_PTR(-EINVAL);
1624 }
1625
1626 static const struct ieee80211_reg_rule *
1627 __freq_reg_info(struct wiphy *wiphy, u32 center_freq, u32 min_bw)
1628 {
1629         const struct ieee80211_regdomain *regd = reg_get_regdomain(wiphy);
1630         const struct ieee80211_reg_rule *reg_rule = NULL;
1631         u32 bw;
1632
1633         for (bw = MHZ_TO_KHZ(20); bw >= min_bw; bw = bw / 2) {
1634                 reg_rule = freq_reg_info_regd(center_freq, regd, bw);
1635                 if (!IS_ERR(reg_rule))
1636                         return reg_rule;
1637         }
1638
1639         return reg_rule;
1640 }
1641
1642 const struct ieee80211_reg_rule *freq_reg_info(struct wiphy *wiphy,
1643                                                u32 center_freq)
1644 {
1645         return __freq_reg_info(wiphy, center_freq, MHZ_TO_KHZ(20));
1646 }
1647 EXPORT_SYMBOL(freq_reg_info);
1648
1649 const char *reg_initiator_name(enum nl80211_reg_initiator initiator)
1650 {
1651         switch (initiator) {
1652         case NL80211_REGDOM_SET_BY_CORE:
1653                 return "core";
1654         case NL80211_REGDOM_SET_BY_USER:
1655                 return "user";
1656         case NL80211_REGDOM_SET_BY_DRIVER:
1657                 return "driver";
1658         case NL80211_REGDOM_SET_BY_COUNTRY_IE:
1659                 return "country element";
1660         default:
1661                 WARN_ON(1);
1662                 return "bug";
1663         }
1664 }
1665 EXPORT_SYMBOL(reg_initiator_name);
1666
1667 static uint32_t reg_rule_to_chan_bw_flags(const struct ieee80211_regdomain *regd,
1668                                           const struct ieee80211_reg_rule *reg_rule,
1669                                           const struct ieee80211_channel *chan)
1670 {
1671         const struct ieee80211_freq_range *freq_range = NULL;
1672         u32 max_bandwidth_khz, bw_flags = 0;
1673
1674         freq_range = &reg_rule->freq_range;
1675
1676         max_bandwidth_khz = freq_range->max_bandwidth_khz;
1677         /* Check if auto calculation requested */
1678         if (reg_rule->flags & NL80211_RRF_AUTO_BW)
1679                 max_bandwidth_khz = reg_get_max_bandwidth(regd, reg_rule);
1680
1681         /* If we get a reg_rule we can assume that at least 5Mhz fit */
1682         if (!cfg80211_does_bw_fit_range(freq_range,
1683                                         MHZ_TO_KHZ(chan->center_freq),
1684                                         MHZ_TO_KHZ(10)))
1685                 bw_flags |= IEEE80211_CHAN_NO_10MHZ;
1686         if (!cfg80211_does_bw_fit_range(freq_range,
1687                                         MHZ_TO_KHZ(chan->center_freq),
1688                                         MHZ_TO_KHZ(20)))
1689                 bw_flags |= IEEE80211_CHAN_NO_20MHZ;
1690
1691         if (max_bandwidth_khz < MHZ_TO_KHZ(10))
1692                 bw_flags |= IEEE80211_CHAN_NO_10MHZ;
1693         if (max_bandwidth_khz < MHZ_TO_KHZ(20))
1694                 bw_flags |= IEEE80211_CHAN_NO_20MHZ;
1695         if (max_bandwidth_khz < MHZ_TO_KHZ(40))
1696                 bw_flags |= IEEE80211_CHAN_NO_HT40;
1697         if (max_bandwidth_khz < MHZ_TO_KHZ(80))
1698                 bw_flags |= IEEE80211_CHAN_NO_80MHZ;
1699         if (max_bandwidth_khz < MHZ_TO_KHZ(160))
1700                 bw_flags |= IEEE80211_CHAN_NO_160MHZ;
1701         return bw_flags;
1702 }
1703
1704 /*
1705  * Note that right now we assume the desired channel bandwidth
1706  * is always 20 MHz for each individual channel (HT40 uses 20 MHz
1707  * per channel, the primary and the extension channel).
1708  */
1709 static void handle_channel(struct wiphy *wiphy,
1710                            enum nl80211_reg_initiator initiator,
1711                            struct ieee80211_channel *chan)
1712 {
1713         u32 flags, bw_flags = 0;
1714         const struct ieee80211_reg_rule *reg_rule = NULL;
1715         const struct ieee80211_power_rule *power_rule = NULL;
1716         struct wiphy *request_wiphy = NULL;
1717         struct regulatory_request *lr = get_last_request();
1718         const struct ieee80211_regdomain *regd;
1719
1720         request_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx);
1721
1722         flags = chan->orig_flags;
1723
1724         reg_rule = freq_reg_info(wiphy, MHZ_TO_KHZ(chan->center_freq));
1725         if (IS_ERR(reg_rule)) {
1726                 /*
1727                  * We will disable all channels that do not match our
1728                  * received regulatory rule unless the hint is coming
1729                  * from a Country IE and the Country IE had no information
1730                  * about a band. The IEEE 802.11 spec allows for an AP
1731                  * to send only a subset of the regulatory rules allowed,
1732                  * so an AP in the US that only supports 2.4 GHz may only send
1733                  * a country IE with information for the 2.4 GHz band
1734                  * while 5 GHz is still supported.
1735                  */
1736                 if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
1737                     PTR_ERR(reg_rule) == -ERANGE)
1738                         return;
1739
1740                 if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
1741                     request_wiphy && request_wiphy == wiphy &&
1742                     request_wiphy->regulatory_flags & REGULATORY_STRICT_REG) {
1743                         pr_debug("Disabling freq %d MHz for good\n",
1744                                  chan->center_freq);
1745                         chan->orig_flags |= IEEE80211_CHAN_DISABLED;
1746                         chan->flags = chan->orig_flags;
1747                 } else {
1748                         pr_debug("Disabling freq %d MHz\n",
1749                                  chan->center_freq);
1750                         chan->flags |= IEEE80211_CHAN_DISABLED;
1751                 }
1752                 return;
1753         }
1754
1755         regd = reg_get_regdomain(wiphy);
1756
1757         power_rule = &reg_rule->power_rule;
1758         bw_flags = reg_rule_to_chan_bw_flags(regd, reg_rule, chan);
1759
1760         if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
1761             request_wiphy && request_wiphy == wiphy &&
1762             request_wiphy->regulatory_flags & REGULATORY_STRICT_REG) {
1763                 /*
1764                  * This guarantees the driver's requested regulatory domain
1765                  * will always be used as a base for further regulatory
1766                  * settings
1767                  */
1768                 chan->flags = chan->orig_flags =
1769                         map_regdom_flags(reg_rule->flags) | bw_flags;
1770                 chan->max_antenna_gain = chan->orig_mag =
1771                         (int) MBI_TO_DBI(power_rule->max_antenna_gain);
1772                 chan->max_reg_power = chan->max_power = chan->orig_mpwr =
1773                         (int) MBM_TO_DBM(power_rule->max_eirp);
1774
1775                 if (chan->flags & IEEE80211_CHAN_RADAR) {
1776                         chan->dfs_cac_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
1777                         if (reg_rule->dfs_cac_ms)
1778                                 chan->dfs_cac_ms = reg_rule->dfs_cac_ms;
1779                 }
1780
1781                 return;
1782         }
1783
1784         chan->dfs_state = NL80211_DFS_USABLE;
1785         chan->dfs_state_entered = jiffies;
1786
1787         chan->beacon_found = false;
1788         chan->flags = flags | bw_flags | map_regdom_flags(reg_rule->flags);
1789         chan->max_antenna_gain =
1790                 min_t(int, chan->orig_mag,
1791                       MBI_TO_DBI(power_rule->max_antenna_gain));
1792         chan->max_reg_power = (int) MBM_TO_DBM(power_rule->max_eirp);
1793
1794         if (chan->flags & IEEE80211_CHAN_RADAR) {
1795                 if (reg_rule->dfs_cac_ms)
1796                         chan->dfs_cac_ms = reg_rule->dfs_cac_ms;
1797                 else
1798                         chan->dfs_cac_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
1799         }
1800
1801         if (chan->orig_mpwr) {
1802                 /*
1803                  * Devices that use REGULATORY_COUNTRY_IE_FOLLOW_POWER
1804                  * will always follow the passed country IE power settings.
1805                  */
1806                 if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
1807                     wiphy->regulatory_flags & REGULATORY_COUNTRY_IE_FOLLOW_POWER)
1808                         chan->max_power = chan->max_reg_power;
1809                 else
1810                         chan->max_power = min(chan->orig_mpwr,
1811                                               chan->max_reg_power);
1812         } else
1813                 chan->max_power = chan->max_reg_power;
1814 }
1815
1816 static void handle_band(struct wiphy *wiphy,
1817                         enum nl80211_reg_initiator initiator,
1818                         struct ieee80211_supported_band *sband)
1819 {
1820         unsigned int i;
1821
1822         if (!sband)
1823                 return;
1824
1825         for (i = 0; i < sband->n_channels; i++)
1826                 handle_channel(wiphy, initiator, &sband->channels[i]);
1827 }
1828
1829 static bool reg_request_cell_base(struct regulatory_request *request)
1830 {
1831         if (request->initiator != NL80211_REGDOM_SET_BY_USER)
1832                 return false;
1833         return request->user_reg_hint_type == NL80211_USER_REG_HINT_CELL_BASE;
1834 }
1835
1836 bool reg_last_request_cell_base(void)
1837 {
1838         return reg_request_cell_base(get_last_request());
1839 }
1840
1841 #ifdef CONFIG_CFG80211_REG_CELLULAR_HINTS
1842 /* Core specific check */
1843 static enum reg_request_treatment
1844 reg_ignore_cell_hint(struct regulatory_request *pending_request)
1845 {
1846         struct regulatory_request *lr = get_last_request();
1847
1848         if (!reg_num_devs_support_basehint)
1849                 return REG_REQ_IGNORE;
1850
1851         if (reg_request_cell_base(lr) &&
1852             !regdom_changes(pending_request->alpha2))
1853                 return REG_REQ_ALREADY_SET;
1854
1855         return REG_REQ_OK;
1856 }
1857
1858 /* Device specific check */
1859 static bool reg_dev_ignore_cell_hint(struct wiphy *wiphy)
1860 {
1861         return !(wiphy->features & NL80211_FEATURE_CELL_BASE_REG_HINTS);
1862 }
1863 #else
1864 static enum reg_request_treatment
1865 reg_ignore_cell_hint(struct regulatory_request *pending_request)
1866 {
1867         return REG_REQ_IGNORE;
1868 }
1869
1870 static bool reg_dev_ignore_cell_hint(struct wiphy *wiphy)
1871 {
1872         return true;
1873 }
1874 #endif
1875
1876 static bool wiphy_strict_alpha2_regd(struct wiphy *wiphy)
1877 {
1878         if (wiphy->regulatory_flags & REGULATORY_STRICT_REG &&
1879             !(wiphy->regulatory_flags & REGULATORY_CUSTOM_REG))
1880                 return true;
1881         return false;
1882 }
1883
1884 static bool ignore_reg_update(struct wiphy *wiphy,
1885                               enum nl80211_reg_initiator initiator)
1886 {
1887         struct regulatory_request *lr = get_last_request();
1888
1889         if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED)
1890                 return true;
1891
1892         if (!lr) {
1893                 pr_debug("Ignoring regulatory request set by %s since last_request is not set\n",
1894                          reg_initiator_name(initiator));
1895                 return true;
1896         }
1897
1898         if (initiator == NL80211_REGDOM_SET_BY_CORE &&
1899             wiphy->regulatory_flags & REGULATORY_CUSTOM_REG) {
1900                 pr_debug("Ignoring regulatory request set by %s since the driver uses its own custom regulatory domain\n",
1901                          reg_initiator_name(initiator));
1902                 return true;
1903         }
1904
1905         /*
1906          * wiphy->regd will be set once the device has its own
1907          * desired regulatory domain set
1908          */
1909         if (wiphy_strict_alpha2_regd(wiphy) && !wiphy->regd &&
1910             initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
1911             !is_world_regdom(lr->alpha2)) {
1912                 pr_debug("Ignoring regulatory request set by %s since the driver requires its own regulatory domain to be set first\n",
1913                          reg_initiator_name(initiator));
1914                 return true;
1915         }
1916
1917         if (reg_request_cell_base(lr))
1918                 return reg_dev_ignore_cell_hint(wiphy);
1919
1920         return false;
1921 }
1922
1923 static bool reg_is_world_roaming(struct wiphy *wiphy)
1924 {
1925         const struct ieee80211_regdomain *cr = get_cfg80211_regdom();
1926         const struct ieee80211_regdomain *wr = get_wiphy_regdom(wiphy);
1927         struct regulatory_request *lr = get_last_request();
1928
1929         if (is_world_regdom(cr->alpha2) || (wr && is_world_regdom(wr->alpha2)))
1930                 return true;
1931
1932         if (lr && lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
1933             wiphy->regulatory_flags & REGULATORY_CUSTOM_REG)
1934                 return true;
1935
1936         return false;
1937 }
1938
1939 static void handle_reg_beacon(struct wiphy *wiphy, unsigned int chan_idx,
1940                               struct reg_beacon *reg_beacon)
1941 {
1942         struct ieee80211_supported_band *sband;
1943         struct ieee80211_channel *chan;
1944         bool channel_changed = false;
1945         struct ieee80211_channel chan_before;
1946
1947         sband = wiphy->bands[reg_beacon->chan.band];
1948         chan = &sband->channels[chan_idx];
1949
1950         if (likely(chan->center_freq != reg_beacon->chan.center_freq))
1951                 return;
1952
1953         if (chan->beacon_found)
1954                 return;
1955
1956         chan->beacon_found = true;
1957
1958         if (!reg_is_world_roaming(wiphy))
1959                 return;
1960
1961         if (wiphy->regulatory_flags & REGULATORY_DISABLE_BEACON_HINTS)
1962                 return;
1963
1964         chan_before = *chan;
1965
1966         if (chan->flags & IEEE80211_CHAN_NO_IR) {
1967                 chan->flags &= ~IEEE80211_CHAN_NO_IR;
1968                 channel_changed = true;
1969         }
1970
1971         if (channel_changed)
1972                 nl80211_send_beacon_hint_event(wiphy, &chan_before, chan);
1973 }
1974
1975 /*
1976  * Called when a scan on a wiphy finds a beacon on
1977  * new channel
1978  */
1979 static void wiphy_update_new_beacon(struct wiphy *wiphy,
1980                                     struct reg_beacon *reg_beacon)
1981 {
1982         unsigned int i;
1983         struct ieee80211_supported_band *sband;
1984
1985         if (!wiphy->bands[reg_beacon->chan.band])
1986                 return;
1987
1988         sband = wiphy->bands[reg_beacon->chan.band];
1989
1990         for (i = 0; i < sband->n_channels; i++)
1991                 handle_reg_beacon(wiphy, i, reg_beacon);
1992 }
1993
1994 /*
1995  * Called upon reg changes or a new wiphy is added
1996  */
1997 static void wiphy_update_beacon_reg(struct wiphy *wiphy)
1998 {
1999         unsigned int i;
2000         struct ieee80211_supported_band *sband;
2001         struct reg_beacon *reg_beacon;
2002
2003         list_for_each_entry(reg_beacon, &reg_beacon_list, list) {
2004                 if (!wiphy->bands[reg_beacon->chan.band])
2005                         continue;
2006                 sband = wiphy->bands[reg_beacon->chan.band];
2007                 for (i = 0; i < sband->n_channels; i++)
2008                         handle_reg_beacon(wiphy, i, reg_beacon);
2009         }
2010 }
2011
2012 /* Reap the advantages of previously found beacons */
2013 static void reg_process_beacons(struct wiphy *wiphy)
2014 {
2015         /*
2016          * Means we are just firing up cfg80211, so no beacons would
2017          * have been processed yet.
2018          */
2019         if (!last_request)
2020                 return;
2021         wiphy_update_beacon_reg(wiphy);
2022 }
2023
2024 static bool is_ht40_allowed(struct ieee80211_channel *chan)
2025 {
2026         if (!chan)
2027                 return false;
2028         if (chan->flags & IEEE80211_CHAN_DISABLED)
2029                 return false;
2030         /* This would happen when regulatory rules disallow HT40 completely */
2031         if ((chan->flags & IEEE80211_CHAN_NO_HT40) == IEEE80211_CHAN_NO_HT40)
2032                 return false;
2033         return true;
2034 }
2035
2036 static void reg_process_ht_flags_channel(struct wiphy *wiphy,
2037                                          struct ieee80211_channel *channel)
2038 {
2039         struct ieee80211_supported_band *sband = wiphy->bands[channel->band];
2040         struct ieee80211_channel *channel_before = NULL, *channel_after = NULL;
2041         const struct ieee80211_regdomain *regd;
2042         unsigned int i;
2043         u32 flags;
2044
2045         if (!is_ht40_allowed(channel)) {
2046                 channel->flags |= IEEE80211_CHAN_NO_HT40;
2047                 return;
2048         }
2049
2050         /*
2051          * We need to ensure the extension channels exist to
2052          * be able to use HT40- or HT40+, this finds them (or not)
2053          */
2054         for (i = 0; i < sband->n_channels; i++) {
2055                 struct ieee80211_channel *c = &sband->channels[i];
2056
2057                 if (c->center_freq == (channel->center_freq - 20))
2058                         channel_before = c;
2059                 if (c->center_freq == (channel->center_freq + 20))
2060                         channel_after = c;
2061         }
2062
2063         flags = 0;
2064         regd = get_wiphy_regdom(wiphy);
2065         if (regd) {
2066                 const struct ieee80211_reg_rule *reg_rule =
2067                         freq_reg_info_regd(MHZ_TO_KHZ(channel->center_freq),
2068                                            regd, MHZ_TO_KHZ(20));
2069
2070                 if (!IS_ERR(reg_rule))
2071                         flags = reg_rule->flags;
2072         }
2073
2074         /*
2075          * Please note that this assumes target bandwidth is 20 MHz,
2076          * if that ever changes we also need to change the below logic
2077          * to include that as well.
2078          */
2079         if (!is_ht40_allowed(channel_before) ||
2080             flags & NL80211_RRF_NO_HT40MINUS)
2081                 channel->flags |= IEEE80211_CHAN_NO_HT40MINUS;
2082         else
2083                 channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
2084
2085         if (!is_ht40_allowed(channel_after) ||
2086             flags & NL80211_RRF_NO_HT40PLUS)
2087                 channel->flags |= IEEE80211_CHAN_NO_HT40PLUS;
2088         else
2089                 channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
2090 }
2091
2092 static void reg_process_ht_flags_band(struct wiphy *wiphy,
2093                                       struct ieee80211_supported_band *sband)
2094 {
2095         unsigned int i;
2096
2097         if (!sband)
2098                 return;
2099
2100         for (i = 0; i < sband->n_channels; i++)
2101                 reg_process_ht_flags_channel(wiphy, &sband->channels[i]);
2102 }
2103
2104 static void reg_process_ht_flags(struct wiphy *wiphy)
2105 {
2106         enum nl80211_band band;
2107
2108         if (!wiphy)
2109                 return;
2110
2111         for (band = 0; band < NUM_NL80211_BANDS; band++)
2112                 reg_process_ht_flags_band(wiphy, wiphy->bands[band]);
2113 }
2114
2115 static void reg_call_notifier(struct wiphy *wiphy,
2116                               struct regulatory_request *request)
2117 {
2118         if (wiphy->reg_notifier)
2119                 wiphy->reg_notifier(wiphy, request);
2120 }
2121
2122 static bool reg_wdev_chan_valid(struct wiphy *wiphy, struct wireless_dev *wdev)
2123 {
2124         struct cfg80211_chan_def chandef;
2125         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
2126         enum nl80211_iftype iftype;
2127
2128         wdev_lock(wdev);
2129         iftype = wdev->iftype;
2130
2131         /* make sure the interface is active */
2132         if (!wdev->netdev || !netif_running(wdev->netdev))
2133                 goto wdev_inactive_unlock;
2134
2135         switch (iftype) {
2136         case NL80211_IFTYPE_AP:
2137         case NL80211_IFTYPE_P2P_GO:
2138                 if (!wdev->beacon_interval)
2139                         goto wdev_inactive_unlock;
2140                 chandef = wdev->chandef;
2141                 break;
2142         case NL80211_IFTYPE_ADHOC:
2143                 if (!wdev->ssid_len)
2144                         goto wdev_inactive_unlock;
2145                 chandef = wdev->chandef;
2146                 break;
2147         case NL80211_IFTYPE_STATION:
2148         case NL80211_IFTYPE_P2P_CLIENT:
2149                 if (!wdev->current_bss ||
2150                     !wdev->current_bss->pub.channel)
2151                         goto wdev_inactive_unlock;
2152
2153                 if (!rdev->ops->get_channel ||
2154                     rdev_get_channel(rdev, wdev, &chandef))
2155                         cfg80211_chandef_create(&chandef,
2156                                                 wdev->current_bss->pub.channel,
2157                                                 NL80211_CHAN_NO_HT);
2158                 break;
2159         case NL80211_IFTYPE_MONITOR:
2160         case NL80211_IFTYPE_AP_VLAN:
2161         case NL80211_IFTYPE_P2P_DEVICE:
2162                 /* no enforcement required */
2163                 break;
2164         default:
2165                 /* others not implemented for now */
2166                 WARN_ON(1);
2167                 break;
2168         }
2169
2170         wdev_unlock(wdev);
2171
2172         switch (iftype) {
2173         case NL80211_IFTYPE_AP:
2174         case NL80211_IFTYPE_P2P_GO:
2175         case NL80211_IFTYPE_ADHOC:
2176                 return cfg80211_reg_can_beacon_relax(wiphy, &chandef, iftype);
2177         case NL80211_IFTYPE_STATION:
2178         case NL80211_IFTYPE_P2P_CLIENT:
2179                 return cfg80211_chandef_usable(wiphy, &chandef,
2180                                                IEEE80211_CHAN_DISABLED);
2181         default:
2182                 break;
2183         }
2184
2185         return true;
2186
2187 wdev_inactive_unlock:
2188         wdev_unlock(wdev);
2189         return true;
2190 }
2191
2192 static void reg_leave_invalid_chans(struct wiphy *wiphy)
2193 {
2194         struct wireless_dev *wdev;
2195         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
2196
2197         ASSERT_RTNL();
2198
2199         list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list)
2200                 if (!reg_wdev_chan_valid(wiphy, wdev))
2201                         cfg80211_leave(rdev, wdev);
2202 }
2203
2204 static void reg_check_chans_work(struct work_struct *work)
2205 {
2206         struct cfg80211_registered_device *rdev;
2207
2208         pr_debug("Verifying active interfaces after reg change\n");
2209         rtnl_lock();
2210
2211         list_for_each_entry(rdev, &cfg80211_rdev_list, list)
2212                 if (!(rdev->wiphy.regulatory_flags &
2213                       REGULATORY_IGNORE_STALE_KICKOFF))
2214                         reg_leave_invalid_chans(&rdev->wiphy);
2215
2216         rtnl_unlock();
2217 }
2218
2219 static void reg_check_channels(void)
2220 {
2221         /*
2222          * Give usermode a chance to do something nicer (move to another
2223          * channel, orderly disconnection), before forcing a disconnection.
2224          */
2225         mod_delayed_work(system_power_efficient_wq,
2226                          &reg_check_chans,
2227                          msecs_to_jiffies(REG_ENFORCE_GRACE_MS));
2228 }
2229
2230 static void wiphy_update_regulatory(struct wiphy *wiphy,
2231                                     enum nl80211_reg_initiator initiator)
2232 {
2233         enum nl80211_band band;
2234         struct regulatory_request *lr = get_last_request();
2235
2236         if (ignore_reg_update(wiphy, initiator)) {
2237                 /*
2238                  * Regulatory updates set by CORE are ignored for custom
2239                  * regulatory cards. Let us notify the changes to the driver,
2240                  * as some drivers used this to restore its orig_* reg domain.
2241                  */
2242                 if (initiator == NL80211_REGDOM_SET_BY_CORE &&
2243                     wiphy->regulatory_flags & REGULATORY_CUSTOM_REG &&
2244                     !(wiphy->regulatory_flags &
2245                       REGULATORY_WIPHY_SELF_MANAGED))
2246                         reg_call_notifier(wiphy, lr);
2247                 return;
2248         }
2249
2250         lr->dfs_region = get_cfg80211_regdom()->dfs_region;
2251
2252         for (band = 0; band < NUM_NL80211_BANDS; band++)
2253                 handle_band(wiphy, initiator, wiphy->bands[band]);
2254
2255         reg_process_beacons(wiphy);
2256         reg_process_ht_flags(wiphy);
2257         reg_call_notifier(wiphy, lr);
2258 }
2259
2260 static void update_all_wiphy_regulatory(enum nl80211_reg_initiator initiator)
2261 {
2262         struct cfg80211_registered_device *rdev;
2263         struct wiphy *wiphy;
2264
2265         ASSERT_RTNL();
2266
2267         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
2268                 wiphy = &rdev->wiphy;
2269                 wiphy_update_regulatory(wiphy, initiator);
2270         }
2271
2272         reg_check_channels();
2273 }
2274
2275 static void handle_channel_custom(struct wiphy *wiphy,
2276                                   struct ieee80211_channel *chan,
2277                                   const struct ieee80211_regdomain *regd)
2278 {
2279         u32 bw_flags = 0;
2280         const struct ieee80211_reg_rule *reg_rule = NULL;
2281         const struct ieee80211_power_rule *power_rule = NULL;
2282         u32 bw;
2283
2284         for (bw = MHZ_TO_KHZ(20); bw >= MHZ_TO_KHZ(5); bw = bw / 2) {
2285                 reg_rule = freq_reg_info_regd(MHZ_TO_KHZ(chan->center_freq),
2286                                               regd, bw);
2287                 if (!IS_ERR(reg_rule))
2288                         break;
2289         }
2290
2291         if (IS_ERR(reg_rule)) {
2292                 pr_debug("Disabling freq %d MHz as custom regd has no rule that fits it\n",
2293                          chan->center_freq);
2294                 if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) {
2295                         chan->flags |= IEEE80211_CHAN_DISABLED;
2296                 } else {
2297                         chan->orig_flags |= IEEE80211_CHAN_DISABLED;
2298                         chan->flags = chan->orig_flags;
2299                 }
2300                 return;
2301         }
2302
2303         power_rule = &reg_rule->power_rule;
2304         bw_flags = reg_rule_to_chan_bw_flags(regd, reg_rule, chan);
2305
2306         chan->dfs_state_entered = jiffies;
2307         chan->dfs_state = NL80211_DFS_USABLE;
2308
2309         chan->beacon_found = false;
2310
2311         if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED)
2312                 chan->flags = chan->orig_flags | bw_flags |
2313                               map_regdom_flags(reg_rule->flags);
2314         else
2315                 chan->flags |= map_regdom_flags(reg_rule->flags) | bw_flags;
2316
2317         chan->max_antenna_gain = (int) MBI_TO_DBI(power_rule->max_antenna_gain);
2318         chan->max_reg_power = chan->max_power =
2319                 (int) MBM_TO_DBM(power_rule->max_eirp);
2320
2321         if (chan->flags & IEEE80211_CHAN_RADAR) {
2322                 if (reg_rule->dfs_cac_ms)
2323                         chan->dfs_cac_ms = reg_rule->dfs_cac_ms;
2324                 else
2325                         chan->dfs_cac_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
2326         }
2327
2328         chan->max_power = chan->max_reg_power;
2329 }
2330
2331 static void handle_band_custom(struct wiphy *wiphy,
2332                                struct ieee80211_supported_band *sband,
2333                                const struct ieee80211_regdomain *regd)
2334 {
2335         unsigned int i;
2336
2337         if (!sband)
2338                 return;
2339
2340         for (i = 0; i < sband->n_channels; i++)
2341                 handle_channel_custom(wiphy, &sband->channels[i], regd);
2342 }
2343
2344 /* Used by drivers prior to wiphy registration */
2345 void wiphy_apply_custom_regulatory(struct wiphy *wiphy,
2346                                    const struct ieee80211_regdomain *regd)
2347 {
2348         enum nl80211_band band;
2349         unsigned int bands_set = 0;
2350
2351         WARN(!(wiphy->regulatory_flags & REGULATORY_CUSTOM_REG),
2352              "wiphy should have REGULATORY_CUSTOM_REG\n");
2353         wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG;
2354
2355         for (band = 0; band < NUM_NL80211_BANDS; band++) {
2356                 if (!wiphy->bands[band])
2357                         continue;
2358                 handle_band_custom(wiphy, wiphy->bands[band], regd);
2359                 bands_set++;
2360         }
2361
2362         /*
2363          * no point in calling this if it won't have any effect
2364          * on your device's supported bands.
2365          */
2366         WARN_ON(!bands_set);
2367 }
2368 EXPORT_SYMBOL(wiphy_apply_custom_regulatory);
2369
2370 static void reg_set_request_processed(void)
2371 {
2372         bool need_more_processing = false;
2373         struct regulatory_request *lr = get_last_request();
2374
2375         lr->processed = true;
2376
2377         spin_lock(&reg_requests_lock);
2378         if (!list_empty(&reg_requests_list))
2379                 need_more_processing = true;
2380         spin_unlock(&reg_requests_lock);
2381
2382         cancel_crda_timeout();
2383
2384         if (need_more_processing)
2385                 schedule_work(&reg_work);
2386 }
2387
2388 /**
2389  * reg_process_hint_core - process core regulatory requests
2390  * @pending_request: a pending core regulatory request
2391  *
2392  * The wireless subsystem can use this function to process
2393  * a regulatory request issued by the regulatory core.
2394  */
2395 static enum reg_request_treatment
2396 reg_process_hint_core(struct regulatory_request *core_request)
2397 {
2398         if (reg_query_database(core_request)) {
2399                 core_request->intersect = false;
2400                 core_request->processed = false;
2401                 reg_update_last_request(core_request);
2402                 return REG_REQ_OK;
2403         }
2404
2405         return REG_REQ_IGNORE;
2406 }
2407
2408 static enum reg_request_treatment
2409 __reg_process_hint_user(struct regulatory_request *user_request)
2410 {
2411         struct regulatory_request *lr = get_last_request();
2412
2413         if (reg_request_cell_base(user_request))
2414                 return reg_ignore_cell_hint(user_request);
2415
2416         if (reg_request_cell_base(lr))
2417                 return REG_REQ_IGNORE;
2418
2419         if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE)
2420                 return REG_REQ_INTERSECT;
2421         /*
2422          * If the user knows better the user should set the regdom
2423          * to their country before the IE is picked up
2424          */
2425         if (lr->initiator == NL80211_REGDOM_SET_BY_USER &&
2426             lr->intersect)
2427                 return REG_REQ_IGNORE;
2428         /*
2429          * Process user requests only after previous user/driver/core
2430          * requests have been processed
2431          */
2432         if ((lr->initiator == NL80211_REGDOM_SET_BY_CORE ||
2433              lr->initiator == NL80211_REGDOM_SET_BY_DRIVER ||
2434              lr->initiator == NL80211_REGDOM_SET_BY_USER) &&
2435             regdom_changes(lr->alpha2))
2436                 return REG_REQ_IGNORE;
2437
2438         if (!regdom_changes(user_request->alpha2))
2439                 return REG_REQ_ALREADY_SET;
2440
2441         return REG_REQ_OK;
2442 }
2443
2444 /**
2445  * reg_process_hint_user - process user regulatory requests
2446  * @user_request: a pending user regulatory request
2447  *
2448  * The wireless subsystem can use this function to process
2449  * a regulatory request initiated by userspace.
2450  */
2451 static enum reg_request_treatment
2452 reg_process_hint_user(struct regulatory_request *user_request)
2453 {
2454         enum reg_request_treatment treatment;
2455
2456         treatment = __reg_process_hint_user(user_request);
2457         if (treatment == REG_REQ_IGNORE ||
2458             treatment == REG_REQ_ALREADY_SET)
2459                 return REG_REQ_IGNORE;
2460
2461         user_request->intersect = treatment == REG_REQ_INTERSECT;
2462         user_request->processed = false;
2463
2464         if (reg_query_database(user_request)) {
2465                 reg_update_last_request(user_request);
2466                 user_alpha2[0] = user_request->alpha2[0];
2467                 user_alpha2[1] = user_request->alpha2[1];
2468                 return REG_REQ_OK;
2469         }
2470
2471         return REG_REQ_IGNORE;
2472 }
2473
2474 static enum reg_request_treatment
2475 __reg_process_hint_driver(struct regulatory_request *driver_request)
2476 {
2477         struct regulatory_request *lr = get_last_request();
2478
2479         if (lr->initiator == NL80211_REGDOM_SET_BY_CORE) {
2480                 if (regdom_changes(driver_request->alpha2))
2481                         return REG_REQ_OK;
2482                 return REG_REQ_ALREADY_SET;
2483         }
2484
2485         /*
2486          * This would happen if you unplug and plug your card
2487          * back in or if you add a new device for which the previously
2488          * loaded card also agrees on the regulatory domain.
2489          */
2490         if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
2491             !regdom_changes(driver_request->alpha2))
2492                 return REG_REQ_ALREADY_SET;
2493
2494         return REG_REQ_INTERSECT;
2495 }
2496
2497 /**
2498  * reg_process_hint_driver - process driver regulatory requests
2499  * @driver_request: a pending driver regulatory request
2500  *
2501  * The wireless subsystem can use this function to process
2502  * a regulatory request issued by an 802.11 driver.
2503  *
2504  * Returns one of the different reg request treatment values.
2505  */
2506 static enum reg_request_treatment
2507 reg_process_hint_driver(struct wiphy *wiphy,
2508                         struct regulatory_request *driver_request)
2509 {
2510         const struct ieee80211_regdomain *regd, *tmp;
2511         enum reg_request_treatment treatment;
2512
2513         treatment = __reg_process_hint_driver(driver_request);
2514
2515         switch (treatment) {
2516         case REG_REQ_OK:
2517                 break;
2518         case REG_REQ_IGNORE:
2519                 return REG_REQ_IGNORE;
2520         case REG_REQ_INTERSECT:
2521         case REG_REQ_ALREADY_SET:
2522                 regd = reg_copy_regd(get_cfg80211_regdom());
2523                 if (IS_ERR(regd))
2524                         return REG_REQ_IGNORE;
2525
2526                 tmp = get_wiphy_regdom(wiphy);
2527                 rcu_assign_pointer(wiphy->regd, regd);
2528                 rcu_free_regdom(tmp);
2529         }
2530
2531
2532         driver_request->intersect = treatment == REG_REQ_INTERSECT;
2533         driver_request->processed = false;
2534
2535         /*
2536          * Since CRDA will not be called in this case as we already
2537          * have applied the requested regulatory domain before we just
2538          * inform userspace we have processed the request
2539          */
2540         if (treatment == REG_REQ_ALREADY_SET) {
2541                 nl80211_send_reg_change_event(driver_request);
2542                 reg_update_last_request(driver_request);
2543                 reg_set_request_processed();
2544                 return REG_REQ_ALREADY_SET;
2545         }
2546
2547         if (reg_query_database(driver_request)) {
2548                 reg_update_last_request(driver_request);
2549                 return REG_REQ_OK;
2550         }
2551
2552         return REG_REQ_IGNORE;
2553 }
2554
2555 static enum reg_request_treatment
2556 __reg_process_hint_country_ie(struct wiphy *wiphy,
2557                               struct regulatory_request *country_ie_request)
2558 {
2559         struct wiphy *last_wiphy = NULL;
2560         struct regulatory_request *lr = get_last_request();
2561
2562         if (reg_request_cell_base(lr)) {
2563                 /* Trust a Cell base station over the AP's country IE */
2564                 if (regdom_changes(country_ie_request->alpha2))
2565                         return REG_REQ_IGNORE;
2566                 return REG_REQ_ALREADY_SET;
2567         } else {
2568                 if (wiphy->regulatory_flags & REGULATORY_COUNTRY_IE_IGNORE)
2569                         return REG_REQ_IGNORE;
2570         }
2571
2572         if (unlikely(!is_an_alpha2(country_ie_request->alpha2)))
2573                 return -EINVAL;
2574
2575         if (lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE)
2576                 return REG_REQ_OK;
2577
2578         last_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx);
2579
2580         if (last_wiphy != wiphy) {
2581                 /*
2582                  * Two cards with two APs claiming different
2583                  * Country IE alpha2s. We could
2584                  * intersect them, but that seems unlikely
2585                  * to be correct. Reject second one for now.
2586                  */
2587                 if (regdom_changes(country_ie_request->alpha2))
2588                         return REG_REQ_IGNORE;
2589                 return REG_REQ_ALREADY_SET;
2590         }
2591
2592         if (regdom_changes(country_ie_request->alpha2))
2593                 return REG_REQ_OK;
2594         return REG_REQ_ALREADY_SET;
2595 }
2596
2597 /**
2598  * reg_process_hint_country_ie - process regulatory requests from country IEs
2599  * @country_ie_request: a regulatory request from a country IE
2600  *
2601  * The wireless subsystem can use this function to process
2602  * a regulatory request issued by a country Information Element.
2603  *
2604  * Returns one of the different reg request treatment values.
2605  */
2606 static enum reg_request_treatment
2607 reg_process_hint_country_ie(struct wiphy *wiphy,
2608                             struct regulatory_request *country_ie_request)
2609 {
2610         enum reg_request_treatment treatment;
2611
2612         treatment = __reg_process_hint_country_ie(wiphy, country_ie_request);
2613
2614         switch (treatment) {
2615         case REG_REQ_OK:
2616                 break;
2617         case REG_REQ_IGNORE:
2618                 return REG_REQ_IGNORE;
2619         case REG_REQ_ALREADY_SET:
2620                 reg_free_request(country_ie_request);
2621                 return REG_REQ_ALREADY_SET;
2622         case REG_REQ_INTERSECT:
2623                 /*
2624                  * This doesn't happen yet, not sure we
2625                  * ever want to support it for this case.
2626                  */
2627                 WARN_ONCE(1, "Unexpected intersection for country elements");
2628                 return REG_REQ_IGNORE;
2629         }
2630
2631         country_ie_request->intersect = false;
2632         country_ie_request->processed = false;
2633
2634         if (reg_query_database(country_ie_request)) {
2635                 reg_update_last_request(country_ie_request);
2636                 return REG_REQ_OK;
2637         }
2638
2639         return REG_REQ_IGNORE;
2640 }
2641
2642 bool reg_dfs_domain_same(struct wiphy *wiphy1, struct wiphy *wiphy2)
2643 {
2644         const struct ieee80211_regdomain *wiphy1_regd = NULL;
2645         const struct ieee80211_regdomain *wiphy2_regd = NULL;
2646         const struct ieee80211_regdomain *cfg80211_regd = NULL;
2647         bool dfs_domain_same;
2648
2649         rcu_read_lock();
2650
2651         cfg80211_regd = rcu_dereference(cfg80211_regdomain);
2652         wiphy1_regd = rcu_dereference(wiphy1->regd);
2653         if (!wiphy1_regd)
2654                 wiphy1_regd = cfg80211_regd;
2655
2656         wiphy2_regd = rcu_dereference(wiphy2->regd);
2657         if (!wiphy2_regd)
2658                 wiphy2_regd = cfg80211_regd;
2659
2660         dfs_domain_same = wiphy1_regd->dfs_region == wiphy2_regd->dfs_region;
2661
2662         rcu_read_unlock();
2663
2664         return dfs_domain_same;
2665 }
2666
2667 static void reg_copy_dfs_chan_state(struct ieee80211_channel *dst_chan,
2668                                     struct ieee80211_channel *src_chan)
2669 {
2670         if (!(dst_chan->flags & IEEE80211_CHAN_RADAR) ||
2671             !(src_chan->flags & IEEE80211_CHAN_RADAR))
2672                 return;
2673
2674         if (dst_chan->flags & IEEE80211_CHAN_DISABLED ||
2675             src_chan->flags & IEEE80211_CHAN_DISABLED)
2676                 return;
2677
2678         if (src_chan->center_freq == dst_chan->center_freq &&
2679             dst_chan->dfs_state == NL80211_DFS_USABLE) {
2680                 dst_chan->dfs_state = src_chan->dfs_state;
2681                 dst_chan->dfs_state_entered = src_chan->dfs_state_entered;
2682         }
2683 }
2684
2685 static void wiphy_share_dfs_chan_state(struct wiphy *dst_wiphy,
2686                                        struct wiphy *src_wiphy)
2687 {
2688         struct ieee80211_supported_band *src_sband, *dst_sband;
2689         struct ieee80211_channel *src_chan, *dst_chan;
2690         int i, j, band;
2691
2692         if (!reg_dfs_domain_same(dst_wiphy, src_wiphy))
2693                 return;
2694
2695         for (band = 0; band < NUM_NL80211_BANDS; band++) {
2696                 dst_sband = dst_wiphy->bands[band];
2697                 src_sband = src_wiphy->bands[band];
2698                 if (!dst_sband || !src_sband)
2699                         continue;
2700
2701                 for (i = 0; i < dst_sband->n_channels; i++) {
2702                         dst_chan = &dst_sband->channels[i];
2703                         for (j = 0; j < src_sband->n_channels; j++) {
2704                                 src_chan = &src_sband->channels[j];
2705                                 reg_copy_dfs_chan_state(dst_chan, src_chan);
2706                         }
2707                 }
2708         }
2709 }
2710
2711 static void wiphy_all_share_dfs_chan_state(struct wiphy *wiphy)
2712 {
2713         struct cfg80211_registered_device *rdev;
2714
2715         ASSERT_RTNL();
2716
2717         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
2718                 if (wiphy == &rdev->wiphy)
2719                         continue;
2720                 wiphy_share_dfs_chan_state(wiphy, &rdev->wiphy);
2721         }
2722 }
2723
2724 /* This processes *all* regulatory hints */
2725 static void reg_process_hint(struct regulatory_request *reg_request)
2726 {
2727         struct wiphy *wiphy = NULL;
2728         enum reg_request_treatment treatment;
2729
2730         if (reg_request->wiphy_idx != WIPHY_IDX_INVALID)
2731                 wiphy = wiphy_idx_to_wiphy(reg_request->wiphy_idx);
2732
2733         switch (reg_request->initiator) {
2734         case NL80211_REGDOM_SET_BY_CORE:
2735                 treatment = reg_process_hint_core(reg_request);
2736                 break;
2737         case NL80211_REGDOM_SET_BY_USER:
2738                 treatment = reg_process_hint_user(reg_request);
2739                 break;
2740         case NL80211_REGDOM_SET_BY_DRIVER:
2741                 if (!wiphy)
2742                         goto out_free;
2743                 treatment = reg_process_hint_driver(wiphy, reg_request);
2744                 break;
2745         case NL80211_REGDOM_SET_BY_COUNTRY_IE:
2746                 if (!wiphy)
2747                         goto out_free;
2748                 treatment = reg_process_hint_country_ie(wiphy, reg_request);
2749                 break;
2750         default:
2751                 WARN(1, "invalid initiator %d\n", reg_request->initiator);
2752                 goto out_free;
2753         }
2754
2755         if (treatment == REG_REQ_IGNORE)
2756                 goto out_free;
2757
2758         WARN(treatment != REG_REQ_OK && treatment != REG_REQ_ALREADY_SET,
2759              "unexpected treatment value %d\n", treatment);
2760
2761         /* This is required so that the orig_* parameters are saved.
2762          * NOTE: treatment must be set for any case that reaches here!
2763          */
2764         if (treatment == REG_REQ_ALREADY_SET && wiphy &&
2765             wiphy->regulatory_flags & REGULATORY_STRICT_REG) {
2766                 wiphy_update_regulatory(wiphy, reg_request->initiator);
2767                 wiphy_all_share_dfs_chan_state(wiphy);
2768                 reg_check_channels();
2769         }
2770
2771         return;
2772
2773 out_free:
2774         reg_free_request(reg_request);
2775 }
2776
2777 static void notify_self_managed_wiphys(struct regulatory_request *request)
2778 {
2779         struct cfg80211_registered_device *rdev;
2780         struct wiphy *wiphy;
2781
2782         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
2783                 wiphy = &rdev->wiphy;
2784                 if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
2785                     request->initiator == NL80211_REGDOM_SET_BY_USER &&
2786                     request->user_reg_hint_type ==
2787                                 NL80211_USER_REG_HINT_CELL_BASE)
2788                         reg_call_notifier(wiphy, request);
2789         }
2790 }
2791
2792 /*
2793  * Processes regulatory hints, this is all the NL80211_REGDOM_SET_BY_*
2794  * Regulatory hints come on a first come first serve basis and we
2795  * must process each one atomically.
2796  */
2797 static void reg_process_pending_hints(void)
2798 {
2799         struct regulatory_request *reg_request, *lr;
2800
2801         lr = get_last_request();
2802
2803         /* When last_request->processed becomes true this will be rescheduled */
2804         if (lr && !lr->processed) {
2805                 reg_process_hint(lr);
2806                 return;
2807         }
2808
2809         spin_lock(&reg_requests_lock);
2810
2811         if (list_empty(&reg_requests_list)) {
2812                 spin_unlock(&reg_requests_lock);
2813                 return;
2814         }
2815
2816         reg_request = list_first_entry(&reg_requests_list,
2817                                        struct regulatory_request,
2818                                        list);
2819         list_del_init(&reg_request->list);
2820
2821         spin_unlock(&reg_requests_lock);
2822
2823         notify_self_managed_wiphys(reg_request);
2824
2825         reg_process_hint(reg_request);
2826
2827         lr = get_last_request();
2828
2829         spin_lock(&reg_requests_lock);
2830         if (!list_empty(&reg_requests_list) && lr && lr->processed)
2831                 schedule_work(&reg_work);
2832         spin_unlock(&reg_requests_lock);
2833 }
2834
2835 /* Processes beacon hints -- this has nothing to do with country IEs */
2836 static void reg_process_pending_beacon_hints(void)
2837 {
2838         struct cfg80211_registered_device *rdev;
2839         struct reg_beacon *pending_beacon, *tmp;
2840
2841         /* This goes through the _pending_ beacon list */
2842         spin_lock_bh(&reg_pending_beacons_lock);
2843
2844         list_for_each_entry_safe(pending_beacon, tmp,
2845                                  &reg_pending_beacons, list) {
2846                 list_del_init(&pending_beacon->list);
2847
2848                 /* Applies the beacon hint to current wiphys */
2849                 list_for_each_entry(rdev, &cfg80211_rdev_list, list)
2850                         wiphy_update_new_beacon(&rdev->wiphy, pending_beacon);
2851
2852                 /* Remembers the beacon hint for new wiphys or reg changes */
2853                 list_add_tail(&pending_beacon->list, &reg_beacon_list);
2854         }
2855
2856         spin_unlock_bh(&reg_pending_beacons_lock);
2857 }
2858
2859 static void reg_process_self_managed_hints(void)
2860 {
2861         struct cfg80211_registered_device *rdev;
2862         struct wiphy *wiphy;
2863         const struct ieee80211_regdomain *tmp;
2864         const struct ieee80211_regdomain *regd;
2865         enum nl80211_band band;
2866         struct regulatory_request request = {};
2867
2868         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
2869                 wiphy = &rdev->wiphy;
2870
2871                 spin_lock(&reg_requests_lock);
2872                 regd = rdev->requested_regd;
2873                 rdev->requested_regd = NULL;
2874                 spin_unlock(&reg_requests_lock);
2875
2876                 if (regd == NULL)
2877                         continue;
2878
2879                 tmp = get_wiphy_regdom(wiphy);
2880                 rcu_assign_pointer(wiphy->regd, regd);
2881                 rcu_free_regdom(tmp);
2882
2883                 for (band = 0; band < NUM_NL80211_BANDS; band++)
2884                         handle_band_custom(wiphy, wiphy->bands[band], regd);
2885
2886                 reg_process_ht_flags(wiphy);
2887
2888                 request.wiphy_idx = get_wiphy_idx(wiphy);
2889                 request.alpha2[0] = regd->alpha2[0];
2890                 request.alpha2[1] = regd->alpha2[1];
2891                 request.initiator = NL80211_REGDOM_SET_BY_DRIVER;
2892
2893                 nl80211_send_wiphy_reg_change_event(&request);
2894         }
2895
2896         reg_check_channels();
2897 }
2898
2899 static void reg_todo(struct work_struct *work)
2900 {
2901         rtnl_lock();
2902         reg_process_pending_hints();
2903         reg_process_pending_beacon_hints();
2904         reg_process_self_managed_hints();
2905         rtnl_unlock();
2906 }
2907
2908 static void queue_regulatory_request(struct regulatory_request *request)
2909 {
2910         request->alpha2[0] = toupper(request->alpha2[0]);
2911         request->alpha2[1] = toupper(request->alpha2[1]);
2912
2913         spin_lock(&reg_requests_lock);
2914         list_add_tail(&request->list, &reg_requests_list);
2915         spin_unlock(&reg_requests_lock);
2916
2917         schedule_work(&reg_work);
2918 }
2919
2920 /*
2921  * Core regulatory hint -- happens during cfg80211_init()
2922  * and when we restore regulatory settings.
2923  */
2924 static int regulatory_hint_core(const char *alpha2)
2925 {
2926         struct regulatory_request *request;
2927
2928         request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
2929         if (!request)
2930                 return -ENOMEM;
2931
2932         request->alpha2[0] = alpha2[0];
2933         request->alpha2[1] = alpha2[1];
2934         request->initiator = NL80211_REGDOM_SET_BY_CORE;
2935
2936         queue_regulatory_request(request);
2937
2938         return 0;
2939 }
2940
2941 /* User hints */
2942 int regulatory_hint_user(const char *alpha2,
2943                          enum nl80211_user_reg_hint_type user_reg_hint_type)
2944 {
2945         struct regulatory_request *request;
2946
2947         if (WARN_ON(!alpha2))
2948                 return -EINVAL;
2949
2950         request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
2951         if (!request)
2952                 return -ENOMEM;
2953
2954         request->wiphy_idx = WIPHY_IDX_INVALID;
2955         request->alpha2[0] = alpha2[0];
2956         request->alpha2[1] = alpha2[1];
2957         request->initiator = NL80211_REGDOM_SET_BY_USER;
2958         request->user_reg_hint_type = user_reg_hint_type;
2959
2960         /* Allow calling CRDA again */
2961         reset_crda_timeouts();
2962
2963         queue_regulatory_request(request);
2964
2965         return 0;
2966 }
2967
2968 int regulatory_hint_indoor(bool is_indoor, u32 portid)
2969 {
2970         spin_lock(&reg_indoor_lock);
2971
2972         /* It is possible that more than one user space process is trying to
2973          * configure the indoor setting. To handle such cases, clear the indoor
2974          * setting in case that some process does not think that the device
2975          * is operating in an indoor environment. In addition, if a user space
2976          * process indicates that it is controlling the indoor setting, save its
2977          * portid, i.e., make it the owner.
2978          */
2979         reg_is_indoor = is_indoor;
2980         if (reg_is_indoor) {
2981                 if (!reg_is_indoor_portid)
2982                         reg_is_indoor_portid = portid;
2983         } else {
2984                 reg_is_indoor_portid = 0;
2985         }
2986
2987         spin_unlock(&reg_indoor_lock);
2988
2989         if (!is_indoor)
2990                 reg_check_channels();
2991
2992         return 0;
2993 }
2994
2995 void regulatory_netlink_notify(u32 portid)
2996 {
2997         spin_lock(&reg_indoor_lock);
2998
2999         if (reg_is_indoor_portid != portid) {
3000                 spin_unlock(&reg_indoor_lock);
3001                 return;
3002         }
3003
3004         reg_is_indoor = false;
3005         reg_is_indoor_portid = 0;
3006
3007         spin_unlock(&reg_indoor_lock);
3008
3009         reg_check_channels();
3010 }
3011
3012 /* Driver hints */
3013 int regulatory_hint(struct wiphy *wiphy, const char *alpha2)
3014 {
3015         struct regulatory_request *request;
3016
3017         if (WARN_ON(!alpha2 || !wiphy))
3018                 return -EINVAL;
3019
3020         wiphy->regulatory_flags &= ~REGULATORY_CUSTOM_REG;
3021
3022         request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
3023         if (!request)
3024                 return -ENOMEM;
3025
3026         request->wiphy_idx = get_wiphy_idx(wiphy);
3027
3028         request->alpha2[0] = alpha2[0];
3029         request->alpha2[1] = alpha2[1];
3030         request->initiator = NL80211_REGDOM_SET_BY_DRIVER;
3031
3032         /* Allow calling CRDA again */
3033         reset_crda_timeouts();
3034
3035         queue_regulatory_request(request);
3036
3037         return 0;
3038 }
3039 EXPORT_SYMBOL(regulatory_hint);
3040
3041 void regulatory_hint_country_ie(struct wiphy *wiphy, enum nl80211_band band,
3042                                 const u8 *country_ie, u8 country_ie_len)
3043 {
3044         char alpha2[2];
3045         enum environment_cap env = ENVIRON_ANY;
3046         struct regulatory_request *request = NULL, *lr;
3047
3048         /* IE len must be evenly divisible by 2 */
3049         if (country_ie_len & 0x01)
3050                 return;
3051
3052         if (country_ie_len < IEEE80211_COUNTRY_IE_MIN_LEN)
3053                 return;
3054
3055         request = kzalloc(sizeof(*request), GFP_KERNEL);
3056         if (!request)
3057                 return;
3058
3059         alpha2[0] = country_ie[0];
3060         alpha2[1] = country_ie[1];
3061
3062         if (country_ie[2] == 'I')
3063                 env = ENVIRON_INDOOR;
3064         else if (country_ie[2] == 'O')
3065                 env = ENVIRON_OUTDOOR;
3066
3067         rcu_read_lock();
3068         lr = get_last_request();
3069
3070         if (unlikely(!lr))
3071                 goto out;
3072
3073         /*
3074          * We will run this only upon a successful connection on cfg80211.
3075          * We leave conflict resolution to the workqueue, where can hold
3076          * the RTNL.
3077          */
3078         if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
3079             lr->wiphy_idx != WIPHY_IDX_INVALID)
3080                 goto out;
3081
3082         request->wiphy_idx = get_wiphy_idx(wiphy);
3083         request->alpha2[0] = alpha2[0];
3084         request->alpha2[1] = alpha2[1];
3085         request->initiator = NL80211_REGDOM_SET_BY_COUNTRY_IE;
3086         request->country_ie_env = env;
3087
3088         /* Allow calling CRDA again */
3089         reset_crda_timeouts();
3090
3091         queue_regulatory_request(request);
3092         request = NULL;
3093 out:
3094         kfree(request);
3095         rcu_read_unlock();
3096 }
3097
3098 static void restore_alpha2(char *alpha2, bool reset_user)
3099 {
3100         /* indicates there is no alpha2 to consider for restoration */
3101         alpha2[0] = '9';
3102         alpha2[1] = '7';
3103
3104         /* The user setting has precedence over the module parameter */
3105         if (is_user_regdom_saved()) {
3106                 /* Unless we're asked to ignore it and reset it */
3107                 if (reset_user) {
3108                         pr_debug("Restoring regulatory settings including user preference\n");
3109                         user_alpha2[0] = '9';
3110                         user_alpha2[1] = '7';
3111
3112                         /*
3113                          * If we're ignoring user settings, we still need to
3114                          * check the module parameter to ensure we put things
3115                          * back as they were for a full restore.
3116                          */
3117                         if (!is_world_regdom(ieee80211_regdom)) {
3118                                 pr_debug("Keeping preference on module parameter ieee80211_regdom: %c%c\n",
3119                                          ieee80211_regdom[0], ieee80211_regdom[1]);
3120                                 alpha2[0] = ieee80211_regdom[0];
3121                                 alpha2[1] = ieee80211_regdom[1];
3122                         }
3123                 } else {
3124                         pr_debug("Restoring regulatory settings while preserving user preference for: %c%c\n",
3125                                  user_alpha2[0], user_alpha2[1]);
3126                         alpha2[0] = user_alpha2[0];
3127                         alpha2[1] = user_alpha2[1];
3128                 }
3129         } else if (!is_world_regdom(ieee80211_regdom)) {
3130                 pr_debug("Keeping preference on module parameter ieee80211_regdom: %c%c\n",
3131                          ieee80211_regdom[0], ieee80211_regdom[1]);
3132                 alpha2[0] = ieee80211_regdom[0];
3133                 alpha2[1] = ieee80211_regdom[1];
3134         } else
3135                 pr_debug("Restoring regulatory settings\n");
3136 }
3137
3138 static void restore_custom_reg_settings(struct wiphy *wiphy)
3139 {
3140         struct ieee80211_supported_band *sband;
3141         enum nl80211_band band;
3142         struct ieee80211_channel *chan;
3143         int i;
3144
3145         for (band = 0; band < NUM_NL80211_BANDS; band++) {
3146                 sband = wiphy->bands[band];
3147                 if (!sband)
3148                         continue;
3149                 for (i = 0; i < sband->n_channels; i++) {
3150                         chan = &sband->channels[i];
3151                         chan->flags = chan->orig_flags;
3152                         chan->max_antenna_gain = chan->orig_mag;
3153                         chan->max_power = chan->orig_mpwr;
3154                         chan->beacon_found = false;
3155                 }
3156         }
3157 }
3158
3159 /*
3160  * Restoring regulatory settings involves ingoring any
3161  * possibly stale country IE information and user regulatory
3162  * settings if so desired, this includes any beacon hints
3163  * learned as we could have traveled outside to another country
3164  * after disconnection. To restore regulatory settings we do
3165  * exactly what we did at bootup:
3166  *
3167  *   - send a core regulatory hint
3168  *   - send a user regulatory hint if applicable
3169  *
3170  * Device drivers that send a regulatory hint for a specific country
3171  * keep their own regulatory domain on wiphy->regd so that does does
3172  * not need to be remembered.
3173  */
3174 static void restore_regulatory_settings(bool reset_user)
3175 {
3176         char alpha2[2];
3177         char world_alpha2[2];
3178         struct reg_beacon *reg_beacon, *btmp;
3179         LIST_HEAD(tmp_reg_req_list);
3180         struct cfg80211_registered_device *rdev;
3181
3182         ASSERT_RTNL();
3183
3184         /*
3185          * Clear the indoor setting in case that it is not controlled by user
3186          * space, as otherwise there is no guarantee that the device is still
3187          * operating in an indoor environment.
3188          */
3189         spin_lock(&reg_indoor_lock);
3190         if (reg_is_indoor && !reg_is_indoor_portid) {
3191                 reg_is_indoor = false;
3192                 reg_check_channels();
3193         }
3194         spin_unlock(&reg_indoor_lock);
3195
3196         reset_regdomains(true, &world_regdom);
3197         restore_alpha2(alpha2, reset_user);
3198
3199         /*
3200          * If there's any pending requests we simply
3201          * stash them to a temporary pending queue and
3202          * add then after we've restored regulatory
3203          * settings.
3204          */
3205         spin_lock(&reg_requests_lock);
3206         list_splice_tail_init(&reg_requests_list, &tmp_reg_req_list);
3207         spin_unlock(&reg_requests_lock);
3208
3209         /* Clear beacon hints */
3210         spin_lock_bh(&reg_pending_beacons_lock);
3211         list_for_each_entry_safe(reg_beacon, btmp, &reg_pending_beacons, list) {
3212                 list_del(&reg_beacon->list);
3213                 kfree(reg_beacon);
3214         }
3215         spin_unlock_bh(&reg_pending_beacons_lock);
3216
3217         list_for_each_entry_safe(reg_beacon, btmp, &reg_beacon_list, list) {
3218                 list_del(&reg_beacon->list);
3219                 kfree(reg_beacon);
3220         }
3221
3222         /* First restore to the basic regulatory settings */
3223         world_alpha2[0] = cfg80211_world_regdom->alpha2[0];
3224         world_alpha2[1] = cfg80211_world_regdom->alpha2[1];
3225
3226         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
3227                 if (rdev->wiphy.regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED)
3228                         continue;
3229                 if (rdev->wiphy.regulatory_flags & REGULATORY_CUSTOM_REG)
3230                         restore_custom_reg_settings(&rdev->wiphy);
3231         }
3232
3233         regulatory_hint_core(world_alpha2);
3234
3235         /*
3236          * This restores the ieee80211_regdom module parameter
3237          * preference or the last user requested regulatory
3238          * settings, user regulatory settings takes precedence.
3239          */
3240         if (is_an_alpha2(alpha2))
3241                 regulatory_hint_user(alpha2, NL80211_USER_REG_HINT_USER);
3242
3243         spin_lock(&reg_requests_lock);
3244         list_splice_tail_init(&tmp_reg_req_list, &reg_requests_list);
3245         spin_unlock(&reg_requests_lock);
3246
3247         pr_debug("Kicking the queue\n");
3248
3249         schedule_work(&reg_work);
3250 }
3251
3252 static bool is_wiphy_all_set_reg_flag(enum ieee80211_regulatory_flags flag)
3253 {
3254         struct cfg80211_registered_device *rdev;
3255         struct wireless_dev *wdev;
3256
3257         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
3258                 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
3259                         wdev_lock(wdev);
3260                         if (!(wdev->wiphy->regulatory_flags & flag)) {
3261                                 wdev_unlock(wdev);
3262                                 return false;
3263                         }
3264                         wdev_unlock(wdev);
3265                 }
3266         }
3267
3268         return true;
3269 }
3270
3271 void regulatory_hint_disconnect(void)
3272 {
3273         /* Restore of regulatory settings is not required when wiphy(s)
3274          * ignore IE from connected access point but clearance of beacon hints
3275          * is required when wiphy(s) supports beacon hints.
3276          */
3277         if (is_wiphy_all_set_reg_flag(REGULATORY_COUNTRY_IE_IGNORE)) {
3278                 struct reg_beacon *reg_beacon, *btmp;
3279
3280                 if (is_wiphy_all_set_reg_flag(REGULATORY_DISABLE_BEACON_HINTS))
3281                         return;
3282
3283                 spin_lock_bh(&reg_pending_beacons_lock);
3284                 list_for_each_entry_safe(reg_beacon, btmp,
3285                                          &reg_pending_beacons, list) {
3286                         list_del(&reg_beacon->list);
3287                         kfree(reg_beacon);
3288                 }
3289                 spin_unlock_bh(&reg_pending_beacons_lock);
3290
3291                 list_for_each_entry_safe(reg_beacon, btmp,
3292                                          &reg_beacon_list, list) {
3293                         list_del(&reg_beacon->list);
3294                         kfree(reg_beacon);
3295                 }
3296
3297                 return;
3298         }
3299
3300         pr_debug("All devices are disconnected, going to restore regulatory settings\n");
3301         restore_regulatory_settings(false);
3302 }
3303
3304 static bool freq_is_chan_12_13_14(u32 freq)
3305 {
3306         if (freq == ieee80211_channel_to_frequency(12, NL80211_BAND_2GHZ) ||
3307             freq == ieee80211_channel_to_frequency(13, NL80211_BAND_2GHZ) ||
3308             freq == ieee80211_channel_to_frequency(14, NL80211_BAND_2GHZ))
3309                 return true;
3310         return false;
3311 }
3312
3313 static bool pending_reg_beacon(struct ieee80211_channel *beacon_chan)
3314 {
3315         struct reg_beacon *pending_beacon;
3316
3317         list_for_each_entry(pending_beacon, &reg_pending_beacons, list)
3318                 if (beacon_chan->center_freq ==
3319                     pending_beacon->chan.center_freq)
3320                         return true;
3321         return false;
3322 }
3323
3324 int regulatory_hint_found_beacon(struct wiphy *wiphy,
3325                                  struct ieee80211_channel *beacon_chan,
3326                                  gfp_t gfp)
3327 {
3328         struct reg_beacon *reg_beacon;
3329         bool processing;
3330
3331         if (beacon_chan->beacon_found ||
3332             beacon_chan->flags & IEEE80211_CHAN_RADAR ||
3333             (beacon_chan->band == NL80211_BAND_2GHZ &&
3334              !freq_is_chan_12_13_14(beacon_chan->center_freq)))
3335                 return 0;
3336
3337         spin_lock_bh(&reg_pending_beacons_lock);
3338         processing = pending_reg_beacon(beacon_chan);
3339         spin_unlock_bh(&reg_pending_beacons_lock);
3340
3341         if (processing)
3342                 return 0;
3343
3344         reg_beacon = kzalloc(sizeof(struct reg_beacon), gfp);
3345         if (!reg_beacon)
3346                 return -ENOMEM;
3347
3348         pr_debug("Found new beacon on frequency: %d MHz (Ch %d) on %s\n",
3349                  beacon_chan->center_freq,
3350                  ieee80211_frequency_to_channel(beacon_chan->center_freq),
3351                  wiphy_name(wiphy));
3352
3353         memcpy(&reg_beacon->chan, beacon_chan,
3354                sizeof(struct ieee80211_channel));
3355
3356         /*
3357          * Since we can be called from BH or and non-BH context
3358          * we must use spin_lock_bh()
3359          */
3360         spin_lock_bh(&reg_pending_beacons_lock);
3361         list_add_tail(&reg_beacon->list, &reg_pending_beacons);
3362         spin_unlock_bh(&reg_pending_beacons_lock);
3363
3364         schedule_work(&reg_work);
3365
3366         return 0;
3367 }
3368
3369 static void print_rd_rules(const struct ieee80211_regdomain *rd)
3370 {
3371         unsigned int i;
3372         const struct ieee80211_reg_rule *reg_rule = NULL;
3373         const struct ieee80211_freq_range *freq_range = NULL;
3374         const struct ieee80211_power_rule *power_rule = NULL;
3375         char bw[32], cac_time[32];
3376
3377         pr_debug("  (start_freq - end_freq @ bandwidth), (max_antenna_gain, max_eirp), (dfs_cac_time)\n");
3378
3379         for (i = 0; i < rd->n_reg_rules; i++) {
3380                 reg_rule = &rd->reg_rules[i];
3381                 freq_range = &reg_rule->freq_range;
3382                 power_rule = &reg_rule->power_rule;
3383
3384                 if (reg_rule->flags & NL80211_RRF_AUTO_BW)
3385                         snprintf(bw, sizeof(bw), "%d KHz, %d KHz AUTO",
3386                                  freq_range->max_bandwidth_khz,
3387                                  reg_get_max_bandwidth(rd, reg_rule));
3388                 else
3389                         snprintf(bw, sizeof(bw), "%d KHz",
3390                                  freq_range->max_bandwidth_khz);
3391
3392                 if (reg_rule->flags & NL80211_RRF_DFS)
3393                         scnprintf(cac_time, sizeof(cac_time), "%u s",
3394                                   reg_rule->dfs_cac_ms/1000);
3395                 else
3396                         scnprintf(cac_time, sizeof(cac_time), "N/A");
3397
3398
3399                 /*
3400                  * There may not be documentation for max antenna gain
3401                  * in certain regions
3402                  */
3403                 if (power_rule->max_antenna_gain)
3404                         pr_debug("  (%d KHz - %d KHz @ %s), (%d mBi, %d mBm), (%s)\n",
3405                                 freq_range->start_freq_khz,
3406                                 freq_range->end_freq_khz,
3407                                 bw,
3408                                 power_rule->max_antenna_gain,
3409                                 power_rule->max_eirp,
3410                                 cac_time);
3411                 else
3412                         pr_debug("  (%d KHz - %d KHz @ %s), (N/A, %d mBm), (%s)\n",
3413                                 freq_range->start_freq_khz,
3414                                 freq_range->end_freq_khz,
3415                                 bw,
3416                                 power_rule->max_eirp,
3417                                 cac_time);
3418         }
3419 }
3420
3421 bool reg_supported_dfs_region(enum nl80211_dfs_regions dfs_region)
3422 {
3423         switch (dfs_region) {
3424         case NL80211_DFS_UNSET:
3425         case NL80211_DFS_FCC:
3426         case NL80211_DFS_ETSI:
3427         case NL80211_DFS_JP:
3428                 return true;
3429         default:
3430                 pr_debug("Ignoring unknown DFS master region: %d\n", dfs_region);
3431                 return false;
3432         }
3433 }
3434
3435 static void print_regdomain(const struct ieee80211_regdomain *rd)
3436 {
3437         struct regulatory_request *lr = get_last_request();
3438
3439         if (is_intersected_alpha2(rd->alpha2)) {
3440                 if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE) {
3441                         struct cfg80211_registered_device *rdev;
3442                         rdev = cfg80211_rdev_by_wiphy_idx(lr->wiphy_idx);
3443                         if (rdev) {
3444                                 pr_debug("Current regulatory domain updated by AP to: %c%c\n",
3445                                         rdev->country_ie_alpha2[0],
3446                                         rdev->country_ie_alpha2[1]);
3447                         } else
3448                                 pr_debug("Current regulatory domain intersected:\n");
3449                 } else
3450                         pr_debug("Current regulatory domain intersected:\n");
3451         } else if (is_world_regdom(rd->alpha2)) {
3452                 pr_debug("World regulatory domain updated:\n");
3453         } else {
3454                 if (is_unknown_alpha2(rd->alpha2))
3455                         pr_debug("Regulatory domain changed to driver built-in settings (unknown country)\n");
3456                 else {
3457                         if (reg_request_cell_base(lr))
3458                                 pr_debug("Regulatory domain changed to country: %c%c by Cell Station\n",
3459                                         rd->alpha2[0], rd->alpha2[1]);
3460                         else
3461                                 pr_debug("Regulatory domain changed to country: %c%c\n",
3462                                         rd->alpha2[0], rd->alpha2[1]);
3463                 }
3464         }
3465
3466         pr_debug(" DFS Master region: %s", reg_dfs_region_str(rd->dfs_region));
3467         print_rd_rules(rd);
3468 }
3469
3470 static void print_regdomain_info(const struct ieee80211_regdomain *rd)
3471 {
3472         pr_debug("Regulatory domain: %c%c\n", rd->alpha2[0], rd->alpha2[1]);
3473         print_rd_rules(rd);
3474 }
3475
3476 static int reg_set_rd_core(const struct ieee80211_regdomain *rd)
3477 {
3478         if (!is_world_regdom(rd->alpha2))
3479                 return -EINVAL;
3480         update_world_regdomain(rd);
3481         return 0;
3482 }
3483
3484 static int reg_set_rd_user(const struct ieee80211_regdomain *rd,
3485                            struct regulatory_request *user_request)
3486 {
3487         const struct ieee80211_regdomain *intersected_rd = NULL;
3488
3489         if (!regdom_changes(rd->alpha2))
3490                 return -EALREADY;
3491
3492         if (!is_valid_rd(rd)) {
3493                 pr_err("Invalid regulatory domain detected: %c%c\n",
3494                        rd->alpha2[0], rd->alpha2[1]);
3495                 print_regdomain_info(rd);
3496                 return -EINVAL;
3497         }
3498
3499         if (!user_request->intersect) {
3500                 reset_regdomains(false, rd);
3501                 return 0;
3502         }
3503
3504         intersected_rd = regdom_intersect(rd, get_cfg80211_regdom());
3505         if (!intersected_rd)
3506                 return -EINVAL;
3507
3508         kfree(rd);
3509         rd = NULL;
3510         reset_regdomains(false, intersected_rd);
3511
3512         return 0;
3513 }
3514
3515 static int reg_set_rd_driver(const struct ieee80211_regdomain *rd,
3516                              struct regulatory_request *driver_request)
3517 {
3518         const struct ieee80211_regdomain *regd;
3519         const struct ieee80211_regdomain *intersected_rd = NULL;
3520         const struct ieee80211_regdomain *tmp;
3521         struct wiphy *request_wiphy;
3522
3523         if (is_world_regdom(rd->alpha2))
3524                 return -EINVAL;
3525
3526         if (!regdom_changes(rd->alpha2))
3527                 return -EALREADY;
3528
3529         if (!is_valid_rd(rd)) {
3530                 pr_err("Invalid regulatory domain detected: %c%c\n",
3531                        rd->alpha2[0], rd->alpha2[1]);
3532                 print_regdomain_info(rd);
3533                 return -EINVAL;
3534         }
3535
3536         request_wiphy = wiphy_idx_to_wiphy(driver_request->wiphy_idx);
3537         if (!request_wiphy)
3538                 return -ENODEV;
3539
3540         if (!driver_request->intersect) {
3541                 if (request_wiphy->regd)
3542                         return -EALREADY;
3543
3544                 regd = reg_copy_regd(rd);
3545                 if (IS_ERR(regd))
3546                         return PTR_ERR(regd);
3547
3548                 rcu_assign_pointer(request_wiphy->regd, regd);
3549                 reset_regdomains(false, rd);
3550                 return 0;
3551         }
3552
3553         intersected_rd = regdom_intersect(rd, get_cfg80211_regdom());
3554         if (!intersected_rd)
3555                 return -EINVAL;
3556
3557         /*
3558          * We can trash what CRDA provided now.
3559          * However if a driver requested this specific regulatory
3560          * domain we keep it for its private use
3561          */
3562         tmp = get_wiphy_regdom(request_wiphy);
3563         rcu_assign_pointer(request_wiphy->regd, rd);
3564         rcu_free_regdom(tmp);
3565
3566         rd = NULL;
3567
3568         reset_regdomains(false, intersected_rd);
3569
3570         return 0;
3571 }
3572
3573 static int reg_set_rd_country_ie(const struct ieee80211_regdomain *rd,
3574                                  struct regulatory_request *country_ie_request)
3575 {
3576         struct wiphy *request_wiphy;
3577
3578         if (!is_alpha2_set(rd->alpha2) && !is_an_alpha2(rd->alpha2) &&
3579             !is_unknown_alpha2(rd->alpha2))
3580                 return -EINVAL;
3581
3582         /*
3583          * Lets only bother proceeding on the same alpha2 if the current
3584          * rd is non static (it means CRDA was present and was used last)
3585          * and the pending request came in from a country IE
3586          */
3587
3588         if (!is_valid_rd(rd)) {
3589                 pr_err("Invalid regulatory domain detected: %c%c\n",
3590                        rd->alpha2[0], rd->alpha2[1]);
3591                 print_regdomain_info(rd);
3592                 return -EINVAL;
3593         }
3594
3595         request_wiphy = wiphy_idx_to_wiphy(country_ie_request->wiphy_idx);
3596         if (!request_wiphy)
3597                 return -ENODEV;
3598
3599         if (country_ie_request->intersect)
3600                 return -EINVAL;
3601
3602         reset_regdomains(false, rd);
3603         return 0;
3604 }
3605
3606 /*
3607  * Use this call to set the current regulatory domain. Conflicts with
3608  * multiple drivers can be ironed out later. Caller must've already
3609  * kmalloc'd the rd structure.
3610  */
3611 int set_regdom(const struct ieee80211_regdomain *rd,
3612                enum ieee80211_regd_source regd_src)
3613 {
3614         struct regulatory_request *lr;
3615         bool user_reset = false;
3616         int r;
3617
3618         if (!reg_is_valid_request(rd->alpha2)) {
3619                 kfree(rd);
3620                 return -EINVAL;
3621         }
3622
3623         if (regd_src == REGD_SOURCE_CRDA)
3624                 reset_crda_timeouts();
3625
3626         lr = get_last_request();
3627
3628         /* Note that this doesn't update the wiphys, this is done below */
3629         switch (lr->initiator) {
3630         case NL80211_REGDOM_SET_BY_CORE:
3631                 r = reg_set_rd_core(rd);
3632                 break;
3633         case NL80211_REGDOM_SET_BY_USER:
3634                 r = reg_set_rd_user(rd, lr);
3635                 user_reset = true;
3636                 break;
3637         case NL80211_REGDOM_SET_BY_DRIVER:
3638                 r = reg_set_rd_driver(rd, lr);
3639                 break;
3640         case NL80211_REGDOM_SET_BY_COUNTRY_IE:
3641                 r = reg_set_rd_country_ie(rd, lr);
3642                 break;
3643         default:
3644                 WARN(1, "invalid initiator %d\n", lr->initiator);
3645                 kfree(rd);
3646                 return -EINVAL;
3647         }
3648
3649         if (r) {
3650                 switch (r) {
3651                 case -EALREADY:
3652                         reg_set_request_processed();
3653                         break;
3654                 default:
3655                         /* Back to world regulatory in case of errors */
3656                         restore_regulatory_settings(user_reset);
3657                 }
3658
3659                 kfree(rd);
3660                 return r;
3661         }
3662
3663         /* This would make this whole thing pointless */
3664         if (WARN_ON(!lr->intersect && rd != get_cfg80211_regdom()))
3665                 return -EINVAL;
3666
3667         /* update all wiphys now with the new established regulatory domain */
3668         update_all_wiphy_regulatory(lr->initiator);
3669
3670         print_regdomain(get_cfg80211_regdom());
3671
3672         nl80211_send_reg_change_event(lr);
3673
3674         reg_set_request_processed();
3675
3676         return 0;
3677 }
3678
3679 static int __regulatory_set_wiphy_regd(struct wiphy *wiphy,
3680                                        struct ieee80211_regdomain *rd)
3681 {
3682         const struct ieee80211_regdomain *regd;
3683         const struct ieee80211_regdomain *prev_regd;
3684         struct cfg80211_registered_device *rdev;
3685
3686         if (WARN_ON(!wiphy || !rd))
3687                 return -EINVAL;
3688
3689         if (WARN(!(wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED),
3690                  "wiphy should have REGULATORY_WIPHY_SELF_MANAGED\n"))
3691                 return -EPERM;
3692
3693         if (WARN(!is_valid_rd(rd), "Invalid regulatory domain detected\n")) {
3694                 print_regdomain_info(rd);
3695                 return -EINVAL;
3696         }
3697
3698         regd = reg_copy_regd(rd);
3699         if (IS_ERR(regd))
3700                 return PTR_ERR(regd);
3701
3702         rdev = wiphy_to_rdev(wiphy);
3703
3704         spin_lock(&reg_requests_lock);
3705         prev_regd = rdev->requested_regd;
3706         rdev->requested_regd = regd;
3707         spin_unlock(&reg_requests_lock);
3708
3709         kfree(prev_regd);
3710         return 0;
3711 }
3712
3713 int regulatory_set_wiphy_regd(struct wiphy *wiphy,
3714                               struct ieee80211_regdomain *rd)
3715 {
3716         int ret = __regulatory_set_wiphy_regd(wiphy, rd);
3717
3718         if (ret)
3719                 return ret;
3720
3721         schedule_work(&reg_work);
3722         return 0;
3723 }
3724 EXPORT_SYMBOL(regulatory_set_wiphy_regd);
3725
3726 int regulatory_set_wiphy_regd_sync_rtnl(struct wiphy *wiphy,
3727                                         struct ieee80211_regdomain *rd)
3728 {
3729         int ret;
3730
3731         ASSERT_RTNL();
3732
3733         ret = __regulatory_set_wiphy_regd(wiphy, rd);
3734         if (ret)
3735                 return ret;
3736
3737         /* process the request immediately */
3738         reg_process_self_managed_hints();
3739         return 0;
3740 }
3741 EXPORT_SYMBOL(regulatory_set_wiphy_regd_sync_rtnl);
3742
3743 void wiphy_regulatory_register(struct wiphy *wiphy)
3744 {
3745         struct regulatory_request *lr = get_last_request();
3746
3747         /* self-managed devices ignore beacon hints and country IE */
3748         if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) {
3749                 wiphy->regulatory_flags |= REGULATORY_DISABLE_BEACON_HINTS |
3750                                            REGULATORY_COUNTRY_IE_IGNORE;
3751
3752                 /*
3753                  * The last request may have been received before this
3754                  * registration call. Call the driver notifier if
3755                  * initiator is USER and user type is CELL_BASE.
3756                  */
3757                 if (lr->initiator == NL80211_REGDOM_SET_BY_USER &&
3758                     lr->user_reg_hint_type == NL80211_USER_REG_HINT_CELL_BASE)
3759                         reg_call_notifier(wiphy, lr);
3760         }
3761
3762         if (!reg_dev_ignore_cell_hint(wiphy))
3763                 reg_num_devs_support_basehint++;
3764
3765         wiphy_update_regulatory(wiphy, lr->initiator);
3766         wiphy_all_share_dfs_chan_state(wiphy);
3767 }
3768
3769 void wiphy_regulatory_deregister(struct wiphy *wiphy)
3770 {
3771         struct wiphy *request_wiphy = NULL;
3772         struct regulatory_request *lr;
3773
3774         lr = get_last_request();
3775
3776         if (!reg_dev_ignore_cell_hint(wiphy))
3777                 reg_num_devs_support_basehint--;
3778
3779         rcu_free_regdom(get_wiphy_regdom(wiphy));
3780         RCU_INIT_POINTER(wiphy->regd, NULL);
3781
3782         if (lr)
3783                 request_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx);
3784
3785         if (!request_wiphy || request_wiphy != wiphy)
3786                 return;
3787
3788         lr->wiphy_idx = WIPHY_IDX_INVALID;
3789         lr->country_ie_env = ENVIRON_ANY;
3790 }
3791
3792 /*
3793  * See http://www.fcc.gov/document/5-ghz-unlicensed-spectrum-unii, for
3794  * UNII band definitions
3795  */
3796 int cfg80211_get_unii(int freq)
3797 {
3798         /* UNII-1 */
3799         if (freq >= 5150 && freq <= 5250)
3800                 return 0;
3801
3802         /* UNII-2A */
3803         if (freq > 5250 && freq <= 5350)
3804                 return 1;
3805
3806         /* UNII-2B */
3807         if (freq > 5350 && freq <= 5470)
3808                 return 2;
3809
3810         /* UNII-2C */
3811         if (freq > 5470 && freq <= 5725)
3812                 return 3;
3813
3814         /* UNII-3 */
3815         if (freq > 5725 && freq <= 5825)
3816                 return 4;
3817
3818         return -EINVAL;
3819 }
3820
3821 bool regulatory_indoor_allowed(void)
3822 {
3823         return reg_is_indoor;
3824 }
3825
3826 bool regulatory_pre_cac_allowed(struct wiphy *wiphy)
3827 {
3828         const struct ieee80211_regdomain *regd = NULL;
3829         const struct ieee80211_regdomain *wiphy_regd = NULL;
3830         bool pre_cac_allowed = false;
3831
3832         rcu_read_lock();
3833
3834         regd = rcu_dereference(cfg80211_regdomain);
3835         wiphy_regd = rcu_dereference(wiphy->regd);
3836         if (!wiphy_regd) {
3837                 if (regd->dfs_region == NL80211_DFS_ETSI)
3838                         pre_cac_allowed = true;
3839
3840                 rcu_read_unlock();
3841
3842                 return pre_cac_allowed;
3843         }
3844
3845         if (regd->dfs_region == wiphy_regd->dfs_region &&
3846             wiphy_regd->dfs_region == NL80211_DFS_ETSI)
3847                 pre_cac_allowed = true;
3848
3849         rcu_read_unlock();
3850
3851         return pre_cac_allowed;
3852 }
3853
3854 void regulatory_propagate_dfs_state(struct wiphy *wiphy,
3855                                     struct cfg80211_chan_def *chandef,
3856                                     enum nl80211_dfs_state dfs_state,
3857                                     enum nl80211_radar_event event)
3858 {
3859         struct cfg80211_registered_device *rdev;
3860
3861         ASSERT_RTNL();
3862
3863         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
3864                 return;
3865
3866         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
3867                 if (wiphy == &rdev->wiphy)
3868                         continue;
3869
3870                 if (!reg_dfs_domain_same(wiphy, &rdev->wiphy))
3871                         continue;
3872
3873                 if (!ieee80211_get_channel(&rdev->wiphy,
3874                                            chandef->chan->center_freq))
3875                         continue;
3876
3877                 cfg80211_set_dfs_state(&rdev->wiphy, chandef, dfs_state);
3878
3879                 if (event == NL80211_RADAR_DETECTED ||
3880                     event == NL80211_RADAR_CAC_FINISHED)
3881                         cfg80211_sched_dfs_chan_update(rdev);
3882
3883                 nl80211_radar_notify(rdev, chandef, event, NULL, GFP_KERNEL);
3884         }
3885 }
3886
3887 static int __init regulatory_init_db(void)
3888 {
3889         int err;
3890
3891         err = load_builtin_regdb_keys();
3892         if (err)
3893                 return err;
3894
3895         /* We always try to get an update for the static regdomain */
3896         err = regulatory_hint_core(cfg80211_world_regdom->alpha2);
3897         if (err) {
3898                 if (err == -ENOMEM) {
3899                         platform_device_unregister(reg_pdev);
3900                         return err;
3901                 }
3902                 /*
3903                  * N.B. kobject_uevent_env() can fail mainly for when we're out
3904                  * memory which is handled and propagated appropriately above
3905                  * but it can also fail during a netlink_broadcast() or during
3906                  * early boot for call_usermodehelper(). For now treat these
3907                  * errors as non-fatal.
3908                  */
3909                 pr_err("kobject_uevent_env() was unable to call CRDA during init\n");
3910         }
3911
3912         /*
3913          * Finally, if the user set the module parameter treat it
3914          * as a user hint.
3915          */
3916         if (!is_world_regdom(ieee80211_regdom))
3917                 regulatory_hint_user(ieee80211_regdom,
3918                                      NL80211_USER_REG_HINT_USER);
3919
3920         return 0;
3921 }
3922 #ifndef MODULE
3923 late_initcall(regulatory_init_db);
3924 #endif
3925
3926 int __init regulatory_init(void)
3927 {
3928         reg_pdev = platform_device_register_simple("regulatory", 0, NULL, 0);
3929         if (IS_ERR(reg_pdev))
3930                 return PTR_ERR(reg_pdev);
3931
3932         spin_lock_init(&reg_requests_lock);
3933         spin_lock_init(&reg_pending_beacons_lock);
3934         spin_lock_init(&reg_indoor_lock);
3935
3936         rcu_assign_pointer(cfg80211_regdomain, cfg80211_world_regdom);
3937
3938         user_alpha2[0] = '9';
3939         user_alpha2[1] = '7';
3940
3941 #ifdef MODULE
3942         return regulatory_init_db();
3943 #else
3944         return 0;
3945 #endif
3946 }
3947
3948 void regulatory_exit(void)
3949 {
3950         struct regulatory_request *reg_request, *tmp;
3951         struct reg_beacon *reg_beacon, *btmp;
3952
3953         cancel_work_sync(&reg_work);
3954         cancel_crda_timeout_sync();
3955         cancel_delayed_work_sync(&reg_check_chans);
3956
3957         /* Lock to suppress warnings */
3958         rtnl_lock();
3959         reset_regdomains(true, NULL);
3960         rtnl_unlock();
3961
3962         dev_set_uevent_suppress(&reg_pdev->dev, true);
3963
3964         platform_device_unregister(reg_pdev);
3965
3966         list_for_each_entry_safe(reg_beacon, btmp, &reg_pending_beacons, list) {
3967                 list_del(&reg_beacon->list);
3968                 kfree(reg_beacon);
3969         }
3970
3971         list_for_each_entry_safe(reg_beacon, btmp, &reg_beacon_list, list) {
3972                 list_del(&reg_beacon->list);
3973                 kfree(reg_beacon);
3974         }
3975
3976         list_for_each_entry_safe(reg_request, tmp, &reg_requests_list, list) {
3977                 list_del(&reg_request->list);
3978                 kfree(reg_request);
3979         }
3980
3981         if (!IS_ERR_OR_NULL(regdb))
3982                 kfree(regdb);
3983
3984         free_regdb_keyring();
3985 }