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