This source file includes following definitions.
- get_cfg80211_regdom
- get_wiphy_regdom
- reg_dfs_region_str
- reg_get_dfs_region
- rcu_free_regdom
- get_last_request
- reg_free_request
- reg_free_last_request
- reg_update_last_request
- reset_regdomains
- update_world_regdomain
- is_world_regdom
- is_alpha2_set
- is_unknown_alpha2
- is_intersected_alpha2
- is_an_alpha2
- alpha2_equal
- regdom_changes
- is_user_regdom_saved
- reg_copy_regd
- cfg80211_save_user_regdom
- reg_regdb_apply
- reg_schedule_apply
- crda_timeout_work
- cancel_crda_timeout
- cancel_crda_timeout_sync
- reset_crda_timeouts
- call_crda
- cancel_crda_timeout
- cancel_crda_timeout_sync
- reset_crda_timeouts
- call_crda
- ecw2cw
- valid_wmm
- valid_rule
- valid_country
- load_keys_from_buffer
- load_builtin_regdb_keys
- regdb_has_valid_signature
- free_regdb_keyring
- load_builtin_regdb_keys
- regdb_has_valid_signature
- free_regdb_keyring
- valid_regdb
- set_wmm_rule
- __regdb_query_wmm
- reg_query_regdb_wmm
- regdb_query_country
- query_regdb
- regdb_fw_cb
- query_regdb_file
- reg_reload_regdb
- reg_query_database
- reg_is_valid_request
- reg_get_regdomain
- reg_get_max_bandwidth_from_range
- reg_get_max_bandwidth
- is_valid_reg_rule
- is_valid_rd
- freq_in_rule_band
- reg_intersect_dfs_region
- reg_wmm_rules_intersect
- reg_rules_intersect
- rule_contains
- add_rule
- regdom_intersect
- map_regdom_flags
- freq_reg_info_regd
- __freq_reg_info
- freq_reg_info
- reg_initiator_name
- reg_rule_to_chan_bw_flags
- handle_channel
- handle_band
- reg_request_cell_base
- reg_last_request_cell_base
- reg_ignore_cell_hint
- reg_dev_ignore_cell_hint
- reg_ignore_cell_hint
- reg_dev_ignore_cell_hint
- wiphy_strict_alpha2_regd
- ignore_reg_update
- reg_is_world_roaming
- handle_reg_beacon
- wiphy_update_new_beacon
- wiphy_update_beacon_reg
- reg_process_beacons
- is_ht40_allowed
- reg_process_ht_flags_channel
- reg_process_ht_flags_band
- reg_process_ht_flags
- reg_call_notifier
- reg_wdev_chan_valid
- reg_leave_invalid_chans
- reg_check_chans_work
- reg_check_channels
- wiphy_update_regulatory
- update_all_wiphy_regulatory
- handle_channel_custom
- handle_band_custom
- wiphy_apply_custom_regulatory
- reg_set_request_processed
- reg_process_hint_core
- __reg_process_hint_user
- reg_process_hint_user
- __reg_process_hint_driver
- reg_process_hint_driver
- __reg_process_hint_country_ie
- reg_process_hint_country_ie
- reg_dfs_domain_same
- reg_copy_dfs_chan_state
- wiphy_share_dfs_chan_state
- wiphy_all_share_dfs_chan_state
- reg_process_hint
- notify_self_managed_wiphys
- reg_process_pending_hints
- reg_process_pending_beacon_hints
- reg_process_self_managed_hints
- reg_todo
- queue_regulatory_request
- regulatory_hint_core
- regulatory_hint_user
- regulatory_hint_indoor
- regulatory_netlink_notify
- regulatory_hint
- regulatory_hint_country_ie
- restore_alpha2
- restore_custom_reg_settings
- restore_regulatory_settings
- is_wiphy_all_set_reg_flag
- regulatory_hint_disconnect
- freq_is_chan_12_13_14
- pending_reg_beacon
- regulatory_hint_found_beacon
- print_rd_rules
- reg_supported_dfs_region
- print_regdomain
- print_regdomain_info
- reg_set_rd_core
- reg_set_rd_user
- reg_set_rd_driver
- reg_set_rd_country_ie
- set_regdom
- __regulatory_set_wiphy_regd
- regulatory_set_wiphy_regd
- regulatory_set_wiphy_regd_sync_rtnl
- wiphy_regulatory_register
- wiphy_regulatory_deregister
- cfg80211_get_unii
- regulatory_indoor_allowed
- regulatory_pre_cac_allowed
- cfg80211_check_and_end_cac
- regulatory_propagate_dfs_state
- regulatory_init_db
- regulatory_init
- regulatory_exit
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
82 enum reg_request_treatment {
83 REG_REQ_OK,
84 REG_REQ_IGNORE,
85 REG_REQ_INTERSECT,
86 REG_REQ_ALREADY_SET,
87 };
88
89 static struct regulatory_request core_request_world = {
90 .initiator = NL80211_REGDOM_SET_BY_CORE,
91 .alpha2[0] = '0',
92 .alpha2[1] = '0',
93 .intersect = false,
94 .processed = true,
95 .country_ie_env = ENVIRON_ANY,
96 };
97
98
99
100
101
102 static struct regulatory_request __rcu *last_request =
103 (void __force __rcu *)&core_request_world;
104
105
106 static struct platform_device *reg_pdev;
107
108
109
110
111
112
113
114 const struct ieee80211_regdomain __rcu *cfg80211_regdomain;
115
116
117
118
119
120
121 static int reg_num_devs_support_basehint;
122
123
124
125
126
127
128 static bool reg_is_indoor;
129 static spinlock_t reg_indoor_lock;
130
131
132 static u32 reg_is_indoor_portid;
133
134 static void restore_regulatory_settings(bool reset_user, bool cached);
135 static void print_regdomain(const struct ieee80211_regdomain *rd);
136
137 static const struct ieee80211_regdomain *get_cfg80211_regdom(void)
138 {
139 return rcu_dereference_rtnl(cfg80211_regdomain);
140 }
141
142 const struct ieee80211_regdomain *get_wiphy_regdom(struct wiphy *wiphy)
143 {
144 return rcu_dereference_rtnl(wiphy->regd);
145 }
146
147 static 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
162 enum 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
183 out:
184 return regd->dfs_region;
185 }
186
187 static 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
194 static struct regulatory_request *get_last_request(void)
195 {
196 return rcu_dereference_rtnl(last_request);
197 }
198
199
200 static LIST_HEAD(reg_requests_list);
201 static spinlock_t reg_requests_lock;
202
203
204 static LIST_HEAD(reg_pending_beacons);
205 static spinlock_t reg_pending_beacons_lock;
206
207
208 static LIST_HEAD(reg_beacon_list);
209
210 struct reg_beacon {
211 struct list_head list;
212 struct ieee80211_channel chan;
213 };
214
215 static void reg_check_chans_work(struct work_struct *work);
216 static DECLARE_DELAYED_WORK(reg_check_chans, reg_check_chans_work);
217
218 static void reg_todo(struct work_struct *work);
219 static DECLARE_WORK(reg_work, reg_todo);
220
221
222 static 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
262 static const struct ieee80211_regdomain *cfg80211_world_regdom =
263 &world_regdom;
264
265 static char *ieee80211_regdom = "00";
266 static char user_alpha2[2];
267 static const struct ieee80211_regdomain *cfg80211_user_regdom;
268
269 module_param(ieee80211_regdom, charp, 0444);
270 MODULE_PARM_DESC(ieee80211_regdom, "IEEE 802.11 regulatory domain code");
271
272 static 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
281 static 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
289 static 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
301 static 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
334 static 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
347 bool is_world_regdom(const char *alpha2)
348 {
349 if (!alpha2)
350 return false;
351 return alpha2[0] == '0' && alpha2[1] == '0';
352 }
353
354 static bool is_alpha2_set(const char *alpha2)
355 {
356 if (!alpha2)
357 return false;
358 return alpha2[0] && alpha2[1];
359 }
360
361 static 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
372 static 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
384 static bool is_an_alpha2(const char *alpha2)
385 {
386 if (!alpha2)
387 return false;
388 return isalpha(alpha2[0]) && isalpha(alpha2[1]);
389 }
390
391 static 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
398 static 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
412 static 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
426 static const struct ieee80211_regdomain *
427 reg_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
446 static 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
455 struct reg_regdb_apply_request {
456 struct list_head list;
457 const struct ieee80211_regdomain *regdom;
458 };
459
460 static LIST_HEAD(reg_regdb_apply_list);
461 static DEFINE_MUTEX(reg_regdb_apply_mutex);
462
463 static 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
484 static DECLARE_WORK(reg_regdb_work, reg_regdb_apply);
485
486 static 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
510 static u32 reg_crda_timeouts;
511
512 static void crda_timeout_work(struct work_struct *work);
513 static DECLARE_DELAYED_WORK(crda_timeout, crda_timeout_work);
514
515 static 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
524 static void cancel_crda_timeout(void)
525 {
526 cancel_delayed_work(&crda_timeout);
527 }
528
529 static void cancel_crda_timeout_sync(void)
530 {
531 cancel_delayed_work_sync(&crda_timeout);
532 }
533
534 static void reset_crda_timeouts(void)
535 {
536 reg_crda_timeouts = 0;
537 }
538
539
540
541
542
543 static 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
572 static inline void cancel_crda_timeout(void) {}
573 static inline void cancel_crda_timeout_sync(void) {}
574 static inline void reset_crda_timeouts(void) {}
575 static inline int call_crda(const char *alpha2)
576 {
577 return -ENODATA;
578 }
579 #endif
580
581
582 static const struct fwdb_header *regdb;
583
584 struct fwdb_country {
585 u8 alpha2[2];
586 __be16 coll_ptr;
587
588 } __packed __aligned(4);
589
590 struct fwdb_collection {
591 u8 len;
592 u8 n_rules;
593 u8 dfs_region;
594
595
596 } __packed __aligned(4);
597
598 enum 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
606 struct fwdb_wmm_ac {
607 u8 ecw;
608 u8 aifsn;
609 __be16 cot;
610 } __packed;
611
612 struct fwdb_wmm_rule {
613 struct fwdb_wmm_ac client[IEEE80211_NUM_ACS];
614 struct fwdb_wmm_ac ap[IEEE80211_NUM_ACS];
615 } __packed;
616
617 struct 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
630 struct fwdb_header {
631 __be32 magic;
632 __be32 version;
633 struct fwdb_country country[];
634 } __packed __aligned(4);
635
636 static int ecw2cw(int ecw)
637 {
638 return (1 << ecw) - 1;
639 }
640
641 static 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
661 static 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
686 static 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
720 static struct key *builtin_regdb_keys;
721
722 static 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
762 dodgy_cert:
763 pr_err("Problem parsing in-kernel X.509 certificate list\n");
764 }
765
766 static 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
790 static 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
808 static void free_regdb_keyring(void)
809 {
810 key_put(builtin_regdb_keys);
811 }
812 #else
813 static int load_builtin_regdb_keys(void)
814 {
815 return 0;
816 }
817
818 static bool regdb_has_valid_signature(const u8 *data, unsigned int size)
819 {
820 return true;
821 }
822
823 static void free_regdb_keyring(void)
824 {
825 }
826 #endif
827
828 static 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
857 static 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
892 static 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
918 int 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 }
939 EXPORT_SYMBOL(reg_query_regdb_wmm);
940
941 static 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
997 static 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
1017 static 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
1061 static 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
1077 int 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
1109 static 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
1120 bool 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
1130 static 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
1146 static unsigned int
1147 reg_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
1196 unsigned 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
1218 static 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
1238 static 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
1273 static 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
1297 static enum nl80211_dfs_regions
1298 reg_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
1306 static 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
1320 static 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
1419 static 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
1446 static 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
1482 static struct ieee80211_regdomain *
1483 regdom_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
1551 static 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
1575 static const struct ieee80211_reg_rule *
1576 freq_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
1613 static 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
1629 const 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 }
1634 EXPORT_SYMBOL(freq_reg_info);
1635
1636 const 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 }
1652 EXPORT_SYMBOL(reg_initiator_name);
1653
1654 static 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
1696 static 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
1803 static 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
1816 static 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
1823 bool 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
1830 static enum reg_request_treatment
1831 reg_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
1846 static bool reg_dev_ignore_cell_hint(struct wiphy *wiphy)
1847 {
1848 return !(wiphy->features & NL80211_FEATURE_CELL_BASE_REG_HINTS);
1849 }
1850 #else
1851 static enum reg_request_treatment
1852 reg_ignore_cell_hint(struct regulatory_request *pending_request)
1853 {
1854 return REG_REQ_IGNORE;
1855 }
1856
1857 static bool reg_dev_ignore_cell_hint(struct wiphy *wiphy)
1858 {
1859 return true;
1860 }
1861 #endif
1862
1863 static 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
1871 static 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
1910 static 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
1926 static 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
1966 static 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
1984 static 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
2000 static 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
2011 static 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
2023 static 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
2079 static 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
2091 static 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
2102 static 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
2109 static 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
2174 wdev_inactive_unlock:
2175 wdev_unlock(wdev);
2176 return true;
2177 }
2178
2179 static 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
2191 static 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
2206 static 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
2217 static 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
2247 static 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
2262 static void handle_channel_custom(struct wiphy *wiphy,
2263 struct ieee80211_channel *chan,
2264 const struct ieee80211_regdomain *regd,
2265 u32 min_bw)
2266 {
2267 u32 bw_flags = 0;
2268 const struct ieee80211_reg_rule *reg_rule = NULL;
2269 const struct ieee80211_power_rule *power_rule = NULL;
2270 u32 bw;
2271
2272 for (bw = MHZ_TO_KHZ(20); bw >= min_bw; bw = bw / 2) {
2273 reg_rule = freq_reg_info_regd(MHZ_TO_KHZ(chan->center_freq),
2274 regd, bw);
2275 if (!IS_ERR(reg_rule))
2276 break;
2277 }
2278
2279 if (IS_ERR_OR_NULL(reg_rule)) {
2280 pr_debug("Disabling freq %d MHz as custom regd has no rule that fits it\n",
2281 chan->center_freq);
2282 if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) {
2283 chan->flags |= IEEE80211_CHAN_DISABLED;
2284 } else {
2285 chan->orig_flags |= IEEE80211_CHAN_DISABLED;
2286 chan->flags = chan->orig_flags;
2287 }
2288 return;
2289 }
2290
2291 power_rule = ®_rule->power_rule;
2292 bw_flags = reg_rule_to_chan_bw_flags(regd, reg_rule, chan);
2293
2294 chan->dfs_state_entered = jiffies;
2295 chan->dfs_state = NL80211_DFS_USABLE;
2296
2297 chan->beacon_found = false;
2298
2299 if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED)
2300 chan->flags = chan->orig_flags | bw_flags |
2301 map_regdom_flags(reg_rule->flags);
2302 else
2303 chan->flags |= map_regdom_flags(reg_rule->flags) | bw_flags;
2304
2305 chan->max_antenna_gain = (int) MBI_TO_DBI(power_rule->max_antenna_gain);
2306 chan->max_reg_power = chan->max_power =
2307 (int) MBM_TO_DBM(power_rule->max_eirp);
2308
2309 if (chan->flags & IEEE80211_CHAN_RADAR) {
2310 if (reg_rule->dfs_cac_ms)
2311 chan->dfs_cac_ms = reg_rule->dfs_cac_ms;
2312 else
2313 chan->dfs_cac_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
2314 }
2315
2316 chan->max_power = chan->max_reg_power;
2317 }
2318
2319 static void handle_band_custom(struct wiphy *wiphy,
2320 struct ieee80211_supported_band *sband,
2321 const struct ieee80211_regdomain *regd)
2322 {
2323 unsigned int i;
2324
2325 if (!sband)
2326 return;
2327
2328
2329
2330
2331
2332
2333 for (i = 0; i < sband->n_channels; i++)
2334 handle_channel_custom(wiphy, &sband->channels[i], regd,
2335 MHZ_TO_KHZ(20));
2336 }
2337
2338
2339 void wiphy_apply_custom_regulatory(struct wiphy *wiphy,
2340 const struct ieee80211_regdomain *regd)
2341 {
2342 enum nl80211_band band;
2343 unsigned int bands_set = 0;
2344
2345 WARN(!(wiphy->regulatory_flags & REGULATORY_CUSTOM_REG),
2346 "wiphy should have REGULATORY_CUSTOM_REG\n");
2347 wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG;
2348
2349 for (band = 0; band < NUM_NL80211_BANDS; band++) {
2350 if (!wiphy->bands[band])
2351 continue;
2352 handle_band_custom(wiphy, wiphy->bands[band], regd);
2353 bands_set++;
2354 }
2355
2356
2357
2358
2359
2360 WARN_ON(!bands_set);
2361 }
2362 EXPORT_SYMBOL(wiphy_apply_custom_regulatory);
2363
2364 static void reg_set_request_processed(void)
2365 {
2366 bool need_more_processing = false;
2367 struct regulatory_request *lr = get_last_request();
2368
2369 lr->processed = true;
2370
2371 spin_lock(®_requests_lock);
2372 if (!list_empty(®_requests_list))
2373 need_more_processing = true;
2374 spin_unlock(®_requests_lock);
2375
2376 cancel_crda_timeout();
2377
2378 if (need_more_processing)
2379 schedule_work(®_work);
2380 }
2381
2382
2383
2384
2385
2386
2387
2388
2389 static enum reg_request_treatment
2390 reg_process_hint_core(struct regulatory_request *core_request)
2391 {
2392 if (reg_query_database(core_request)) {
2393 core_request->intersect = false;
2394 core_request->processed = false;
2395 reg_update_last_request(core_request);
2396 return REG_REQ_OK;
2397 }
2398
2399 return REG_REQ_IGNORE;
2400 }
2401
2402 static enum reg_request_treatment
2403 __reg_process_hint_user(struct regulatory_request *user_request)
2404 {
2405 struct regulatory_request *lr = get_last_request();
2406
2407 if (reg_request_cell_base(user_request))
2408 return reg_ignore_cell_hint(user_request);
2409
2410 if (reg_request_cell_base(lr))
2411 return REG_REQ_IGNORE;
2412
2413 if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE)
2414 return REG_REQ_INTERSECT;
2415
2416
2417
2418
2419 if (lr->initiator == NL80211_REGDOM_SET_BY_USER &&
2420 lr->intersect)
2421 return REG_REQ_IGNORE;
2422
2423
2424
2425
2426 if ((lr->initiator == NL80211_REGDOM_SET_BY_CORE ||
2427 lr->initiator == NL80211_REGDOM_SET_BY_DRIVER ||
2428 lr->initiator == NL80211_REGDOM_SET_BY_USER) &&
2429 regdom_changes(lr->alpha2))
2430 return REG_REQ_IGNORE;
2431
2432 if (!regdom_changes(user_request->alpha2))
2433 return REG_REQ_ALREADY_SET;
2434
2435 return REG_REQ_OK;
2436 }
2437
2438
2439
2440
2441
2442
2443
2444
2445 static enum reg_request_treatment
2446 reg_process_hint_user(struct regulatory_request *user_request)
2447 {
2448 enum reg_request_treatment treatment;
2449
2450 treatment = __reg_process_hint_user(user_request);
2451 if (treatment == REG_REQ_IGNORE ||
2452 treatment == REG_REQ_ALREADY_SET)
2453 return REG_REQ_IGNORE;
2454
2455 user_request->intersect = treatment == REG_REQ_INTERSECT;
2456 user_request->processed = false;
2457
2458 if (reg_query_database(user_request)) {
2459 reg_update_last_request(user_request);
2460 user_alpha2[0] = user_request->alpha2[0];
2461 user_alpha2[1] = user_request->alpha2[1];
2462 return REG_REQ_OK;
2463 }
2464
2465 return REG_REQ_IGNORE;
2466 }
2467
2468 static enum reg_request_treatment
2469 __reg_process_hint_driver(struct regulatory_request *driver_request)
2470 {
2471 struct regulatory_request *lr = get_last_request();
2472
2473 if (lr->initiator == NL80211_REGDOM_SET_BY_CORE) {
2474 if (regdom_changes(driver_request->alpha2))
2475 return REG_REQ_OK;
2476 return REG_REQ_ALREADY_SET;
2477 }
2478
2479
2480
2481
2482
2483
2484 if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
2485 !regdom_changes(driver_request->alpha2))
2486 return REG_REQ_ALREADY_SET;
2487
2488 return REG_REQ_INTERSECT;
2489 }
2490
2491
2492
2493
2494
2495
2496
2497
2498
2499
2500 static enum reg_request_treatment
2501 reg_process_hint_driver(struct wiphy *wiphy,
2502 struct regulatory_request *driver_request)
2503 {
2504 const struct ieee80211_regdomain *regd, *tmp;
2505 enum reg_request_treatment treatment;
2506
2507 treatment = __reg_process_hint_driver(driver_request);
2508
2509 switch (treatment) {
2510 case REG_REQ_OK:
2511 break;
2512 case REG_REQ_IGNORE:
2513 return REG_REQ_IGNORE;
2514 case REG_REQ_INTERSECT:
2515 case REG_REQ_ALREADY_SET:
2516 regd = reg_copy_regd(get_cfg80211_regdom());
2517 if (IS_ERR(regd))
2518 return REG_REQ_IGNORE;
2519
2520 tmp = get_wiphy_regdom(wiphy);
2521 rcu_assign_pointer(wiphy->regd, regd);
2522 rcu_free_regdom(tmp);
2523 }
2524
2525
2526 driver_request->intersect = treatment == REG_REQ_INTERSECT;
2527 driver_request->processed = false;
2528
2529
2530
2531
2532
2533
2534 if (treatment == REG_REQ_ALREADY_SET) {
2535 nl80211_send_reg_change_event(driver_request);
2536 reg_update_last_request(driver_request);
2537 reg_set_request_processed();
2538 return REG_REQ_ALREADY_SET;
2539 }
2540
2541 if (reg_query_database(driver_request)) {
2542 reg_update_last_request(driver_request);
2543 return REG_REQ_OK;
2544 }
2545
2546 return REG_REQ_IGNORE;
2547 }
2548
2549 static enum reg_request_treatment
2550 __reg_process_hint_country_ie(struct wiphy *wiphy,
2551 struct regulatory_request *country_ie_request)
2552 {
2553 struct wiphy *last_wiphy = NULL;
2554 struct regulatory_request *lr = get_last_request();
2555
2556 if (reg_request_cell_base(lr)) {
2557
2558 if (regdom_changes(country_ie_request->alpha2))
2559 return REG_REQ_IGNORE;
2560 return REG_REQ_ALREADY_SET;
2561 } else {
2562 if (wiphy->regulatory_flags & REGULATORY_COUNTRY_IE_IGNORE)
2563 return REG_REQ_IGNORE;
2564 }
2565
2566 if (unlikely(!is_an_alpha2(country_ie_request->alpha2)))
2567 return -EINVAL;
2568
2569 if (lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE)
2570 return REG_REQ_OK;
2571
2572 last_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx);
2573
2574 if (last_wiphy != wiphy) {
2575
2576
2577
2578
2579
2580
2581 if (regdom_changes(country_ie_request->alpha2))
2582 return REG_REQ_IGNORE;
2583 return REG_REQ_ALREADY_SET;
2584 }
2585
2586 if (regdom_changes(country_ie_request->alpha2))
2587 return REG_REQ_OK;
2588 return REG_REQ_ALREADY_SET;
2589 }
2590
2591
2592
2593
2594
2595
2596
2597
2598
2599
2600 static enum reg_request_treatment
2601 reg_process_hint_country_ie(struct wiphy *wiphy,
2602 struct regulatory_request *country_ie_request)
2603 {
2604 enum reg_request_treatment treatment;
2605
2606 treatment = __reg_process_hint_country_ie(wiphy, country_ie_request);
2607
2608 switch (treatment) {
2609 case REG_REQ_OK:
2610 break;
2611 case REG_REQ_IGNORE:
2612 return REG_REQ_IGNORE;
2613 case REG_REQ_ALREADY_SET:
2614 reg_free_request(country_ie_request);
2615 return REG_REQ_ALREADY_SET;
2616 case REG_REQ_INTERSECT:
2617
2618
2619
2620
2621 WARN_ONCE(1, "Unexpected intersection for country elements");
2622 return REG_REQ_IGNORE;
2623 }
2624
2625 country_ie_request->intersect = false;
2626 country_ie_request->processed = false;
2627
2628 if (reg_query_database(country_ie_request)) {
2629 reg_update_last_request(country_ie_request);
2630 return REG_REQ_OK;
2631 }
2632
2633 return REG_REQ_IGNORE;
2634 }
2635
2636 bool reg_dfs_domain_same(struct wiphy *wiphy1, struct wiphy *wiphy2)
2637 {
2638 const struct ieee80211_regdomain *wiphy1_regd = NULL;
2639 const struct ieee80211_regdomain *wiphy2_regd = NULL;
2640 const struct ieee80211_regdomain *cfg80211_regd = NULL;
2641 bool dfs_domain_same;
2642
2643 rcu_read_lock();
2644
2645 cfg80211_regd = rcu_dereference(cfg80211_regdomain);
2646 wiphy1_regd = rcu_dereference(wiphy1->regd);
2647 if (!wiphy1_regd)
2648 wiphy1_regd = cfg80211_regd;
2649
2650 wiphy2_regd = rcu_dereference(wiphy2->regd);
2651 if (!wiphy2_regd)
2652 wiphy2_regd = cfg80211_regd;
2653
2654 dfs_domain_same = wiphy1_regd->dfs_region == wiphy2_regd->dfs_region;
2655
2656 rcu_read_unlock();
2657
2658 return dfs_domain_same;
2659 }
2660
2661 static void reg_copy_dfs_chan_state(struct ieee80211_channel *dst_chan,
2662 struct ieee80211_channel *src_chan)
2663 {
2664 if (!(dst_chan->flags & IEEE80211_CHAN_RADAR) ||
2665 !(src_chan->flags & IEEE80211_CHAN_RADAR))
2666 return;
2667
2668 if (dst_chan->flags & IEEE80211_CHAN_DISABLED ||
2669 src_chan->flags & IEEE80211_CHAN_DISABLED)
2670 return;
2671
2672 if (src_chan->center_freq == dst_chan->center_freq &&
2673 dst_chan->dfs_state == NL80211_DFS_USABLE) {
2674 dst_chan->dfs_state = src_chan->dfs_state;
2675 dst_chan->dfs_state_entered = src_chan->dfs_state_entered;
2676 }
2677 }
2678
2679 static void wiphy_share_dfs_chan_state(struct wiphy *dst_wiphy,
2680 struct wiphy *src_wiphy)
2681 {
2682 struct ieee80211_supported_band *src_sband, *dst_sband;
2683 struct ieee80211_channel *src_chan, *dst_chan;
2684 int i, j, band;
2685
2686 if (!reg_dfs_domain_same(dst_wiphy, src_wiphy))
2687 return;
2688
2689 for (band = 0; band < NUM_NL80211_BANDS; band++) {
2690 dst_sband = dst_wiphy->bands[band];
2691 src_sband = src_wiphy->bands[band];
2692 if (!dst_sband || !src_sband)
2693 continue;
2694
2695 for (i = 0; i < dst_sband->n_channels; i++) {
2696 dst_chan = &dst_sband->channels[i];
2697 for (j = 0; j < src_sband->n_channels; j++) {
2698 src_chan = &src_sband->channels[j];
2699 reg_copy_dfs_chan_state(dst_chan, src_chan);
2700 }
2701 }
2702 }
2703 }
2704
2705 static void wiphy_all_share_dfs_chan_state(struct wiphy *wiphy)
2706 {
2707 struct cfg80211_registered_device *rdev;
2708
2709 ASSERT_RTNL();
2710
2711 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
2712 if (wiphy == &rdev->wiphy)
2713 continue;
2714 wiphy_share_dfs_chan_state(wiphy, &rdev->wiphy);
2715 }
2716 }
2717
2718
2719 static void reg_process_hint(struct regulatory_request *reg_request)
2720 {
2721 struct wiphy *wiphy = NULL;
2722 enum reg_request_treatment treatment;
2723 enum nl80211_reg_initiator initiator = reg_request->initiator;
2724
2725 if (reg_request->wiphy_idx != WIPHY_IDX_INVALID)
2726 wiphy = wiphy_idx_to_wiphy(reg_request->wiphy_idx);
2727
2728 switch (initiator) {
2729 case NL80211_REGDOM_SET_BY_CORE:
2730 treatment = reg_process_hint_core(reg_request);
2731 break;
2732 case NL80211_REGDOM_SET_BY_USER:
2733 treatment = reg_process_hint_user(reg_request);
2734 break;
2735 case NL80211_REGDOM_SET_BY_DRIVER:
2736 if (!wiphy)
2737 goto out_free;
2738 treatment = reg_process_hint_driver(wiphy, reg_request);
2739 break;
2740 case NL80211_REGDOM_SET_BY_COUNTRY_IE:
2741 if (!wiphy)
2742 goto out_free;
2743 treatment = reg_process_hint_country_ie(wiphy, reg_request);
2744 break;
2745 default:
2746 WARN(1, "invalid initiator %d\n", initiator);
2747 goto out_free;
2748 }
2749
2750 if (treatment == REG_REQ_IGNORE)
2751 goto out_free;
2752
2753 WARN(treatment != REG_REQ_OK && treatment != REG_REQ_ALREADY_SET,
2754 "unexpected treatment value %d\n", treatment);
2755
2756
2757
2758
2759 if (treatment == REG_REQ_ALREADY_SET && wiphy &&
2760 wiphy->regulatory_flags & REGULATORY_STRICT_REG) {
2761 wiphy_update_regulatory(wiphy, initiator);
2762 wiphy_all_share_dfs_chan_state(wiphy);
2763 reg_check_channels();
2764 }
2765
2766 return;
2767
2768 out_free:
2769 reg_free_request(reg_request);
2770 }
2771
2772 static void notify_self_managed_wiphys(struct regulatory_request *request)
2773 {
2774 struct cfg80211_registered_device *rdev;
2775 struct wiphy *wiphy;
2776
2777 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
2778 wiphy = &rdev->wiphy;
2779 if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
2780 request->initiator == NL80211_REGDOM_SET_BY_USER)
2781 reg_call_notifier(wiphy, request);
2782 }
2783 }
2784
2785
2786
2787
2788
2789
2790 static void reg_process_pending_hints(void)
2791 {
2792 struct regulatory_request *reg_request, *lr;
2793
2794 lr = get_last_request();
2795
2796
2797 if (lr && !lr->processed) {
2798 pr_debug("Pending regulatory request, waiting for it to be processed...\n");
2799 return;
2800 }
2801
2802 spin_lock(®_requests_lock);
2803
2804 if (list_empty(®_requests_list)) {
2805 spin_unlock(®_requests_lock);
2806 return;
2807 }
2808
2809 reg_request = list_first_entry(®_requests_list,
2810 struct regulatory_request,
2811 list);
2812 list_del_init(®_request->list);
2813
2814 spin_unlock(®_requests_lock);
2815
2816 notify_self_managed_wiphys(reg_request);
2817
2818 reg_process_hint(reg_request);
2819
2820 lr = get_last_request();
2821
2822 spin_lock(®_requests_lock);
2823 if (!list_empty(®_requests_list) && lr && lr->processed)
2824 schedule_work(®_work);
2825 spin_unlock(®_requests_lock);
2826 }
2827
2828
2829 static void reg_process_pending_beacon_hints(void)
2830 {
2831 struct cfg80211_registered_device *rdev;
2832 struct reg_beacon *pending_beacon, *tmp;
2833
2834
2835 spin_lock_bh(®_pending_beacons_lock);
2836
2837 list_for_each_entry_safe(pending_beacon, tmp,
2838 ®_pending_beacons, list) {
2839 list_del_init(&pending_beacon->list);
2840
2841
2842 list_for_each_entry(rdev, &cfg80211_rdev_list, list)
2843 wiphy_update_new_beacon(&rdev->wiphy, pending_beacon);
2844
2845
2846 list_add_tail(&pending_beacon->list, ®_beacon_list);
2847 }
2848
2849 spin_unlock_bh(®_pending_beacons_lock);
2850 }
2851
2852 static void reg_process_self_managed_hints(void)
2853 {
2854 struct cfg80211_registered_device *rdev;
2855 struct wiphy *wiphy;
2856 const struct ieee80211_regdomain *tmp;
2857 const struct ieee80211_regdomain *regd;
2858 enum nl80211_band band;
2859 struct regulatory_request request = {};
2860
2861 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
2862 wiphy = &rdev->wiphy;
2863
2864 spin_lock(®_requests_lock);
2865 regd = rdev->requested_regd;
2866 rdev->requested_regd = NULL;
2867 spin_unlock(®_requests_lock);
2868
2869 if (regd == NULL)
2870 continue;
2871
2872 tmp = get_wiphy_regdom(wiphy);
2873 rcu_assign_pointer(wiphy->regd, regd);
2874 rcu_free_regdom(tmp);
2875
2876 for (band = 0; band < NUM_NL80211_BANDS; band++)
2877 handle_band_custom(wiphy, wiphy->bands[band], regd);
2878
2879 reg_process_ht_flags(wiphy);
2880
2881 request.wiphy_idx = get_wiphy_idx(wiphy);
2882 request.alpha2[0] = regd->alpha2[0];
2883 request.alpha2[1] = regd->alpha2[1];
2884 request.initiator = NL80211_REGDOM_SET_BY_DRIVER;
2885
2886 nl80211_send_wiphy_reg_change_event(&request);
2887 }
2888
2889 reg_check_channels();
2890 }
2891
2892 static void reg_todo(struct work_struct *work)
2893 {
2894 rtnl_lock();
2895 reg_process_pending_hints();
2896 reg_process_pending_beacon_hints();
2897 reg_process_self_managed_hints();
2898 rtnl_unlock();
2899 }
2900
2901 static void queue_regulatory_request(struct regulatory_request *request)
2902 {
2903 request->alpha2[0] = toupper(request->alpha2[0]);
2904 request->alpha2[1] = toupper(request->alpha2[1]);
2905
2906 spin_lock(®_requests_lock);
2907 list_add_tail(&request->list, ®_requests_list);
2908 spin_unlock(®_requests_lock);
2909
2910 schedule_work(®_work);
2911 }
2912
2913
2914
2915
2916
2917 static int regulatory_hint_core(const char *alpha2)
2918 {
2919 struct regulatory_request *request;
2920
2921 request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
2922 if (!request)
2923 return -ENOMEM;
2924
2925 request->alpha2[0] = alpha2[0];
2926 request->alpha2[1] = alpha2[1];
2927 request->initiator = NL80211_REGDOM_SET_BY_CORE;
2928 request->wiphy_idx = WIPHY_IDX_INVALID;
2929
2930 queue_regulatory_request(request);
2931
2932 return 0;
2933 }
2934
2935
2936 int regulatory_hint_user(const char *alpha2,
2937 enum nl80211_user_reg_hint_type user_reg_hint_type)
2938 {
2939 struct regulatory_request *request;
2940
2941 if (WARN_ON(!alpha2))
2942 return -EINVAL;
2943
2944 request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
2945 if (!request)
2946 return -ENOMEM;
2947
2948 request->wiphy_idx = WIPHY_IDX_INVALID;
2949 request->alpha2[0] = alpha2[0];
2950 request->alpha2[1] = alpha2[1];
2951 request->initiator = NL80211_REGDOM_SET_BY_USER;
2952 request->user_reg_hint_type = user_reg_hint_type;
2953
2954
2955 reset_crda_timeouts();
2956
2957 queue_regulatory_request(request);
2958
2959 return 0;
2960 }
2961
2962 int regulatory_hint_indoor(bool is_indoor, u32 portid)
2963 {
2964 spin_lock(®_indoor_lock);
2965
2966
2967
2968
2969
2970
2971
2972
2973 reg_is_indoor = is_indoor;
2974 if (reg_is_indoor) {
2975 if (!reg_is_indoor_portid)
2976 reg_is_indoor_portid = portid;
2977 } else {
2978 reg_is_indoor_portid = 0;
2979 }
2980
2981 spin_unlock(®_indoor_lock);
2982
2983 if (!is_indoor)
2984 reg_check_channels();
2985
2986 return 0;
2987 }
2988
2989 void regulatory_netlink_notify(u32 portid)
2990 {
2991 spin_lock(®_indoor_lock);
2992
2993 if (reg_is_indoor_portid != portid) {
2994 spin_unlock(®_indoor_lock);
2995 return;
2996 }
2997
2998 reg_is_indoor = false;
2999 reg_is_indoor_portid = 0;
3000
3001 spin_unlock(®_indoor_lock);
3002
3003 reg_check_channels();
3004 }
3005
3006
3007 int regulatory_hint(struct wiphy *wiphy, const char *alpha2)
3008 {
3009 struct regulatory_request *request;
3010
3011 if (WARN_ON(!alpha2 || !wiphy))
3012 return -EINVAL;
3013
3014 wiphy->regulatory_flags &= ~REGULATORY_CUSTOM_REG;
3015
3016 request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
3017 if (!request)
3018 return -ENOMEM;
3019
3020 request->wiphy_idx = get_wiphy_idx(wiphy);
3021
3022 request->alpha2[0] = alpha2[0];
3023 request->alpha2[1] = alpha2[1];
3024 request->initiator = NL80211_REGDOM_SET_BY_DRIVER;
3025
3026
3027 reset_crda_timeouts();
3028
3029 queue_regulatory_request(request);
3030
3031 return 0;
3032 }
3033 EXPORT_SYMBOL(regulatory_hint);
3034
3035 void regulatory_hint_country_ie(struct wiphy *wiphy, enum nl80211_band band,
3036 const u8 *country_ie, u8 country_ie_len)
3037 {
3038 char alpha2[2];
3039 enum environment_cap env = ENVIRON_ANY;
3040 struct regulatory_request *request = NULL, *lr;
3041
3042
3043 if (country_ie_len & 0x01)
3044 return;
3045
3046 if (country_ie_len < IEEE80211_COUNTRY_IE_MIN_LEN)
3047 return;
3048
3049 request = kzalloc(sizeof(*request), GFP_KERNEL);
3050 if (!request)
3051 return;
3052
3053 alpha2[0] = country_ie[0];
3054 alpha2[1] = country_ie[1];
3055
3056 if (country_ie[2] == 'I')
3057 env = ENVIRON_INDOOR;
3058 else if (country_ie[2] == 'O')
3059 env = ENVIRON_OUTDOOR;
3060
3061 rcu_read_lock();
3062 lr = get_last_request();
3063
3064 if (unlikely(!lr))
3065 goto out;
3066
3067
3068
3069
3070
3071
3072 if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
3073 lr->wiphy_idx != WIPHY_IDX_INVALID)
3074 goto out;
3075
3076 request->wiphy_idx = get_wiphy_idx(wiphy);
3077 request->alpha2[0] = alpha2[0];
3078 request->alpha2[1] = alpha2[1];
3079 request->initiator = NL80211_REGDOM_SET_BY_COUNTRY_IE;
3080 request->country_ie_env = env;
3081
3082
3083 reset_crda_timeouts();
3084
3085 queue_regulatory_request(request);
3086 request = NULL;
3087 out:
3088 kfree(request);
3089 rcu_read_unlock();
3090 }
3091
3092 static void restore_alpha2(char *alpha2, bool reset_user)
3093 {
3094
3095 alpha2[0] = '9';
3096 alpha2[1] = '7';
3097
3098
3099 if (is_user_regdom_saved()) {
3100
3101 if (reset_user) {
3102 pr_debug("Restoring regulatory settings including user preference\n");
3103 user_alpha2[0] = '9';
3104 user_alpha2[1] = '7';
3105
3106
3107
3108
3109
3110
3111 if (!is_world_regdom(ieee80211_regdom)) {
3112 pr_debug("Keeping preference on module parameter ieee80211_regdom: %c%c\n",
3113 ieee80211_regdom[0], ieee80211_regdom[1]);
3114 alpha2[0] = ieee80211_regdom[0];
3115 alpha2[1] = ieee80211_regdom[1];
3116 }
3117 } else {
3118 pr_debug("Restoring regulatory settings while preserving user preference for: %c%c\n",
3119 user_alpha2[0], user_alpha2[1]);
3120 alpha2[0] = user_alpha2[0];
3121 alpha2[1] = user_alpha2[1];
3122 }
3123 } else if (!is_world_regdom(ieee80211_regdom)) {
3124 pr_debug("Keeping preference on module parameter ieee80211_regdom: %c%c\n",
3125 ieee80211_regdom[0], ieee80211_regdom[1]);
3126 alpha2[0] = ieee80211_regdom[0];
3127 alpha2[1] = ieee80211_regdom[1];
3128 } else
3129 pr_debug("Restoring regulatory settings\n");
3130 }
3131
3132 static void restore_custom_reg_settings(struct wiphy *wiphy)
3133 {
3134 struct ieee80211_supported_band *sband;
3135 enum nl80211_band band;
3136 struct ieee80211_channel *chan;
3137 int i;
3138
3139 for (band = 0; band < NUM_NL80211_BANDS; band++) {
3140 sband = wiphy->bands[band];
3141 if (!sband)
3142 continue;
3143 for (i = 0; i < sband->n_channels; i++) {
3144 chan = &sband->channels[i];
3145 chan->flags = chan->orig_flags;
3146 chan->max_antenna_gain = chan->orig_mag;
3147 chan->max_power = chan->orig_mpwr;
3148 chan->beacon_found = false;
3149 }
3150 }
3151 }
3152
3153
3154
3155
3156
3157
3158
3159
3160
3161
3162
3163
3164
3165
3166
3167
3168 static void restore_regulatory_settings(bool reset_user, bool cached)
3169 {
3170 char alpha2[2];
3171 char world_alpha2[2];
3172 struct reg_beacon *reg_beacon, *btmp;
3173 LIST_HEAD(tmp_reg_req_list);
3174 struct cfg80211_registered_device *rdev;
3175
3176 ASSERT_RTNL();
3177
3178
3179
3180
3181
3182
3183 spin_lock(®_indoor_lock);
3184 if (reg_is_indoor && !reg_is_indoor_portid) {
3185 reg_is_indoor = false;
3186 reg_check_channels();
3187 }
3188 spin_unlock(®_indoor_lock);
3189
3190 reset_regdomains(true, &world_regdom);
3191 restore_alpha2(alpha2, reset_user);
3192
3193
3194
3195
3196
3197
3198
3199 spin_lock(®_requests_lock);
3200 list_splice_tail_init(®_requests_list, &tmp_reg_req_list);
3201 spin_unlock(®_requests_lock);
3202
3203
3204 spin_lock_bh(®_pending_beacons_lock);
3205 list_for_each_entry_safe(reg_beacon, btmp, ®_pending_beacons, list) {
3206 list_del(®_beacon->list);
3207 kfree(reg_beacon);
3208 }
3209 spin_unlock_bh(®_pending_beacons_lock);
3210
3211 list_for_each_entry_safe(reg_beacon, btmp, ®_beacon_list, list) {
3212 list_del(®_beacon->list);
3213 kfree(reg_beacon);
3214 }
3215
3216
3217 world_alpha2[0] = cfg80211_world_regdom->alpha2[0];
3218 world_alpha2[1] = cfg80211_world_regdom->alpha2[1];
3219
3220 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
3221 if (rdev->wiphy.regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED)
3222 continue;
3223 if (rdev->wiphy.regulatory_flags & REGULATORY_CUSTOM_REG)
3224 restore_custom_reg_settings(&rdev->wiphy);
3225 }
3226
3227 if (cached && (!is_an_alpha2(alpha2) ||
3228 !IS_ERR_OR_NULL(cfg80211_user_regdom))) {
3229 reset_regdomains(false, cfg80211_world_regdom);
3230 update_all_wiphy_regulatory(NL80211_REGDOM_SET_BY_CORE);
3231 print_regdomain(get_cfg80211_regdom());
3232 nl80211_send_reg_change_event(&core_request_world);
3233 reg_set_request_processed();
3234
3235 if (is_an_alpha2(alpha2) &&
3236 !regulatory_hint_user(alpha2, NL80211_USER_REG_HINT_USER)) {
3237 struct regulatory_request *ureq;
3238
3239 spin_lock(®_requests_lock);
3240 ureq = list_last_entry(®_requests_list,
3241 struct regulatory_request,
3242 list);
3243 list_del(&ureq->list);
3244 spin_unlock(®_requests_lock);
3245
3246 notify_self_managed_wiphys(ureq);
3247 reg_update_last_request(ureq);
3248 set_regdom(reg_copy_regd(cfg80211_user_regdom),
3249 REGD_SOURCE_CACHED);
3250 }
3251 } else {
3252 regulatory_hint_core(world_alpha2);
3253
3254
3255
3256
3257
3258
3259 if (is_an_alpha2(alpha2))
3260 regulatory_hint_user(alpha2, NL80211_USER_REG_HINT_USER);
3261 }
3262
3263 spin_lock(®_requests_lock);
3264 list_splice_tail_init(&tmp_reg_req_list, ®_requests_list);
3265 spin_unlock(®_requests_lock);
3266
3267 pr_debug("Kicking the queue\n");
3268
3269 schedule_work(®_work);
3270 }
3271
3272 static bool is_wiphy_all_set_reg_flag(enum ieee80211_regulatory_flags flag)
3273 {
3274 struct cfg80211_registered_device *rdev;
3275 struct wireless_dev *wdev;
3276
3277 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
3278 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
3279 wdev_lock(wdev);
3280 if (!(wdev->wiphy->regulatory_flags & flag)) {
3281 wdev_unlock(wdev);
3282 return false;
3283 }
3284 wdev_unlock(wdev);
3285 }
3286 }
3287
3288 return true;
3289 }
3290
3291 void regulatory_hint_disconnect(void)
3292 {
3293
3294
3295
3296
3297 if (is_wiphy_all_set_reg_flag(REGULATORY_COUNTRY_IE_IGNORE)) {
3298 struct reg_beacon *reg_beacon, *btmp;
3299
3300 if (is_wiphy_all_set_reg_flag(REGULATORY_DISABLE_BEACON_HINTS))
3301 return;
3302
3303 spin_lock_bh(®_pending_beacons_lock);
3304 list_for_each_entry_safe(reg_beacon, btmp,
3305 ®_pending_beacons, list) {
3306 list_del(®_beacon->list);
3307 kfree(reg_beacon);
3308 }
3309 spin_unlock_bh(®_pending_beacons_lock);
3310
3311 list_for_each_entry_safe(reg_beacon, btmp,
3312 ®_beacon_list, list) {
3313 list_del(®_beacon->list);
3314 kfree(reg_beacon);
3315 }
3316
3317 return;
3318 }
3319
3320 pr_debug("All devices are disconnected, going to restore regulatory settings\n");
3321 restore_regulatory_settings(false, true);
3322 }
3323
3324 static bool freq_is_chan_12_13_14(u32 freq)
3325 {
3326 if (freq == ieee80211_channel_to_frequency(12, NL80211_BAND_2GHZ) ||
3327 freq == ieee80211_channel_to_frequency(13, NL80211_BAND_2GHZ) ||
3328 freq == ieee80211_channel_to_frequency(14, NL80211_BAND_2GHZ))
3329 return true;
3330 return false;
3331 }
3332
3333 static bool pending_reg_beacon(struct ieee80211_channel *beacon_chan)
3334 {
3335 struct reg_beacon *pending_beacon;
3336
3337 list_for_each_entry(pending_beacon, ®_pending_beacons, list)
3338 if (beacon_chan->center_freq ==
3339 pending_beacon->chan.center_freq)
3340 return true;
3341 return false;
3342 }
3343
3344 int regulatory_hint_found_beacon(struct wiphy *wiphy,
3345 struct ieee80211_channel *beacon_chan,
3346 gfp_t gfp)
3347 {
3348 struct reg_beacon *reg_beacon;
3349 bool processing;
3350
3351 if (beacon_chan->beacon_found ||
3352 beacon_chan->flags & IEEE80211_CHAN_RADAR ||
3353 (beacon_chan->band == NL80211_BAND_2GHZ &&
3354 !freq_is_chan_12_13_14(beacon_chan->center_freq)))
3355 return 0;
3356
3357 spin_lock_bh(®_pending_beacons_lock);
3358 processing = pending_reg_beacon(beacon_chan);
3359 spin_unlock_bh(®_pending_beacons_lock);
3360
3361 if (processing)
3362 return 0;
3363
3364 reg_beacon = kzalloc(sizeof(struct reg_beacon), gfp);
3365 if (!reg_beacon)
3366 return -ENOMEM;
3367
3368 pr_debug("Found new beacon on frequency: %d MHz (Ch %d) on %s\n",
3369 beacon_chan->center_freq,
3370 ieee80211_frequency_to_channel(beacon_chan->center_freq),
3371 wiphy_name(wiphy));
3372
3373 memcpy(®_beacon->chan, beacon_chan,
3374 sizeof(struct ieee80211_channel));
3375
3376
3377
3378
3379
3380 spin_lock_bh(®_pending_beacons_lock);
3381 list_add_tail(®_beacon->list, ®_pending_beacons);
3382 spin_unlock_bh(®_pending_beacons_lock);
3383
3384 schedule_work(®_work);
3385
3386 return 0;
3387 }
3388
3389 static void print_rd_rules(const struct ieee80211_regdomain *rd)
3390 {
3391 unsigned int i;
3392 const struct ieee80211_reg_rule *reg_rule = NULL;
3393 const struct ieee80211_freq_range *freq_range = NULL;
3394 const struct ieee80211_power_rule *power_rule = NULL;
3395 char bw[32], cac_time[32];
3396
3397 pr_debug(" (start_freq - end_freq @ bandwidth), (max_antenna_gain, max_eirp), (dfs_cac_time)\n");
3398
3399 for (i = 0; i < rd->n_reg_rules; i++) {
3400 reg_rule = &rd->reg_rules[i];
3401 freq_range = ®_rule->freq_range;
3402 power_rule = ®_rule->power_rule;
3403
3404 if (reg_rule->flags & NL80211_RRF_AUTO_BW)
3405 snprintf(bw, sizeof(bw), "%d KHz, %d KHz AUTO",
3406 freq_range->max_bandwidth_khz,
3407 reg_get_max_bandwidth(rd, reg_rule));
3408 else
3409 snprintf(bw, sizeof(bw), "%d KHz",
3410 freq_range->max_bandwidth_khz);
3411
3412 if (reg_rule->flags & NL80211_RRF_DFS)
3413 scnprintf(cac_time, sizeof(cac_time), "%u s",
3414 reg_rule->dfs_cac_ms/1000);
3415 else
3416 scnprintf(cac_time, sizeof(cac_time), "N/A");
3417
3418
3419
3420
3421
3422
3423 if (power_rule->max_antenna_gain)
3424 pr_debug(" (%d KHz - %d KHz @ %s), (%d mBi, %d mBm), (%s)\n",
3425 freq_range->start_freq_khz,
3426 freq_range->end_freq_khz,
3427 bw,
3428 power_rule->max_antenna_gain,
3429 power_rule->max_eirp,
3430 cac_time);
3431 else
3432 pr_debug(" (%d KHz - %d KHz @ %s), (N/A, %d mBm), (%s)\n",
3433 freq_range->start_freq_khz,
3434 freq_range->end_freq_khz,
3435 bw,
3436 power_rule->max_eirp,
3437 cac_time);
3438 }
3439 }
3440
3441 bool reg_supported_dfs_region(enum nl80211_dfs_regions dfs_region)
3442 {
3443 switch (dfs_region) {
3444 case NL80211_DFS_UNSET:
3445 case NL80211_DFS_FCC:
3446 case NL80211_DFS_ETSI:
3447 case NL80211_DFS_JP:
3448 return true;
3449 default:
3450 pr_debug("Ignoring unknown DFS master region: %d\n", dfs_region);
3451 return false;
3452 }
3453 }
3454
3455 static void print_regdomain(const struct ieee80211_regdomain *rd)
3456 {
3457 struct regulatory_request *lr = get_last_request();
3458
3459 if (is_intersected_alpha2(rd->alpha2)) {
3460 if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE) {
3461 struct cfg80211_registered_device *rdev;
3462 rdev = cfg80211_rdev_by_wiphy_idx(lr->wiphy_idx);
3463 if (rdev) {
3464 pr_debug("Current regulatory domain updated by AP to: %c%c\n",
3465 rdev->country_ie_alpha2[0],
3466 rdev->country_ie_alpha2[1]);
3467 } else
3468 pr_debug("Current regulatory domain intersected:\n");
3469 } else
3470 pr_debug("Current regulatory domain intersected:\n");
3471 } else if (is_world_regdom(rd->alpha2)) {
3472 pr_debug("World regulatory domain updated:\n");
3473 } else {
3474 if (is_unknown_alpha2(rd->alpha2))
3475 pr_debug("Regulatory domain changed to driver built-in settings (unknown country)\n");
3476 else {
3477 if (reg_request_cell_base(lr))
3478 pr_debug("Regulatory domain changed to country: %c%c by Cell Station\n",
3479 rd->alpha2[0], rd->alpha2[1]);
3480 else
3481 pr_debug("Regulatory domain changed to country: %c%c\n",
3482 rd->alpha2[0], rd->alpha2[1]);
3483 }
3484 }
3485
3486 pr_debug(" DFS Master region: %s", reg_dfs_region_str(rd->dfs_region));
3487 print_rd_rules(rd);
3488 }
3489
3490 static void print_regdomain_info(const struct ieee80211_regdomain *rd)
3491 {
3492 pr_debug("Regulatory domain: %c%c\n", rd->alpha2[0], rd->alpha2[1]);
3493 print_rd_rules(rd);
3494 }
3495
3496 static int reg_set_rd_core(const struct ieee80211_regdomain *rd)
3497 {
3498 if (!is_world_regdom(rd->alpha2))
3499 return -EINVAL;
3500 update_world_regdomain(rd);
3501 return 0;
3502 }
3503
3504 static int reg_set_rd_user(const struct ieee80211_regdomain *rd,
3505 struct regulatory_request *user_request)
3506 {
3507 const struct ieee80211_regdomain *intersected_rd = NULL;
3508
3509 if (!regdom_changes(rd->alpha2))
3510 return -EALREADY;
3511
3512 if (!is_valid_rd(rd)) {
3513 pr_err("Invalid regulatory domain detected: %c%c\n",
3514 rd->alpha2[0], rd->alpha2[1]);
3515 print_regdomain_info(rd);
3516 return -EINVAL;
3517 }
3518
3519 if (!user_request->intersect) {
3520 reset_regdomains(false, rd);
3521 return 0;
3522 }
3523
3524 intersected_rd = regdom_intersect(rd, get_cfg80211_regdom());
3525 if (!intersected_rd)
3526 return -EINVAL;
3527
3528 kfree(rd);
3529 rd = NULL;
3530 reset_regdomains(false, intersected_rd);
3531
3532 return 0;
3533 }
3534
3535 static int reg_set_rd_driver(const struct ieee80211_regdomain *rd,
3536 struct regulatory_request *driver_request)
3537 {
3538 const struct ieee80211_regdomain *regd;
3539 const struct ieee80211_regdomain *intersected_rd = NULL;
3540 const struct ieee80211_regdomain *tmp;
3541 struct wiphy *request_wiphy;
3542
3543 if (is_world_regdom(rd->alpha2))
3544 return -EINVAL;
3545
3546 if (!regdom_changes(rd->alpha2))
3547 return -EALREADY;
3548
3549 if (!is_valid_rd(rd)) {
3550 pr_err("Invalid regulatory domain detected: %c%c\n",
3551 rd->alpha2[0], rd->alpha2[1]);
3552 print_regdomain_info(rd);
3553 return -EINVAL;
3554 }
3555
3556 request_wiphy = wiphy_idx_to_wiphy(driver_request->wiphy_idx);
3557 if (!request_wiphy)
3558 return -ENODEV;
3559
3560 if (!driver_request->intersect) {
3561 if (request_wiphy->regd)
3562 return -EALREADY;
3563
3564 regd = reg_copy_regd(rd);
3565 if (IS_ERR(regd))
3566 return PTR_ERR(regd);
3567
3568 rcu_assign_pointer(request_wiphy->regd, regd);
3569 reset_regdomains(false, rd);
3570 return 0;
3571 }
3572
3573 intersected_rd = regdom_intersect(rd, get_cfg80211_regdom());
3574 if (!intersected_rd)
3575 return -EINVAL;
3576
3577
3578
3579
3580
3581
3582 tmp = get_wiphy_regdom(request_wiphy);
3583 rcu_assign_pointer(request_wiphy->regd, rd);
3584 rcu_free_regdom(tmp);
3585
3586 rd = NULL;
3587
3588 reset_regdomains(false, intersected_rd);
3589
3590 return 0;
3591 }
3592
3593 static int reg_set_rd_country_ie(const struct ieee80211_regdomain *rd,
3594 struct regulatory_request *country_ie_request)
3595 {
3596 struct wiphy *request_wiphy;
3597
3598 if (!is_alpha2_set(rd->alpha2) && !is_an_alpha2(rd->alpha2) &&
3599 !is_unknown_alpha2(rd->alpha2))
3600 return -EINVAL;
3601
3602
3603
3604
3605
3606
3607
3608 if (!is_valid_rd(rd)) {
3609 pr_err("Invalid regulatory domain detected: %c%c\n",
3610 rd->alpha2[0], rd->alpha2[1]);
3611 print_regdomain_info(rd);
3612 return -EINVAL;
3613 }
3614
3615 request_wiphy = wiphy_idx_to_wiphy(country_ie_request->wiphy_idx);
3616 if (!request_wiphy)
3617 return -ENODEV;
3618
3619 if (country_ie_request->intersect)
3620 return -EINVAL;
3621
3622 reset_regdomains(false, rd);
3623 return 0;
3624 }
3625
3626
3627
3628
3629
3630
3631 int set_regdom(const struct ieee80211_regdomain *rd,
3632 enum ieee80211_regd_source regd_src)
3633 {
3634 struct regulatory_request *lr;
3635 bool user_reset = false;
3636 int r;
3637
3638 if (IS_ERR_OR_NULL(rd))
3639 return -ENODATA;
3640
3641 if (!reg_is_valid_request(rd->alpha2)) {
3642 kfree(rd);
3643 return -EINVAL;
3644 }
3645
3646 if (regd_src == REGD_SOURCE_CRDA)
3647 reset_crda_timeouts();
3648
3649 lr = get_last_request();
3650
3651
3652 switch (lr->initiator) {
3653 case NL80211_REGDOM_SET_BY_CORE:
3654 r = reg_set_rd_core(rd);
3655 break;
3656 case NL80211_REGDOM_SET_BY_USER:
3657 cfg80211_save_user_regdom(rd);
3658 r = reg_set_rd_user(rd, lr);
3659 user_reset = true;
3660 break;
3661 case NL80211_REGDOM_SET_BY_DRIVER:
3662 r = reg_set_rd_driver(rd, lr);
3663 break;
3664 case NL80211_REGDOM_SET_BY_COUNTRY_IE:
3665 r = reg_set_rd_country_ie(rd, lr);
3666 break;
3667 default:
3668 WARN(1, "invalid initiator %d\n", lr->initiator);
3669 kfree(rd);
3670 return -EINVAL;
3671 }
3672
3673 if (r) {
3674 switch (r) {
3675 case -EALREADY:
3676 reg_set_request_processed();
3677 break;
3678 default:
3679
3680 restore_regulatory_settings(user_reset, false);
3681 }
3682
3683 kfree(rd);
3684 return r;
3685 }
3686
3687
3688 if (WARN_ON(!lr->intersect && rd != get_cfg80211_regdom()))
3689 return -EINVAL;
3690
3691
3692 update_all_wiphy_regulatory(lr->initiator);
3693
3694 print_regdomain(get_cfg80211_regdom());
3695
3696 nl80211_send_reg_change_event(lr);
3697
3698 reg_set_request_processed();
3699
3700 return 0;
3701 }
3702
3703 static int __regulatory_set_wiphy_regd(struct wiphy *wiphy,
3704 struct ieee80211_regdomain *rd)
3705 {
3706 const struct ieee80211_regdomain *regd;
3707 const struct ieee80211_regdomain *prev_regd;
3708 struct cfg80211_registered_device *rdev;
3709
3710 if (WARN_ON(!wiphy || !rd))
3711 return -EINVAL;
3712
3713 if (WARN(!(wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED),
3714 "wiphy should have REGULATORY_WIPHY_SELF_MANAGED\n"))
3715 return -EPERM;
3716
3717 if (WARN(!is_valid_rd(rd), "Invalid regulatory domain detected\n")) {
3718 print_regdomain_info(rd);
3719 return -EINVAL;
3720 }
3721
3722 regd = reg_copy_regd(rd);
3723 if (IS_ERR(regd))
3724 return PTR_ERR(regd);
3725
3726 rdev = wiphy_to_rdev(wiphy);
3727
3728 spin_lock(®_requests_lock);
3729 prev_regd = rdev->requested_regd;
3730 rdev->requested_regd = regd;
3731 spin_unlock(®_requests_lock);
3732
3733 kfree(prev_regd);
3734 return 0;
3735 }
3736
3737 int regulatory_set_wiphy_regd(struct wiphy *wiphy,
3738 struct ieee80211_regdomain *rd)
3739 {
3740 int ret = __regulatory_set_wiphy_regd(wiphy, rd);
3741
3742 if (ret)
3743 return ret;
3744
3745 schedule_work(®_work);
3746 return 0;
3747 }
3748 EXPORT_SYMBOL(regulatory_set_wiphy_regd);
3749
3750 int regulatory_set_wiphy_regd_sync_rtnl(struct wiphy *wiphy,
3751 struct ieee80211_regdomain *rd)
3752 {
3753 int ret;
3754
3755 ASSERT_RTNL();
3756
3757 ret = __regulatory_set_wiphy_regd(wiphy, rd);
3758 if (ret)
3759 return ret;
3760
3761
3762 reg_process_self_managed_hints();
3763 return 0;
3764 }
3765 EXPORT_SYMBOL(regulatory_set_wiphy_regd_sync_rtnl);
3766
3767 void wiphy_regulatory_register(struct wiphy *wiphy)
3768 {
3769 struct regulatory_request *lr = get_last_request();
3770
3771
3772 if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) {
3773 wiphy->regulatory_flags |= REGULATORY_DISABLE_BEACON_HINTS |
3774 REGULATORY_COUNTRY_IE_IGNORE;
3775
3776
3777
3778
3779
3780
3781 if (lr->initiator == NL80211_REGDOM_SET_BY_USER)
3782 reg_call_notifier(wiphy, lr);
3783 }
3784
3785 if (!reg_dev_ignore_cell_hint(wiphy))
3786 reg_num_devs_support_basehint++;
3787
3788 wiphy_update_regulatory(wiphy, lr->initiator);
3789 wiphy_all_share_dfs_chan_state(wiphy);
3790 }
3791
3792 void wiphy_regulatory_deregister(struct wiphy *wiphy)
3793 {
3794 struct wiphy *request_wiphy = NULL;
3795 struct regulatory_request *lr;
3796
3797 lr = get_last_request();
3798
3799 if (!reg_dev_ignore_cell_hint(wiphy))
3800 reg_num_devs_support_basehint--;
3801
3802 rcu_free_regdom(get_wiphy_regdom(wiphy));
3803 RCU_INIT_POINTER(wiphy->regd, NULL);
3804
3805 if (lr)
3806 request_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx);
3807
3808 if (!request_wiphy || request_wiphy != wiphy)
3809 return;
3810
3811 lr->wiphy_idx = WIPHY_IDX_INVALID;
3812 lr->country_ie_env = ENVIRON_ANY;
3813 }
3814
3815
3816
3817
3818
3819
3820 int cfg80211_get_unii(int freq)
3821 {
3822
3823 if (freq >= 5150 && freq <= 5250)
3824 return 0;
3825
3826
3827 if (freq > 5250 && freq <= 5350)
3828 return 1;
3829
3830
3831 if (freq > 5350 && freq <= 5470)
3832 return 2;
3833
3834
3835 if (freq > 5470 && freq <= 5725)
3836 return 3;
3837
3838
3839 if (freq > 5725 && freq <= 5825)
3840 return 4;
3841
3842
3843 if (freq > 5925 && freq <= 6425)
3844 return 5;
3845
3846
3847 if (freq > 6425 && freq <= 6525)
3848 return 6;
3849
3850
3851 if (freq > 6525 && freq <= 6875)
3852 return 7;
3853
3854
3855 if (freq > 6875 && freq <= 7125)
3856 return 8;
3857
3858 return -EINVAL;
3859 }
3860
3861 bool regulatory_indoor_allowed(void)
3862 {
3863 return reg_is_indoor;
3864 }
3865
3866 bool regulatory_pre_cac_allowed(struct wiphy *wiphy)
3867 {
3868 const struct ieee80211_regdomain *regd = NULL;
3869 const struct ieee80211_regdomain *wiphy_regd = NULL;
3870 bool pre_cac_allowed = false;
3871
3872 rcu_read_lock();
3873
3874 regd = rcu_dereference(cfg80211_regdomain);
3875 wiphy_regd = rcu_dereference(wiphy->regd);
3876 if (!wiphy_regd) {
3877 if (regd->dfs_region == NL80211_DFS_ETSI)
3878 pre_cac_allowed = true;
3879
3880 rcu_read_unlock();
3881
3882 return pre_cac_allowed;
3883 }
3884
3885 if (regd->dfs_region == wiphy_regd->dfs_region &&
3886 wiphy_regd->dfs_region == NL80211_DFS_ETSI)
3887 pre_cac_allowed = true;
3888
3889 rcu_read_unlock();
3890
3891 return pre_cac_allowed;
3892 }
3893 EXPORT_SYMBOL(regulatory_pre_cac_allowed);
3894
3895 static void cfg80211_check_and_end_cac(struct cfg80211_registered_device *rdev)
3896 {
3897 struct wireless_dev *wdev;
3898
3899
3900
3901
3902
3903
3904
3905
3906
3907 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
3908 if (wdev->cac_started &&
3909 !cfg80211_chandef_dfs_usable(&rdev->wiphy, &wdev->chandef))
3910 rdev_end_cac(rdev, wdev->netdev);
3911 }
3912 }
3913
3914 void regulatory_propagate_dfs_state(struct wiphy *wiphy,
3915 struct cfg80211_chan_def *chandef,
3916 enum nl80211_dfs_state dfs_state,
3917 enum nl80211_radar_event event)
3918 {
3919 struct cfg80211_registered_device *rdev;
3920
3921 ASSERT_RTNL();
3922
3923 if (WARN_ON(!cfg80211_chandef_valid(chandef)))
3924 return;
3925
3926 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
3927 if (wiphy == &rdev->wiphy)
3928 continue;
3929
3930 if (!reg_dfs_domain_same(wiphy, &rdev->wiphy))
3931 continue;
3932
3933 if (!ieee80211_get_channel(&rdev->wiphy,
3934 chandef->chan->center_freq))
3935 continue;
3936
3937 cfg80211_set_dfs_state(&rdev->wiphy, chandef, dfs_state);
3938
3939 if (event == NL80211_RADAR_DETECTED ||
3940 event == NL80211_RADAR_CAC_FINISHED) {
3941 cfg80211_sched_dfs_chan_update(rdev);
3942 cfg80211_check_and_end_cac(rdev);
3943 }
3944
3945 nl80211_radar_notify(rdev, chandef, event, NULL, GFP_KERNEL);
3946 }
3947 }
3948
3949 static int __init regulatory_init_db(void)
3950 {
3951 int err;
3952
3953
3954
3955
3956
3957
3958
3959 if (IS_ERR_OR_NULL(reg_pdev))
3960 return -EINVAL;
3961
3962 err = load_builtin_regdb_keys();
3963 if (err)
3964 return err;
3965
3966
3967 err = regulatory_hint_core(cfg80211_world_regdom->alpha2);
3968 if (err) {
3969 if (err == -ENOMEM) {
3970 platform_device_unregister(reg_pdev);
3971 return err;
3972 }
3973
3974
3975
3976
3977
3978
3979
3980 pr_err("kobject_uevent_env() was unable to call CRDA during init\n");
3981 }
3982
3983
3984
3985
3986
3987 if (!is_world_regdom(ieee80211_regdom))
3988 regulatory_hint_user(ieee80211_regdom,
3989 NL80211_USER_REG_HINT_USER);
3990
3991 return 0;
3992 }
3993 #ifndef MODULE
3994 late_initcall(regulatory_init_db);
3995 #endif
3996
3997 int __init regulatory_init(void)
3998 {
3999 reg_pdev = platform_device_register_simple("regulatory", 0, NULL, 0);
4000 if (IS_ERR(reg_pdev))
4001 return PTR_ERR(reg_pdev);
4002
4003 spin_lock_init(®_requests_lock);
4004 spin_lock_init(®_pending_beacons_lock);
4005 spin_lock_init(®_indoor_lock);
4006
4007 rcu_assign_pointer(cfg80211_regdomain, cfg80211_world_regdom);
4008
4009 user_alpha2[0] = '9';
4010 user_alpha2[1] = '7';
4011
4012 #ifdef MODULE
4013 return regulatory_init_db();
4014 #else
4015 return 0;
4016 #endif
4017 }
4018
4019 void regulatory_exit(void)
4020 {
4021 struct regulatory_request *reg_request, *tmp;
4022 struct reg_beacon *reg_beacon, *btmp;
4023
4024 cancel_work_sync(®_work);
4025 cancel_crda_timeout_sync();
4026 cancel_delayed_work_sync(®_check_chans);
4027
4028
4029 rtnl_lock();
4030 reset_regdomains(true, NULL);
4031 rtnl_unlock();
4032
4033 dev_set_uevent_suppress(®_pdev->dev, true);
4034
4035 platform_device_unregister(reg_pdev);
4036
4037 list_for_each_entry_safe(reg_beacon, btmp, ®_pending_beacons, list) {
4038 list_del(®_beacon->list);
4039 kfree(reg_beacon);
4040 }
4041
4042 list_for_each_entry_safe(reg_beacon, btmp, ®_beacon_list, list) {
4043 list_del(®_beacon->list);
4044 kfree(reg_beacon);
4045 }
4046
4047 list_for_each_entry_safe(reg_request, tmp, ®_requests_list, list) {
4048 list_del(®_request->list);
4049 kfree(reg_request);
4050 }
4051
4052 if (!IS_ERR_OR_NULL(regdb))
4053 kfree(regdb);
4054 if (!IS_ERR_OR_NULL(cfg80211_user_regdom))
4055 kfree(cfg80211_user_regdom);
4056
4057 free_regdb_keyring();
4058 }