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