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#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
46
47#include <linux/kernel.h>
48#include <linux/export.h>
49#include <linux/slab.h>
50#include <linux/list.h>
51#include <linux/ctype.h>
52#include <linux/nl80211.h>
53#include <linux/platform_device.h>
54#include <linux/moduleparam.h>
55#include <net/cfg80211.h>
56#include "core.h"
57#include "reg.h"
58#include "regdb.h"
59#include "nl80211.h"
60
61#ifdef CONFIG_CFG80211_REG_DEBUG
62#define REG_DBG_PRINT(format, args...) \
63 printk(KERN_DEBUG pr_fmt(format), ##args)
64#else
65#define REG_DBG_PRINT(args...)
66#endif
67
68enum reg_request_treatment {
69 REG_REQ_OK,
70 REG_REQ_IGNORE,
71 REG_REQ_INTERSECT,
72 REG_REQ_ALREADY_SET,
73};
74
75static struct regulatory_request core_request_world = {
76 .initiator = NL80211_REGDOM_SET_BY_CORE,
77 .alpha2[0] = '0',
78 .alpha2[1] = '0',
79 .intersect = false,
80 .processed = true,
81 .country_ie_env = ENVIRON_ANY,
82};
83
84
85static struct regulatory_request __rcu *last_request =
86 (void __rcu *)&core_request_world;
87
88
89static struct platform_device *reg_pdev;
90
91static struct device_type reg_device_type = {
92 .uevent = reg_device_uevent,
93};
94
95
96
97
98
99
100const struct ieee80211_regdomain __rcu *cfg80211_regdomain;
101
102
103
104
105
106
107
108
109static DEFINE_MUTEX(reg_mutex);
110
111
112
113
114
115static int reg_num_devs_support_basehint;
116
117static inline void assert_reg_lock(void)
118{
119 lockdep_assert_held(®_mutex);
120}
121
122static const struct ieee80211_regdomain *get_cfg80211_regdom(void)
123{
124 return rcu_dereference_protected(cfg80211_regdomain,
125 lockdep_is_held(®_mutex));
126}
127
128static const struct ieee80211_regdomain *get_wiphy_regdom(struct wiphy *wiphy)
129{
130 return rcu_dereference_protected(wiphy->regd,
131 lockdep_is_held(®_mutex));
132}
133
134static void rcu_free_regdom(const struct ieee80211_regdomain *r)
135{
136 if (!r)
137 return;
138 kfree_rcu((struct ieee80211_regdomain *)r, rcu_head);
139}
140
141static struct regulatory_request *get_last_request(void)
142{
143 return rcu_dereference_check(last_request,
144 lockdep_is_held(®_mutex));
145}
146
147
148static LIST_HEAD(reg_requests_list);
149static spinlock_t reg_requests_lock;
150
151
152static LIST_HEAD(reg_pending_beacons);
153static spinlock_t reg_pending_beacons_lock;
154
155
156static LIST_HEAD(reg_beacon_list);
157
158struct reg_beacon {
159 struct list_head list;
160 struct ieee80211_channel chan;
161};
162
163static void reg_todo(struct work_struct *work);
164static DECLARE_WORK(reg_work, reg_todo);
165
166static void reg_timeout_work(struct work_struct *work);
167static DECLARE_DELAYED_WORK(reg_timeout, reg_timeout_work);
168
169
170static const struct ieee80211_regdomain world_regdom = {
171 .n_reg_rules = 6,
172 .alpha2 = "00",
173 .reg_rules = {
174
175 REG_RULE(2412-10, 2462+10, 40, 6, 20, 0),
176
177 REG_RULE(2467-10, 2472+10, 40, 6, 20,
178 NL80211_RRF_PASSIVE_SCAN |
179 NL80211_RRF_NO_IBSS),
180
181
182 REG_RULE(2484-10, 2484+10, 20, 6, 20,
183 NL80211_RRF_PASSIVE_SCAN |
184 NL80211_RRF_NO_IBSS |
185 NL80211_RRF_NO_OFDM),
186
187 REG_RULE(5180-10, 5240+10, 80, 6, 20,
188 NL80211_RRF_PASSIVE_SCAN |
189 NL80211_RRF_NO_IBSS),
190
191
192
193
194 REG_RULE(5745-10, 5825+10, 80, 6, 20,
195 NL80211_RRF_PASSIVE_SCAN |
196 NL80211_RRF_NO_IBSS),
197
198
199 REG_RULE(56160+2160*1-1080, 56160+2160*3+1080, 2160, 0, 0, 0),
200 }
201};
202
203static const struct ieee80211_regdomain *cfg80211_world_regdom =
204 &world_regdom;
205
206static char *ieee80211_regdom = "00";
207static char user_alpha2[2];
208
209module_param(ieee80211_regdom, charp, 0444);
210MODULE_PARM_DESC(ieee80211_regdom, "IEEE 802.11 regulatory domain code");
211
212static void reset_regdomains(bool full_reset,
213 const struct ieee80211_regdomain *new_regdom)
214{
215 const struct ieee80211_regdomain *r;
216 struct regulatory_request *lr;
217
218 assert_reg_lock();
219
220 r = get_cfg80211_regdom();
221
222
223 if (r == cfg80211_world_regdom)
224 r = NULL;
225 if (cfg80211_world_regdom == &world_regdom)
226 cfg80211_world_regdom = NULL;
227 if (r == &world_regdom)
228 r = NULL;
229
230 rcu_free_regdom(r);
231 rcu_free_regdom(cfg80211_world_regdom);
232
233 cfg80211_world_regdom = &world_regdom;
234 rcu_assign_pointer(cfg80211_regdomain, new_regdom);
235
236 if (!full_reset)
237 return;
238
239 lr = get_last_request();
240 if (lr != &core_request_world && lr)
241 kfree_rcu(lr, rcu_head);
242 rcu_assign_pointer(last_request, &core_request_world);
243}
244
245
246
247
248
249static void update_world_regdomain(const struct ieee80211_regdomain *rd)
250{
251 struct regulatory_request *lr;
252
253 lr = get_last_request();
254
255 WARN_ON(!lr);
256
257 reset_regdomains(false, rd);
258
259 cfg80211_world_regdom = rd;
260}
261
262bool is_world_regdom(const char *alpha2)
263{
264 if (!alpha2)
265 return false;
266 return alpha2[0] == '0' && alpha2[1] == '0';
267}
268
269static bool is_alpha2_set(const char *alpha2)
270{
271 if (!alpha2)
272 return false;
273 return alpha2[0] && alpha2[1];
274}
275
276static bool is_unknown_alpha2(const char *alpha2)
277{
278 if (!alpha2)
279 return false;
280
281
282
283
284 return alpha2[0] == '9' && alpha2[1] == '9';
285}
286
287static bool is_intersected_alpha2(const char *alpha2)
288{
289 if (!alpha2)
290 return false;
291
292
293
294
295
296 return alpha2[0] == '9' && alpha2[1] == '8';
297}
298
299static bool is_an_alpha2(const char *alpha2)
300{
301 if (!alpha2)
302 return false;
303 return isalpha(alpha2[0]) && isalpha(alpha2[1]);
304}
305
306static bool alpha2_equal(const char *alpha2_x, const char *alpha2_y)
307{
308 if (!alpha2_x || !alpha2_y)
309 return false;
310 return alpha2_x[0] == alpha2_y[0] && alpha2_x[1] == alpha2_y[1];
311}
312
313static bool regdom_changes(const char *alpha2)
314{
315 const struct ieee80211_regdomain *r = get_cfg80211_regdom();
316
317 if (!r)
318 return true;
319 return !alpha2_equal(r->alpha2, alpha2);
320}
321
322
323
324
325
326
327static bool is_user_regdom_saved(void)
328{
329 if (user_alpha2[0] == '9' && user_alpha2[1] == '7')
330 return false;
331
332
333 if (WARN(!is_world_regdom(user_alpha2) && !is_an_alpha2(user_alpha2),
334 "Unexpected user alpha2: %c%c\n",
335 user_alpha2[0], user_alpha2[1]))
336 return false;
337
338 return true;
339}
340
341static const struct ieee80211_regdomain *
342reg_copy_regd(const struct ieee80211_regdomain *src_regd)
343{
344 struct ieee80211_regdomain *regd;
345 int size_of_regd;
346 unsigned int i;
347
348 size_of_regd =
349 sizeof(struct ieee80211_regdomain) +
350 src_regd->n_reg_rules * sizeof(struct ieee80211_reg_rule);
351
352 regd = kzalloc(size_of_regd, GFP_KERNEL);
353 if (!regd)
354 return ERR_PTR(-ENOMEM);
355
356 memcpy(regd, src_regd, sizeof(struct ieee80211_regdomain));
357
358 for (i = 0; i < src_regd->n_reg_rules; i++)
359 memcpy(®d->reg_rules[i], &src_regd->reg_rules[i],
360 sizeof(struct ieee80211_reg_rule));
361
362 return regd;
363}
364
365#ifdef CONFIG_CFG80211_INTERNAL_REGDB
366struct reg_regdb_search_request {
367 char alpha2[2];
368 struct list_head list;
369};
370
371static LIST_HEAD(reg_regdb_search_list);
372static DEFINE_MUTEX(reg_regdb_search_mutex);
373
374static void reg_regdb_search(struct work_struct *work)
375{
376 struct reg_regdb_search_request *request;
377 const struct ieee80211_regdomain *curdom, *regdom = NULL;
378 int i;
379
380 mutex_lock(&cfg80211_mutex);
381
382 mutex_lock(®_regdb_search_mutex);
383 while (!list_empty(®_regdb_search_list)) {
384 request = list_first_entry(®_regdb_search_list,
385 struct reg_regdb_search_request,
386 list);
387 list_del(&request->list);
388
389 for (i = 0; i < reg_regdb_size; i++) {
390 curdom = reg_regdb[i];
391
392 if (alpha2_equal(request->alpha2, curdom->alpha2)) {
393 regdom = reg_copy_regd(curdom);
394 break;
395 }
396 }
397
398 kfree(request);
399 }
400 mutex_unlock(®_regdb_search_mutex);
401
402 if (!IS_ERR_OR_NULL(regdom))
403 set_regdom(regdom);
404
405 mutex_unlock(&cfg80211_mutex);
406}
407
408static DECLARE_WORK(reg_regdb_work, reg_regdb_search);
409
410static void reg_regdb_query(const char *alpha2)
411{
412 struct reg_regdb_search_request *request;
413
414 if (!alpha2)
415 return;
416
417 request = kzalloc(sizeof(struct reg_regdb_search_request), GFP_KERNEL);
418 if (!request)
419 return;
420
421 memcpy(request->alpha2, alpha2, 2);
422
423 mutex_lock(®_regdb_search_mutex);
424 list_add_tail(&request->list, ®_regdb_search_list);
425 mutex_unlock(®_regdb_search_mutex);
426
427 schedule_work(®_regdb_work);
428}
429
430
431static void reg_regdb_size_check(void)
432{
433
434 WARN_ONCE(!reg_regdb_size, "db.txt is empty, you should update it...");
435}
436#else
437static inline void reg_regdb_size_check(void) {}
438static inline void reg_regdb_query(const char *alpha2) {}
439#endif
440
441
442
443
444
445
446static int call_crda(const char *alpha2)
447{
448 if (!is_world_regdom((char *) alpha2))
449 pr_info("Calling CRDA for country: %c%c\n",
450 alpha2[0], alpha2[1]);
451 else
452 pr_info("Calling CRDA to update world regulatory domain\n");
453
454
455 reg_regdb_query(alpha2);
456
457 return kobject_uevent(®_pdev->dev.kobj, KOBJ_CHANGE);
458}
459
460static bool reg_is_valid_request(const char *alpha2)
461{
462 struct regulatory_request *lr = get_last_request();
463
464 if (!lr || lr->processed)
465 return false;
466
467 return alpha2_equal(lr->alpha2, alpha2);
468}
469
470
471static bool is_valid_reg_rule(const struct ieee80211_reg_rule *rule)
472{
473 const struct ieee80211_freq_range *freq_range = &rule->freq_range;
474 u32 freq_diff;
475
476 if (freq_range->start_freq_khz <= 0 || freq_range->end_freq_khz <= 0)
477 return false;
478
479 if (freq_range->start_freq_khz > freq_range->end_freq_khz)
480 return false;
481
482 freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
483
484 if (freq_range->end_freq_khz <= freq_range->start_freq_khz ||
485 freq_range->max_bandwidth_khz > freq_diff)
486 return false;
487
488 return true;
489}
490
491static bool is_valid_rd(const struct ieee80211_regdomain *rd)
492{
493 const struct ieee80211_reg_rule *reg_rule = NULL;
494 unsigned int i;
495
496 if (!rd->n_reg_rules)
497 return false;
498
499 if (WARN_ON(rd->n_reg_rules > NL80211_MAX_SUPP_REG_RULES))
500 return false;
501
502 for (i = 0; i < rd->n_reg_rules; i++) {
503 reg_rule = &rd->reg_rules[i];
504 if (!is_valid_reg_rule(reg_rule))
505 return false;
506 }
507
508 return true;
509}
510
511static bool reg_does_bw_fit(const struct ieee80211_freq_range *freq_range,
512 u32 center_freq_khz, u32 bw_khz)
513{
514 u32 start_freq_khz, end_freq_khz;
515
516 start_freq_khz = center_freq_khz - (bw_khz/2);
517 end_freq_khz = center_freq_khz + (bw_khz/2);
518
519 if (start_freq_khz >= freq_range->start_freq_khz &&
520 end_freq_khz <= freq_range->end_freq_khz)
521 return true;
522
523 return false;
524}
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541static bool freq_in_rule_band(const struct ieee80211_freq_range *freq_range,
542 u32 freq_khz)
543{
544#define ONE_GHZ_IN_KHZ 1000000
545
546
547
548
549
550 u32 limit = freq_khz > 45 * ONE_GHZ_IN_KHZ ?
551 10 * ONE_GHZ_IN_KHZ : 2 * ONE_GHZ_IN_KHZ;
552 if (abs(freq_khz - freq_range->start_freq_khz) <= limit)
553 return true;
554 if (abs(freq_khz - freq_range->end_freq_khz) <= limit)
555 return true;
556 return false;
557#undef ONE_GHZ_IN_KHZ
558}
559
560
561
562
563
564static int reg_rules_intersect(const struct ieee80211_reg_rule *rule1,
565 const struct ieee80211_reg_rule *rule2,
566 struct ieee80211_reg_rule *intersected_rule)
567{
568 const struct ieee80211_freq_range *freq_range1, *freq_range2;
569 struct ieee80211_freq_range *freq_range;
570 const struct ieee80211_power_rule *power_rule1, *power_rule2;
571 struct ieee80211_power_rule *power_rule;
572 u32 freq_diff;
573
574 freq_range1 = &rule1->freq_range;
575 freq_range2 = &rule2->freq_range;
576 freq_range = &intersected_rule->freq_range;
577
578 power_rule1 = &rule1->power_rule;
579 power_rule2 = &rule2->power_rule;
580 power_rule = &intersected_rule->power_rule;
581
582 freq_range->start_freq_khz = max(freq_range1->start_freq_khz,
583 freq_range2->start_freq_khz);
584 freq_range->end_freq_khz = min(freq_range1->end_freq_khz,
585 freq_range2->end_freq_khz);
586 freq_range->max_bandwidth_khz = min(freq_range1->max_bandwidth_khz,
587 freq_range2->max_bandwidth_khz);
588
589 freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
590 if (freq_range->max_bandwidth_khz > freq_diff)
591 freq_range->max_bandwidth_khz = freq_diff;
592
593 power_rule->max_eirp = min(power_rule1->max_eirp,
594 power_rule2->max_eirp);
595 power_rule->max_antenna_gain = min(power_rule1->max_antenna_gain,
596 power_rule2->max_antenna_gain);
597
598 intersected_rule->flags = rule1->flags | rule2->flags;
599
600 if (!is_valid_reg_rule(intersected_rule))
601 return -EINVAL;
602
603 return 0;
604}
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619static struct ieee80211_regdomain *
620regdom_intersect(const struct ieee80211_regdomain *rd1,
621 const struct ieee80211_regdomain *rd2)
622{
623 int r, size_of_regd;
624 unsigned int x, y;
625 unsigned int num_rules = 0, rule_idx = 0;
626 const struct ieee80211_reg_rule *rule1, *rule2;
627 struct ieee80211_reg_rule *intersected_rule;
628 struct ieee80211_regdomain *rd;
629
630 struct ieee80211_reg_rule dummy_rule;
631
632 if (!rd1 || !rd2)
633 return NULL;
634
635
636
637
638
639
640
641
642
643 for (x = 0; x < rd1->n_reg_rules; x++) {
644 rule1 = &rd1->reg_rules[x];
645 for (y = 0; y < rd2->n_reg_rules; y++) {
646 rule2 = &rd2->reg_rules[y];
647 if (!reg_rules_intersect(rule1, rule2, &dummy_rule))
648 num_rules++;
649 }
650 }
651
652 if (!num_rules)
653 return NULL;
654
655 size_of_regd = sizeof(struct ieee80211_regdomain) +
656 num_rules * sizeof(struct ieee80211_reg_rule);
657
658 rd = kzalloc(size_of_regd, GFP_KERNEL);
659 if (!rd)
660 return NULL;
661
662 for (x = 0; x < rd1->n_reg_rules && rule_idx < num_rules; x++) {
663 rule1 = &rd1->reg_rules[x];
664 for (y = 0; y < rd2->n_reg_rules && rule_idx < num_rules; y++) {
665 rule2 = &rd2->reg_rules[y];
666
667
668
669
670
671 intersected_rule = &rd->reg_rules[rule_idx];
672 r = reg_rules_intersect(rule1, rule2, intersected_rule);
673
674
675
676
677 if (r)
678 continue;
679 rule_idx++;
680 }
681 }
682
683 if (rule_idx != num_rules) {
684 kfree(rd);
685 return NULL;
686 }
687
688 rd->n_reg_rules = num_rules;
689 rd->alpha2[0] = '9';
690 rd->alpha2[1] = '8';
691
692 return rd;
693}
694
695
696
697
698
699static u32 map_regdom_flags(u32 rd_flags)
700{
701 u32 channel_flags = 0;
702 if (rd_flags & NL80211_RRF_PASSIVE_SCAN)
703 channel_flags |= IEEE80211_CHAN_PASSIVE_SCAN;
704 if (rd_flags & NL80211_RRF_NO_IBSS)
705 channel_flags |= IEEE80211_CHAN_NO_IBSS;
706 if (rd_flags & NL80211_RRF_DFS)
707 channel_flags |= IEEE80211_CHAN_RADAR;
708 if (rd_flags & NL80211_RRF_NO_OFDM)
709 channel_flags |= IEEE80211_CHAN_NO_OFDM;
710 return channel_flags;
711}
712
713static const struct ieee80211_reg_rule *
714freq_reg_info_regd(struct wiphy *wiphy, u32 center_freq,
715 const struct ieee80211_regdomain *regd)
716{
717 int i;
718 bool band_rule_found = false;
719 bool bw_fits = false;
720
721 if (!regd)
722 return ERR_PTR(-EINVAL);
723
724 for (i = 0; i < regd->n_reg_rules; i++) {
725 const struct ieee80211_reg_rule *rr;
726 const struct ieee80211_freq_range *fr = NULL;
727
728 rr = ®d->reg_rules[i];
729 fr = &rr->freq_range;
730
731
732
733
734
735
736 if (!band_rule_found)
737 band_rule_found = freq_in_rule_band(fr, center_freq);
738
739 bw_fits = reg_does_bw_fit(fr, center_freq, MHZ_TO_KHZ(20));
740
741 if (band_rule_found && bw_fits)
742 return rr;
743 }
744
745 if (!band_rule_found)
746 return ERR_PTR(-ERANGE);
747
748 return ERR_PTR(-EINVAL);
749}
750
751const struct ieee80211_reg_rule *freq_reg_info(struct wiphy *wiphy,
752 u32 center_freq)
753{
754 const struct ieee80211_regdomain *regd;
755 struct regulatory_request *lr = get_last_request();
756
757
758
759
760
761 if (lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
762 lr->initiator != NL80211_REGDOM_SET_BY_USER &&
763 wiphy->regd)
764 regd = get_wiphy_regdom(wiphy);
765 else
766 regd = get_cfg80211_regdom();
767
768 return freq_reg_info_regd(wiphy, center_freq, regd);
769}
770EXPORT_SYMBOL(freq_reg_info);
771
772#ifdef CONFIG_CFG80211_REG_DEBUG
773static const char *reg_initiator_name(enum nl80211_reg_initiator initiator)
774{
775 switch (initiator) {
776 case NL80211_REGDOM_SET_BY_CORE:
777 return "Set by core";
778 case NL80211_REGDOM_SET_BY_USER:
779 return "Set by user";
780 case NL80211_REGDOM_SET_BY_DRIVER:
781 return "Set by driver";
782 case NL80211_REGDOM_SET_BY_COUNTRY_IE:
783 return "Set by country IE";
784 default:
785 WARN_ON(1);
786 return "Set by bug";
787 }
788}
789
790static void chan_reg_rule_print_dbg(struct ieee80211_channel *chan,
791 const struct ieee80211_reg_rule *reg_rule)
792{
793 const struct ieee80211_power_rule *power_rule;
794 const struct ieee80211_freq_range *freq_range;
795 char max_antenna_gain[32];
796
797 power_rule = ®_rule->power_rule;
798 freq_range = ®_rule->freq_range;
799
800 if (!power_rule->max_antenna_gain)
801 snprintf(max_antenna_gain, 32, "N/A");
802 else
803 snprintf(max_antenna_gain, 32, "%d", power_rule->max_antenna_gain);
804
805 REG_DBG_PRINT("Updating information on frequency %d MHz with regulatory rule:\n",
806 chan->center_freq);
807
808 REG_DBG_PRINT("%d KHz - %d KHz @ %d KHz), (%s mBi, %d mBm)\n",
809 freq_range->start_freq_khz, freq_range->end_freq_khz,
810 freq_range->max_bandwidth_khz, max_antenna_gain,
811 power_rule->max_eirp);
812}
813#else
814static void chan_reg_rule_print_dbg(struct ieee80211_channel *chan,
815 const struct ieee80211_reg_rule *reg_rule)
816{
817 return;
818}
819#endif
820
821
822
823
824
825
826static void handle_channel(struct wiphy *wiphy,
827 enum nl80211_reg_initiator initiator,
828 struct ieee80211_channel *chan)
829{
830 u32 flags, bw_flags = 0;
831 const struct ieee80211_reg_rule *reg_rule = NULL;
832 const struct ieee80211_power_rule *power_rule = NULL;
833 const struct ieee80211_freq_range *freq_range = NULL;
834 struct wiphy *request_wiphy = NULL;
835 struct regulatory_request *lr = get_last_request();
836
837 request_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx);
838
839 flags = chan->orig_flags;
840
841 reg_rule = freq_reg_info(wiphy, MHZ_TO_KHZ(chan->center_freq));
842 if (IS_ERR(reg_rule)) {
843
844
845
846
847
848
849
850
851
852
853 if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
854 PTR_ERR(reg_rule) == -ERANGE)
855 return;
856
857 REG_DBG_PRINT("Disabling freq %d MHz\n", chan->center_freq);
858 chan->flags |= IEEE80211_CHAN_DISABLED;
859 return;
860 }
861
862 chan_reg_rule_print_dbg(chan, reg_rule);
863
864 power_rule = ®_rule->power_rule;
865 freq_range = ®_rule->freq_range;
866
867 if (freq_range->max_bandwidth_khz < MHZ_TO_KHZ(40))
868 bw_flags = IEEE80211_CHAN_NO_HT40;
869 if (freq_range->max_bandwidth_khz < MHZ_TO_KHZ(80))
870 bw_flags |= IEEE80211_CHAN_NO_80MHZ;
871 if (freq_range->max_bandwidth_khz < MHZ_TO_KHZ(160))
872 bw_flags |= IEEE80211_CHAN_NO_160MHZ;
873
874 if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
875 request_wiphy && request_wiphy == wiphy &&
876 request_wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY) {
877
878
879
880
881
882 chan->flags = chan->orig_flags =
883 map_regdom_flags(reg_rule->flags) | bw_flags;
884 chan->max_antenna_gain = chan->orig_mag =
885 (int) MBI_TO_DBI(power_rule->max_antenna_gain);
886 chan->max_reg_power = chan->max_power = chan->orig_mpwr =
887 (int) MBM_TO_DBM(power_rule->max_eirp);
888 return;
889 }
890
891 chan->dfs_state = NL80211_DFS_USABLE;
892 chan->dfs_state_entered = jiffies;
893
894 chan->beacon_found = false;
895 chan->flags = flags | bw_flags | map_regdom_flags(reg_rule->flags);
896 chan->max_antenna_gain =
897 min_t(int, chan->orig_mag,
898 MBI_TO_DBI(power_rule->max_antenna_gain));
899 chan->max_reg_power = (int) MBM_TO_DBM(power_rule->max_eirp);
900 if (chan->orig_mpwr) {
901
902
903
904
905
906 if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
907 wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY &&
908 wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY)
909 chan->max_power = chan->max_reg_power;
910 else
911 chan->max_power = min(chan->orig_mpwr,
912 chan->max_reg_power);
913 } else
914 chan->max_power = chan->max_reg_power;
915}
916
917static void handle_band(struct wiphy *wiphy,
918 enum nl80211_reg_initiator initiator,
919 struct ieee80211_supported_band *sband)
920{
921 unsigned int i;
922
923 if (!sband)
924 return;
925
926 for (i = 0; i < sband->n_channels; i++)
927 handle_channel(wiphy, initiator, &sband->channels[i]);
928}
929
930static bool reg_request_cell_base(struct regulatory_request *request)
931{
932 if (request->initiator != NL80211_REGDOM_SET_BY_USER)
933 return false;
934 return request->user_reg_hint_type == NL80211_USER_REG_HINT_CELL_BASE;
935}
936
937bool reg_last_request_cell_base(void)
938{
939 bool val;
940
941 mutex_lock(®_mutex);
942 val = reg_request_cell_base(get_last_request());
943 mutex_unlock(®_mutex);
944
945 return val;
946}
947
948#ifdef CONFIG_CFG80211_CERTIFICATION_ONUS
949
950static enum reg_request_treatment
951reg_ignore_cell_hint(struct regulatory_request *pending_request)
952{
953 struct regulatory_request *lr = get_last_request();
954
955 if (!reg_num_devs_support_basehint)
956 return REG_REQ_IGNORE;
957
958 if (reg_request_cell_base(lr) &&
959 !regdom_changes(pending_request->alpha2))
960 return REG_REQ_ALREADY_SET;
961
962 return REG_REQ_OK;
963}
964
965
966static bool reg_dev_ignore_cell_hint(struct wiphy *wiphy)
967{
968 return !(wiphy->features & NL80211_FEATURE_CELL_BASE_REG_HINTS);
969}
970#else
971static int reg_ignore_cell_hint(struct regulatory_request *pending_request)
972{
973 return REG_REQ_IGNORE;
974}
975
976static bool reg_dev_ignore_cell_hint(struct wiphy *wiphy)
977{
978 return true;
979}
980#endif
981
982
983static bool ignore_reg_update(struct wiphy *wiphy,
984 enum nl80211_reg_initiator initiator)
985{
986 struct regulatory_request *lr = get_last_request();
987
988 if (!lr) {
989 REG_DBG_PRINT("Ignoring regulatory request %s since last_request is not set\n",
990 reg_initiator_name(initiator));
991 return true;
992 }
993
994 if (initiator == NL80211_REGDOM_SET_BY_CORE &&
995 wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY) {
996 REG_DBG_PRINT("Ignoring regulatory request %s since the driver uses its own custom regulatory domain\n",
997 reg_initiator_name(initiator));
998 return true;
999 }
1000
1001
1002
1003
1004
1005 if (wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY && !wiphy->regd &&
1006 initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
1007 !is_world_regdom(lr->alpha2)) {
1008 REG_DBG_PRINT("Ignoring regulatory request %s since the driver requires its own regulatory domain to be set first\n",
1009 reg_initiator_name(initiator));
1010 return true;
1011 }
1012
1013 if (reg_request_cell_base(lr))
1014 return reg_dev_ignore_cell_hint(wiphy);
1015
1016 return false;
1017}
1018
1019static bool reg_is_world_roaming(struct wiphy *wiphy)
1020{
1021 const struct ieee80211_regdomain *cr = get_cfg80211_regdom();
1022 const struct ieee80211_regdomain *wr = get_wiphy_regdom(wiphy);
1023 struct regulatory_request *lr = get_last_request();
1024
1025 if (is_world_regdom(cr->alpha2) || (wr && is_world_regdom(wr->alpha2)))
1026 return true;
1027
1028 if (lr && lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
1029 wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY)
1030 return true;
1031
1032 return false;
1033}
1034
1035static void handle_reg_beacon(struct wiphy *wiphy, unsigned int chan_idx,
1036 struct reg_beacon *reg_beacon)
1037{
1038 struct ieee80211_supported_band *sband;
1039 struct ieee80211_channel *chan;
1040 bool channel_changed = false;
1041 struct ieee80211_channel chan_before;
1042
1043 sband = wiphy->bands[reg_beacon->chan.band];
1044 chan = &sband->channels[chan_idx];
1045
1046 if (likely(chan->center_freq != reg_beacon->chan.center_freq))
1047 return;
1048
1049 if (chan->beacon_found)
1050 return;
1051
1052 chan->beacon_found = true;
1053
1054 if (!reg_is_world_roaming(wiphy))
1055 return;
1056
1057 if (wiphy->flags & WIPHY_FLAG_DISABLE_BEACON_HINTS)
1058 return;
1059
1060 chan_before.center_freq = chan->center_freq;
1061 chan_before.flags = chan->flags;
1062
1063 if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN) {
1064 chan->flags &= ~IEEE80211_CHAN_PASSIVE_SCAN;
1065 channel_changed = true;
1066 }
1067
1068 if (chan->flags & IEEE80211_CHAN_NO_IBSS) {
1069 chan->flags &= ~IEEE80211_CHAN_NO_IBSS;
1070 channel_changed = true;
1071 }
1072
1073 if (channel_changed)
1074 nl80211_send_beacon_hint_event(wiphy, &chan_before, chan);
1075}
1076
1077
1078
1079
1080
1081static void wiphy_update_new_beacon(struct wiphy *wiphy,
1082 struct reg_beacon *reg_beacon)
1083{
1084 unsigned int i;
1085 struct ieee80211_supported_band *sband;
1086
1087 if (!wiphy->bands[reg_beacon->chan.band])
1088 return;
1089
1090 sband = wiphy->bands[reg_beacon->chan.band];
1091
1092 for (i = 0; i < sband->n_channels; i++)
1093 handle_reg_beacon(wiphy, i, reg_beacon);
1094}
1095
1096
1097
1098
1099static void wiphy_update_beacon_reg(struct wiphy *wiphy)
1100{
1101 unsigned int i;
1102 struct ieee80211_supported_band *sband;
1103 struct reg_beacon *reg_beacon;
1104
1105 list_for_each_entry(reg_beacon, ®_beacon_list, list) {
1106 if (!wiphy->bands[reg_beacon->chan.band])
1107 continue;
1108 sband = wiphy->bands[reg_beacon->chan.band];
1109 for (i = 0; i < sband->n_channels; i++)
1110 handle_reg_beacon(wiphy, i, reg_beacon);
1111 }
1112}
1113
1114
1115static void reg_process_beacons(struct wiphy *wiphy)
1116{
1117
1118
1119
1120
1121 if (!last_request)
1122 return;
1123 wiphy_update_beacon_reg(wiphy);
1124}
1125
1126static bool is_ht40_allowed(struct ieee80211_channel *chan)
1127{
1128 if (!chan)
1129 return false;
1130 if (chan->flags & IEEE80211_CHAN_DISABLED)
1131 return false;
1132
1133 if ((chan->flags & IEEE80211_CHAN_NO_HT40) == IEEE80211_CHAN_NO_HT40)
1134 return false;
1135 return true;
1136}
1137
1138static void reg_process_ht_flags_channel(struct wiphy *wiphy,
1139 struct ieee80211_channel *channel)
1140{
1141 struct ieee80211_supported_band *sband = wiphy->bands[channel->band];
1142 struct ieee80211_channel *channel_before = NULL, *channel_after = NULL;
1143 unsigned int i;
1144
1145 if (!is_ht40_allowed(channel)) {
1146 channel->flags |= IEEE80211_CHAN_NO_HT40;
1147 return;
1148 }
1149
1150
1151
1152
1153
1154 for (i = 0; i < sband->n_channels; i++) {
1155 struct ieee80211_channel *c = &sband->channels[i];
1156
1157 if (c->center_freq == (channel->center_freq - 20))
1158 channel_before = c;
1159 if (c->center_freq == (channel->center_freq + 20))
1160 channel_after = c;
1161 }
1162
1163
1164
1165
1166
1167
1168 if (!is_ht40_allowed(channel_before))
1169 channel->flags |= IEEE80211_CHAN_NO_HT40MINUS;
1170 else
1171 channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
1172
1173 if (!is_ht40_allowed(channel_after))
1174 channel->flags |= IEEE80211_CHAN_NO_HT40PLUS;
1175 else
1176 channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
1177}
1178
1179static void reg_process_ht_flags_band(struct wiphy *wiphy,
1180 struct ieee80211_supported_band *sband)
1181{
1182 unsigned int i;
1183
1184 if (!sband)
1185 return;
1186
1187 for (i = 0; i < sband->n_channels; i++)
1188 reg_process_ht_flags_channel(wiphy, &sband->channels[i]);
1189}
1190
1191static void reg_process_ht_flags(struct wiphy *wiphy)
1192{
1193 enum ieee80211_band band;
1194
1195 if (!wiphy)
1196 return;
1197
1198 for (band = 0; band < IEEE80211_NUM_BANDS; band++)
1199 reg_process_ht_flags_band(wiphy, wiphy->bands[band]);
1200}
1201
1202static void wiphy_update_regulatory(struct wiphy *wiphy,
1203 enum nl80211_reg_initiator initiator)
1204{
1205 enum ieee80211_band band;
1206 struct regulatory_request *lr = get_last_request();
1207
1208 if (ignore_reg_update(wiphy, initiator))
1209 return;
1210
1211 lr->dfs_region = get_cfg80211_regdom()->dfs_region;
1212
1213 for (band = 0; band < IEEE80211_NUM_BANDS; band++)
1214 handle_band(wiphy, initiator, wiphy->bands[band]);
1215
1216 reg_process_beacons(wiphy);
1217 reg_process_ht_flags(wiphy);
1218
1219 if (wiphy->reg_notifier)
1220 wiphy->reg_notifier(wiphy, lr);
1221}
1222
1223static void update_all_wiphy_regulatory(enum nl80211_reg_initiator initiator)
1224{
1225 struct cfg80211_registered_device *rdev;
1226 struct wiphy *wiphy;
1227
1228 assert_cfg80211_lock();
1229
1230 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
1231 wiphy = &rdev->wiphy;
1232 wiphy_update_regulatory(wiphy, initiator);
1233
1234
1235
1236
1237
1238 if (initiator == NL80211_REGDOM_SET_BY_CORE &&
1239 wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY &&
1240 wiphy->reg_notifier)
1241 wiphy->reg_notifier(wiphy, get_last_request());
1242 }
1243}
1244
1245static void handle_channel_custom(struct wiphy *wiphy,
1246 struct ieee80211_channel *chan,
1247 const struct ieee80211_regdomain *regd)
1248{
1249 u32 bw_flags = 0;
1250 const struct ieee80211_reg_rule *reg_rule = NULL;
1251 const struct ieee80211_power_rule *power_rule = NULL;
1252 const struct ieee80211_freq_range *freq_range = NULL;
1253
1254 reg_rule = freq_reg_info_regd(wiphy, MHZ_TO_KHZ(chan->center_freq),
1255 regd);
1256
1257 if (IS_ERR(reg_rule)) {
1258 REG_DBG_PRINT("Disabling freq %d MHz as custom regd has no rule that fits it\n",
1259 chan->center_freq);
1260 chan->flags = IEEE80211_CHAN_DISABLED;
1261 return;
1262 }
1263
1264 chan_reg_rule_print_dbg(chan, reg_rule);
1265
1266 power_rule = ®_rule->power_rule;
1267 freq_range = ®_rule->freq_range;
1268
1269 if (freq_range->max_bandwidth_khz < MHZ_TO_KHZ(40))
1270 bw_flags = IEEE80211_CHAN_NO_HT40;
1271 if (freq_range->max_bandwidth_khz < MHZ_TO_KHZ(80))
1272 bw_flags |= IEEE80211_CHAN_NO_80MHZ;
1273 if (freq_range->max_bandwidth_khz < MHZ_TO_KHZ(160))
1274 bw_flags |= IEEE80211_CHAN_NO_160MHZ;
1275
1276 chan->flags |= map_regdom_flags(reg_rule->flags) | bw_flags;
1277 chan->max_antenna_gain = (int) MBI_TO_DBI(power_rule->max_antenna_gain);
1278 chan->max_reg_power = chan->max_power =
1279 (int) MBM_TO_DBM(power_rule->max_eirp);
1280}
1281
1282static void handle_band_custom(struct wiphy *wiphy,
1283 struct ieee80211_supported_band *sband,
1284 const struct ieee80211_regdomain *regd)
1285{
1286 unsigned int i;
1287
1288 if (!sband)
1289 return;
1290
1291 for (i = 0; i < sband->n_channels; i++)
1292 handle_channel_custom(wiphy, &sband->channels[i], regd);
1293}
1294
1295
1296void wiphy_apply_custom_regulatory(struct wiphy *wiphy,
1297 const struct ieee80211_regdomain *regd)
1298{
1299 enum ieee80211_band band;
1300 unsigned int bands_set = 0;
1301
1302 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1303 if (!wiphy->bands[band])
1304 continue;
1305 handle_band_custom(wiphy, wiphy->bands[band], regd);
1306 bands_set++;
1307 }
1308
1309
1310
1311
1312
1313 WARN_ON(!bands_set);
1314}
1315EXPORT_SYMBOL(wiphy_apply_custom_regulatory);
1316
1317
1318
1319static enum reg_request_treatment
1320get_reg_request_treatment(struct wiphy *wiphy,
1321 struct regulatory_request *pending_request)
1322{
1323 struct wiphy *last_wiphy = NULL;
1324 struct regulatory_request *lr = get_last_request();
1325
1326
1327 if (!lr)
1328 return REG_REQ_OK;
1329
1330 switch (pending_request->initiator) {
1331 case NL80211_REGDOM_SET_BY_CORE:
1332 return REG_REQ_OK;
1333 case NL80211_REGDOM_SET_BY_COUNTRY_IE:
1334 if (reg_request_cell_base(lr)) {
1335
1336 if (regdom_changes(pending_request->alpha2))
1337 return REG_REQ_IGNORE;
1338 return REG_REQ_ALREADY_SET;
1339 }
1340
1341 last_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx);
1342
1343 if (unlikely(!is_an_alpha2(pending_request->alpha2)))
1344 return -EINVAL;
1345 if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE) {
1346 if (last_wiphy != wiphy) {
1347
1348
1349
1350
1351
1352
1353 if (regdom_changes(pending_request->alpha2))
1354 return REG_REQ_IGNORE;
1355 return REG_REQ_ALREADY_SET;
1356 }
1357
1358
1359
1360
1361 if (WARN_ON(regdom_changes(pending_request->alpha2)))
1362 return REG_REQ_OK;
1363 return REG_REQ_ALREADY_SET;
1364 }
1365 return 0;
1366 case NL80211_REGDOM_SET_BY_DRIVER:
1367 if (lr->initiator == NL80211_REGDOM_SET_BY_CORE) {
1368 if (regdom_changes(pending_request->alpha2))
1369 return REG_REQ_OK;
1370 return REG_REQ_ALREADY_SET;
1371 }
1372
1373
1374
1375
1376
1377
1378 if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
1379 !regdom_changes(pending_request->alpha2))
1380 return REG_REQ_ALREADY_SET;
1381
1382 return REG_REQ_INTERSECT;
1383 case NL80211_REGDOM_SET_BY_USER:
1384 if (reg_request_cell_base(pending_request))
1385 return reg_ignore_cell_hint(pending_request);
1386
1387 if (reg_request_cell_base(lr))
1388 return REG_REQ_IGNORE;
1389
1390 if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE)
1391 return REG_REQ_INTERSECT;
1392
1393
1394
1395
1396 if (lr->initiator == NL80211_REGDOM_SET_BY_USER &&
1397 lr->intersect)
1398 return REG_REQ_IGNORE;
1399
1400
1401
1402
1403 if ((lr->initiator == NL80211_REGDOM_SET_BY_CORE ||
1404 lr->initiator == NL80211_REGDOM_SET_BY_DRIVER ||
1405 lr->initiator == NL80211_REGDOM_SET_BY_USER) &&
1406 regdom_changes(lr->alpha2))
1407 return REG_REQ_IGNORE;
1408
1409 if (!regdom_changes(pending_request->alpha2))
1410 return REG_REQ_ALREADY_SET;
1411
1412 return REG_REQ_OK;
1413 }
1414
1415 return REG_REQ_IGNORE;
1416}
1417
1418static void reg_set_request_processed(void)
1419{
1420 bool need_more_processing = false;
1421 struct regulatory_request *lr = get_last_request();
1422
1423 lr->processed = true;
1424
1425 spin_lock(®_requests_lock);
1426 if (!list_empty(®_requests_list))
1427 need_more_processing = true;
1428 spin_unlock(®_requests_lock);
1429
1430 if (lr->initiator == NL80211_REGDOM_SET_BY_USER)
1431 cancel_delayed_work(®_timeout);
1432
1433 if (need_more_processing)
1434 schedule_work(®_work);
1435}
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450static enum reg_request_treatment
1451__regulatory_hint(struct wiphy *wiphy,
1452 struct regulatory_request *pending_request)
1453{
1454 const struct ieee80211_regdomain *regd;
1455 bool intersect = false;
1456 enum reg_request_treatment treatment;
1457 struct regulatory_request *lr;
1458
1459 treatment = get_reg_request_treatment(wiphy, pending_request);
1460
1461 switch (treatment) {
1462 case REG_REQ_INTERSECT:
1463 if (pending_request->initiator ==
1464 NL80211_REGDOM_SET_BY_DRIVER) {
1465 regd = reg_copy_regd(get_cfg80211_regdom());
1466 if (IS_ERR(regd)) {
1467 kfree(pending_request);
1468 return PTR_ERR(regd);
1469 }
1470 rcu_assign_pointer(wiphy->regd, regd);
1471 }
1472 intersect = true;
1473 break;
1474 case REG_REQ_OK:
1475 break;
1476 default:
1477
1478
1479
1480
1481
1482 if (treatment == REG_REQ_ALREADY_SET &&
1483 pending_request->initiator == NL80211_REGDOM_SET_BY_DRIVER) {
1484 regd = reg_copy_regd(get_cfg80211_regdom());
1485 if (IS_ERR(regd)) {
1486 kfree(pending_request);
1487 return REG_REQ_IGNORE;
1488 }
1489 treatment = REG_REQ_ALREADY_SET;
1490 rcu_assign_pointer(wiphy->regd, regd);
1491 goto new_request;
1492 }
1493 kfree(pending_request);
1494 return treatment;
1495 }
1496
1497new_request:
1498 lr = get_last_request();
1499 if (lr != &core_request_world && lr)
1500 kfree_rcu(lr, rcu_head);
1501
1502 pending_request->intersect = intersect;
1503 pending_request->processed = false;
1504 rcu_assign_pointer(last_request, pending_request);
1505 lr = pending_request;
1506
1507 pending_request = NULL;
1508
1509 if (lr->initiator == NL80211_REGDOM_SET_BY_USER) {
1510 user_alpha2[0] = lr->alpha2[0];
1511 user_alpha2[1] = lr->alpha2[1];
1512 }
1513
1514
1515 if (treatment != REG_REQ_OK && treatment != REG_REQ_INTERSECT) {
1516
1517
1518
1519
1520
1521 if (treatment == REG_REQ_ALREADY_SET) {
1522 nl80211_send_reg_change_event(lr);
1523 reg_set_request_processed();
1524 }
1525 return treatment;
1526 }
1527
1528 if (call_crda(lr->alpha2))
1529 return REG_REQ_IGNORE;
1530 return REG_REQ_OK;
1531}
1532
1533
1534static void reg_process_hint(struct regulatory_request *reg_request,
1535 enum nl80211_reg_initiator reg_initiator)
1536{
1537 struct wiphy *wiphy = NULL;
1538
1539 if (WARN_ON(!reg_request->alpha2))
1540 return;
1541
1542 if (reg_request->wiphy_idx != WIPHY_IDX_INVALID)
1543 wiphy = wiphy_idx_to_wiphy(reg_request->wiphy_idx);
1544
1545 if (reg_initiator == NL80211_REGDOM_SET_BY_DRIVER && !wiphy) {
1546 kfree(reg_request);
1547 return;
1548 }
1549
1550 switch (__regulatory_hint(wiphy, reg_request)) {
1551 case REG_REQ_ALREADY_SET:
1552
1553 if (wiphy && wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY)
1554 wiphy_update_regulatory(wiphy, reg_initiator);
1555 break;
1556 default:
1557 if (reg_initiator == NL80211_REGDOM_SET_BY_USER)
1558 schedule_delayed_work(®_timeout,
1559 msecs_to_jiffies(3142));
1560 break;
1561 }
1562}
1563
1564
1565
1566
1567
1568
1569static void reg_process_pending_hints(void)
1570{
1571 struct regulatory_request *reg_request, *lr;
1572
1573 mutex_lock(&cfg80211_mutex);
1574 mutex_lock(®_mutex);
1575 lr = get_last_request();
1576
1577
1578 if (lr && !lr->processed) {
1579 REG_DBG_PRINT("Pending regulatory request, waiting for it to be processed...\n");
1580 goto out;
1581 }
1582
1583 spin_lock(®_requests_lock);
1584
1585 if (list_empty(®_requests_list)) {
1586 spin_unlock(®_requests_lock);
1587 goto out;
1588 }
1589
1590 reg_request = list_first_entry(®_requests_list,
1591 struct regulatory_request,
1592 list);
1593 list_del_init(®_request->list);
1594
1595 spin_unlock(®_requests_lock);
1596
1597 reg_process_hint(reg_request, reg_request->initiator);
1598
1599out:
1600 mutex_unlock(®_mutex);
1601 mutex_unlock(&cfg80211_mutex);
1602}
1603
1604
1605static void reg_process_pending_beacon_hints(void)
1606{
1607 struct cfg80211_registered_device *rdev;
1608 struct reg_beacon *pending_beacon, *tmp;
1609
1610 mutex_lock(&cfg80211_mutex);
1611 mutex_lock(®_mutex);
1612
1613
1614 spin_lock_bh(®_pending_beacons_lock);
1615
1616 list_for_each_entry_safe(pending_beacon, tmp,
1617 ®_pending_beacons, list) {
1618 list_del_init(&pending_beacon->list);
1619
1620
1621 list_for_each_entry(rdev, &cfg80211_rdev_list, list)
1622 wiphy_update_new_beacon(&rdev->wiphy, pending_beacon);
1623
1624
1625 list_add_tail(&pending_beacon->list, ®_beacon_list);
1626 }
1627
1628 spin_unlock_bh(®_pending_beacons_lock);
1629 mutex_unlock(®_mutex);
1630 mutex_unlock(&cfg80211_mutex);
1631}
1632
1633static void reg_todo(struct work_struct *work)
1634{
1635 reg_process_pending_hints();
1636 reg_process_pending_beacon_hints();
1637}
1638
1639static void queue_regulatory_request(struct regulatory_request *request)
1640{
1641 request->alpha2[0] = toupper(request->alpha2[0]);
1642 request->alpha2[1] = toupper(request->alpha2[1]);
1643
1644 spin_lock(®_requests_lock);
1645 list_add_tail(&request->list, ®_requests_list);
1646 spin_unlock(®_requests_lock);
1647
1648 schedule_work(®_work);
1649}
1650
1651
1652
1653
1654
1655static int regulatory_hint_core(const char *alpha2)
1656{
1657 struct regulatory_request *request;
1658
1659 request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
1660 if (!request)
1661 return -ENOMEM;
1662
1663 request->alpha2[0] = alpha2[0];
1664 request->alpha2[1] = alpha2[1];
1665 request->initiator = NL80211_REGDOM_SET_BY_CORE;
1666
1667 queue_regulatory_request(request);
1668
1669 return 0;
1670}
1671
1672
1673int regulatory_hint_user(const char *alpha2,
1674 enum nl80211_user_reg_hint_type user_reg_hint_type)
1675{
1676 struct regulatory_request *request;
1677
1678 if (WARN_ON(!alpha2))
1679 return -EINVAL;
1680
1681 request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
1682 if (!request)
1683 return -ENOMEM;
1684
1685 request->wiphy_idx = WIPHY_IDX_INVALID;
1686 request->alpha2[0] = alpha2[0];
1687 request->alpha2[1] = alpha2[1];
1688 request->initiator = NL80211_REGDOM_SET_BY_USER;
1689 request->user_reg_hint_type = user_reg_hint_type;
1690
1691 queue_regulatory_request(request);
1692
1693 return 0;
1694}
1695
1696
1697int regulatory_hint(struct wiphy *wiphy, const char *alpha2)
1698{
1699 struct regulatory_request *request;
1700
1701 if (WARN_ON(!alpha2 || !wiphy))
1702 return -EINVAL;
1703
1704 request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
1705 if (!request)
1706 return -ENOMEM;
1707
1708 request->wiphy_idx = get_wiphy_idx(wiphy);
1709
1710 request->alpha2[0] = alpha2[0];
1711 request->alpha2[1] = alpha2[1];
1712 request->initiator = NL80211_REGDOM_SET_BY_DRIVER;
1713
1714 queue_regulatory_request(request);
1715
1716 return 0;
1717}
1718EXPORT_SYMBOL(regulatory_hint);
1719
1720
1721
1722
1723
1724void regulatory_hint_11d(struct wiphy *wiphy, enum ieee80211_band band,
1725 const u8 *country_ie, u8 country_ie_len)
1726{
1727 char alpha2[2];
1728 enum environment_cap env = ENVIRON_ANY;
1729 struct regulatory_request *request, *lr;
1730
1731 mutex_lock(®_mutex);
1732 lr = get_last_request();
1733
1734 if (unlikely(!lr))
1735 goto out;
1736
1737
1738 if (country_ie_len & 0x01)
1739 goto out;
1740
1741 if (country_ie_len < IEEE80211_COUNTRY_IE_MIN_LEN)
1742 goto out;
1743
1744 alpha2[0] = country_ie[0];
1745 alpha2[1] = country_ie[1];
1746
1747 if (country_ie[2] == 'I')
1748 env = ENVIRON_INDOOR;
1749 else if (country_ie[2] == 'O')
1750 env = ENVIRON_OUTDOOR;
1751
1752
1753
1754
1755
1756
1757 if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
1758 lr->wiphy_idx != WIPHY_IDX_INVALID)
1759 goto out;
1760
1761 request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
1762 if (!request)
1763 goto out;
1764
1765 request->wiphy_idx = get_wiphy_idx(wiphy);
1766 request->alpha2[0] = alpha2[0];
1767 request->alpha2[1] = alpha2[1];
1768 request->initiator = NL80211_REGDOM_SET_BY_COUNTRY_IE;
1769 request->country_ie_env = env;
1770
1771 queue_regulatory_request(request);
1772out:
1773 mutex_unlock(®_mutex);
1774}
1775
1776static void restore_alpha2(char *alpha2, bool reset_user)
1777{
1778
1779 alpha2[0] = '9';
1780 alpha2[1] = '7';
1781
1782
1783 if (is_user_regdom_saved()) {
1784
1785 if (reset_user) {
1786 REG_DBG_PRINT("Restoring regulatory settings including user preference\n");
1787 user_alpha2[0] = '9';
1788 user_alpha2[1] = '7';
1789
1790
1791
1792
1793
1794
1795 if (!is_world_regdom(ieee80211_regdom)) {
1796 REG_DBG_PRINT("Keeping preference on module parameter ieee80211_regdom: %c%c\n",
1797 ieee80211_regdom[0], ieee80211_regdom[1]);
1798 alpha2[0] = ieee80211_regdom[0];
1799 alpha2[1] = ieee80211_regdom[1];
1800 }
1801 } else {
1802 REG_DBG_PRINT("Restoring regulatory settings while preserving user preference for: %c%c\n",
1803 user_alpha2[0], user_alpha2[1]);
1804 alpha2[0] = user_alpha2[0];
1805 alpha2[1] = user_alpha2[1];
1806 }
1807 } else if (!is_world_regdom(ieee80211_regdom)) {
1808 REG_DBG_PRINT("Keeping preference on module parameter ieee80211_regdom: %c%c\n",
1809 ieee80211_regdom[0], ieee80211_regdom[1]);
1810 alpha2[0] = ieee80211_regdom[0];
1811 alpha2[1] = ieee80211_regdom[1];
1812 } else
1813 REG_DBG_PRINT("Restoring regulatory settings\n");
1814}
1815
1816static void restore_custom_reg_settings(struct wiphy *wiphy)
1817{
1818 struct ieee80211_supported_band *sband;
1819 enum ieee80211_band band;
1820 struct ieee80211_channel *chan;
1821 int i;
1822
1823 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1824 sband = wiphy->bands[band];
1825 if (!sband)
1826 continue;
1827 for (i = 0; i < sband->n_channels; i++) {
1828 chan = &sband->channels[i];
1829 chan->flags = chan->orig_flags;
1830 chan->max_antenna_gain = chan->orig_mag;
1831 chan->max_power = chan->orig_mpwr;
1832 chan->beacon_found = false;
1833 }
1834 }
1835}
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852static void restore_regulatory_settings(bool reset_user)
1853{
1854 char alpha2[2];
1855 char world_alpha2[2];
1856 struct reg_beacon *reg_beacon, *btmp;
1857 struct regulatory_request *reg_request, *tmp;
1858 LIST_HEAD(tmp_reg_req_list);
1859 struct cfg80211_registered_device *rdev;
1860
1861 mutex_lock(&cfg80211_mutex);
1862 mutex_lock(®_mutex);
1863
1864 reset_regdomains(true, &world_regdom);
1865 restore_alpha2(alpha2, reset_user);
1866
1867
1868
1869
1870
1871
1872
1873 spin_lock(®_requests_lock);
1874 list_for_each_entry_safe(reg_request, tmp, ®_requests_list, list) {
1875 if (reg_request->initiator != NL80211_REGDOM_SET_BY_USER)
1876 continue;
1877 list_move_tail(®_request->list, &tmp_reg_req_list);
1878 }
1879 spin_unlock(®_requests_lock);
1880
1881
1882 spin_lock_bh(®_pending_beacons_lock);
1883 list_for_each_entry_safe(reg_beacon, btmp, ®_pending_beacons, list) {
1884 list_del(®_beacon->list);
1885 kfree(reg_beacon);
1886 }
1887 spin_unlock_bh(®_pending_beacons_lock);
1888
1889 list_for_each_entry_safe(reg_beacon, btmp, ®_beacon_list, list) {
1890 list_del(®_beacon->list);
1891 kfree(reg_beacon);
1892 }
1893
1894
1895 world_alpha2[0] = cfg80211_world_regdom->alpha2[0];
1896 world_alpha2[1] = cfg80211_world_regdom->alpha2[1];
1897
1898 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
1899 if (rdev->wiphy.flags & WIPHY_FLAG_CUSTOM_REGULATORY)
1900 restore_custom_reg_settings(&rdev->wiphy);
1901 }
1902
1903 regulatory_hint_core(world_alpha2);
1904
1905
1906
1907
1908
1909
1910 if (is_an_alpha2(alpha2))
1911 regulatory_hint_user(user_alpha2, NL80211_USER_REG_HINT_USER);
1912
1913 spin_lock(®_requests_lock);
1914 list_splice_tail_init(&tmp_reg_req_list, ®_requests_list);
1915 spin_unlock(®_requests_lock);
1916
1917 mutex_unlock(®_mutex);
1918 mutex_unlock(&cfg80211_mutex);
1919
1920 REG_DBG_PRINT("Kicking the queue\n");
1921
1922 schedule_work(®_work);
1923}
1924
1925void regulatory_hint_disconnect(void)
1926{
1927 REG_DBG_PRINT("All devices are disconnected, going to restore regulatory settings\n");
1928 restore_regulatory_settings(false);
1929}
1930
1931static bool freq_is_chan_12_13_14(u16 freq)
1932{
1933 if (freq == ieee80211_channel_to_frequency(12, IEEE80211_BAND_2GHZ) ||
1934 freq == ieee80211_channel_to_frequency(13, IEEE80211_BAND_2GHZ) ||
1935 freq == ieee80211_channel_to_frequency(14, IEEE80211_BAND_2GHZ))
1936 return true;
1937 return false;
1938}
1939
1940static bool pending_reg_beacon(struct ieee80211_channel *beacon_chan)
1941{
1942 struct reg_beacon *pending_beacon;
1943
1944 list_for_each_entry(pending_beacon, ®_pending_beacons, list)
1945 if (beacon_chan->center_freq ==
1946 pending_beacon->chan.center_freq)
1947 return true;
1948 return false;
1949}
1950
1951int regulatory_hint_found_beacon(struct wiphy *wiphy,
1952 struct ieee80211_channel *beacon_chan,
1953 gfp_t gfp)
1954{
1955 struct reg_beacon *reg_beacon;
1956 bool processing;
1957
1958 if (beacon_chan->beacon_found ||
1959 beacon_chan->flags & IEEE80211_CHAN_RADAR ||
1960 (beacon_chan->band == IEEE80211_BAND_2GHZ &&
1961 !freq_is_chan_12_13_14(beacon_chan->center_freq)))
1962 return 0;
1963
1964 spin_lock_bh(®_pending_beacons_lock);
1965 processing = pending_reg_beacon(beacon_chan);
1966 spin_unlock_bh(®_pending_beacons_lock);
1967
1968 if (processing)
1969 return 0;
1970
1971 reg_beacon = kzalloc(sizeof(struct reg_beacon), gfp);
1972 if (!reg_beacon)
1973 return -ENOMEM;
1974
1975 REG_DBG_PRINT("Found new beacon on frequency: %d MHz (Ch %d) on %s\n",
1976 beacon_chan->center_freq,
1977 ieee80211_frequency_to_channel(beacon_chan->center_freq),
1978 wiphy_name(wiphy));
1979
1980 memcpy(®_beacon->chan, beacon_chan,
1981 sizeof(struct ieee80211_channel));
1982
1983
1984
1985
1986
1987 spin_lock_bh(®_pending_beacons_lock);
1988 list_add_tail(®_beacon->list, ®_pending_beacons);
1989 spin_unlock_bh(®_pending_beacons_lock);
1990
1991 schedule_work(®_work);
1992
1993 return 0;
1994}
1995
1996static void print_rd_rules(const struct ieee80211_regdomain *rd)
1997{
1998 unsigned int i;
1999 const struct ieee80211_reg_rule *reg_rule = NULL;
2000 const struct ieee80211_freq_range *freq_range = NULL;
2001 const struct ieee80211_power_rule *power_rule = NULL;
2002
2003 pr_info(" (start_freq - end_freq @ bandwidth), (max_antenna_gain, max_eirp)\n");
2004
2005 for (i = 0; i < rd->n_reg_rules; i++) {
2006 reg_rule = &rd->reg_rules[i];
2007 freq_range = ®_rule->freq_range;
2008 power_rule = ®_rule->power_rule;
2009
2010
2011
2012
2013
2014 if (power_rule->max_antenna_gain)
2015 pr_info(" (%d KHz - %d KHz @ %d KHz), (%d mBi, %d mBm)\n",
2016 freq_range->start_freq_khz,
2017 freq_range->end_freq_khz,
2018 freq_range->max_bandwidth_khz,
2019 power_rule->max_antenna_gain,
2020 power_rule->max_eirp);
2021 else
2022 pr_info(" (%d KHz - %d KHz @ %d KHz), (N/A, %d mBm)\n",
2023 freq_range->start_freq_khz,
2024 freq_range->end_freq_khz,
2025 freq_range->max_bandwidth_khz,
2026 power_rule->max_eirp);
2027 }
2028}
2029
2030bool reg_supported_dfs_region(u8 dfs_region)
2031{
2032 switch (dfs_region) {
2033 case NL80211_DFS_UNSET:
2034 case NL80211_DFS_FCC:
2035 case NL80211_DFS_ETSI:
2036 case NL80211_DFS_JP:
2037 return true;
2038 default:
2039 REG_DBG_PRINT("Ignoring uknown DFS master region: %d\n",
2040 dfs_region);
2041 return false;
2042 }
2043}
2044
2045static void print_dfs_region(u8 dfs_region)
2046{
2047 if (!dfs_region)
2048 return;
2049
2050 switch (dfs_region) {
2051 case NL80211_DFS_FCC:
2052 pr_info(" DFS Master region FCC");
2053 break;
2054 case NL80211_DFS_ETSI:
2055 pr_info(" DFS Master region ETSI");
2056 break;
2057 case NL80211_DFS_JP:
2058 pr_info(" DFS Master region JP");
2059 break;
2060 default:
2061 pr_info(" DFS Master region Unknown");
2062 break;
2063 }
2064}
2065
2066static void print_regdomain(const struct ieee80211_regdomain *rd)
2067{
2068 struct regulatory_request *lr = get_last_request();
2069
2070 if (is_intersected_alpha2(rd->alpha2)) {
2071 if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE) {
2072 struct cfg80211_registered_device *rdev;
2073 rdev = cfg80211_rdev_by_wiphy_idx(lr->wiphy_idx);
2074 if (rdev) {
2075 pr_info("Current regulatory domain updated by AP to: %c%c\n",
2076 rdev->country_ie_alpha2[0],
2077 rdev->country_ie_alpha2[1]);
2078 } else
2079 pr_info("Current regulatory domain intersected:\n");
2080 } else
2081 pr_info("Current regulatory domain intersected:\n");
2082 } else if (is_world_regdom(rd->alpha2)) {
2083 pr_info("World regulatory domain updated:\n");
2084 } else {
2085 if (is_unknown_alpha2(rd->alpha2))
2086 pr_info("Regulatory domain changed to driver built-in settings (unknown country)\n");
2087 else {
2088 if (reg_request_cell_base(lr))
2089 pr_info("Regulatory domain changed to country: %c%c by Cell Station\n",
2090 rd->alpha2[0], rd->alpha2[1]);
2091 else
2092 pr_info("Regulatory domain changed to country: %c%c\n",
2093 rd->alpha2[0], rd->alpha2[1]);
2094 }
2095 }
2096
2097 print_dfs_region(rd->dfs_region);
2098 print_rd_rules(rd);
2099}
2100
2101static void print_regdomain_info(const struct ieee80211_regdomain *rd)
2102{
2103 pr_info("Regulatory domain: %c%c\n", rd->alpha2[0], rd->alpha2[1]);
2104 print_rd_rules(rd);
2105}
2106
2107
2108static int __set_regdom(const struct ieee80211_regdomain *rd)
2109{
2110 const struct ieee80211_regdomain *regd;
2111 const struct ieee80211_regdomain *intersected_rd = NULL;
2112 struct wiphy *request_wiphy;
2113 struct regulatory_request *lr = get_last_request();
2114
2115
2116
2117 if (!reg_is_valid_request(rd->alpha2))
2118 return -EINVAL;
2119
2120 if (is_world_regdom(rd->alpha2)) {
2121 update_world_regdomain(rd);
2122 return 0;
2123 }
2124
2125 if (!is_alpha2_set(rd->alpha2) && !is_an_alpha2(rd->alpha2) &&
2126 !is_unknown_alpha2(rd->alpha2))
2127 return -EINVAL;
2128
2129
2130
2131
2132
2133
2134 if (lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE) {
2135
2136
2137
2138
2139 if (!regdom_changes(rd->alpha2))
2140 return -EALREADY;
2141 }
2142
2143
2144
2145
2146
2147
2148
2149
2150 if (!is_valid_rd(rd)) {
2151 pr_err("Invalid regulatory domain detected:\n");
2152 print_regdomain_info(rd);
2153 return -EINVAL;
2154 }
2155
2156 request_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx);
2157 if (!request_wiphy &&
2158 (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER ||
2159 lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE)) {
2160 schedule_delayed_work(®_timeout, 0);
2161 return -ENODEV;
2162 }
2163
2164 if (!lr->intersect) {
2165 if (lr->initiator != NL80211_REGDOM_SET_BY_DRIVER) {
2166 reset_regdomains(false, rd);
2167 return 0;
2168 }
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179 if (request_wiphy->regd)
2180 return -EALREADY;
2181
2182 regd = reg_copy_regd(rd);
2183 if (IS_ERR(regd))
2184 return PTR_ERR(regd);
2185
2186 rcu_assign_pointer(request_wiphy->regd, regd);
2187 reset_regdomains(false, rd);
2188 return 0;
2189 }
2190
2191
2192
2193 if (lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE) {
2194 intersected_rd = regdom_intersect(rd, get_cfg80211_regdom());
2195 if (!intersected_rd)
2196 return -EINVAL;
2197
2198
2199
2200
2201
2202
2203 if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER) {
2204 const struct ieee80211_regdomain *tmp;
2205
2206 tmp = get_wiphy_regdom(request_wiphy);
2207 rcu_assign_pointer(request_wiphy->regd, rd);
2208 rcu_free_regdom(tmp);
2209 } else {
2210 kfree(rd);
2211 }
2212
2213 rd = NULL;
2214
2215 reset_regdomains(false, intersected_rd);
2216
2217 return 0;
2218 }
2219
2220 return -EINVAL;
2221}
2222
2223
2224
2225
2226
2227
2228
2229int set_regdom(const struct ieee80211_regdomain *rd)
2230{
2231 struct regulatory_request *lr;
2232 int r;
2233
2234 mutex_lock(®_mutex);
2235 lr = get_last_request();
2236
2237
2238 r = __set_regdom(rd);
2239 if (r) {
2240 if (r == -EALREADY)
2241 reg_set_request_processed();
2242
2243 kfree(rd);
2244 goto out;
2245 }
2246
2247
2248 if (WARN_ON(!lr->intersect && rd != get_cfg80211_regdom())) {
2249 r = -EINVAL;
2250 goto out;
2251 }
2252
2253
2254 update_all_wiphy_regulatory(lr->initiator);
2255
2256 print_regdomain(get_cfg80211_regdom());
2257
2258 nl80211_send_reg_change_event(lr);
2259
2260 reg_set_request_processed();
2261
2262 out:
2263 mutex_unlock(®_mutex);
2264
2265 return r;
2266}
2267
2268int reg_device_uevent(struct device *dev, struct kobj_uevent_env *env)
2269{
2270 struct regulatory_request *lr;
2271 u8 alpha2[2];
2272 bool add = false;
2273
2274 rcu_read_lock();
2275 lr = get_last_request();
2276 if (lr && !lr->processed) {
2277 memcpy(alpha2, lr->alpha2, 2);
2278 add = true;
2279 }
2280 rcu_read_unlock();
2281
2282 if (add)
2283 return add_uevent_var(env, "COUNTRY=%c%c",
2284 alpha2[0], alpha2[1]);
2285 return 0;
2286}
2287
2288void wiphy_regulatory_register(struct wiphy *wiphy)
2289{
2290 mutex_lock(®_mutex);
2291
2292 if (!reg_dev_ignore_cell_hint(wiphy))
2293 reg_num_devs_support_basehint++;
2294
2295 wiphy_update_regulatory(wiphy, NL80211_REGDOM_SET_BY_CORE);
2296
2297 mutex_unlock(®_mutex);
2298}
2299
2300
2301void wiphy_regulatory_deregister(struct wiphy *wiphy)
2302{
2303 struct wiphy *request_wiphy = NULL;
2304 struct regulatory_request *lr;
2305
2306 mutex_lock(®_mutex);
2307 lr = get_last_request();
2308
2309 if (!reg_dev_ignore_cell_hint(wiphy))
2310 reg_num_devs_support_basehint--;
2311
2312 rcu_free_regdom(get_wiphy_regdom(wiphy));
2313 rcu_assign_pointer(wiphy->regd, NULL);
2314
2315 if (lr)
2316 request_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx);
2317
2318 if (!request_wiphy || request_wiphy != wiphy)
2319 goto out;
2320
2321 lr->wiphy_idx = WIPHY_IDX_INVALID;
2322 lr->country_ie_env = ENVIRON_ANY;
2323out:
2324 mutex_unlock(®_mutex);
2325}
2326
2327static void reg_timeout_work(struct work_struct *work)
2328{
2329 REG_DBG_PRINT("Timeout while waiting for CRDA to reply, restoring regulatory settings\n");
2330 restore_regulatory_settings(true);
2331}
2332
2333int __init regulatory_init(void)
2334{
2335 int err = 0;
2336
2337 reg_pdev = platform_device_register_simple("regulatory", 0, NULL, 0);
2338 if (IS_ERR(reg_pdev))
2339 return PTR_ERR(reg_pdev);
2340
2341 reg_pdev->dev.type = ®_device_type;
2342
2343 spin_lock_init(®_requests_lock);
2344 spin_lock_init(®_pending_beacons_lock);
2345
2346 reg_regdb_size_check();
2347
2348 rcu_assign_pointer(cfg80211_regdomain, cfg80211_world_regdom);
2349
2350 user_alpha2[0] = '9';
2351 user_alpha2[1] = '7';
2352
2353
2354 err = regulatory_hint_core(cfg80211_world_regdom->alpha2);
2355 if (err) {
2356 if (err == -ENOMEM)
2357 return err;
2358
2359
2360
2361
2362
2363
2364
2365 pr_err("kobject_uevent_env() was unable to call CRDA during init\n");
2366 }
2367
2368
2369
2370
2371
2372 if (!is_world_regdom(ieee80211_regdom))
2373 regulatory_hint_user(ieee80211_regdom,
2374 NL80211_USER_REG_HINT_USER);
2375
2376 return 0;
2377}
2378
2379void regulatory_exit(void)
2380{
2381 struct regulatory_request *reg_request, *tmp;
2382 struct reg_beacon *reg_beacon, *btmp;
2383
2384 cancel_work_sync(®_work);
2385 cancel_delayed_work_sync(®_timeout);
2386
2387
2388 mutex_lock(®_mutex);
2389 reset_regdomains(true, NULL);
2390 mutex_unlock(®_mutex);
2391
2392 dev_set_uevent_suppress(®_pdev->dev, true);
2393
2394 platform_device_unregister(reg_pdev);
2395
2396 list_for_each_entry_safe(reg_beacon, btmp, ®_pending_beacons, list) {
2397 list_del(®_beacon->list);
2398 kfree(reg_beacon);
2399 }
2400
2401 list_for_each_entry_safe(reg_beacon, btmp, ®_beacon_list, list) {
2402 list_del(®_beacon->list);
2403 kfree(reg_beacon);
2404 }
2405
2406 list_for_each_entry_safe(reg_request, tmp, ®_requests_list, list) {
2407 list_del(®_request->list);
2408 kfree(reg_request);
2409 }
2410}
2411