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