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