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	* Copyright 2013-2014 Intel Mobile Communications GmbH
7	* Copyright 2017 Intel Deutschland GmbH
8	* Copyright (C) 2018 - 2024 Intel Corporation
9	*
10	* Permission to use, copy, modify, and/or distribute this software for any
11	* purpose with or without fee is hereby granted, provided that the above
12	* copyright notice and this permission notice appear in all copies.
13	*
14	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
15	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
16	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
17	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
18	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
19	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
20	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
21	*/
22
23
24	/**
25	* DOC: Wireless regulatory infrastructure
26	*
27	* The usual implementation is for a driver to read a device EEPROM to
28	* determine which regulatory domain it should be operating under, then
29	* looking up the allowable channels in a driver-local table and finally
30	* registering those channels in the wiphy structure.
31	*
32	* Another set of compliance enforcement is for drivers to use their
33	* own compliance limits which can be stored on the EEPROM. The host
34	* driver or firmware may ensure these are used.
35	*
36	* In addition to all this we provide an extra layer of regulatory
37	* conformance. For drivers which do not have any regulatory
38	* information CRDA provides the complete regulatory solution.
39	* For others it provides a community effort on further restrictions
40	* to enhance compliance.
41	*
42	* Note: When number of rules --> infinity we will not be able to
43	* index on alpha2 any more, instead we'll probably have to
44	* rely on some SHA1 checksum of the regdomain for example.
45	*
46	*/
47
48	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
49
50	#include <linux/kernel.h>
51	#include <linux/export.h>
52	#include <linux/slab.h>
53	#include <linux/list.h>
54	#include <linux/ctype.h>
55	#include <linux/nl80211.h>
56	#include <linux/platform_device.h>
57	#include <linux/verification.h>
58	#include <linux/moduleparam.h>
59	#include <linux/firmware.h>
60	#include <linux/units.h>
61
62	#include <net/cfg80211.h>
63	#include "core.h"
64	#include "reg.h"
65	#include "rdev-ops.h"
66	#include "nl80211.h"
67
68	/*
69	* Grace period we give before making sure all current interfaces reside on
70	* channels allowed by the current regulatory domain.
71	*/
72	#define REG_ENFORCE_GRACE_MS 60000
73
74	/**
75	* enum reg_request_treatment - regulatory request treatment
76	*
77	* @REG_REQ_OK: continue processing the regulatory request
78	* @REG_REQ_IGNORE: ignore the regulatory request
79	* @REG_REQ_INTERSECT: the regulatory domain resulting from this request should
80	* be intersected with the current one.
81	* @REG_REQ_ALREADY_SET: the regulatory request will not change the current
82	* regulatory settings, and no further processing is required.
83	*/
84	enum reg_request_treatment {
85	REG_REQ_OK,
86	REG_REQ_IGNORE,
87	REG_REQ_INTERSECT,
88	REG_REQ_ALREADY_SET,
89	};
90
91	static struct regulatory_request core_request_world = {
92	.initiator = NL80211_REGDOM_SET_BY_CORE,
93	.alpha2[0] = '0',
94	.alpha2[1] = '0',
95	.intersect = false,
96	.processed = true,
97	.country_ie_env = ENVIRON_ANY,
98	};
99
100	/*
101	* Receipt of information from last regulatory request,
102	* protected by RTNL (and can be accessed with RCU protection)
103	*/
104	static struct regulatory_request __rcu *last_request =
105	(void __force __rcu *)&core_request_world;
106
107	/* To trigger userspace events and load firmware */
108	static struct platform_device *reg_pdev;
109
110	/*
111	* Central wireless core regulatory domains, we only need two,
112	* the current one and a world regulatory domain in case we have no
113	* information to give us an alpha2.
114	* (protected by RTNL, can be read under RCU)
115	*/
116	const struct ieee80211_regdomain __rcu *cfg80211_regdomain;
117
118	/*
119	* Number of devices that registered to the core
120	* that support cellular base station regulatory hints
121	* (protected by RTNL)
122	*/
123	static int reg_num_devs_support_basehint;
124
125	/*
126	* State variable indicating if the platform on which the devices
127	* are attached is operating in an indoor environment. The state variable
128	* is relevant for all registered devices.
129	*/
130	static bool reg_is_indoor;
131	static DEFINE_SPINLOCK(reg_indoor_lock);
132
133	/* Used to track the userspace process controlling the indoor setting */
134	static u32 reg_is_indoor_portid;
135
136	static void restore_regulatory_settings(bool reset_user, bool cached);
137	static void print_regdomain(const struct ieee80211_regdomain *rd);
138	static void reg_process_hint(struct regulatory_request *reg_request);
139
140	static const struct ieee80211_regdomain *get_cfg80211_regdom(void)
141	{
142	return rcu_dereference_rtnl(cfg80211_regdomain);
143	}
144
145	/*
146	* Returns the regulatory domain associated with the wiphy.
147	*
148	* Requires any of RTNL, wiphy mutex or RCU protection.
149	*/
150	const struct ieee80211_regdomain *get_wiphy_regdom(struct wiphy *wiphy)
151	{
152	return rcu_dereference_check(wiphy->regd,
153	lockdep_is_held(&wiphy->mtx) ||
154	lockdep_rtnl_is_held());
155	}
156	EXPORT_SYMBOL(get_wiphy_regdom);
157
158	static const char *reg_dfs_region_str(enum nl80211_dfs_regions dfs_region)
159	{
160	switch (dfs_region) {
161	case NL80211_DFS_UNSET:
162	return "unset";
163	case NL80211_DFS_FCC:
164	return "FCC";
165	case NL80211_DFS_ETSI:
166	return "ETSI";
167	case NL80211_DFS_JP:
168	return "JP";
169	}
170	return "Unknown";
171	}
172
173	enum nl80211_dfs_regions reg_get_dfs_region(struct wiphy *wiphy)
174	{
175	const struct ieee80211_regdomain *regd = NULL;
176	const struct ieee80211_regdomain *wiphy_regd = NULL;
177	enum nl80211_dfs_regions dfs_region;
178
179	rcu_read_lock();
180	regd = get_cfg80211_regdom();
181	dfs_region = regd->dfs_region;
182
183	if (!wiphy)
184	goto out;
185
186	wiphy_regd = get_wiphy_regdom(wiphy);
187	if (!wiphy_regd)
188	goto out;
189
190	if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) {
191	dfs_region = wiphy_regd->dfs_region;
192	goto out;
193	}
194
195	if (wiphy_regd->dfs_region == regd->dfs_region)
196	goto out;
197
198	pr_debug("%s: device specific dfs_region (%s) disagrees with cfg80211's central dfs_region (%s)\n",
199	dev_name(&wiphy->dev),
200	reg_dfs_region_str(wiphy_regd->dfs_region),
201	reg_dfs_region_str(regd->dfs_region));
202
203	out:
204	rcu_read_unlock();
205
206	return dfs_region;
207	}
208
209	static void rcu_free_regdom(const struct ieee80211_regdomain *r)
210	{
211	if (!r)
212	return;
213	kfree_rcu((struct ieee80211_regdomain *)r, rcu_head);
214	}
215
216	static struct regulatory_request *get_last_request(void)
217	{
218	return rcu_dereference_rtnl(last_request);
219	}
220
221	/* Used to queue up regulatory hints */
222	static LIST_HEAD(reg_requests_list);
223	static DEFINE_SPINLOCK(reg_requests_lock);
224
225	/* Used to queue up beacon hints for review */
226	static LIST_HEAD(reg_pending_beacons);
227	static DEFINE_SPINLOCK(reg_pending_beacons_lock);
228
229	/* Used to keep track of processed beacon hints */
230	static LIST_HEAD(reg_beacon_list);
231
232	struct reg_beacon {
233	struct list_head list;
234	struct ieee80211_channel chan;
235	};
236
237	static void reg_check_chans_work(struct work_struct *work);
238	static DECLARE_DELAYED_WORK(reg_check_chans, reg_check_chans_work);
239
240	static void reg_todo(struct work_struct *work);
241	static DECLARE_WORK(reg_work, reg_todo);
242
243	/* We keep a static world regulatory domain in case of the absence of CRDA */
244	static const struct ieee80211_regdomain world_regdom = {
245	.n_reg_rules = 8,
246	.alpha2 = "00",
247	.reg_rules = {
248	/* IEEE 802.11b/g, channels 1..11 */
249	REG_RULE(2412-10, 2462+10, 40, 6, 20, 0),
250	/* IEEE 802.11b/g, channels 12..13. */
251	REG_RULE(2467-10, 2472+10, 20, 6, 20,
252	NL80211_RRF_NO_IR | NL80211_RRF_AUTO_BW),
253	/* IEEE 802.11 channel 14 - Only JP enables
254	* this and for 802.11b only */
255	REG_RULE(2484-10, 2484+10, 20, 6, 20,
256	NL80211_RRF_NO_IR |
257	NL80211_RRF_NO_OFDM),
258	/* IEEE 802.11a, channel 36..48 */
259	REG_RULE(5180-10, 5240+10, 80, 6, 20,
260	NL80211_RRF_NO_IR |
261	NL80211_RRF_AUTO_BW),
262
263	/* IEEE 802.11a, channel 52..64 - DFS required */
264	REG_RULE(5260-10, 5320+10, 80, 6, 20,
265	NL80211_RRF_NO_IR |
266	NL80211_RRF_AUTO_BW |
267	NL80211_RRF_DFS),
268
269	/* IEEE 802.11a, channel 100..144 - DFS required */
270	REG_RULE(5500-10, 5720+10, 160, 6, 20,
271	NL80211_RRF_NO_IR |
272	NL80211_RRF_DFS),
273
274	/* IEEE 802.11a, channel 149..165 */
275	REG_RULE(5745-10, 5825+10, 80, 6, 20,
276	NL80211_RRF_NO_IR),
277
278	/* IEEE 802.11ad (60GHz), channels 1..3 */
279	REG_RULE(56160+2160*1-1080, 56160+2160*3+1080, 2160, 0, 0, 0),
280	}
281	};
282
283	/* protected by RTNL */
284	static const struct ieee80211_regdomain *cfg80211_world_regdom =
285	&world_regdom;
286
287	static char *ieee80211_regdom = "00";
288	static char user_alpha2[2];
289	static const struct ieee80211_regdomain *cfg80211_user_regdom;
290
291	module_param(ieee80211_regdom, charp, 0444);
292	MODULE_PARM_DESC(ieee80211_regdom, "IEEE 802.11 regulatory domain code");
293
294	static void reg_free_request(struct regulatory_request *request)
295	{
296	if (request == &core_request_world)
297	return;
298
299	if (request != get_last_request())
300	kfree(objp: request);
301	}
302
303	static void reg_free_last_request(void)
304	{
305	struct regulatory_request *lr = get_last_request();
306
307	if (lr != &core_request_world && lr)
308	kfree_rcu(lr, rcu_head);
309	}
310
311	static void reg_update_last_request(struct regulatory_request *request)
312	{
313	struct regulatory_request *lr;
314
315	lr = get_last_request();
316	if (lr == request)
317	return;
318
319	reg_free_last_request();
320	rcu_assign_pointer(last_request, request);
321	}
322
323	static void reset_regdomains(bool full_reset,
324	const struct ieee80211_regdomain *new_regdom)
325	{
326	const struct ieee80211_regdomain *r;
327
328	ASSERT_RTNL();
329
330	r = get_cfg80211_regdom();
331
332	/* avoid freeing static information or freeing something twice */
333	if (r == cfg80211_world_regdom)
334	r = NULL;
335	if (cfg80211_world_regdom == &world_regdom)
336	cfg80211_world_regdom = NULL;
337	if (r == &world_regdom)
338	r = NULL;
339
340	rcu_free_regdom(r);
341	rcu_free_regdom(r: cfg80211_world_regdom);
342
343	cfg80211_world_regdom = &world_regdom;
344	rcu_assign_pointer(cfg80211_regdomain, new_regdom);
345
346	if (!full_reset)
347	return;
348
349	reg_update_last_request(request: &core_request_world);
350	}
351
352	/*
353	* Dynamic world regulatory domain requested by the wireless
354	* core upon initialization
355	*/
356	static void update_world_regdomain(const struct ieee80211_regdomain *rd)
357	{
358	struct regulatory_request *lr;
359
360	lr = get_last_request();
361
362	WARN_ON(!lr);
363
364	reset_regdomains(full_reset: false, new_regdom: rd);
365
366	cfg80211_world_regdom = rd;
367	}
368
369	bool is_world_regdom(const char *alpha2)
370	{
371	if (!alpha2)
372	return false;
373	return alpha2[0] == '0' && alpha2[1] == '0';
374	}
375
376	static bool is_alpha2_set(const char *alpha2)
377	{
378	if (!alpha2)
379	return false;
380	return alpha2[0] && alpha2[1];
381	}
382
383	static bool is_unknown_alpha2(const char *alpha2)
384	{
385	if (!alpha2)
386	return false;
387	/*
388	* Special case where regulatory domain was built by driver
389	* but a specific alpha2 cannot be determined
390	*/
391	return alpha2[0] == '9' && alpha2[1] == '9';
392	}
393
394	static bool is_intersected_alpha2(const char *alpha2)
395	{
396	if (!alpha2)
397	return false;
398	/*
399	* Special case where regulatory domain is the
400	* result of an intersection between two regulatory domain
401	* structures
402	*/
403	return alpha2[0] == '9' && alpha2[1] == '8';
404	}
405
406	static bool is_an_alpha2(const char *alpha2)
407	{
408	if (!alpha2)
409	return false;
410	return isalpha(alpha2[0]) && isalpha(alpha2[1]);
411	}
412
413	static bool alpha2_equal(const char *alpha2_x, const char *alpha2_y)
414	{
415	if (!alpha2_x || !alpha2_y)
416	return false;
417	return alpha2_x[0] == alpha2_y[0] && alpha2_x[1] == alpha2_y[1];
418	}
419
420	static bool regdom_changes(const char *alpha2)
421	{
422	const struct ieee80211_regdomain *r = get_cfg80211_regdom();
423
424	if (!r)
425	return true;
426	return !alpha2_equal(alpha2_x: r->alpha2, alpha2_y: alpha2);
427	}
428
429	/*
430	* The NL80211_REGDOM_SET_BY_USER regdom alpha2 is cached, this lets
431	* you know if a valid regulatory hint with NL80211_REGDOM_SET_BY_USER
432	* has ever been issued.
433	*/
434	static bool is_user_regdom_saved(void)
435	{
436	if (user_alpha2[0] == '9' && user_alpha2[1] == '7')
437	return false;
438
439	/* This would indicate a mistake on the design */
440	if (WARN(!is_world_regdom(user_alpha2) && !is_an_alpha2(user_alpha2),
441	"Unexpected user alpha2: %c%c\n",
442	user_alpha2[0], user_alpha2[1]))
443	return false;
444
445	return true;
446	}
447
448	static const struct ieee80211_regdomain *
449	reg_copy_regd(const struct ieee80211_regdomain *src_regd)
450	{
451	struct ieee80211_regdomain *regd;
452	unsigned int i;
453
454	regd = kzalloc(struct_size(regd, reg_rules, src_regd->n_reg_rules),
455	GFP_KERNEL);
456	if (!regd)
457	return ERR_PTR(error: -ENOMEM);
458
459	memcpy(regd, src_regd, sizeof(struct ieee80211_regdomain));
460
461	for (i = 0; i < src_regd->n_reg_rules; i++)
462	memcpy(&regd->reg_rules[i], &src_regd->reg_rules[i],
463	sizeof(struct ieee80211_reg_rule));
464
465	return regd;
466	}
467
468	static void cfg80211_save_user_regdom(const struct ieee80211_regdomain *rd)
469	{
470	ASSERT_RTNL();
471
472	if (!IS_ERR(ptr: cfg80211_user_regdom))
473	kfree(objp: cfg80211_user_regdom);
474	cfg80211_user_regdom = reg_copy_regd(src_regd: rd);
475	}
476
477	struct reg_regdb_apply_request {
478	struct list_head list;
479	const struct ieee80211_regdomain *regdom;
480	};
481
482	static LIST_HEAD(reg_regdb_apply_list);
483	static DEFINE_MUTEX(reg_regdb_apply_mutex);
484
485	static void reg_regdb_apply(struct work_struct *work)
486	{
487	struct reg_regdb_apply_request *request;
488
489	rtnl_lock();
490
491	mutex_lock(&reg_regdb_apply_mutex);
492	while (!list_empty(head: &reg_regdb_apply_list)) {
493	request = list_first_entry(&reg_regdb_apply_list,
494	struct reg_regdb_apply_request,
495	list);
496	list_del(entry: &request->list);
497
498	set_regdom(rd: request->regdom, regd_src: REGD_SOURCE_INTERNAL_DB);
499	kfree(objp: request);
500	}
501	mutex_unlock(lock: &reg_regdb_apply_mutex);
502
503	rtnl_unlock();
504	}
505
506	static DECLARE_WORK(reg_regdb_work, reg_regdb_apply);
507
508	static int reg_schedule_apply(const struct ieee80211_regdomain *regdom)
509	{
510	struct reg_regdb_apply_request *request;
511
512	request = kzalloc(size: sizeof(struct reg_regdb_apply_request), GFP_KERNEL);
513	if (!request) {
514	kfree(objp: regdom);
515	return -ENOMEM;
516	}
517
518	request->regdom = regdom;
519
520	mutex_lock(&reg_regdb_apply_mutex);
521	list_add_tail(new: &request->list, head: &reg_regdb_apply_list);
522	mutex_unlock(lock: &reg_regdb_apply_mutex);
523
524	schedule_work(work: &reg_regdb_work);
525	return 0;
526	}
527
528	#ifdef CONFIG_CFG80211_CRDA_SUPPORT
529	/* Max number of consecutive attempts to communicate with CRDA */
530	#define REG_MAX_CRDA_TIMEOUTS 10
531
532	static u32 reg_crda_timeouts;
533
534	static void crda_timeout_work(struct work_struct *work);
535	static DECLARE_DELAYED_WORK(crda_timeout, crda_timeout_work);
536
537	static void crda_timeout_work(struct work_struct *work)
538	{
539	pr_debug("Timeout while waiting for CRDA to reply, restoring regulatory settings\n");
540	rtnl_lock();
541	reg_crda_timeouts++;
542	restore_regulatory_settings(reset_user: true, cached: false);
543	rtnl_unlock();
544	}
545
546	static void cancel_crda_timeout(void)
547	{
548	cancel_delayed_work(dwork: &crda_timeout);
549	}
550
551	static void cancel_crda_timeout_sync(void)
552	{
553	cancel_delayed_work_sync(dwork: &crda_timeout);
554	}
555
556	static void reset_crda_timeouts(void)
557	{
558	reg_crda_timeouts = 0;
559	}
560
561	/*
562	* This lets us keep regulatory code which is updated on a regulatory
563	* basis in userspace.
564	*/
565	static int call_crda(const char *alpha2)
566	{
567	char country[12];
568	char *env[] = { country, NULL };
569	int ret;
570
571	snprintf(buf: country, size: sizeof(country), fmt: "COUNTRY=%c%c",
572	alpha2[0], alpha2[1]);
573
574	if (reg_crda_timeouts > REG_MAX_CRDA_TIMEOUTS) {
575	pr_debug("Exceeded CRDA call max attempts. Not calling CRDA\n");
576	return -EINVAL;
577	}
578
579	if (!is_world_regdom(alpha2: (char *) alpha2))
580	pr_debug("Calling CRDA for country: %c%c\n",
581	alpha2[0], alpha2[1]);
582	else
583	pr_debug("Calling CRDA to update world regulatory domain\n");
584
585	ret = kobject_uevent_env(kobj: &reg_pdev->dev.kobj, action: KOBJ_CHANGE, envp: env);
586	if (ret)
587	return ret;
588
589	queue_delayed_work(wq: system_power_efficient_wq,
590	dwork: &crda_timeout, delay: msecs_to_jiffies(m: 3142));
591	return 0;
592	}
593	#else
594	static inline void cancel_crda_timeout(void) {}
595	static inline void cancel_crda_timeout_sync(void) {}
596	static inline void reset_crda_timeouts(void) {}
597	static inline int call_crda(const char *alpha2)
598	{
599	return -ENODATA;
600	}
601	#endif /* CONFIG_CFG80211_CRDA_SUPPORT */
602
603	/* code to directly load a firmware database through request_firmware */
604	static const struct fwdb_header *regdb;
605
606	struct fwdb_country {
607	u8 alpha2[2];
608	__be16 coll_ptr;
609	/* this struct cannot be extended */
610	} __packed __aligned(4);
611
612	struct fwdb_collection {
613	u8 len;
614	u8 n_rules;
615	u8 dfs_region;
616	/* no optional data yet */
617	/* aligned to 2, then followed by __be16 array of rule pointers */
618	} __packed __aligned(4);
619
620	enum fwdb_flags {
621	FWDB_FLAG_NO_OFDM = BIT(0),
622	FWDB_FLAG_NO_OUTDOOR = BIT(1),
623	FWDB_FLAG_DFS = BIT(2),
624	FWDB_FLAG_NO_IR = BIT(3),
625	FWDB_FLAG_AUTO_BW = BIT(4),
626	};
627
628	struct fwdb_wmm_ac {
629	u8 ecw;
630	u8 aifsn;
631	__be16 cot;
632	} __packed;
633
634	struct fwdb_wmm_rule {
635	struct fwdb_wmm_ac client[IEEE80211_NUM_ACS];
636	struct fwdb_wmm_ac ap[IEEE80211_NUM_ACS];
637	} __packed;
638
639	struct fwdb_rule {
640	u8 len;
641	u8 flags;
642	__be16 max_eirp;
643	__be32 start, end, max_bw;
644	/* start of optional data */
645	__be16 cac_timeout;
646	__be16 wmm_ptr;
647	} __packed __aligned(4);
648
649	#define FWDB_MAGIC 0x52474442
650	#define FWDB_VERSION 20
651
652	struct fwdb_header {
653	__be32 magic;
654	__be32 version;
655	struct fwdb_country country[];
656	} __packed __aligned(4);
657
658	static int ecw2cw(int ecw)
659	{
660	return (1 << ecw) - 1;
661	}
662
663	static bool valid_wmm(struct fwdb_wmm_rule *rule)
664	{
665	struct fwdb_wmm_ac *ac = (struct fwdb_wmm_ac *)rule;
666	int i;
667
668	for (i = 0; i < IEEE80211_NUM_ACS * 2; i++) {
669	u16 cw_min = ecw2cw(ecw: (ac[i].ecw & 0xf0) >> 4);
670	u16 cw_max = ecw2cw(ecw: ac[i].ecw & 0x0f);
671	u8 aifsn = ac[i].aifsn;
672
673	if (cw_min >= cw_max)
674	return false;
675
676	if (aifsn < 1)
677	return false;
678	}
679
680	return true;
681	}
682
683	static bool valid_rule(const u8 *data, unsigned int size, u16 rule_ptr)
684	{
685	struct fwdb_rule *rule = (void *)(data + (rule_ptr << 2));
686
687	if ((u8 *)rule + sizeof(rule->len) > data + size)
688	return false;
689
690	/* mandatory fields */
691	if (rule->len < offsetofend(struct fwdb_rule, max_bw))
692	return false;
693	if (rule->len >= offsetofend(struct fwdb_rule, wmm_ptr)) {
694	u32 wmm_ptr = be16_to_cpu(rule->wmm_ptr) << 2;
695	struct fwdb_wmm_rule *wmm;
696
697	if (wmm_ptr + sizeof(struct fwdb_wmm_rule) > size)
698	return false;
699
700	wmm = (void *)(data + wmm_ptr);
701
702	if (!valid_wmm(rule: wmm))
703	return false;
704	}
705	return true;
706	}
707
708	static bool valid_country(const u8 *data, unsigned int size,
709	const struct fwdb_country *country)
710	{
711	unsigned int ptr = be16_to_cpu(country->coll_ptr) << 2;
712	struct fwdb_collection *coll = (void *)(data + ptr);
713	__be16 *rules_ptr;
714	unsigned int i;
715
716	/* make sure we can read len/n_rules */
717	if ((u8 *)coll + offsetofend(typeof(*coll), n_rules) > data + size)
718	return false;
719
720	/* make sure base struct and all rules fit */
721	if ((u8 *)coll + ALIGN(coll->len, 2) +
722	(coll->n_rules * 2) > data + size)
723	return false;
724
725	/* mandatory fields must exist */
726	if (coll->len < offsetofend(struct fwdb_collection, dfs_region))
727	return false;
728
729	rules_ptr = (void *)((u8 *)coll + ALIGN(coll->len, 2));
730
731	for (i = 0; i < coll->n_rules; i++) {
732	u16 rule_ptr = be16_to_cpu(rules_ptr[i]);
733
734	if (!valid_rule(data, size, rule_ptr))
735	return false;
736	}
737
738	return true;
739	}
740
741	#ifdef CONFIG_CFG80211_REQUIRE_SIGNED_REGDB
742	#include <keys/asymmetric-type.h>
743
744	static struct key *builtin_regdb_keys;
745
746	static int __init load_builtin_regdb_keys(void)
747	{
748	builtin_regdb_keys =
749	keyring_alloc(description: ".builtin_regdb_keys",
750	KUIDT_INIT(0), KGIDT_INIT(0), current_cred(),
751	perm: ((KEY_POS_ALL & ~KEY_POS_SETATTR) |
752	KEY_USR_VIEW | KEY_USR_READ | KEY_USR_SEARCH),
753	KEY_ALLOC_NOT_IN_QUOTA, NULL, NULL);
754	if (IS_ERR(builtin_regdb_keys))
755	return PTR_ERR(builtin_regdb_keys);
756
757	pr_notice("Loading compiled-in X.509 certificates for regulatory database\n");
758
759	#ifdef CONFIG_CFG80211_USE_KERNEL_REGDB_KEYS
760	x509_load_certificate_list(shipped_regdb_certs,
761	shipped_regdb_certs_len,
762	builtin_regdb_keys);
763	#endif
764	#ifdef CONFIG_CFG80211_EXTRA_REGDB_KEYDIR
765	if (CONFIG_CFG80211_EXTRA_REGDB_KEYDIR[0] != '\0')
766	x509_load_certificate_list(extra_regdb_certs,
767	extra_regdb_certs_len,
768	builtin_regdb_keys);
769	#endif
770
771	return 0;
772	}
773
774	MODULE_FIRMWARE("regulatory.db.p7s");
775
776	static bool regdb_has_valid_signature(const u8 *data, unsigned int size)
777	{
778	const struct firmware *sig;
779	bool result;
780
781	if (request_firmware(fw: &sig, name: "regulatory.db.p7s", device: &reg_pdev->dev))
782	return false;
783
784	result = verify_pkcs7_signature(data, len: size, raw_pkcs7: sig->data, pkcs7_len: sig->size,
785	trusted_keys: builtin_regdb_keys,
786	usage: VERIFYING_UNSPECIFIED_SIGNATURE,
787	NULL, NULL) == 0;
788
789	release_firmware(fw: sig);
790
791	return result;
792	}
793
794	static void free_regdb_keyring(void)
795	{
796	key_put(key: builtin_regdb_keys);
797	}
798	#else
799	static int load_builtin_regdb_keys(void)
800	{
801	return 0;
802	}
803
804	static bool regdb_has_valid_signature(const u8 *data, unsigned int size)
805	{
806	return true;
807	}
808
809	static void free_regdb_keyring(void)
810	{
811	}
812	#endif /* CONFIG_CFG80211_REQUIRE_SIGNED_REGDB */
813
814	static bool valid_regdb(const u8 *data, unsigned int size)
815	{
816	const struct fwdb_header *hdr = (void *)data;
817	const struct fwdb_country *country;
818
819	if (size < sizeof(*hdr))
820	return false;
821
822	if (hdr->magic != cpu_to_be32(FWDB_MAGIC))
823	return false;
824
825	if (hdr->version != cpu_to_be32(FWDB_VERSION))
826	return false;
827
828	if (!regdb_has_valid_signature(data, size))
829	return false;
830
831	country = &hdr->country[0];
832	while ((u8 *)(country + 1) <= data + size) {
833	if (!country->coll_ptr)
834	break;
835	if (!valid_country(data, size, country))
836	return false;
837	country++;
838	}
839
840	return true;
841	}
842
843	static void set_wmm_rule(const struct fwdb_header *db,
844	const struct fwdb_country *country,
845	const struct fwdb_rule *rule,
846	struct ieee80211_reg_rule *rrule)
847	{
848	struct ieee80211_wmm_rule *wmm_rule = &rrule->wmm_rule;
849	struct fwdb_wmm_rule *wmm;
850	unsigned int i, wmm_ptr;
851
852	wmm_ptr = be16_to_cpu(rule->wmm_ptr) << 2;
853	wmm = (void *)((u8 *)db + wmm_ptr);
854
855	if (!valid_wmm(rule: wmm)) {
856	pr_err("Invalid regulatory WMM rule %u-%u in domain %c%c\n",
857	be32_to_cpu(rule->start), be32_to_cpu(rule->end),
858	country->alpha2[0], country->alpha2[1]);
859	return;
860	}
861
862	for (i = 0; i < IEEE80211_NUM_ACS; i++) {
863	wmm_rule->client[i].cw_min =
864	ecw2cw(ecw: (wmm->client[i].ecw & 0xf0) >> 4);
865	wmm_rule->client[i].cw_max = ecw2cw(ecw: wmm->client[i].ecw & 0x0f);
866	wmm_rule->client[i].aifsn = wmm->client[i].aifsn;
867	wmm_rule->client[i].cot =
868	1000 * be16_to_cpu(wmm->client[i].cot);
869	wmm_rule->ap[i].cw_min = ecw2cw(ecw: (wmm->ap[i].ecw & 0xf0) >> 4);
870	wmm_rule->ap[i].cw_max = ecw2cw(ecw: wmm->ap[i].ecw & 0x0f);
871	wmm_rule->ap[i].aifsn = wmm->ap[i].aifsn;
872	wmm_rule->ap[i].cot = 1000 * be16_to_cpu(wmm->ap[i].cot);
873	}
874
875	rrule->has_wmm = true;
876	}
877
878	static int __regdb_query_wmm(const struct fwdb_header *db,
879	const struct fwdb_country *country, int freq,
880	struct ieee80211_reg_rule *rrule)
881	{
882	unsigned int ptr = be16_to_cpu(country->coll_ptr) << 2;
883	struct fwdb_collection *coll = (void *)((u8 *)db + ptr);
884	int i;
885
886	for (i = 0; i < coll->n_rules; i++) {
887	__be16 *rules_ptr = (void *)((u8 *)coll + ALIGN(coll->len, 2));
888	unsigned int rule_ptr = be16_to_cpu(rules_ptr[i]) << 2;
889	struct fwdb_rule *rule = (void *)((u8 *)db + rule_ptr);
890
891	if (rule->len < offsetofend(struct fwdb_rule, wmm_ptr))
892	continue;
893
894	if (freq >= KHZ_TO_MHZ(be32_to_cpu(rule->start)) &&
895	freq <= KHZ_TO_MHZ(be32_to_cpu(rule->end))) {
896	set_wmm_rule(db, country, rule, rrule);
897	return 0;
898	}
899	}
900
901	return -ENODATA;
902	}
903
904	int reg_query_regdb_wmm(char *alpha2, int freq, struct ieee80211_reg_rule *rule)
905	{
906	const struct fwdb_header *hdr = regdb;
907	const struct fwdb_country *country;
908
909	if (!regdb)
910	return -ENODATA;
911
912	if (IS_ERR(ptr: regdb))
913	return PTR_ERR(ptr: regdb);
914
915	country = &hdr->country[0];
916	while (country->coll_ptr) {
917	if (alpha2_equal(alpha2_x: alpha2, alpha2_y: country->alpha2))
918	return __regdb_query_wmm(db: regdb, country, freq, rrule: rule);
919
920	country++;
921	}
922
923	return -ENODATA;
924	}
925	EXPORT_SYMBOL(reg_query_regdb_wmm);
926
927	static int regdb_query_country(const struct fwdb_header *db,
928	const struct fwdb_country *country)
929	{
930	unsigned int ptr = be16_to_cpu(country->coll_ptr) << 2;
931	struct fwdb_collection *coll = (void *)((u8 *)db + ptr);
932	struct ieee80211_regdomain *regdom;
933	unsigned int i;
934
935	regdom = kzalloc(struct_size(regdom, reg_rules, coll->n_rules),
936	GFP_KERNEL);
937	if (!regdom)
938	return -ENOMEM;
939
940	regdom->n_reg_rules = coll->n_rules;
941	regdom->alpha2[0] = country->alpha2[0];
942	regdom->alpha2[1] = country->alpha2[1];
943	regdom->dfs_region = coll->dfs_region;
944
945	for (i = 0; i < regdom->n_reg_rules; i++) {
946	__be16 *rules_ptr = (void *)((u8 *)coll + ALIGN(coll->len, 2));
947	unsigned int rule_ptr = be16_to_cpu(rules_ptr[i]) << 2;
948	struct fwdb_rule *rule = (void *)((u8 *)db + rule_ptr);
949	struct ieee80211_reg_rule *rrule = &regdom->reg_rules[i];
950
951	rrule->freq_range.start_freq_khz = be32_to_cpu(rule->start);
952	rrule->freq_range.end_freq_khz = be32_to_cpu(rule->end);
953	rrule->freq_range.max_bandwidth_khz = be32_to_cpu(rule->max_bw);
954
955	rrule->power_rule.max_antenna_gain = 0;
956	rrule->power_rule.max_eirp = be16_to_cpu(rule->max_eirp);
957
958	rrule->flags = 0;
959	if (rule->flags & FWDB_FLAG_NO_OFDM)
960	rrule->flags |= NL80211_RRF_NO_OFDM;
961	if (rule->flags & FWDB_FLAG_NO_OUTDOOR)
962	rrule->flags |= NL80211_RRF_NO_OUTDOOR;
963	if (rule->flags & FWDB_FLAG_DFS)
964	rrule->flags |= NL80211_RRF_DFS;
965	if (rule->flags & FWDB_FLAG_NO_IR)
966	rrule->flags |= NL80211_RRF_NO_IR;
967	if (rule->flags & FWDB_FLAG_AUTO_BW)
968	rrule->flags |= NL80211_RRF_AUTO_BW;
969
970	rrule->dfs_cac_ms = 0;
971
972	/* handle optional data */
973	if (rule->len >= offsetofend(struct fwdb_rule, cac_timeout))
974	rrule->dfs_cac_ms =
975	1000 * be16_to_cpu(rule->cac_timeout);
976	if (rule->len >= offsetofend(struct fwdb_rule, wmm_ptr))
977	set_wmm_rule(db, country, rule, rrule);
978	}
979
980	return reg_schedule_apply(regdom);
981	}
982
983	static int query_regdb(const char *alpha2)
984	{
985	const struct fwdb_header *hdr = regdb;
986	const struct fwdb_country *country;
987
988	ASSERT_RTNL();
989
990	if (IS_ERR(ptr: regdb))
991	return PTR_ERR(ptr: regdb);
992
993	country = &hdr->country[0];
994	while (country->coll_ptr) {
995	if (alpha2_equal(alpha2_x: alpha2, alpha2_y: country->alpha2))
996	return regdb_query_country(db: regdb, country);
997	country++;
998	}
999
1000	return -ENODATA;
1001	}
1002
1003	static void regdb_fw_cb(const struct firmware *fw, void *context)
1004	{
1005	int set_error = 0;
1006	bool restore = true;
1007	void *db;
1008
1009	if (!fw) {
1010	pr_info("failed to load regulatory.db\n");
1011	set_error = -ENODATA;
1012	} else if (!valid_regdb(data: fw->data, size: fw->size)) {
1013	pr_info("loaded regulatory.db is malformed or signature is missing/invalid\n");
1014	set_error = -EINVAL;
1015	}
1016
1017	rtnl_lock();
1018	if (regdb && !IS_ERR(ptr: regdb)) {
1019	/* negative case - a bug
1020	* positive case - can happen due to race in case of multiple cb's in
1021	* queue, due to usage of asynchronous callback
1022	*
1023	* Either case, just restore and free new db.
1024	*/
1025	} else if (set_error) {
1026	regdb = ERR_PTR(error: set_error);
1027	} else if (fw) {
1028	db = kmemdup(p: fw->data, size: fw->size, GFP_KERNEL);
1029	if (db) {
1030	regdb = db;
1031	restore = context && query_regdb(alpha2: context);
1032	} else {
1033	restore = true;
1034	}
1035	}
1036
1037	if (restore)
1038	restore_regulatory_settings(reset_user: true, cached: false);
1039
1040	rtnl_unlock();
1041
1042	kfree(objp: context);
1043
1044	release_firmware(fw);
1045	}
1046
1047	MODULE_FIRMWARE("regulatory.db");
1048
1049	static int query_regdb_file(const char *alpha2)
1050	{
1051	int err;
1052
1053	ASSERT_RTNL();
1054
1055	if (regdb)
1056	return query_regdb(alpha2);
1057
1058	alpha2 = kmemdup(p: alpha2, size: 2, GFP_KERNEL);
1059	if (!alpha2)
1060	return -ENOMEM;
1061
1062	err = request_firmware_nowait(THIS_MODULE, uevent: true, name: "regulatory.db",
1063	device: &reg_pdev->dev, GFP_KERNEL,
1064	context: (void *)alpha2, cont: regdb_fw_cb);
1065	if (err)
1066	kfree(objp: alpha2);
1067
1068	return err;
1069	}
1070
1071	int reg_reload_regdb(void)
1072	{
1073	const struct firmware *fw;
1074	void *db;
1075	int err;
1076	const struct ieee80211_regdomain *current_regdomain;
1077	struct regulatory_request *request;
1078
1079	err = request_firmware(fw: &fw, name: "regulatory.db", device: &reg_pdev->dev);
1080	if (err)
1081	return err;
1082
1083	if (!valid_regdb(data: fw->data, size: fw->size)) {
1084	err = -ENODATA;
1085	goto out;
1086	}
1087
1088	db = kmemdup(p: fw->data, size: fw->size, GFP_KERNEL);
1089	if (!db) {
1090	err = -ENOMEM;
1091	goto out;
1092	}
1093
1094	rtnl_lock();
1095	if (!IS_ERR_OR_NULL(ptr: regdb))
1096	kfree(objp: regdb);
1097	regdb = db;
1098
1099	/* reset regulatory domain */
1100	current_regdomain = get_cfg80211_regdom();
1101
1102	request = kzalloc(size: sizeof(*request), GFP_KERNEL);
1103	if (!request) {
1104	err = -ENOMEM;
1105	goto out_unlock;
1106	}
1107
1108	request->wiphy_idx = WIPHY_IDX_INVALID;
1109	request->alpha2[0] = current_regdomain->alpha2[0];
1110	request->alpha2[1] = current_regdomain->alpha2[1];
1111	request->initiator = NL80211_REGDOM_SET_BY_CORE;
1112	request->user_reg_hint_type = NL80211_USER_REG_HINT_USER;
1113
1114	reg_process_hint(reg_request: request);
1115
1116	out_unlock:
1117	rtnl_unlock();
1118	out:
1119	release_firmware(fw);
1120	return err;
1121	}
1122
1123	static bool reg_query_database(struct regulatory_request *request)
1124	{
1125	if (query_regdb_file(alpha2: request->alpha2) == 0)
1126	return true;
1127
1128	if (call_crda(alpha2: request->alpha2) == 0)
1129	return true;
1130
1131	return false;
1132	}
1133
1134	bool reg_is_valid_request(const char *alpha2)
1135	{
1136	struct regulatory_request *lr = get_last_request();
1137
1138	if (!lr || lr->processed)
1139	return false;
1140
1141	return alpha2_equal(alpha2_x: lr->alpha2, alpha2_y: alpha2);
1142	}
1143
1144	static const struct ieee80211_regdomain *reg_get_regdomain(struct wiphy *wiphy)
1145	{
1146	struct regulatory_request *lr = get_last_request();
1147
1148	/*
1149	* Follow the driver's regulatory domain, if present, unless a country
1150	* IE has been processed or a user wants to help complaince further
1151	*/
1152	if (lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
1153	lr->initiator != NL80211_REGDOM_SET_BY_USER &&
1154	wiphy->regd)
1155	return get_wiphy_regdom(wiphy);
1156
1157	return get_cfg80211_regdom();
1158	}
1159
1160	static unsigned int
1161	reg_get_max_bandwidth_from_range(const struct ieee80211_regdomain *rd,
1162	const struct ieee80211_reg_rule *rule)
1163	{
1164	const struct ieee80211_freq_range *freq_range = &rule->freq_range;
1165	const struct ieee80211_freq_range *freq_range_tmp;
1166	const struct ieee80211_reg_rule *tmp;
1167	u32 start_freq, end_freq, idx, no;
1168
1169	for (idx = 0; idx < rd->n_reg_rules; idx++)
1170	if (rule == &rd->reg_rules[idx])
1171	break;
1172
1173	if (idx == rd->n_reg_rules)
1174	return 0;
1175
1176	/* get start_freq */
1177	no = idx;
1178
1179	while (no) {
1180	tmp = &rd->reg_rules[--no];
1181	freq_range_tmp = &tmp->freq_range;
1182
1183	if (freq_range_tmp->end_freq_khz < freq_range->start_freq_khz)
1184	break;
1185
1186	freq_range = freq_range_tmp;
1187	}
1188
1189	start_freq = freq_range->start_freq_khz;
1190
1191	/* get end_freq */
1192	freq_range = &rule->freq_range;
1193	no = idx;
1194
1195	while (no < rd->n_reg_rules - 1) {
1196	tmp = &rd->reg_rules[++no];
1197	freq_range_tmp = &tmp->freq_range;
1198
1199	if (freq_range_tmp->start_freq_khz > freq_range->end_freq_khz)
1200	break;
1201
1202	freq_range = freq_range_tmp;
1203	}
1204
1205	end_freq = freq_range->end_freq_khz;
1206
1207	return end_freq - start_freq;
1208	}
1209
1210	unsigned int reg_get_max_bandwidth(const struct ieee80211_regdomain *rd,
1211	const struct ieee80211_reg_rule *rule)
1212	{
1213	unsigned int bw = reg_get_max_bandwidth_from_range(rd, rule);
1214
1215	if (rule->flags & NL80211_RRF_NO_320MHZ)
1216	bw = min_t(unsigned int, bw, MHZ_TO_KHZ(160));
1217	if (rule->flags & NL80211_RRF_NO_160MHZ)
1218	bw = min_t(unsigned int, bw, MHZ_TO_KHZ(80));
1219	if (rule->flags & NL80211_RRF_NO_80MHZ)
1220	bw = min_t(unsigned int, bw, MHZ_TO_KHZ(40));
1221
1222	/*
1223	* HT40+/HT40- limits are handled per-channel. Only limit BW if both
1224	* are not allowed.
1225	*/
1226	if (rule->flags & NL80211_RRF_NO_HT40MINUS &&
1227	rule->flags & NL80211_RRF_NO_HT40PLUS)
1228	bw = min_t(unsigned int, bw, MHZ_TO_KHZ(20));
1229
1230	return bw;
1231	}
1232
1233	/* Sanity check on a regulatory rule */
1234	static bool is_valid_reg_rule(const struct ieee80211_reg_rule *rule)
1235	{
1236	const struct ieee80211_freq_range *freq_range = &rule->freq_range;
1237	u32 freq_diff;
1238
1239	if (freq_range->start_freq_khz <= 0 || freq_range->end_freq_khz <= 0)
1240	return false;
1241
1242	if (freq_range->start_freq_khz > freq_range->end_freq_khz)
1243	return false;
1244
1245	freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
1246
1247	if (freq_range->end_freq_khz <= freq_range->start_freq_khz ||
1248	freq_range->max_bandwidth_khz > freq_diff)
1249	return false;
1250
1251	return true;
1252	}
1253
1254	static bool is_valid_rd(const struct ieee80211_regdomain *rd)
1255	{
1256	const struct ieee80211_reg_rule *reg_rule = NULL;
1257	unsigned int i;
1258
1259	if (!rd->n_reg_rules)
1260	return false;
1261
1262	if (WARN_ON(rd->n_reg_rules > NL80211_MAX_SUPP_REG_RULES))
1263	return false;
1264
1265	for (i = 0; i < rd->n_reg_rules; i++) {
1266	reg_rule = &rd->reg_rules[i];
1267	if (!is_valid_reg_rule(rule: reg_rule))
1268	return false;
1269	}
1270
1271	return true;
1272	}
1273
1274	/**
1275	* freq_in_rule_band - tells us if a frequency is in a frequency band
1276	* @freq_range: frequency rule we want to query
1277	* @freq_khz: frequency we are inquiring about
1278	*
1279	* This lets us know if a specific frequency rule is or is not relevant to
1280	* a specific frequency's band. Bands are device specific and artificial
1281	* definitions (the "2.4 GHz band", the "5 GHz band" and the "60GHz band"),
1282	* however it is safe for now to assume that a frequency rule should not be
1283	* part of a frequency's band if the start freq or end freq are off by more
1284	* than 2 GHz for the 2.4 and 5 GHz bands, and by more than 20 GHz for the
1285	* 60 GHz band.
1286	* This resolution can be lowered and should be considered as we add
1287	* regulatory rule support for other "bands".
1288	*
1289	* Returns: whether or not the frequency is in the range
1290	*/
1291	static bool freq_in_rule_band(const struct ieee80211_freq_range *freq_range,
1292	u32 freq_khz)
1293	{
1294	/*
1295	* From 802.11ad: directional multi-gigabit (DMG):
1296	* Pertaining to operation in a frequency band containing a channel
1297	* with the Channel starting frequency above 45 GHz.
1298	*/
1299	u32 limit = freq_khz > 45 * KHZ_PER_GHZ ? 20 * KHZ_PER_GHZ : 2 * KHZ_PER_GHZ;
1300	if (abs(freq_khz - freq_range->start_freq_khz) <= limit)
1301	return true;
1302	if (abs(freq_khz - freq_range->end_freq_khz) <= limit)
1303	return true;
1304	return false;
1305	}
1306
1307	/*
1308	* Later on we can perhaps use the more restrictive DFS
1309	* region but we don't have information for that yet so
1310	* for now simply disallow conflicts.
1311	*/
1312	static enum nl80211_dfs_regions
1313	reg_intersect_dfs_region(const enum nl80211_dfs_regions dfs_region1,
1314	const enum nl80211_dfs_regions dfs_region2)
1315	{
1316	if (dfs_region1 != dfs_region2)
1317	return NL80211_DFS_UNSET;
1318	return dfs_region1;
1319	}
1320
1321	static void reg_wmm_rules_intersect(const struct ieee80211_wmm_ac *wmm_ac1,
1322	const struct ieee80211_wmm_ac *wmm_ac2,
1323	struct ieee80211_wmm_ac *intersect)
1324	{
1325	intersect->cw_min = max_t(u16, wmm_ac1->cw_min, wmm_ac2->cw_min);
1326	intersect->cw_max = max_t(u16, wmm_ac1->cw_max, wmm_ac2->cw_max);
1327	intersect->cot = min_t(u16, wmm_ac1->cot, wmm_ac2->cot);
1328	intersect->aifsn = max_t(u8, wmm_ac1->aifsn, wmm_ac2->aifsn);
1329	}
1330
1331	/*
1332	* Helper for regdom_intersect(), this does the real
1333	* mathematical intersection fun
1334	*/
1335	static int reg_rules_intersect(const struct ieee80211_regdomain *rd1,
1336	const struct ieee80211_regdomain *rd2,
1337	const struct ieee80211_reg_rule *rule1,
1338	const struct ieee80211_reg_rule *rule2,
1339	struct ieee80211_reg_rule *intersected_rule)
1340	{
1341	const struct ieee80211_freq_range *freq_range1, *freq_range2;
1342	struct ieee80211_freq_range *freq_range;
1343	const struct ieee80211_power_rule *power_rule1, *power_rule2;
1344	struct ieee80211_power_rule *power_rule;
1345	const struct ieee80211_wmm_rule *wmm_rule1, *wmm_rule2;
1346	struct ieee80211_wmm_rule *wmm_rule;
1347	u32 freq_diff, max_bandwidth1, max_bandwidth2;
1348
1349	freq_range1 = &rule1->freq_range;
1350	freq_range2 = &rule2->freq_range;
1351	freq_range = &intersected_rule->freq_range;
1352
1353	power_rule1 = &rule1->power_rule;
1354	power_rule2 = &rule2->power_rule;
1355	power_rule = &intersected_rule->power_rule;
1356
1357	wmm_rule1 = &rule1->wmm_rule;
1358	wmm_rule2 = &rule2->wmm_rule;
1359	wmm_rule = &intersected_rule->wmm_rule;
1360
1361	freq_range->start_freq_khz = max(freq_range1->start_freq_khz,
1362	freq_range2->start_freq_khz);
1363	freq_range->end_freq_khz = min(freq_range1->end_freq_khz,
1364	freq_range2->end_freq_khz);
1365
1366	max_bandwidth1 = freq_range1->max_bandwidth_khz;
1367	max_bandwidth2 = freq_range2->max_bandwidth_khz;
1368
1369	if (rule1->flags & NL80211_RRF_AUTO_BW)
1370	max_bandwidth1 = reg_get_max_bandwidth(rd: rd1, rule: rule1);
1371	if (rule2->flags & NL80211_RRF_AUTO_BW)
1372	max_bandwidth2 = reg_get_max_bandwidth(rd: rd2, rule: rule2);
1373
1374	freq_range->max_bandwidth_khz = min(max_bandwidth1, max_bandwidth2);
1375
1376	intersected_rule->flags = rule1->flags | rule2->flags;
1377
1378	/*
1379	* In case NL80211_RRF_AUTO_BW requested for both rules
1380	* set AUTO_BW in intersected rule also. Next we will
1381	* calculate BW correctly in handle_channel function.
1382	* In other case remove AUTO_BW flag while we calculate
1383	* maximum bandwidth correctly and auto calculation is
1384	* not required.
1385	*/
1386	if ((rule1->flags & NL80211_RRF_AUTO_BW) &&
1387	(rule2->flags & NL80211_RRF_AUTO_BW))
1388	intersected_rule->flags |= NL80211_RRF_AUTO_BW;
1389	else
1390	intersected_rule->flags &= ~NL80211_RRF_AUTO_BW;
1391
1392	freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
1393	if (freq_range->max_bandwidth_khz > freq_diff)
1394	freq_range->max_bandwidth_khz = freq_diff;
1395
1396	power_rule->max_eirp = min(power_rule1->max_eirp,
1397	power_rule2->max_eirp);
1398	power_rule->max_antenna_gain = min(power_rule1->max_antenna_gain,
1399	power_rule2->max_antenna_gain);
1400
1401	intersected_rule->dfs_cac_ms = max(rule1->dfs_cac_ms,
1402	rule2->dfs_cac_ms);
1403
1404	if (rule1->has_wmm && rule2->has_wmm) {
1405	u8 ac;
1406
1407	for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
1408	reg_wmm_rules_intersect(wmm_ac1: &wmm_rule1->client[ac],
1409	wmm_ac2: &wmm_rule2->client[ac],
1410	intersect: &wmm_rule->client[ac]);
1411	reg_wmm_rules_intersect(wmm_ac1: &wmm_rule1->ap[ac],
1412	wmm_ac2: &wmm_rule2->ap[ac],
1413	intersect: &wmm_rule->ap[ac]);
1414	}
1415
1416	intersected_rule->has_wmm = true;
1417	} else if (rule1->has_wmm) {
1418	*wmm_rule = *wmm_rule1;
1419	intersected_rule->has_wmm = true;
1420	} else if (rule2->has_wmm) {
1421	*wmm_rule = *wmm_rule2;
1422	intersected_rule->has_wmm = true;
1423	} else {
1424	intersected_rule->has_wmm = false;
1425	}
1426
1427	if (!is_valid_reg_rule(rule: intersected_rule))
1428	return -EINVAL;
1429
1430	return 0;
1431	}
1432
1433	/* check whether old rule contains new rule */
1434	static bool rule_contains(struct ieee80211_reg_rule *r1,
1435	struct ieee80211_reg_rule *r2)
1436	{
1437	/* for simplicity, currently consider only same flags */
1438	if (r1->flags != r2->flags)
1439	return false;
1440
1441	/* verify r1 is more restrictive */
1442	if ((r1->power_rule.max_antenna_gain >
1443	r2->power_rule.max_antenna_gain) ||
1444	r1->power_rule.max_eirp > r2->power_rule.max_eirp)
1445	return false;
1446
1447	/* make sure r2's range is contained within r1 */
1448	if (r1->freq_range.start_freq_khz > r2->freq_range.start_freq_khz ||
1449	r1->freq_range.end_freq_khz < r2->freq_range.end_freq_khz)
1450	return false;
1451
1452	/* and finally verify that r1.max_bw >= r2.max_bw */
1453	if (r1->freq_range.max_bandwidth_khz <
1454	r2->freq_range.max_bandwidth_khz)
1455	return false;
1456
1457	return true;
1458	}
1459
1460	/* add or extend current rules. do nothing if rule is already contained */
1461	static void add_rule(struct ieee80211_reg_rule *rule,
1462	struct ieee80211_reg_rule *reg_rules, u32 *n_rules)
1463	{
1464	struct ieee80211_reg_rule *tmp_rule;
1465	int i;
1466
1467	for (i = 0; i < *n_rules; i++) {
1468	tmp_rule = &reg_rules[i];
1469	/* rule is already contained - do nothing */
1470	if (rule_contains(r1: tmp_rule, r2: rule))
1471	return;
1472
1473	/* extend rule if possible */
1474	if (rule_contains(r1: rule, r2: tmp_rule)) {
1475	memcpy(tmp_rule, rule, sizeof(*rule));
1476	return;
1477	}
1478	}
1479
1480	memcpy(&reg_rules[*n_rules], rule, sizeof(*rule));
1481	(*n_rules)++;
1482	}
1483
1484	/**
1485	* regdom_intersect - do the intersection between two regulatory domains
1486	* @rd1: first regulatory domain
1487	* @rd2: second regulatory domain
1488	*
1489	* Use this function to get the intersection between two regulatory domains.
1490	* Once completed we will mark the alpha2 for the rd as intersected, "98",
1491	* as no one single alpha2 can represent this regulatory domain.
1492	*
1493	* Returns a pointer to the regulatory domain structure which will hold the
1494	* resulting intersection of rules between rd1 and rd2. We will
1495	* kzalloc() this structure for you.
1496	*
1497	* Returns: the intersected regdomain
1498	*/
1499	static struct ieee80211_regdomain *
1500	regdom_intersect(const struct ieee80211_regdomain *rd1,
1501	const struct ieee80211_regdomain *rd2)
1502	{
1503	int r;
1504	unsigned int x, y;
1505	unsigned int num_rules = 0;
1506	const struct ieee80211_reg_rule *rule1, *rule2;
1507	struct ieee80211_reg_rule intersected_rule;
1508	struct ieee80211_regdomain *rd;
1509
1510	if (!rd1 || !rd2)
1511	return NULL;
1512
1513	/*
1514	* First we get a count of the rules we'll need, then we actually
1515	* build them. This is to so we can malloc() and free() a
1516	* regdomain once. The reason we use reg_rules_intersect() here
1517	* is it will return -EINVAL if the rule computed makes no sense.
1518	* All rules that do check out OK are valid.
1519	*/
1520
1521	for (x = 0; x < rd1->n_reg_rules; x++) {
1522	rule1 = &rd1->reg_rules[x];
1523	for (y = 0; y < rd2->n_reg_rules; y++) {
1524	rule2 = &rd2->reg_rules[y];
1525	if (!reg_rules_intersect(rd1, rd2, rule1, rule2,
1526	intersected_rule: &intersected_rule))
1527	num_rules++;
1528	}
1529	}
1530
1531	if (!num_rules)
1532	return NULL;
1533
1534	rd = kzalloc(struct_size(rd, reg_rules, num_rules), GFP_KERNEL);
1535	if (!rd)
1536	return NULL;
1537
1538	for (x = 0; x < rd1->n_reg_rules; x++) {
1539	rule1 = &rd1->reg_rules[x];
1540	for (y = 0; y < rd2->n_reg_rules; y++) {
1541	rule2 = &rd2->reg_rules[y];
1542	r = reg_rules_intersect(rd1, rd2, rule1, rule2,
1543	intersected_rule: &intersected_rule);
1544	/*
1545	* No need to memset here the intersected rule here as
1546	* we're not using the stack anymore
1547	*/
1548	if (r)
1549	continue;
1550
1551	add_rule(rule: &intersected_rule, reg_rules: rd->reg_rules,
1552	n_rules: &rd->n_reg_rules);
1553	}
1554	}
1555
1556	rd->alpha2[0] = '9';
1557	rd->alpha2[1] = '8';
1558	rd->dfs_region = reg_intersect_dfs_region(dfs_region1: rd1->dfs_region,
1559	dfs_region2: rd2->dfs_region);
1560
1561	return rd;
1562	}
1563
1564	/*
1565	* XXX: add support for the rest of enum nl80211_reg_rule_flags, we may
1566	* want to just have the channel structure use these
1567	*/
1568	static u32 map_regdom_flags(u32 rd_flags)
1569	{
1570	u32 channel_flags = 0;
1571	if (rd_flags & NL80211_RRF_NO_IR_ALL)
1572	channel_flags |= IEEE80211_CHAN_NO_IR;
1573	if (rd_flags & NL80211_RRF_DFS)
1574	channel_flags |= IEEE80211_CHAN_RADAR;
1575	if (rd_flags & NL80211_RRF_NO_OFDM)
1576	channel_flags |= IEEE80211_CHAN_NO_OFDM;
1577	if (rd_flags & NL80211_RRF_NO_OUTDOOR)
1578	channel_flags |= IEEE80211_CHAN_INDOOR_ONLY;
1579	if (rd_flags & NL80211_RRF_IR_CONCURRENT)
1580	channel_flags |= IEEE80211_CHAN_IR_CONCURRENT;
1581	if (rd_flags & NL80211_RRF_NO_HT40MINUS)
1582	channel_flags |= IEEE80211_CHAN_NO_HT40MINUS;
1583	if (rd_flags & NL80211_RRF_NO_HT40PLUS)
1584	channel_flags |= IEEE80211_CHAN_NO_HT40PLUS;
1585	if (rd_flags & NL80211_RRF_NO_80MHZ)
1586	channel_flags |= IEEE80211_CHAN_NO_80MHZ;
1587	if (rd_flags & NL80211_RRF_NO_160MHZ)
1588	channel_flags |= IEEE80211_CHAN_NO_160MHZ;
1589	if (rd_flags & NL80211_RRF_NO_HE)
1590	channel_flags |= IEEE80211_CHAN_NO_HE;
1591	if (rd_flags & NL80211_RRF_NO_320MHZ)
1592	channel_flags |= IEEE80211_CHAN_NO_320MHZ;
1593	if (rd_flags & NL80211_RRF_NO_EHT)
1594	channel_flags |= IEEE80211_CHAN_NO_EHT;
1595	if (rd_flags & NL80211_RRF_DFS_CONCURRENT)
1596	channel_flags |= IEEE80211_CHAN_DFS_CONCURRENT;
1597	if (rd_flags & NL80211_RRF_NO_6GHZ_VLP_CLIENT)
1598	channel_flags |= IEEE80211_CHAN_NO_6GHZ_VLP_CLIENT;
1599	if (rd_flags & NL80211_RRF_NO_6GHZ_AFC_CLIENT)
1600	channel_flags |= IEEE80211_CHAN_NO_6GHZ_AFC_CLIENT;
1601	if (rd_flags & NL80211_RRF_PSD)
1602	channel_flags |= IEEE80211_CHAN_PSD;
1603	return channel_flags;
1604	}
1605
1606	static const struct ieee80211_reg_rule *
1607	freq_reg_info_regd(u32 center_freq,
1608	const struct ieee80211_regdomain *regd, u32 bw)
1609	{
1610	int i;
1611	bool band_rule_found = false;
1612	bool bw_fits = false;
1613
1614	if (!regd)
1615	return ERR_PTR(error: -EINVAL);
1616
1617	for (i = 0; i < regd->n_reg_rules; i++) {
1618	const struct ieee80211_reg_rule *rr;
1619	const struct ieee80211_freq_range *fr = NULL;
1620
1621	rr = &regd->reg_rules[i];
1622	fr = &rr->freq_range;
1623
1624	/*
1625	* We only need to know if one frequency rule was
1626	* in center_freq's band, that's enough, so let's
1627	* not overwrite it once found
1628	*/
1629	if (!band_rule_found)
1630	band_rule_found = freq_in_rule_band(freq_range: fr, freq_khz: center_freq);
1631
1632	bw_fits = cfg80211_does_bw_fit_range(freq_range: fr, center_freq_khz: center_freq, bw_khz: bw);
1633
1634	if (band_rule_found && bw_fits)
1635	return rr;
1636	}
1637
1638	if (!band_rule_found)
1639	return ERR_PTR(error: -ERANGE);
1640
1641	return ERR_PTR(error: -EINVAL);
1642	}
1643
1644	static const struct ieee80211_reg_rule *
1645	__freq_reg_info(struct wiphy *wiphy, u32 center_freq, u32 min_bw)
1646	{
1647	const struct ieee80211_regdomain *regd = reg_get_regdomain(wiphy);
1648	static const u32 bws[] = {0, 1, 2, 4, 5, 8, 10, 16, 20};
1649	const struct ieee80211_reg_rule *reg_rule = ERR_PTR(error: -ERANGE);
1650	int i = ARRAY_SIZE(bws) - 1;
1651	u32 bw;
1652
1653	for (bw = MHZ_TO_KHZ(bws[i]); bw >= min_bw; bw = MHZ_TO_KHZ(bws[i--])) {
1654	reg_rule = freq_reg_info_regd(center_freq, regd, bw);
1655	if (!IS_ERR(ptr: reg_rule))
1656	return reg_rule;
1657	}
1658
1659	return reg_rule;
1660	}
1661
1662	const struct ieee80211_reg_rule *freq_reg_info(struct wiphy *wiphy,
1663	u32 center_freq)
1664	{
1665	u32 min_bw = center_freq < MHZ_TO_KHZ(1000) ? 1 : 20;
1666
1667	return __freq_reg_info(wiphy, center_freq, MHZ_TO_KHZ(min_bw));
1668	}
1669	EXPORT_SYMBOL(freq_reg_info);
1670
1671	const char *reg_initiator_name(enum nl80211_reg_initiator initiator)
1672	{
1673	switch (initiator) {
1674	case NL80211_REGDOM_SET_BY_CORE:
1675	return "core";
1676	case NL80211_REGDOM_SET_BY_USER:
1677	return "user";
1678	case NL80211_REGDOM_SET_BY_DRIVER:
1679	return "driver";
1680	case NL80211_REGDOM_SET_BY_COUNTRY_IE:
1681	return "country element";
1682	default:
1683	WARN_ON(1);
1684	return "bug";
1685	}
1686	}
1687	EXPORT_SYMBOL(reg_initiator_name);
1688
1689	static uint32_t reg_rule_to_chan_bw_flags(const struct ieee80211_regdomain *regd,
1690	const struct ieee80211_reg_rule *reg_rule,
1691	const struct ieee80211_channel *chan)
1692	{
1693	const struct ieee80211_freq_range *freq_range = NULL;
1694	u32 max_bandwidth_khz, center_freq_khz, bw_flags = 0;
1695	bool is_s1g = chan->band == NL80211_BAND_S1GHZ;
1696
1697	freq_range = &reg_rule->freq_range;
1698
1699	max_bandwidth_khz = freq_range->max_bandwidth_khz;
1700	center_freq_khz = ieee80211_channel_to_khz(chan);
1701	/* Check if auto calculation requested */
1702	if (reg_rule->flags & NL80211_RRF_AUTO_BW)
1703	max_bandwidth_khz = reg_get_max_bandwidth(rd: regd, rule: reg_rule);
1704
1705	/* If we get a reg_rule we can assume that at least 5Mhz fit */
1706	if (!cfg80211_does_bw_fit_range(freq_range,
1707	center_freq_khz,
1708	MHZ_TO_KHZ(10)))
1709	bw_flags |= IEEE80211_CHAN_NO_10MHZ;
1710	if (!cfg80211_does_bw_fit_range(freq_range,
1711	center_freq_khz,
1712	MHZ_TO_KHZ(20)))
1713	bw_flags |= IEEE80211_CHAN_NO_20MHZ;
1714
1715	if (is_s1g) {
1716	/* S1G is strict about non overlapping channels. We can
1717	* calculate which bandwidth is allowed per channel by finding
1718	* the largest bandwidth which cleanly divides the freq_range.
1719	*/
1720	int edge_offset;
1721	int ch_bw = max_bandwidth_khz;
1722
1723	while (ch_bw) {
1724	edge_offset = (center_freq_khz - ch_bw / 2) -
1725	freq_range->start_freq_khz;
1726	if (edge_offset % ch_bw == 0) {
1727	switch (KHZ_TO_MHZ(ch_bw)) {
1728	case 1:
1729	bw_flags |= IEEE80211_CHAN_1MHZ;
1730	break;
1731	case 2:
1732	bw_flags |= IEEE80211_CHAN_2MHZ;
1733	break;
1734	case 4:
1735	bw_flags |= IEEE80211_CHAN_4MHZ;
1736	break;
1737	case 8:
1738	bw_flags |= IEEE80211_CHAN_8MHZ;
1739	break;
1740	case 16:
1741	bw_flags |= IEEE80211_CHAN_16MHZ;
1742	break;
1743	default:
1744	/* If we got here, no bandwidths fit on
1745	* this frequency, ie. band edge.
1746	*/
1747	bw_flags |= IEEE80211_CHAN_DISABLED;
1748	break;
1749	}
1750	break;
1751	}
1752	ch_bw /= 2;
1753	}
1754	} else {
1755	if (max_bandwidth_khz < MHZ_TO_KHZ(10))
1756	bw_flags |= IEEE80211_CHAN_NO_10MHZ;
1757	if (max_bandwidth_khz < MHZ_TO_KHZ(20))
1758	bw_flags |= IEEE80211_CHAN_NO_20MHZ;
1759	if (max_bandwidth_khz < MHZ_TO_KHZ(40))
1760	bw_flags |= IEEE80211_CHAN_NO_HT40;
1761	if (max_bandwidth_khz < MHZ_TO_KHZ(80))
1762	bw_flags |= IEEE80211_CHAN_NO_80MHZ;
1763	if (max_bandwidth_khz < MHZ_TO_KHZ(160))
1764	bw_flags |= IEEE80211_CHAN_NO_160MHZ;
1765	if (max_bandwidth_khz < MHZ_TO_KHZ(320))
1766	bw_flags |= IEEE80211_CHAN_NO_320MHZ;
1767	}
1768	return bw_flags;
1769	}
1770
1771	static void handle_channel_single_rule(struct wiphy *wiphy,
1772	enum nl80211_reg_initiator initiator,
1773	struct ieee80211_channel *chan,
1774	u32 flags,
1775	struct regulatory_request *lr,
1776	struct wiphy *request_wiphy,
1777	const struct ieee80211_reg_rule *reg_rule)
1778	{
1779	u32 bw_flags = 0;
1780	const struct ieee80211_power_rule *power_rule = NULL;
1781	const struct ieee80211_regdomain *regd;
1782
1783	regd = reg_get_regdomain(wiphy);
1784
1785	power_rule = &reg_rule->power_rule;
1786	bw_flags = reg_rule_to_chan_bw_flags(regd, reg_rule, chan);
1787
1788	if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
1789	request_wiphy && request_wiphy == wiphy &&
1790	request_wiphy->regulatory_flags & REGULATORY_STRICT_REG) {
1791	/*
1792	* This guarantees the driver's requested regulatory domain
1793	* will always be used as a base for further regulatory
1794	* settings
1795	*/
1796	chan->flags = chan->orig_flags =
1797	map_regdom_flags(rd_flags: reg_rule->flags) | bw_flags;
1798	chan->max_antenna_gain = chan->orig_mag =
1799	(int) MBI_TO_DBI(power_rule->max_antenna_gain);
1800	chan->max_reg_power = chan->max_power = chan->orig_mpwr =
1801	(int) MBM_TO_DBM(power_rule->max_eirp);
1802
1803	if (chan->flags & IEEE80211_CHAN_RADAR) {
1804	chan->dfs_cac_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
1805	if (reg_rule->dfs_cac_ms)
1806	chan->dfs_cac_ms = reg_rule->dfs_cac_ms;
1807	}
1808
1809	if (chan->flags & IEEE80211_CHAN_PSD)
1810	chan->psd = reg_rule->psd;
1811
1812	return;
1813	}
1814
1815	chan->dfs_state = NL80211_DFS_USABLE;
1816	chan->dfs_state_entered = jiffies;
1817
1818	chan->beacon_found = false;
1819	chan->flags = flags | bw_flags | map_regdom_flags(rd_flags: reg_rule->flags);
1820	chan->max_antenna_gain =
1821	min_t(int, chan->orig_mag,
1822	MBI_TO_DBI(power_rule->max_antenna_gain));
1823	chan->max_reg_power = (int) MBM_TO_DBM(power_rule->max_eirp);
1824
1825	if (chan->flags & IEEE80211_CHAN_RADAR) {
1826	if (reg_rule->dfs_cac_ms)
1827	chan->dfs_cac_ms = reg_rule->dfs_cac_ms;
1828	else
1829	chan->dfs_cac_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
1830	}
1831
1832	if (chan->flags & IEEE80211_CHAN_PSD)
1833	chan->psd = reg_rule->psd;
1834
1835	if (chan->orig_mpwr) {
1836	/*
1837	* Devices that use REGULATORY_COUNTRY_IE_FOLLOW_POWER
1838	* will always follow the passed country IE power settings.
1839	*/
1840	if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
1841	wiphy->regulatory_flags & REGULATORY_COUNTRY_IE_FOLLOW_POWER)
1842	chan->max_power = chan->max_reg_power;
1843	else
1844	chan->max_power = min(chan->orig_mpwr,
1845	chan->max_reg_power);
1846	} else
1847	chan->max_power = chan->max_reg_power;
1848	}
1849
1850	static void handle_channel_adjacent_rules(struct wiphy *wiphy,
1851	enum nl80211_reg_initiator initiator,
1852	struct ieee80211_channel *chan,
1853	u32 flags,
1854	struct regulatory_request *lr,
1855	struct wiphy *request_wiphy,
1856	const struct ieee80211_reg_rule *rrule1,
1857	const struct ieee80211_reg_rule *rrule2,
1858	struct ieee80211_freq_range *comb_range)
1859	{
1860	u32 bw_flags1 = 0;
1861	u32 bw_flags2 = 0;
1862	const struct ieee80211_power_rule *power_rule1 = NULL;
1863	const struct ieee80211_power_rule *power_rule2 = NULL;
1864	const struct ieee80211_regdomain *regd;
1865
1866	regd = reg_get_regdomain(wiphy);
1867
1868	power_rule1 = &rrule1->power_rule;
1869	power_rule2 = &rrule2->power_rule;
1870	bw_flags1 = reg_rule_to_chan_bw_flags(regd, reg_rule: rrule1, chan);
1871	bw_flags2 = reg_rule_to_chan_bw_flags(regd, reg_rule: rrule2, chan);
1872
1873	if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
1874	request_wiphy && request_wiphy == wiphy &&
1875	request_wiphy->regulatory_flags & REGULATORY_STRICT_REG) {
1876	/* This guarantees the driver's requested regulatory domain
1877	* will always be used as a base for further regulatory
1878	* settings
1879	*/
1880	chan->flags =
1881	map_regdom_flags(rd_flags: rrule1->flags) |
1882	map_regdom_flags(rd_flags: rrule2->flags) |
1883	bw_flags1 |
1884	bw_flags2;
1885	chan->orig_flags = chan->flags;
1886	chan->max_antenna_gain =
1887	min_t(int, MBI_TO_DBI(power_rule1->max_antenna_gain),
1888	MBI_TO_DBI(power_rule2->max_antenna_gain));
1889	chan->orig_mag = chan->max_antenna_gain;
1890	chan->max_reg_power =
1891	min_t(int, MBM_TO_DBM(power_rule1->max_eirp),
1892	MBM_TO_DBM(power_rule2->max_eirp));
1893	chan->max_power = chan->max_reg_power;
1894	chan->orig_mpwr = chan->max_reg_power;
1895
1896	if (chan->flags & IEEE80211_CHAN_RADAR) {
1897	chan->dfs_cac_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
1898	if (rrule1->dfs_cac_ms || rrule2->dfs_cac_ms)
1899	chan->dfs_cac_ms = max_t(unsigned int,
1900	rrule1->dfs_cac_ms,
1901	rrule2->dfs_cac_ms);
1902	}
1903
1904	if ((rrule1->flags & NL80211_RRF_PSD) &&
1905	(rrule2->flags & NL80211_RRF_PSD))
1906	chan->psd = min_t(s8, rrule1->psd, rrule2->psd);
1907	else
1908	chan->flags &= ~NL80211_RRF_PSD;
1909
1910	return;
1911	}
1912
1913	chan->dfs_state = NL80211_DFS_USABLE;
1914	chan->dfs_state_entered = jiffies;
1915
1916	chan->beacon_found = false;
1917	chan->flags = flags | bw_flags1 | bw_flags2 |
1918	map_regdom_flags(rd_flags: rrule1->flags) |
1919	map_regdom_flags(rd_flags: rrule2->flags);
1920
1921	/* reg_rule_to_chan_bw_flags may forbids 10 and forbids 20 MHz
1922	* (otherwise no adj. rule case), recheck therefore
1923	*/
1924	if (cfg80211_does_bw_fit_range(freq_range: comb_range,
1925	center_freq_khz: ieee80211_channel_to_khz(chan),
1926	MHZ_TO_KHZ(10)))
1927	chan->flags &= ~IEEE80211_CHAN_NO_10MHZ;
1928	if (cfg80211_does_bw_fit_range(freq_range: comb_range,
1929	center_freq_khz: ieee80211_channel_to_khz(chan),
1930	MHZ_TO_KHZ(20)))
1931	chan->flags &= ~IEEE80211_CHAN_NO_20MHZ;
1932
1933	chan->max_antenna_gain =
1934	min_t(int, chan->orig_mag,
1935	min_t(int,
1936	MBI_TO_DBI(power_rule1->max_antenna_gain),
1937	MBI_TO_DBI(power_rule2->max_antenna_gain)));
1938	chan->max_reg_power = min_t(int,
1939	MBM_TO_DBM(power_rule1->max_eirp),
1940	MBM_TO_DBM(power_rule2->max_eirp));
1941
1942	if (chan->flags & IEEE80211_CHAN_RADAR) {
1943	if (rrule1->dfs_cac_ms || rrule2->dfs_cac_ms)
1944	chan->dfs_cac_ms = max_t(unsigned int,
1945	rrule1->dfs_cac_ms,
1946	rrule2->dfs_cac_ms);
1947	else
1948	chan->dfs_cac_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
1949	}
1950
1951	if (chan->orig_mpwr) {
1952	/* Devices that use REGULATORY_COUNTRY_IE_FOLLOW_POWER
1953	* will always follow the passed country IE power settings.
1954	*/
1955	if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
1956	wiphy->regulatory_flags & REGULATORY_COUNTRY_IE_FOLLOW_POWER)
1957	chan->max_power = chan->max_reg_power;
1958	else
1959	chan->max_power = min(chan->orig_mpwr,
1960	chan->max_reg_power);
1961	} else {
1962	chan->max_power = chan->max_reg_power;
1963	}
1964	}
1965
1966	/* Note that right now we assume the desired channel bandwidth
1967	* is always 20 MHz for each individual channel (HT40 uses 20 MHz
1968	* per channel, the primary and the extension channel).
1969	*/
1970	static void handle_channel(struct wiphy *wiphy,
1971	enum nl80211_reg_initiator initiator,
1972	struct ieee80211_channel *chan)
1973	{
1974	const u32 orig_chan_freq = ieee80211_channel_to_khz(chan);
1975	struct regulatory_request *lr = get_last_request();
1976	struct wiphy *request_wiphy = wiphy_idx_to_wiphy(wiphy_idx: lr->wiphy_idx);
1977	const struct ieee80211_reg_rule *rrule = NULL;
1978	const struct ieee80211_reg_rule *rrule1 = NULL;
1979	const struct ieee80211_reg_rule *rrule2 = NULL;
1980
1981	u32 flags = chan->orig_flags;
1982
1983	rrule = freq_reg_info(wiphy, orig_chan_freq);
1984	if (IS_ERR(ptr: rrule)) {
1985	/* check for adjacent match, therefore get rules for
1986	* chan - 20 MHz and chan + 20 MHz and test
1987	* if reg rules are adjacent
1988	*/
1989	rrule1 = freq_reg_info(wiphy,
1990	orig_chan_freq - MHZ_TO_KHZ(20));
1991	rrule2 = freq_reg_info(wiphy,
1992	orig_chan_freq + MHZ_TO_KHZ(20));
1993	if (!IS_ERR(ptr: rrule1) && !IS_ERR(ptr: rrule2)) {
1994	struct ieee80211_freq_range comb_range;
1995
1996	if (rrule1->freq_range.end_freq_khz !=
1997	rrule2->freq_range.start_freq_khz)
1998	goto disable_chan;
1999
2000	comb_range.start_freq_khz =
2001	rrule1->freq_range.start_freq_khz;
2002	comb_range.end_freq_khz =
2003	rrule2->freq_range.end_freq_khz;
2004	comb_range.max_bandwidth_khz =
2005	min_t(u32,
2006	rrule1->freq_range.max_bandwidth_khz,
2007	rrule2->freq_range.max_bandwidth_khz);
2008
2009	if (!cfg80211_does_bw_fit_range(freq_range: &comb_range,
2010	center_freq_khz: orig_chan_freq,
2011	MHZ_TO_KHZ(20)))
2012	goto disable_chan;
2013
2014	handle_channel_adjacent_rules(wiphy, initiator, chan,
2015	flags, lr, request_wiphy,
2016	rrule1, rrule2,
2017	comb_range: &comb_range);
2018	return;
2019	}
2020
2021	disable_chan:
2022	/* We will disable all channels that do not match our
2023	* received regulatory rule unless the hint is coming
2024	* from a Country IE and the Country IE had no information
2025	* about a band. The IEEE 802.11 spec allows for an AP
2026	* to send only a subset of the regulatory rules allowed,
2027	* so an AP in the US that only supports 2.4 GHz may only send
2028	* a country IE with information for the 2.4 GHz band
2029	* while 5 GHz is still supported.
2030	*/
2031	if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
2032	PTR_ERR(ptr: rrule) == -ERANGE)
2033	return;
2034
2035	if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
2036	request_wiphy && request_wiphy == wiphy &&
2037	request_wiphy->regulatory_flags & REGULATORY_STRICT_REG) {
2038	pr_debug("Disabling freq %d.%03d MHz for good\n",
2039	chan->center_freq, chan->freq_offset);
2040	chan->orig_flags |= IEEE80211_CHAN_DISABLED;
2041	chan->flags = chan->orig_flags;
2042	} else {
2043	pr_debug("Disabling freq %d.%03d MHz\n",
2044	chan->center_freq, chan->freq_offset);
2045	chan->flags |= IEEE80211_CHAN_DISABLED;
2046	}
2047	return;
2048	}
2049
2050	handle_channel_single_rule(wiphy, initiator, chan, flags, lr,
2051	request_wiphy, reg_rule: rrule);
2052	}
2053
2054	static void handle_band(struct wiphy *wiphy,
2055	enum nl80211_reg_initiator initiator,
2056	struct ieee80211_supported_band *sband)
2057	{
2058	unsigned int i;
2059
2060	if (!sband)
2061	return;
2062
2063	for (i = 0; i < sband->n_channels; i++)
2064	handle_channel(wiphy, initiator, chan: &sband->channels[i]);
2065	}
2066
2067	static bool reg_request_cell_base(struct regulatory_request *request)
2068	{
2069	if (request->initiator != NL80211_REGDOM_SET_BY_USER)
2070	return false;
2071	return request->user_reg_hint_type == NL80211_USER_REG_HINT_CELL_BASE;
2072	}
2073
2074	bool reg_last_request_cell_base(void)
2075	{
2076	return reg_request_cell_base(request: get_last_request());
2077	}
2078
2079	#ifdef CONFIG_CFG80211_REG_CELLULAR_HINTS
2080	/* Core specific check */
2081	static enum reg_request_treatment
2082	reg_ignore_cell_hint(struct regulatory_request *pending_request)
2083	{
2084	struct regulatory_request *lr = get_last_request();
2085
2086	if (!reg_num_devs_support_basehint)
2087	return REG_REQ_IGNORE;
2088
2089	if (reg_request_cell_base(request: lr) &&
2090	!regdom_changes(alpha2: pending_request->alpha2))
2091	return REG_REQ_ALREADY_SET;
2092
2093	return REG_REQ_OK;
2094	}
2095
2096	/* Device specific check */
2097	static bool reg_dev_ignore_cell_hint(struct wiphy *wiphy)
2098	{
2099	return !(wiphy->features & NL80211_FEATURE_CELL_BASE_REG_HINTS);
2100	}
2101	#else
2102	static enum reg_request_treatment
2103	reg_ignore_cell_hint(struct regulatory_request *pending_request)
2104	{
2105	return REG_REQ_IGNORE;
2106	}
2107
2108	static bool reg_dev_ignore_cell_hint(struct wiphy *wiphy)
2109	{
2110	return true;
2111	}
2112	#endif
2113
2114	static bool wiphy_strict_alpha2_regd(struct wiphy *wiphy)
2115	{
2116	if (wiphy->regulatory_flags & REGULATORY_STRICT_REG &&
2117	!(wiphy->regulatory_flags & REGULATORY_CUSTOM_REG))
2118	return true;
2119	return false;
2120	}
2121
2122	static bool ignore_reg_update(struct wiphy *wiphy,
2123	enum nl80211_reg_initiator initiator)
2124	{
2125	struct regulatory_request *lr = get_last_request();
2126
2127	if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED)
2128	return true;
2129
2130	if (!lr) {
2131	pr_debug("Ignoring regulatory request set by %s since last_request is not set\n",
2132	reg_initiator_name(initiator));
2133	return true;
2134	}
2135
2136	if (initiator == NL80211_REGDOM_SET_BY_CORE &&
2137	wiphy->regulatory_flags & REGULATORY_CUSTOM_REG) {
2138	pr_debug("Ignoring regulatory request set by %s since the driver uses its own custom regulatory domain\n",
2139	reg_initiator_name(initiator));
2140	return true;
2141	}
2142
2143	/*
2144	* wiphy->regd will be set once the device has its own
2145	* desired regulatory domain set
2146	*/
2147	if (wiphy_strict_alpha2_regd(wiphy) && !wiphy->regd &&
2148	initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
2149	!is_world_regdom(alpha2: lr->alpha2)) {
2150	pr_debug("Ignoring regulatory request set by %s since the driver requires its own regulatory domain to be set first\n",
2151	reg_initiator_name(initiator));
2152	return true;
2153	}
2154
2155	if (reg_request_cell_base(request: lr))
2156	return reg_dev_ignore_cell_hint(wiphy);
2157
2158	return false;
2159	}
2160
2161	static bool reg_is_world_roaming(struct wiphy *wiphy)
2162	{
2163	const struct ieee80211_regdomain *cr = get_cfg80211_regdom();
2164	const struct ieee80211_regdomain *wr = get_wiphy_regdom(wiphy);
2165	struct regulatory_request *lr = get_last_request();
2166
2167	if (is_world_regdom(alpha2: cr->alpha2) || (wr && is_world_regdom(alpha2: wr->alpha2)))
2168	return true;
2169
2170	if (lr && lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
2171	wiphy->regulatory_flags & REGULATORY_CUSTOM_REG)
2172	return true;
2173
2174	return false;
2175	}
2176
2177	static void reg_call_notifier(struct wiphy *wiphy,
2178	struct regulatory_request *request)
2179	{
2180	if (wiphy->reg_notifier)
2181	wiphy->reg_notifier(wiphy, request);
2182	}
2183
2184	static void handle_reg_beacon(struct wiphy *wiphy, unsigned int chan_idx,
2185	struct reg_beacon *reg_beacon)
2186	{
2187	struct ieee80211_supported_band *sband;
2188	struct ieee80211_channel *chan;
2189	bool channel_changed = false;
2190	struct ieee80211_channel chan_before;
2191	struct regulatory_request *lr = get_last_request();
2192
2193	sband = wiphy->bands[reg_beacon->chan.band];
2194	chan = &sband->channels[chan_idx];
2195
2196	if (likely(!ieee80211_channel_equal(chan, &reg_beacon->chan)))
2197	return;
2198
2199	if (chan->beacon_found)
2200	return;
2201
2202	chan->beacon_found = true;
2203
2204	if (!reg_is_world_roaming(wiphy))
2205	return;
2206
2207	if (wiphy->regulatory_flags & REGULATORY_DISABLE_BEACON_HINTS)
2208	return;
2209
2210	chan_before = *chan;
2211
2212	if (chan->flags & IEEE80211_CHAN_NO_IR) {
2213	chan->flags &= ~IEEE80211_CHAN_NO_IR;
2214	channel_changed = true;
2215	}
2216
2217	if (channel_changed) {
2218	nl80211_send_beacon_hint_event(wiphy, channel_before: &chan_before, channel_after: chan);
2219	if (wiphy->flags & WIPHY_FLAG_CHANNEL_CHANGE_ON_BEACON)
2220	reg_call_notifier(wiphy, request: lr);
2221	}
2222	}
2223
2224	/*
2225	* Called when a scan on a wiphy finds a beacon on
2226	* new channel
2227	*/
2228	static void wiphy_update_new_beacon(struct wiphy *wiphy,
2229	struct reg_beacon *reg_beacon)
2230	{
2231	unsigned int i;
2232	struct ieee80211_supported_band *sband;
2233
2234	if (!wiphy->bands[reg_beacon->chan.band])
2235	return;
2236
2237	sband = wiphy->bands[reg_beacon->chan.band];
2238
2239	for (i = 0; i < sband->n_channels; i++)
2240	handle_reg_beacon(wiphy, chan_idx: i, reg_beacon);
2241	}
2242
2243	/*
2244	* Called upon reg changes or a new wiphy is added
2245	*/
2246	static void wiphy_update_beacon_reg(struct wiphy *wiphy)
2247	{
2248	unsigned int i;
2249	struct ieee80211_supported_band *sband;
2250	struct reg_beacon *reg_beacon;
2251
2252	list_for_each_entry(reg_beacon, &reg_beacon_list, list) {
2253	if (!wiphy->bands[reg_beacon->chan.band])
2254	continue;
2255	sband = wiphy->bands[reg_beacon->chan.band];
2256	for (i = 0; i < sband->n_channels; i++)
2257	handle_reg_beacon(wiphy, chan_idx: i, reg_beacon);
2258	}
2259	}
2260
2261	/* Reap the advantages of previously found beacons */
2262	static void reg_process_beacons(struct wiphy *wiphy)
2263	{
2264	/*
2265	* Means we are just firing up cfg80211, so no beacons would
2266	* have been processed yet.
2267	*/
2268	if (!last_request)
2269	return;
2270	wiphy_update_beacon_reg(wiphy);
2271	}
2272
2273	static bool is_ht40_allowed(struct ieee80211_channel *chan)
2274	{
2275	if (!chan)
2276	return false;
2277	if (chan->flags & IEEE80211_CHAN_DISABLED)
2278	return false;
2279	/* This would happen when regulatory rules disallow HT40 completely */
2280	if ((chan->flags & IEEE80211_CHAN_NO_HT40) == IEEE80211_CHAN_NO_HT40)
2281	return false;
2282	return true;
2283	}
2284
2285	static void reg_process_ht_flags_channel(struct wiphy *wiphy,
2286	struct ieee80211_channel *channel)
2287	{
2288	struct ieee80211_supported_band *sband = wiphy->bands[channel->band];
2289	struct ieee80211_channel *channel_before = NULL, *channel_after = NULL;
2290	const struct ieee80211_regdomain *regd;
2291	unsigned int i;
2292	u32 flags;
2293
2294	if (!is_ht40_allowed(chan: channel)) {
2295	channel->flags |= IEEE80211_CHAN_NO_HT40;
2296	return;
2297	}
2298
2299	/*
2300	* We need to ensure the extension channels exist to
2301	* be able to use HT40- or HT40+, this finds them (or not)
2302	*/
2303	for (i = 0; i < sband->n_channels; i++) {
2304	struct ieee80211_channel *c = &sband->channels[i];
2305
2306	if (c->center_freq == (channel->center_freq - 20))
2307	channel_before = c;
2308	if (c->center_freq == (channel->center_freq + 20))
2309	channel_after = c;
2310	}
2311
2312	flags = 0;
2313	regd = get_wiphy_regdom(wiphy);
2314	if (regd) {
2315	const struct ieee80211_reg_rule *reg_rule =
2316	freq_reg_info_regd(MHZ_TO_KHZ(channel->center_freq),
2317	regd, MHZ_TO_KHZ(20));
2318
2319	if (!IS_ERR(ptr: reg_rule))
2320	flags = reg_rule->flags;
2321	}
2322
2323	/*
2324	* Please note that this assumes target bandwidth is 20 MHz,
2325	* if that ever changes we also need to change the below logic
2326	* to include that as well.
2327	*/
2328	if (!is_ht40_allowed(chan: channel_before) ||
2329	flags & NL80211_RRF_NO_HT40MINUS)
2330	channel->flags |= IEEE80211_CHAN_NO_HT40MINUS;
2331	else
2332	channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
2333
2334	if (!is_ht40_allowed(chan: channel_after) ||
2335	flags & NL80211_RRF_NO_HT40PLUS)
2336	channel->flags |= IEEE80211_CHAN_NO_HT40PLUS;
2337	else
2338	channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
2339	}
2340
2341	static void reg_process_ht_flags_band(struct wiphy *wiphy,
2342	struct ieee80211_supported_band *sband)
2343	{
2344	unsigned int i;
2345
2346	if (!sband)
2347	return;
2348
2349	for (i = 0; i < sband->n_channels; i++)
2350	reg_process_ht_flags_channel(wiphy, channel: &sband->channels[i]);
2351	}
2352
2353	static void reg_process_ht_flags(struct wiphy *wiphy)
2354	{
2355	enum nl80211_band band;
2356
2357	if (!wiphy)
2358	return;
2359
2360	for (band = 0; band < NUM_NL80211_BANDS; band++)
2361	reg_process_ht_flags_band(wiphy, sband: wiphy->bands[band]);
2362	}
2363
2364	static bool reg_wdev_chan_valid(struct wiphy *wiphy, struct wireless_dev *wdev)
2365	{
2366	struct cfg80211_chan_def chandef = {};
2367	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
2368	enum nl80211_iftype iftype;
2369	bool ret;
2370	int link;
2371
2372	iftype = wdev->iftype;
2373
2374	/* make sure the interface is active */
2375	if (!wdev->netdev || !netif_running(dev: wdev->netdev))
2376	return true;
2377
2378	for (link = 0; link < ARRAY_SIZE(wdev->links); link++) {
2379	struct ieee80211_channel *chan;
2380
2381	if (!wdev->valid_links && link > 0)
2382	break;
2383	if (wdev->valid_links && !(wdev->valid_links & BIT(link)))
2384	continue;
2385	switch (iftype) {
2386	case NL80211_IFTYPE_AP:
2387	case NL80211_IFTYPE_P2P_GO:
2388	if (!wdev->links[link].ap.beacon_interval)
2389	continue;
2390	chandef = wdev->links[link].ap.chandef;
2391	break;
2392	case NL80211_IFTYPE_MESH_POINT:
2393	if (!wdev->u.mesh.beacon_interval)
2394	continue;
2395	chandef = wdev->u.mesh.chandef;
2396	break;
2397	case NL80211_IFTYPE_ADHOC:
2398	if (!wdev->u.ibss.ssid_len)
2399	continue;
2400	chandef = wdev->u.ibss.chandef;
2401	break;
2402	case NL80211_IFTYPE_STATION:
2403	case NL80211_IFTYPE_P2P_CLIENT:
2404	/* Maybe we could consider disabling that link only? */
2405	if (!wdev->links[link].client.current_bss)
2406	continue;
2407
2408	chan = wdev->links[link].client.current_bss->pub.channel;
2409	if (!chan)
2410	continue;
2411
2412	if (!rdev->ops->get_channel ||
2413	rdev_get_channel(rdev, wdev, link_id: link, chandef: &chandef))
2414	cfg80211_chandef_create(chandef: &chandef, channel: chan,
2415	chantype: NL80211_CHAN_NO_HT);
2416	break;
2417	case NL80211_IFTYPE_MONITOR:
2418	case NL80211_IFTYPE_AP_VLAN:
2419	case NL80211_IFTYPE_P2P_DEVICE:
2420	/* no enforcement required */
2421	break;
2422	case NL80211_IFTYPE_OCB:
2423	if (!wdev->u.ocb.chandef.chan)
2424	continue;
2425	chandef = wdev->u.ocb.chandef;
2426	break;
2427	case NL80211_IFTYPE_NAN:
2428	/* we have no info, but NAN is also pretty universal */
2429	continue;
2430	default:
2431	/* others not implemented for now */
2432	WARN_ON_ONCE(1);
2433	break;
2434	}
2435
2436	switch (iftype) {
2437	case NL80211_IFTYPE_AP:
2438	case NL80211_IFTYPE_P2P_GO:
2439	case NL80211_IFTYPE_ADHOC:
2440	case NL80211_IFTYPE_MESH_POINT:
2441	ret = cfg80211_reg_can_beacon_relax(wiphy, chandef: &chandef,
2442	iftype);
2443	if (!ret)
2444	return ret;
2445	break;
2446	case NL80211_IFTYPE_STATION:
2447	case NL80211_IFTYPE_P2P_CLIENT:
2448	ret = cfg80211_chandef_usable(wiphy, chandef: &chandef,
2449	prohibited_flags: IEEE80211_CHAN_DISABLED);
2450	if (!ret)
2451	return ret;
2452	break;
2453	default:
2454	break;
2455	}
2456	}
2457
2458	return true;
2459	}
2460
2461	static void reg_leave_invalid_chans(struct wiphy *wiphy)
2462	{
2463	struct wireless_dev *wdev;
2464	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
2465
2466	wiphy_lock(wiphy);
2467	list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list)
2468	if (!reg_wdev_chan_valid(wiphy, wdev))
2469	cfg80211_leave(rdev, wdev);
2470	wiphy_unlock(wiphy);
2471	}
2472
2473	static void reg_check_chans_work(struct work_struct *work)
2474	{
2475	struct cfg80211_registered_device *rdev;
2476
2477	pr_debug("Verifying active interfaces after reg change\n");
2478	rtnl_lock();
2479
2480	for_each_rdev(rdev)
2481	reg_leave_invalid_chans(wiphy: &rdev->wiphy);
2482
2483	rtnl_unlock();
2484	}
2485
2486	void reg_check_channels(void)
2487	{
2488	/*
2489	* Give usermode a chance to do something nicer (move to another
2490	* channel, orderly disconnection), before forcing a disconnection.
2491	*/
2492	mod_delayed_work(wq: system_power_efficient_wq,
2493	dwork: &reg_check_chans,
2494	delay: msecs_to_jiffies(REG_ENFORCE_GRACE_MS));
2495	}
2496
2497	static void wiphy_update_regulatory(struct wiphy *wiphy,
2498	enum nl80211_reg_initiator initiator)
2499	{
2500	enum nl80211_band band;
2501	struct regulatory_request *lr = get_last_request();
2502
2503	if (ignore_reg_update(wiphy, initiator)) {
2504	/*
2505	* Regulatory updates set by CORE are ignored for custom
2506	* regulatory cards. Let us notify the changes to the driver,
2507	* as some drivers used this to restore its orig_* reg domain.
2508	*/
2509	if (initiator == NL80211_REGDOM_SET_BY_CORE &&
2510	wiphy->regulatory_flags & REGULATORY_CUSTOM_REG &&
2511	!(wiphy->regulatory_flags &
2512	REGULATORY_WIPHY_SELF_MANAGED))
2513	reg_call_notifier(wiphy, request: lr);
2514	return;
2515	}
2516
2517	lr->dfs_region = get_cfg80211_regdom()->dfs_region;
2518
2519	for (band = 0; band < NUM_NL80211_BANDS; band++)
2520	handle_band(wiphy, initiator, sband: wiphy->bands[band]);
2521
2522	reg_process_beacons(wiphy);
2523	reg_process_ht_flags(wiphy);
2524	reg_call_notifier(wiphy, request: lr);
2525	}
2526
2527	static void update_all_wiphy_regulatory(enum nl80211_reg_initiator initiator)
2528	{
2529	struct cfg80211_registered_device *rdev;
2530	struct wiphy *wiphy;
2531
2532	ASSERT_RTNL();
2533
2534	for_each_rdev(rdev) {
2535	wiphy = &rdev->wiphy;
2536	wiphy_update_regulatory(wiphy, initiator);
2537	}
2538
2539	reg_check_channels();
2540	}
2541
2542	static void handle_channel_custom(struct wiphy *wiphy,
2543	struct ieee80211_channel *chan,
2544	const struct ieee80211_regdomain *regd,
2545	u32 min_bw)
2546	{
2547	u32 bw_flags = 0;
2548	const struct ieee80211_reg_rule *reg_rule = NULL;
2549	const struct ieee80211_power_rule *power_rule = NULL;
2550	u32 bw, center_freq_khz;
2551
2552	center_freq_khz = ieee80211_channel_to_khz(chan);
2553	for (bw = MHZ_TO_KHZ(20); bw >= min_bw; bw = bw / 2) {
2554	reg_rule = freq_reg_info_regd(center_freq: center_freq_khz, regd, bw);
2555	if (!IS_ERR(ptr: reg_rule))
2556	break;
2557	}
2558
2559	if (IS_ERR_OR_NULL(ptr: reg_rule)) {
2560	pr_debug("Disabling freq %d.%03d MHz as custom regd has no rule that fits it\n",
2561	chan->center_freq, chan->freq_offset);
2562	if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) {
2563	chan->flags |= IEEE80211_CHAN_DISABLED;
2564	} else {
2565	chan->orig_flags |= IEEE80211_CHAN_DISABLED;
2566	chan->flags = chan->orig_flags;
2567	}
2568	return;
2569	}
2570
2571	power_rule = &reg_rule->power_rule;
2572	bw_flags = reg_rule_to_chan_bw_flags(regd, reg_rule, chan);
2573
2574	chan->dfs_state_entered = jiffies;
2575	chan->dfs_state = NL80211_DFS_USABLE;
2576
2577	chan->beacon_found = false;
2578
2579	if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED)
2580	chan->flags = chan->orig_flags | bw_flags |
2581	map_regdom_flags(rd_flags: reg_rule->flags);
2582	else
2583	chan->flags |= map_regdom_flags(rd_flags: reg_rule->flags) | bw_flags;
2584
2585	chan->max_antenna_gain = (int) MBI_TO_DBI(power_rule->max_antenna_gain);
2586	chan->max_reg_power = chan->max_power =
2587	(int) MBM_TO_DBM(power_rule->max_eirp);
2588
2589	if (chan->flags & IEEE80211_CHAN_RADAR) {
2590	if (reg_rule->dfs_cac_ms)
2591	chan->dfs_cac_ms = reg_rule->dfs_cac_ms;
2592	else
2593	chan->dfs_cac_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
2594	}
2595
2596	if (chan->flags & IEEE80211_CHAN_PSD)
2597	chan->psd = reg_rule->psd;
2598
2599	chan->max_power = chan->max_reg_power;
2600	}
2601
2602	static void handle_band_custom(struct wiphy *wiphy,
2603	struct ieee80211_supported_band *sband,
2604	const struct ieee80211_regdomain *regd)
2605	{
2606	unsigned int i;
2607
2608	if (!sband)
2609	return;
2610
2611	/*
2612	* We currently assume that you always want at least 20 MHz,
2613	* otherwise channel 12 might get enabled if this rule is
2614	* compatible to US, which permits 2402 - 2472 MHz.
2615	*/
2616	for (i = 0; i < sband->n_channels; i++)
2617	handle_channel_custom(wiphy, chan: &sband->channels[i], regd,
2618	MHZ_TO_KHZ(20));
2619	}
2620
2621	/* Used by drivers prior to wiphy registration */
2622	void wiphy_apply_custom_regulatory(struct wiphy *wiphy,
2623	const struct ieee80211_regdomain *regd)
2624	{
2625	const struct ieee80211_regdomain *new_regd, *tmp;
2626	enum nl80211_band band;
2627	unsigned int bands_set = 0;
2628
2629	WARN(!(wiphy->regulatory_flags & REGULATORY_CUSTOM_REG),
2630	"wiphy should have REGULATORY_CUSTOM_REG\n");
2631	wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG;
2632
2633	for (band = 0; band < NUM_NL80211_BANDS; band++) {
2634	if (!wiphy->bands[band])
2635	continue;
2636	handle_band_custom(wiphy, sband: wiphy->bands[band], regd);
2637	bands_set++;
2638	}
2639
2640	/*
2641	* no point in calling this if it won't have any effect
2642	* on your device's supported bands.
2643	*/
2644	WARN_ON(!bands_set);
2645	new_regd = reg_copy_regd(src_regd: regd);
2646	if (IS_ERR(ptr: new_regd))
2647	return;
2648
2649	rtnl_lock();
2650	wiphy_lock(wiphy);
2651
2652	tmp = get_wiphy_regdom(wiphy);
2653	rcu_assign_pointer(wiphy->regd, new_regd);
2654	rcu_free_regdom(r: tmp);
2655
2656	wiphy_unlock(wiphy);
2657	rtnl_unlock();
2658	}
2659	EXPORT_SYMBOL(wiphy_apply_custom_regulatory);
2660
2661	static void reg_set_request_processed(void)
2662	{
2663	bool need_more_processing = false;
2664	struct regulatory_request *lr = get_last_request();
2665
2666	lr->processed = true;
2667
2668	spin_lock(lock: &reg_requests_lock);
2669	if (!list_empty(head: &reg_requests_list))
2670	need_more_processing = true;
2671	spin_unlock(lock: &reg_requests_lock);
2672
2673	cancel_crda_timeout();
2674
2675	if (need_more_processing)
2676	schedule_work(work: &reg_work);
2677	}
2678
2679	/**
2680	* reg_process_hint_core - process core regulatory requests
2681	* @core_request: a pending core regulatory request
2682	*
2683	* The wireless subsystem can use this function to process
2684	* a regulatory request issued by the regulatory core.
2685	*
2686	* Returns: %REG_REQ_OK or %REG_REQ_IGNORE, indicating if the
2687	* hint was processed or ignored
2688	*/
2689	static enum reg_request_treatment
2690	reg_process_hint_core(struct regulatory_request *core_request)
2691	{
2692	if (reg_query_database(request: core_request)) {
2693	core_request->intersect = false;
2694	core_request->processed = false;
2695	reg_update_last_request(request: core_request);
2696	return REG_REQ_OK;
2697	}
2698
2699	return REG_REQ_IGNORE;
2700	}
2701
2702	static enum reg_request_treatment
2703	__reg_process_hint_user(struct regulatory_request *user_request)
2704	{
2705	struct regulatory_request *lr = get_last_request();
2706
2707	if (reg_request_cell_base(request: user_request))
2708	return reg_ignore_cell_hint(pending_request: user_request);
2709
2710	if (reg_request_cell_base(request: lr))
2711	return REG_REQ_IGNORE;
2712
2713	if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE)
2714	return REG_REQ_INTERSECT;
2715	/*
2716	* If the user knows better the user should set the regdom
2717	* to their country before the IE is picked up
2718	*/
2719	if (lr->initiator == NL80211_REGDOM_SET_BY_USER &&
2720	lr->intersect)
2721	return REG_REQ_IGNORE;
2722	/*
2723	* Process user requests only after previous user/driver/core
2724	* requests have been processed
2725	*/
2726	if ((lr->initiator == NL80211_REGDOM_SET_BY_CORE ||
2727	lr->initiator == NL80211_REGDOM_SET_BY_DRIVER ||
2728	lr->initiator == NL80211_REGDOM_SET_BY_USER) &&
2729	regdom_changes(alpha2: lr->alpha2))
2730	return REG_REQ_IGNORE;
2731
2732	if (!regdom_changes(alpha2: user_request->alpha2))
2733	return REG_REQ_ALREADY_SET;
2734
2735	return REG_REQ_OK;
2736	}
2737
2738	/**
2739	* reg_process_hint_user - process user regulatory requests
2740	* @user_request: a pending user regulatory request
2741	*
2742	* The wireless subsystem can use this function to process
2743	* a regulatory request initiated by userspace.
2744	*
2745	* Returns: %REG_REQ_OK or %REG_REQ_IGNORE, indicating if the
2746	* hint was processed or ignored
2747	*/
2748	static enum reg_request_treatment
2749	reg_process_hint_user(struct regulatory_request *user_request)
2750	{
2751	enum reg_request_treatment treatment;
2752
2753	treatment = __reg_process_hint_user(user_request);
2754	if (treatment == REG_REQ_IGNORE ||
2755	treatment == REG_REQ_ALREADY_SET)
2756	return REG_REQ_IGNORE;
2757
2758	user_request->intersect = treatment == REG_REQ_INTERSECT;
2759	user_request->processed = false;
2760
2761	if (reg_query_database(request: user_request)) {
2762	reg_update_last_request(request: user_request);
2763	user_alpha2[0] = user_request->alpha2[0];
2764	user_alpha2[1] = user_request->alpha2[1];
2765	return REG_REQ_OK;
2766	}
2767
2768	return REG_REQ_IGNORE;
2769	}
2770
2771	static enum reg_request_treatment
2772	__reg_process_hint_driver(struct regulatory_request *driver_request)
2773	{
2774	struct regulatory_request *lr = get_last_request();
2775
2776	if (lr->initiator == NL80211_REGDOM_SET_BY_CORE) {
2777	if (regdom_changes(alpha2: driver_request->alpha2))
2778	return REG_REQ_OK;
2779	return REG_REQ_ALREADY_SET;
2780	}
2781
2782	/*
2783	* This would happen if you unplug and plug your card
2784	* back in or if you add a new device for which the previously
2785	* loaded card also agrees on the regulatory domain.
2786	*/
2787	if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
2788	!regdom_changes(alpha2: driver_request->alpha2))
2789	return REG_REQ_ALREADY_SET;
2790
2791	return REG_REQ_INTERSECT;
2792	}
2793
2794	/**
2795	* reg_process_hint_driver - process driver regulatory requests
2796	* @wiphy: the wireless device for the regulatory request
2797	* @driver_request: a pending driver regulatory request
2798	*
2799	* The wireless subsystem can use this function to process
2800	* a regulatory request issued by an 802.11 driver.
2801	*
2802	* Returns: one of the different reg request treatment values.
2803	*/
2804	static enum reg_request_treatment
2805	reg_process_hint_driver(struct wiphy *wiphy,
2806	struct regulatory_request *driver_request)
2807	{
2808	const struct ieee80211_regdomain *regd, *tmp;
2809	enum reg_request_treatment treatment;
2810
2811	treatment = __reg_process_hint_driver(driver_request);
2812
2813	switch (treatment) {
2814	case REG_REQ_OK:
2815	break;
2816	case REG_REQ_IGNORE:
2817	return REG_REQ_IGNORE;
2818	case REG_REQ_INTERSECT:
2819	case REG_REQ_ALREADY_SET:
2820	regd = reg_copy_regd(src_regd: get_cfg80211_regdom());
2821	if (IS_ERR(ptr: regd))
2822	return REG_REQ_IGNORE;
2823
2824	tmp = get_wiphy_regdom(wiphy);
2825	ASSERT_RTNL();
2826	wiphy_lock(wiphy);
2827	rcu_assign_pointer(wiphy->regd, regd);
2828	wiphy_unlock(wiphy);
2829	rcu_free_regdom(r: tmp);
2830	}
2831
2832
2833	driver_request->intersect = treatment == REG_REQ_INTERSECT;
2834	driver_request->processed = false;
2835
2836	/*
2837	* Since CRDA will not be called in this case as we already
2838	* have applied the requested regulatory domain before we just
2839	* inform userspace we have processed the request
2840	*/
2841	if (treatment == REG_REQ_ALREADY_SET) {
2842	nl80211_send_reg_change_event(request: driver_request);
2843	reg_update_last_request(request: driver_request);
2844	reg_set_request_processed();
2845	return REG_REQ_ALREADY_SET;
2846	}
2847
2848	if (reg_query_database(request: driver_request)) {
2849	reg_update_last_request(request: driver_request);
2850	return REG_REQ_OK;
2851	}
2852
2853	return REG_REQ_IGNORE;
2854	}
2855
2856	static enum reg_request_treatment
2857	__reg_process_hint_country_ie(struct wiphy *wiphy,
2858	struct regulatory_request *country_ie_request)
2859	{
2860	struct wiphy *last_wiphy = NULL;
2861	struct regulatory_request *lr = get_last_request();
2862
2863	if (reg_request_cell_base(request: lr)) {
2864	/* Trust a Cell base station over the AP's country IE */
2865	if (regdom_changes(alpha2: country_ie_request->alpha2))
2866	return REG_REQ_IGNORE;
2867	return REG_REQ_ALREADY_SET;
2868	} else {
2869	if (wiphy->regulatory_flags & REGULATORY_COUNTRY_IE_IGNORE)
2870	return REG_REQ_IGNORE;
2871	}
2872
2873	if (unlikely(!is_an_alpha2(country_ie_request->alpha2)))
2874	return -EINVAL;
2875
2876	if (lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE)
2877	return REG_REQ_OK;
2878
2879	last_wiphy = wiphy_idx_to_wiphy(wiphy_idx: lr->wiphy_idx);
2880
2881	if (last_wiphy != wiphy) {
2882	/*
2883	* Two cards with two APs claiming different
2884	* Country IE alpha2s. We could
2885	* intersect them, but that seems unlikely
2886	* to be correct. Reject second one for now.
2887	*/
2888	if (regdom_changes(alpha2: country_ie_request->alpha2))
2889	return REG_REQ_IGNORE;
2890	return REG_REQ_ALREADY_SET;
2891	}
2892
2893	if (regdom_changes(alpha2: country_ie_request->alpha2))
2894	return REG_REQ_OK;
2895	return REG_REQ_ALREADY_SET;
2896	}
2897
2898	/**
2899	* reg_process_hint_country_ie - process regulatory requests from country IEs
2900	* @wiphy: the wireless device for the regulatory request
2901	* @country_ie_request: a regulatory request from a country IE
2902	*
2903	* The wireless subsystem can use this function to process
2904	* a regulatory request issued by a country Information Element.
2905	*
2906	* Returns: one of the different reg request treatment values.
2907	*/
2908	static enum reg_request_treatment
2909	reg_process_hint_country_ie(struct wiphy *wiphy,
2910	struct regulatory_request *country_ie_request)
2911	{
2912	enum reg_request_treatment treatment;
2913
2914	treatment = __reg_process_hint_country_ie(wiphy, country_ie_request);
2915
2916	switch (treatment) {
2917	case REG_REQ_OK:
2918	break;
2919	case REG_REQ_IGNORE:
2920	return REG_REQ_IGNORE;
2921	case REG_REQ_ALREADY_SET:
2922	reg_free_request(request: country_ie_request);
2923	return REG_REQ_ALREADY_SET;
2924	case REG_REQ_INTERSECT:
2925	/*
2926	* This doesn't happen yet, not sure we
2927	* ever want to support it for this case.
2928	*/
2929	WARN_ONCE(1, "Unexpected intersection for country elements");
2930	return REG_REQ_IGNORE;
2931	}
2932
2933	country_ie_request->intersect = false;
2934	country_ie_request->processed = false;
2935
2936	if (reg_query_database(request: country_ie_request)) {
2937	reg_update_last_request(request: country_ie_request);
2938	return REG_REQ_OK;
2939	}
2940
2941	return REG_REQ_IGNORE;
2942	}
2943
2944	bool reg_dfs_domain_same(struct wiphy *wiphy1, struct wiphy *wiphy2)
2945	{
2946	const struct ieee80211_regdomain *wiphy1_regd = NULL;
2947	const struct ieee80211_regdomain *wiphy2_regd = NULL;
2948	const struct ieee80211_regdomain *cfg80211_regd = NULL;
2949	bool dfs_domain_same;
2950
2951	rcu_read_lock();
2952
2953	cfg80211_regd = rcu_dereference(cfg80211_regdomain);
2954	wiphy1_regd = rcu_dereference(wiphy1->regd);
2955	if (!wiphy1_regd)
2956	wiphy1_regd = cfg80211_regd;
2957
2958	wiphy2_regd = rcu_dereference(wiphy2->regd);
2959	if (!wiphy2_regd)
2960	wiphy2_regd = cfg80211_regd;
2961
2962	dfs_domain_same = wiphy1_regd->dfs_region == wiphy2_regd->dfs_region;
2963
2964	rcu_read_unlock();
2965
2966	return dfs_domain_same;
2967	}
2968
2969	static void reg_copy_dfs_chan_state(struct ieee80211_channel *dst_chan,
2970	struct ieee80211_channel *src_chan)
2971	{
2972	if (!(dst_chan->flags & IEEE80211_CHAN_RADAR) ||
2973	!(src_chan->flags & IEEE80211_CHAN_RADAR))
2974	return;
2975
2976	if (dst_chan->flags & IEEE80211_CHAN_DISABLED ||
2977	src_chan->flags & IEEE80211_CHAN_DISABLED)
2978	return;
2979
2980	if (src_chan->center_freq == dst_chan->center_freq &&
2981	dst_chan->dfs_state == NL80211_DFS_USABLE) {
2982	dst_chan->dfs_state = src_chan->dfs_state;
2983	dst_chan->dfs_state_entered = src_chan->dfs_state_entered;
2984	}
2985	}
2986
2987	static void wiphy_share_dfs_chan_state(struct wiphy *dst_wiphy,
2988	struct wiphy *src_wiphy)
2989	{
2990	struct ieee80211_supported_band *src_sband, *dst_sband;
2991	struct ieee80211_channel *src_chan, *dst_chan;
2992	int i, j, band;
2993
2994	if (!reg_dfs_domain_same(wiphy1: dst_wiphy, wiphy2: src_wiphy))
2995	return;
2996
2997	for (band = 0; band < NUM_NL80211_BANDS; band++) {
2998	dst_sband = dst_wiphy->bands[band];
2999	src_sband = src_wiphy->bands[band];
3000	if (!dst_sband || !src_sband)
3001	continue;
3002
3003	for (i = 0; i < dst_sband->n_channels; i++) {
3004	dst_chan = &dst_sband->channels[i];
3005	for (j = 0; j < src_sband->n_channels; j++) {
3006	src_chan = &src_sband->channels[j];
3007	reg_copy_dfs_chan_state(dst_chan, src_chan);
3008	}
3009	}
3010	}
3011	}
3012
3013	static void wiphy_all_share_dfs_chan_state(struct wiphy *wiphy)
3014	{
3015	struct cfg80211_registered_device *rdev;
3016
3017	ASSERT_RTNL();
3018
3019	for_each_rdev(rdev) {
3020	if (wiphy == &rdev->wiphy)
3021	continue;
3022	wiphy_share_dfs_chan_state(dst_wiphy: wiphy, src_wiphy: &rdev->wiphy);
3023	}
3024	}
3025
3026	/* This processes *all* regulatory hints */
3027	static void reg_process_hint(struct regulatory_request *reg_request)
3028	{
3029	struct wiphy *wiphy = NULL;
3030	enum reg_request_treatment treatment;
3031	enum nl80211_reg_initiator initiator = reg_request->initiator;
3032
3033	if (reg_request->wiphy_idx != WIPHY_IDX_INVALID)
3034	wiphy = wiphy_idx_to_wiphy(wiphy_idx: reg_request->wiphy_idx);
3035
3036	switch (initiator) {
3037	case NL80211_REGDOM_SET_BY_CORE:
3038	treatment = reg_process_hint_core(core_request: reg_request);
3039	break;
3040	case NL80211_REGDOM_SET_BY_USER:
3041	treatment = reg_process_hint_user(user_request: reg_request);
3042	break;
3043	case NL80211_REGDOM_SET_BY_DRIVER:
3044	if (!wiphy)
3045	goto out_free;
3046	treatment = reg_process_hint_driver(wiphy, driver_request: reg_request);
3047	break;
3048	case NL80211_REGDOM_SET_BY_COUNTRY_IE:
3049	if (!wiphy)
3050	goto out_free;
3051	treatment = reg_process_hint_country_ie(wiphy, country_ie_request: reg_request);
3052	break;
3053	default:
3054	WARN(1, "invalid initiator %d\n", initiator);
3055	goto out_free;
3056	}
3057
3058	if (treatment == REG_REQ_IGNORE)
3059	goto out_free;
3060
3061	WARN(treatment != REG_REQ_OK && treatment != REG_REQ_ALREADY_SET,
3062	"unexpected treatment value %d\n", treatment);
3063
3064	/* This is required so that the orig_* parameters are saved.
3065	* NOTE: treatment must be set for any case that reaches here!
3066	*/
3067	if (treatment == REG_REQ_ALREADY_SET && wiphy &&
3068	wiphy->regulatory_flags & REGULATORY_STRICT_REG) {
3069	wiphy_update_regulatory(wiphy, initiator);
3070	wiphy_all_share_dfs_chan_state(wiphy);
3071	reg_check_channels();
3072	}
3073
3074	return;
3075
3076	out_free:
3077	reg_free_request(request: reg_request);
3078	}
3079
3080	static void notify_self_managed_wiphys(struct regulatory_request *request)
3081	{
3082	struct cfg80211_registered_device *rdev;
3083	struct wiphy *wiphy;
3084
3085	for_each_rdev(rdev) {
3086	wiphy = &rdev->wiphy;
3087	if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
3088	request->initiator == NL80211_REGDOM_SET_BY_USER)
3089	reg_call_notifier(wiphy, request);
3090	}
3091	}
3092
3093	/*
3094	* Processes regulatory hints, this is all the NL80211_REGDOM_SET_BY_*
3095	* Regulatory hints come on a first come first serve basis and we
3096	* must process each one atomically.
3097	*/
3098	static void reg_process_pending_hints(void)
3099	{
3100	struct regulatory_request *reg_request, *lr;
3101
3102	lr = get_last_request();
3103
3104	/* When last_request->processed becomes true this will be rescheduled */
3105	if (lr && !lr->processed) {
3106	pr_debug("Pending regulatory request, waiting for it to be processed...\n");
3107	return;
3108	}
3109
3110	spin_lock(lock: &reg_requests_lock);
3111
3112	if (list_empty(head: &reg_requests_list)) {
3113	spin_unlock(lock: &reg_requests_lock);
3114	return;
3115	}
3116
3117	reg_request = list_first_entry(&reg_requests_list,
3118	struct regulatory_request,
3119	list);
3120	list_del_init(entry: &reg_request->list);
3121
3122	spin_unlock(lock: &reg_requests_lock);
3123
3124	notify_self_managed_wiphys(request: reg_request);
3125
3126	reg_process_hint(reg_request);
3127
3128	lr = get_last_request();
3129
3130	spin_lock(lock: &reg_requests_lock);
3131	if (!list_empty(head: &reg_requests_list) && lr && lr->processed)
3132	schedule_work(work: &reg_work);
3133	spin_unlock(lock: &reg_requests_lock);
3134	}
3135
3136	/* Processes beacon hints -- this has nothing to do with country IEs */
3137	static void reg_process_pending_beacon_hints(void)
3138	{
3139	struct cfg80211_registered_device *rdev;
3140	struct reg_beacon *pending_beacon, *tmp;
3141
3142	/* This goes through the _pending_ beacon list */
3143	spin_lock_bh(lock: &reg_pending_beacons_lock);
3144
3145	list_for_each_entry_safe(pending_beacon, tmp,
3146	&reg_pending_beacons, list) {
3147	list_del_init(entry: &pending_beacon->list);
3148
3149	/* Applies the beacon hint to current wiphys */
3150	for_each_rdev(rdev)
3151	wiphy_update_new_beacon(wiphy: &rdev->wiphy, reg_beacon: pending_beacon);
3152
3153	/* Remembers the beacon hint for new wiphys or reg changes */
3154	list_add_tail(new: &pending_beacon->list, head: &reg_beacon_list);
3155	}
3156
3157	spin_unlock_bh(lock: &reg_pending_beacons_lock);
3158	}
3159
3160	static void reg_process_self_managed_hint(struct wiphy *wiphy)
3161	{
3162	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
3163	const struct ieee80211_regdomain *tmp;
3164	const struct ieee80211_regdomain *regd;
3165	enum nl80211_band band;
3166	struct regulatory_request request = {};
3167
3168	ASSERT_RTNL();
3169	lockdep_assert_wiphy(wiphy);
3170
3171	spin_lock(lock: &reg_requests_lock);
3172	regd = rdev->requested_regd;
3173	rdev->requested_regd = NULL;
3174	spin_unlock(lock: &reg_requests_lock);
3175
3176	if (!regd)
3177	return;
3178
3179	tmp = get_wiphy_regdom(wiphy);
3180	rcu_assign_pointer(wiphy->regd, regd);
3181	rcu_free_regdom(r: tmp);
3182
3183	for (band = 0; band < NUM_NL80211_BANDS; band++)
3184	handle_band_custom(wiphy, sband: wiphy->bands[band], regd);
3185
3186	reg_process_ht_flags(wiphy);
3187
3188	request.wiphy_idx = get_wiphy_idx(wiphy);
3189	request.alpha2[0] = regd->alpha2[0];
3190	request.alpha2[1] = regd->alpha2[1];
3191	request.initiator = NL80211_REGDOM_SET_BY_DRIVER;
3192
3193	if (wiphy->flags & WIPHY_FLAG_NOTIFY_REGDOM_BY_DRIVER)
3194	reg_call_notifier(wiphy, request: &request);
3195
3196	nl80211_send_wiphy_reg_change_event(request: &request);
3197	}
3198
3199	static void reg_process_self_managed_hints(void)
3200	{
3201	struct cfg80211_registered_device *rdev;
3202
3203	ASSERT_RTNL();
3204
3205	for_each_rdev(rdev) {
3206	wiphy_lock(wiphy: &rdev->wiphy);
3207	reg_process_self_managed_hint(wiphy: &rdev->wiphy);
3208	wiphy_unlock(wiphy: &rdev->wiphy);
3209	}
3210
3211	reg_check_channels();
3212	}
3213
3214	static void reg_todo(struct work_struct *work)
3215	{
3216	rtnl_lock();
3217	reg_process_pending_hints();
3218	reg_process_pending_beacon_hints();
3219	reg_process_self_managed_hints();
3220	rtnl_unlock();
3221	}
3222
3223	static void queue_regulatory_request(struct regulatory_request *request)
3224	{
3225	request->alpha2[0] = toupper(request->alpha2[0]);
3226	request->alpha2[1] = toupper(request->alpha2[1]);
3227
3228	spin_lock(lock: &reg_requests_lock);
3229	list_add_tail(new: &request->list, head: &reg_requests_list);
3230	spin_unlock(lock: &reg_requests_lock);
3231
3232	schedule_work(work: &reg_work);
3233	}
3234
3235	/*
3236	* Core regulatory hint -- happens during cfg80211_init()
3237	* and when we restore regulatory settings.
3238	*/
3239	static int regulatory_hint_core(const char *alpha2)
3240	{
3241	struct regulatory_request *request;
3242
3243	request = kzalloc(size: sizeof(struct regulatory_request), GFP_KERNEL);
3244	if (!request)
3245	return -ENOMEM;
3246
3247	request->alpha2[0] = alpha2[0];
3248	request->alpha2[1] = alpha2[1];
3249	request->initiator = NL80211_REGDOM_SET_BY_CORE;
3250	request->wiphy_idx = WIPHY_IDX_INVALID;
3251
3252	queue_regulatory_request(request);
3253
3254	return 0;
3255	}
3256
3257	/* User hints */
3258	int regulatory_hint_user(const char *alpha2,
3259	enum nl80211_user_reg_hint_type user_reg_hint_type)
3260	{
3261	struct regulatory_request *request;
3262
3263	if (WARN_ON(!alpha2))
3264	return -EINVAL;
3265
3266	if (!is_world_regdom(alpha2) && !is_an_alpha2(alpha2))
3267	return -EINVAL;
3268
3269	request = kzalloc(size: sizeof(struct regulatory_request), GFP_KERNEL);
3270	if (!request)
3271	return -ENOMEM;
3272
3273	request->wiphy_idx = WIPHY_IDX_INVALID;
3274	request->alpha2[0] = alpha2[0];
3275	request->alpha2[1] = alpha2[1];
3276	request->initiator = NL80211_REGDOM_SET_BY_USER;
3277	request->user_reg_hint_type = user_reg_hint_type;
3278
3279	/* Allow calling CRDA again */
3280	reset_crda_timeouts();
3281
3282	queue_regulatory_request(request);
3283
3284	return 0;
3285	}
3286
3287	int regulatory_hint_indoor(bool is_indoor, u32 portid)
3288	{
3289	spin_lock(lock: &reg_indoor_lock);
3290
3291	/* It is possible that more than one user space process is trying to
3292	* configure the indoor setting. To handle such cases, clear the indoor
3293	* setting in case that some process does not think that the device
3294	* is operating in an indoor environment. In addition, if a user space
3295	* process indicates that it is controlling the indoor setting, save its
3296	* portid, i.e., make it the owner.
3297	*/
3298	reg_is_indoor = is_indoor;
3299	if (reg_is_indoor) {
3300	if (!reg_is_indoor_portid)
3301	reg_is_indoor_portid = portid;
3302	} else {
3303	reg_is_indoor_portid = 0;
3304	}
3305
3306	spin_unlock(lock: &reg_indoor_lock);
3307
3308	if (!is_indoor)
3309	reg_check_channels();
3310
3311	return 0;
3312	}
3313
3314	void regulatory_netlink_notify(u32 portid)
3315	{
3316	spin_lock(lock: &reg_indoor_lock);
3317
3318	if (reg_is_indoor_portid != portid) {
3319	spin_unlock(lock: &reg_indoor_lock);
3320	return;
3321	}
3322
3323	reg_is_indoor = false;
3324	reg_is_indoor_portid = 0;
3325
3326	spin_unlock(lock: &reg_indoor_lock);
3327
3328	reg_check_channels();
3329	}
3330
3331	/* Driver hints */
3332	int regulatory_hint(struct wiphy *wiphy, const char *alpha2)
3333	{
3334	struct regulatory_request *request;
3335
3336	if (WARN_ON(!alpha2 || !wiphy))
3337	return -EINVAL;
3338
3339	wiphy->regulatory_flags &= ~REGULATORY_CUSTOM_REG;
3340
3341	request = kzalloc(size: sizeof(struct regulatory_request), GFP_KERNEL);
3342	if (!request)
3343	return -ENOMEM;
3344
3345	request->wiphy_idx = get_wiphy_idx(wiphy);
3346
3347	request->alpha2[0] = alpha2[0];
3348	request->alpha2[1] = alpha2[1];
3349	request->initiator = NL80211_REGDOM_SET_BY_DRIVER;
3350
3351	/* Allow calling CRDA again */
3352	reset_crda_timeouts();
3353
3354	queue_regulatory_request(request);
3355
3356	return 0;
3357	}
3358	EXPORT_SYMBOL(regulatory_hint);
3359
3360	void regulatory_hint_country_ie(struct wiphy *wiphy, enum nl80211_band band,
3361	const u8 *country_ie, u8 country_ie_len)
3362	{
3363	char alpha2[2];
3364	enum environment_cap env = ENVIRON_ANY;
3365	struct regulatory_request *request = NULL, *lr;
3366
3367	/* IE len must be evenly divisible by 2 */
3368	if (country_ie_len & 0x01)
3369	return;
3370
3371	if (country_ie_len < IEEE80211_COUNTRY_IE_MIN_LEN)
3372	return;
3373
3374	request = kzalloc(size: sizeof(*request), GFP_KERNEL);
3375	if (!request)
3376	return;
3377
3378	alpha2[0] = country_ie[0];
3379	alpha2[1] = country_ie[1];
3380
3381	if (country_ie[2] == 'I')
3382	env = ENVIRON_INDOOR;
3383	else if (country_ie[2] == 'O')
3384	env = ENVIRON_OUTDOOR;
3385
3386	rcu_read_lock();
3387	lr = get_last_request();
3388
3389	if (unlikely(!lr))
3390	goto out;
3391
3392	/*
3393	* We will run this only upon a successful connection on cfg80211.
3394	* We leave conflict resolution to the workqueue, where can hold
3395	* the RTNL.
3396	*/
3397	if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
3398	lr->wiphy_idx != WIPHY_IDX_INVALID)
3399	goto out;
3400
3401	request->wiphy_idx = get_wiphy_idx(wiphy);
3402	request->alpha2[0] = alpha2[0];
3403	request->alpha2[1] = alpha2[1];
3404	request->initiator = NL80211_REGDOM_SET_BY_COUNTRY_IE;
3405	request->country_ie_env = env;
3406
3407	/* Allow calling CRDA again */
3408	reset_crda_timeouts();
3409
3410	queue_regulatory_request(request);
3411	request = NULL;
3412	out:
3413	kfree(objp: request);
3414	rcu_read_unlock();
3415	}
3416
3417	static void restore_alpha2(char *alpha2, bool reset_user)
3418	{
3419	/* indicates there is no alpha2 to consider for restoration */
3420	alpha2[0] = '9';
3421	alpha2[1] = '7';
3422
3423	/* The user setting has precedence over the module parameter */
3424	if (is_user_regdom_saved()) {
3425	/* Unless we're asked to ignore it and reset it */
3426	if (reset_user) {
3427	pr_debug("Restoring regulatory settings including user preference\n");
3428	user_alpha2[0] = '9';
3429	user_alpha2[1] = '7';
3430
3431	/*
3432	* If we're ignoring user settings, we still need to
3433	* check the module parameter to ensure we put things
3434	* back as they were for a full restore.
3435	*/
3436	if (!is_world_regdom(alpha2: ieee80211_regdom)) {
3437	pr_debug("Keeping preference on module parameter ieee80211_regdom: %c%c\n",
3438	ieee80211_regdom[0], ieee80211_regdom[1]);
3439	alpha2[0] = ieee80211_regdom[0];
3440	alpha2[1] = ieee80211_regdom[1];
3441	}
3442	} else {
3443	pr_debug("Restoring regulatory settings while preserving user preference for: %c%c\n",
3444	user_alpha2[0], user_alpha2[1]);
3445	alpha2[0] = user_alpha2[0];
3446	alpha2[1] = user_alpha2[1];
3447	}
3448	} else if (!is_world_regdom(alpha2: ieee80211_regdom)) {
3449	pr_debug("Keeping preference on module parameter ieee80211_regdom: %c%c\n",
3450	ieee80211_regdom[0], ieee80211_regdom[1]);
3451	alpha2[0] = ieee80211_regdom[0];
3452	alpha2[1] = ieee80211_regdom[1];
3453	} else
3454	pr_debug("Restoring regulatory settings\n");
3455	}
3456
3457	static void restore_custom_reg_settings(struct wiphy *wiphy)
3458	{
3459	struct ieee80211_supported_band *sband;
3460	enum nl80211_band band;
3461	struct ieee80211_channel *chan;
3462	int i;
3463
3464	for (band = 0; band < NUM_NL80211_BANDS; band++) {
3465	sband = wiphy->bands[band];
3466	if (!sband)
3467	continue;
3468	for (i = 0; i < sband->n_channels; i++) {
3469	chan = &sband->channels[i];
3470	chan->flags = chan->orig_flags;
3471	chan->max_antenna_gain = chan->orig_mag;
3472	chan->max_power = chan->orig_mpwr;
3473	chan->beacon_found = false;
3474	}
3475	}
3476	}
3477
3478	/*
3479	* Restoring regulatory settings involves ignoring any
3480	* possibly stale country IE information and user regulatory
3481	* settings if so desired, this includes any beacon hints
3482	* learned as we could have traveled outside to another country
3483	* after disconnection. To restore regulatory settings we do
3484	* exactly what we did at bootup:
3485	*
3486	* - send a core regulatory hint
3487	* - send a user regulatory hint if applicable
3488	*
3489	* Device drivers that send a regulatory hint for a specific country
3490	* keep their own regulatory domain on wiphy->regd so that does
3491	* not need to be remembered.
3492	*/
3493	static void restore_regulatory_settings(bool reset_user, bool cached)
3494	{
3495	char alpha2[2];
3496	char world_alpha2[2];
3497	struct reg_beacon *reg_beacon, *btmp;
3498	LIST_HEAD(tmp_reg_req_list);
3499	struct cfg80211_registered_device *rdev;
3500
3501	ASSERT_RTNL();
3502
3503	/*
3504	* Clear the indoor setting in case that it is not controlled by user
3505	* space, as otherwise there is no guarantee that the device is still
3506	* operating in an indoor environment.
3507	*/
3508	spin_lock(lock: &reg_indoor_lock);
3509	if (reg_is_indoor && !reg_is_indoor_portid) {
3510	reg_is_indoor = false;
3511	reg_check_channels();
3512	}
3513	spin_unlock(lock: &reg_indoor_lock);
3514
3515	reset_regdomains(full_reset: true, new_regdom: &world_regdom);
3516	restore_alpha2(alpha2, reset_user);
3517
3518	/*
3519	* If there's any pending requests we simply
3520	* stash them to a temporary pending queue and
3521	* add then after we've restored regulatory
3522	* settings.
3523	*/
3524	spin_lock(lock: &reg_requests_lock);
3525	list_splice_tail_init(list: &reg_requests_list, head: &tmp_reg_req_list);
3526	spin_unlock(lock: &reg_requests_lock);
3527
3528	/* Clear beacon hints */
3529	spin_lock_bh(lock: &reg_pending_beacons_lock);
3530	list_for_each_entry_safe(reg_beacon, btmp, &reg_pending_beacons, list) {
3531	list_del(entry: &reg_beacon->list);
3532	kfree(objp: reg_beacon);
3533	}
3534	spin_unlock_bh(lock: &reg_pending_beacons_lock);
3535
3536	list_for_each_entry_safe(reg_beacon, btmp, &reg_beacon_list, list) {
3537	list_del(entry: &reg_beacon->list);
3538	kfree(objp: reg_beacon);
3539	}
3540
3541	/* First restore to the basic regulatory settings */
3542	world_alpha2[0] = cfg80211_world_regdom->alpha2[0];
3543	world_alpha2[1] = cfg80211_world_regdom->alpha2[1];
3544
3545	for_each_rdev(rdev) {
3546	if (rdev->wiphy.regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED)
3547	continue;
3548	if (rdev->wiphy.regulatory_flags & REGULATORY_CUSTOM_REG)
3549	restore_custom_reg_settings(wiphy: &rdev->wiphy);
3550	}
3551
3552	if (cached && (!is_an_alpha2(alpha2) ||
3553	!IS_ERR_OR_NULL(ptr: cfg80211_user_regdom))) {
3554	reset_regdomains(full_reset: false, new_regdom: cfg80211_world_regdom);
3555	update_all_wiphy_regulatory(initiator: NL80211_REGDOM_SET_BY_CORE);
3556	print_regdomain(rd: get_cfg80211_regdom());
3557	nl80211_send_reg_change_event(request: &core_request_world);
3558	reg_set_request_processed();
3559
3560	if (is_an_alpha2(alpha2) &&
3561	!regulatory_hint_user(alpha2, user_reg_hint_type: NL80211_USER_REG_HINT_USER)) {
3562	struct regulatory_request *ureq;
3563
3564	spin_lock(lock: &reg_requests_lock);
3565	ureq = list_last_entry(&reg_requests_list,
3566	struct regulatory_request,
3567	list);
3568	list_del(entry: &ureq->list);
3569	spin_unlock(lock: &reg_requests_lock);
3570
3571	notify_self_managed_wiphys(request: ureq);
3572	reg_update_last_request(request: ureq);
3573	set_regdom(rd: reg_copy_regd(src_regd: cfg80211_user_regdom),
3574	regd_src: REGD_SOURCE_CACHED);
3575	}
3576	} else {
3577	regulatory_hint_core(alpha2: world_alpha2);
3578
3579	/*
3580	* This restores the ieee80211_regdom module parameter
3581	* preference or the last user requested regulatory
3582	* settings, user regulatory settings takes precedence.
3583	*/
3584	if (is_an_alpha2(alpha2))
3585	regulatory_hint_user(alpha2, user_reg_hint_type: NL80211_USER_REG_HINT_USER);
3586	}
3587
3588	spin_lock(lock: &reg_requests_lock);
3589	list_splice_tail_init(list: &tmp_reg_req_list, head: &reg_requests_list);
3590	spin_unlock(lock: &reg_requests_lock);
3591
3592	pr_debug("Kicking the queue\n");
3593
3594	schedule_work(work: &reg_work);
3595	}
3596
3597	static bool is_wiphy_all_set_reg_flag(enum ieee80211_regulatory_flags flag)
3598	{
3599	struct cfg80211_registered_device *rdev;
3600	struct wireless_dev *wdev;
3601
3602	for_each_rdev(rdev) {
3603	wiphy_lock(wiphy: &rdev->wiphy);
3604	list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
3605	if (!(wdev->wiphy->regulatory_flags & flag)) {
3606	wiphy_unlock(wiphy: &rdev->wiphy);
3607	return false;
3608	}
3609	}
3610	wiphy_unlock(wiphy: &rdev->wiphy);
3611	}
3612
3613	return true;
3614	}
3615
3616	void regulatory_hint_disconnect(void)
3617	{
3618	/* Restore of regulatory settings is not required when wiphy(s)
3619	* ignore IE from connected access point but clearance of beacon hints
3620	* is required when wiphy(s) supports beacon hints.
3621	*/
3622	if (is_wiphy_all_set_reg_flag(flag: REGULATORY_COUNTRY_IE_IGNORE)) {
3623	struct reg_beacon *reg_beacon, *btmp;
3624
3625	if (is_wiphy_all_set_reg_flag(flag: REGULATORY_DISABLE_BEACON_HINTS))
3626	return;
3627
3628	spin_lock_bh(lock: &reg_pending_beacons_lock);
3629	list_for_each_entry_safe(reg_beacon, btmp,
3630	&reg_pending_beacons, list) {
3631	list_del(entry: &reg_beacon->list);
3632	kfree(objp: reg_beacon);
3633	}
3634	spin_unlock_bh(lock: &reg_pending_beacons_lock);
3635
3636	list_for_each_entry_safe(reg_beacon, btmp,
3637	&reg_beacon_list, list) {
3638	list_del(entry: &reg_beacon->list);
3639	kfree(objp: reg_beacon);
3640	}
3641
3642	return;
3643	}
3644
3645	pr_debug("All devices are disconnected, going to restore regulatory settings\n");
3646	restore_regulatory_settings(reset_user: false, cached: true);
3647	}
3648
3649	static bool freq_is_chan_12_13_14(u32 freq)
3650	{
3651	if (freq == ieee80211_channel_to_frequency(chan: 12, band: NL80211_BAND_2GHZ) ||
3652	freq == ieee80211_channel_to_frequency(chan: 13, band: NL80211_BAND_2GHZ) ||
3653	freq == ieee80211_channel_to_frequency(chan: 14, band: NL80211_BAND_2GHZ))
3654	return true;
3655	return false;
3656	}
3657
3658	static bool pending_reg_beacon(struct ieee80211_channel *beacon_chan)
3659	{
3660	struct reg_beacon *pending_beacon;
3661
3662	list_for_each_entry(pending_beacon, &reg_pending_beacons, list)
3663	if (ieee80211_channel_equal(a: beacon_chan,
3664	b: &pending_beacon->chan))
3665	return true;
3666	return false;
3667	}
3668
3669	int regulatory_hint_found_beacon(struct wiphy *wiphy,
3670	struct ieee80211_channel *beacon_chan,
3671	gfp_t gfp)
3672	{
3673	struct reg_beacon *reg_beacon;
3674	bool processing;
3675
3676	if (beacon_chan->beacon_found ||
3677	beacon_chan->flags & IEEE80211_CHAN_RADAR ||
3678	(beacon_chan->band == NL80211_BAND_2GHZ &&
3679	!freq_is_chan_12_13_14(freq: beacon_chan->center_freq)))
3680	return 0;
3681
3682	spin_lock_bh(lock: &reg_pending_beacons_lock);
3683	processing = pending_reg_beacon(beacon_chan);
3684	spin_unlock_bh(lock: &reg_pending_beacons_lock);
3685
3686	if (processing)
3687	return 0;
3688
3689	reg_beacon = kzalloc(size: sizeof(struct reg_beacon), flags: gfp);
3690	if (!reg_beacon)
3691	return -ENOMEM;
3692
3693	pr_debug("Found new beacon on frequency: %d.%03d MHz (Ch %d) on %s\n",
3694	beacon_chan->center_freq, beacon_chan->freq_offset,
3695	ieee80211_freq_khz_to_channel(
3696	ieee80211_channel_to_khz(beacon_chan)),
3697	wiphy_name(wiphy));
3698
3699	memcpy(&reg_beacon->chan, beacon_chan,
3700	sizeof(struct ieee80211_channel));
3701
3702	/*
3703	* Since we can be called from BH or and non-BH context
3704	* we must use spin_lock_bh()
3705	*/
3706	spin_lock_bh(lock: &reg_pending_beacons_lock);
3707	list_add_tail(new: &reg_beacon->list, head: &reg_pending_beacons);
3708	spin_unlock_bh(lock: &reg_pending_beacons_lock);
3709
3710	schedule_work(work: &reg_work);
3711
3712	return 0;
3713	}
3714
3715	static void print_rd_rules(const struct ieee80211_regdomain *rd)
3716	{
3717	unsigned int i;
3718	const struct ieee80211_reg_rule *reg_rule = NULL;
3719	const struct ieee80211_freq_range *freq_range = NULL;
3720	const struct ieee80211_power_rule *power_rule = NULL;
3721	char bw[32], cac_time[32];
3722
3723	pr_debug(" (start_freq - end_freq @ bandwidth), (max_antenna_gain, max_eirp), (dfs_cac_time)\n");
3724
3725	for (i = 0; i < rd->n_reg_rules; i++) {
3726	reg_rule = &rd->reg_rules[i];
3727	freq_range = &reg_rule->freq_range;
3728	power_rule = &reg_rule->power_rule;
3729
3730	if (reg_rule->flags & NL80211_RRF_AUTO_BW)
3731	snprintf(buf: bw, size: sizeof(bw), fmt: "%d KHz, %u KHz AUTO",
3732	freq_range->max_bandwidth_khz,
3733	reg_get_max_bandwidth(rd, rule: reg_rule));
3734	else
3735	snprintf(buf: bw, size: sizeof(bw), fmt: "%d KHz",
3736	freq_range->max_bandwidth_khz);
3737
3738	if (reg_rule->flags & NL80211_RRF_DFS)
3739	scnprintf(buf: cac_time, size: sizeof(cac_time), fmt: "%u s",
3740	reg_rule->dfs_cac_ms/1000);
3741	else
3742	scnprintf(buf: cac_time, size: sizeof(cac_time), fmt: "N/A");
3743
3744
3745	/*
3746	* There may not be documentation for max antenna gain
3747	* in certain regions
3748	*/
3749	if (power_rule->max_antenna_gain)
3750	pr_debug(" (%d KHz - %d KHz @ %s), (%d mBi, %d mBm), (%s)\n",
3751	freq_range->start_freq_khz,
3752	freq_range->end_freq_khz,
3753	bw,
3754	power_rule->max_antenna_gain,
3755	power_rule->max_eirp,
3756	cac_time);
3757	else
3758	pr_debug(" (%d KHz - %d KHz @ %s), (N/A, %d mBm), (%s)\n",
3759	freq_range->start_freq_khz,
3760	freq_range->end_freq_khz,
3761	bw,
3762	power_rule->max_eirp,
3763	cac_time);
3764	}
3765	}
3766
3767	bool reg_supported_dfs_region(enum nl80211_dfs_regions dfs_region)
3768	{
3769	switch (dfs_region) {
3770	case NL80211_DFS_UNSET:
3771	case NL80211_DFS_FCC:
3772	case NL80211_DFS_ETSI:
3773	case NL80211_DFS_JP:
3774	return true;
3775	default:
3776	pr_debug("Ignoring unknown DFS master region: %d\n", dfs_region);
3777	return false;
3778	}
3779	}
3780
3781	static void print_regdomain(const struct ieee80211_regdomain *rd)
3782	{
3783	struct regulatory_request *lr = get_last_request();
3784
3785	if (is_intersected_alpha2(alpha2: rd->alpha2)) {
3786	if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE) {
3787	struct cfg80211_registered_device *rdev;
3788	rdev = cfg80211_rdev_by_wiphy_idx(wiphy_idx: lr->wiphy_idx);
3789	if (rdev) {
3790	pr_debug("Current regulatory domain updated by AP to: %c%c\n",
3791	rdev->country_ie_alpha2[0],
3792	rdev->country_ie_alpha2[1]);
3793	} else
3794	pr_debug("Current regulatory domain intersected:\n");
3795	} else
3796	pr_debug("Current regulatory domain intersected:\n");
3797	} else if (is_world_regdom(alpha2: rd->alpha2)) {
3798	pr_debug("World regulatory domain updated:\n");
3799	} else {
3800	if (is_unknown_alpha2(alpha2: rd->alpha2))
3801	pr_debug("Regulatory domain changed to driver built-in settings (unknown country)\n");
3802	else {
3803	if (reg_request_cell_base(request: lr))
3804	pr_debug("Regulatory domain changed to country: %c%c by Cell Station\n",
3805	rd->alpha2[0], rd->alpha2[1]);
3806	else
3807	pr_debug("Regulatory domain changed to country: %c%c\n",
3808	rd->alpha2[0], rd->alpha2[1]);
3809	}
3810	}
3811
3812	pr_debug(" DFS Master region: %s", reg_dfs_region_str(rd->dfs_region));
3813	print_rd_rules(rd);
3814	}
3815
3816	static void print_regdomain_info(const struct ieee80211_regdomain *rd)
3817	{
3818	pr_debug("Regulatory domain: %c%c\n", rd->alpha2[0], rd->alpha2[1]);
3819	print_rd_rules(rd);
3820	}
3821
3822	static int reg_set_rd_core(const struct ieee80211_regdomain *rd)
3823	{
3824	if (!is_world_regdom(alpha2: rd->alpha2))
3825	return -EINVAL;
3826	update_world_regdomain(rd);
3827	return 0;
3828	}
3829
3830	static int reg_set_rd_user(const struct ieee80211_regdomain *rd,
3831	struct regulatory_request *user_request)
3832	{
3833	const struct ieee80211_regdomain *intersected_rd = NULL;
3834
3835	if (!regdom_changes(alpha2: rd->alpha2))
3836	return -EALREADY;
3837
3838	if (!is_valid_rd(rd)) {
3839	pr_err("Invalid regulatory domain detected: %c%c\n",
3840	rd->alpha2[0], rd->alpha2[1]);
3841	print_regdomain_info(rd);
3842	return -EINVAL;
3843	}
3844
3845	if (!user_request->intersect) {
3846	reset_regdomains(full_reset: false, new_regdom: rd);
3847	return 0;
3848	}
3849
3850	intersected_rd = regdom_intersect(rd1: rd, rd2: get_cfg80211_regdom());
3851	if (!intersected_rd)
3852	return -EINVAL;
3853
3854	kfree(objp: rd);
3855	rd = NULL;
3856	reset_regdomains(full_reset: false, new_regdom: intersected_rd);
3857
3858	return 0;
3859	}
3860
3861	static int reg_set_rd_driver(const struct ieee80211_regdomain *rd,
3862	struct regulatory_request *driver_request)
3863	{
3864	const struct ieee80211_regdomain *regd;
3865	const struct ieee80211_regdomain *intersected_rd = NULL;
3866	const struct ieee80211_regdomain *tmp = NULL;
3867	struct wiphy *request_wiphy;
3868
3869	if (is_world_regdom(alpha2: rd->alpha2))
3870	return -EINVAL;
3871
3872	if (!regdom_changes(alpha2: rd->alpha2))
3873	return -EALREADY;
3874
3875	if (!is_valid_rd(rd)) {
3876	pr_err("Invalid regulatory domain detected: %c%c\n",
3877	rd->alpha2[0], rd->alpha2[1]);
3878	print_regdomain_info(rd);
3879	return -EINVAL;
3880	}
3881
3882	request_wiphy = wiphy_idx_to_wiphy(wiphy_idx: driver_request->wiphy_idx);
3883	if (!request_wiphy)
3884	return -ENODEV;
3885
3886	if (!driver_request->intersect) {
3887	ASSERT_RTNL();
3888	wiphy_lock(wiphy: request_wiphy);
3889	if (request_wiphy->regd)
3890	tmp = get_wiphy_regdom(request_wiphy);
3891
3892	regd = reg_copy_regd(src_regd: rd);
3893	if (IS_ERR(ptr: regd)) {
3894	wiphy_unlock(wiphy: request_wiphy);
3895	return PTR_ERR(ptr: regd);
3896	}
3897
3898	rcu_assign_pointer(request_wiphy->regd, regd);
3899	rcu_free_regdom(r: tmp);
3900	wiphy_unlock(wiphy: request_wiphy);
3901	reset_regdomains(full_reset: false, new_regdom: rd);
3902	return 0;
3903	}
3904
3905	intersected_rd = regdom_intersect(rd1: rd, rd2: get_cfg80211_regdom());
3906	if (!intersected_rd)
3907	return -EINVAL;
3908
3909	/*
3910	* We can trash what CRDA provided now.
3911	* However if a driver requested this specific regulatory
3912	* domain we keep it for its private use
3913	*/
3914	tmp = get_wiphy_regdom(request_wiphy);
3915	rcu_assign_pointer(request_wiphy->regd, rd);
3916	rcu_free_regdom(r: tmp);
3917
3918	rd = NULL;
3919
3920	reset_regdomains(full_reset: false, new_regdom: intersected_rd);
3921
3922	return 0;
3923	}
3924
3925	static int reg_set_rd_country_ie(const struct ieee80211_regdomain *rd,
3926	struct regulatory_request *country_ie_request)
3927	{
3928	struct wiphy *request_wiphy;
3929
3930	if (!is_alpha2_set(alpha2: rd->alpha2) && !is_an_alpha2(alpha2: rd->alpha2) &&
3931	!is_unknown_alpha2(alpha2: rd->alpha2))
3932	return -EINVAL;
3933
3934	/*
3935	* Lets only bother proceeding on the same alpha2 if the current
3936	* rd is non static (it means CRDA was present and was used last)
3937	* and the pending request came in from a country IE
3938	*/
3939
3940	if (!is_valid_rd(rd)) {
3941	pr_err("Invalid regulatory domain detected: %c%c\n",
3942	rd->alpha2[0], rd->alpha2[1]);
3943	print_regdomain_info(rd);
3944	return -EINVAL;
3945	}
3946
3947	request_wiphy = wiphy_idx_to_wiphy(wiphy_idx: country_ie_request->wiphy_idx);
3948	if (!request_wiphy)
3949	return -ENODEV;
3950
3951	if (country_ie_request->intersect)
3952	return -EINVAL;
3953
3954	reset_regdomains(full_reset: false, new_regdom: rd);
3955	return 0;
3956	}
3957
3958	/*
3959	* Use this call to set the current regulatory domain. Conflicts with
3960	* multiple drivers can be ironed out later. Caller must've already
3961	* kmalloc'd the rd structure.
3962	*/
3963	int set_regdom(const struct ieee80211_regdomain *rd,
3964	enum ieee80211_regd_source regd_src)
3965	{
3966	struct regulatory_request *lr;
3967	bool user_reset = false;
3968	int r;
3969
3970	if (IS_ERR_OR_NULL(ptr: rd))
3971	return -ENODATA;
3972
3973	if (!reg_is_valid_request(alpha2: rd->alpha2)) {
3974	kfree(objp: rd);
3975	return -EINVAL;
3976	}
3977
3978	if (regd_src == REGD_SOURCE_CRDA)
3979	reset_crda_timeouts();
3980
3981	lr = get_last_request();
3982
3983	/* Note that this doesn't update the wiphys, this is done below */
3984	switch (lr->initiator) {
3985	case NL80211_REGDOM_SET_BY_CORE:
3986	r = reg_set_rd_core(rd);
3987	break;
3988	case NL80211_REGDOM_SET_BY_USER:
3989	cfg80211_save_user_regdom(rd);
3990	r = reg_set_rd_user(rd, user_request: lr);
3991	user_reset = true;
3992	break;
3993	case NL80211_REGDOM_SET_BY_DRIVER:
3994	r = reg_set_rd_driver(rd, driver_request: lr);
3995	break;
3996	case NL80211_REGDOM_SET_BY_COUNTRY_IE:
3997	r = reg_set_rd_country_ie(rd, country_ie_request: lr);
3998	break;
3999	default:
4000	WARN(1, "invalid initiator %d\n", lr->initiator);
4001	kfree(objp: rd);
4002	return -EINVAL;
4003	}
4004
4005	if (r) {
4006	switch (r) {
4007	case -EALREADY:
4008	reg_set_request_processed();
4009	break;
4010	default:
4011	/* Back to world regulatory in case of errors */
4012	restore_regulatory_settings(reset_user: user_reset, cached: false);
4013	}
4014
4015	kfree(objp: rd);
4016	return r;
4017	}
4018
4019	/* This would make this whole thing pointless */
4020	if (WARN_ON(!lr->intersect && rd != get_cfg80211_regdom()))
4021	return -EINVAL;
4022
4023	/* update all wiphys now with the new established regulatory domain */
4024	update_all_wiphy_regulatory(initiator: lr->initiator);
4025
4026	print_regdomain(rd: get_cfg80211_regdom());
4027
4028	nl80211_send_reg_change_event(request: lr);
4029
4030	reg_set_request_processed();
4031
4032	return 0;
4033	}
4034
4035	static int __regulatory_set_wiphy_regd(struct wiphy *wiphy,
4036	struct ieee80211_regdomain *rd)
4037	{
4038	const struct ieee80211_regdomain *regd;
4039	const struct ieee80211_regdomain *prev_regd;
4040	struct cfg80211_registered_device *rdev;
4041
4042	if (WARN_ON(!wiphy || !rd))
4043	return -EINVAL;
4044
4045	if (WARN(!(wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED),
4046	"wiphy should have REGULATORY_WIPHY_SELF_MANAGED\n"))
4047	return -EPERM;
4048
4049	if (WARN(!is_valid_rd(rd),
4050	"Invalid regulatory domain detected: %c%c\n",
4051	rd->alpha2[0], rd->alpha2[1])) {
4052	print_regdomain_info(rd);
4053	return -EINVAL;
4054	}
4055
4056	regd = reg_copy_regd(src_regd: rd);
4057	if (IS_ERR(ptr: regd))
4058	return PTR_ERR(ptr: regd);
4059
4060	rdev = wiphy_to_rdev(wiphy);
4061
4062	spin_lock(lock: &reg_requests_lock);
4063	prev_regd = rdev->requested_regd;
4064	rdev->requested_regd = regd;
4065	spin_unlock(lock: &reg_requests_lock);
4066
4067	kfree(objp: prev_regd);
4068	return 0;
4069	}
4070
4071	int regulatory_set_wiphy_regd(struct wiphy *wiphy,
4072	struct ieee80211_regdomain *rd)
4073	{
4074	int ret = __regulatory_set_wiphy_regd(wiphy, rd);
4075
4076	if (ret)
4077	return ret;
4078
4079	schedule_work(work: &reg_work);
4080	return 0;
4081	}
4082	EXPORT_SYMBOL(regulatory_set_wiphy_regd);
4083
4084	int regulatory_set_wiphy_regd_sync(struct wiphy *wiphy,
4085	struct ieee80211_regdomain *rd)
4086	{
4087	int ret;
4088
4089	ASSERT_RTNL();
4090
4091	ret = __regulatory_set_wiphy_regd(wiphy, rd);
4092	if (ret)
4093	return ret;
4094
4095	/* process the request immediately */
4096	reg_process_self_managed_hint(wiphy);
4097	reg_check_channels();
4098	return 0;
4099	}
4100	EXPORT_SYMBOL(regulatory_set_wiphy_regd_sync);
4101
4102	void wiphy_regulatory_register(struct wiphy *wiphy)
4103	{
4104	struct regulatory_request *lr = get_last_request();
4105
4106	/* self-managed devices ignore beacon hints and country IE */
4107	if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) {
4108	wiphy->regulatory_flags |= REGULATORY_DISABLE_BEACON_HINTS |
4109	REGULATORY_COUNTRY_IE_IGNORE;
4110
4111	/*
4112	* The last request may have been received before this
4113	* registration call. Call the driver notifier if
4114	* initiator is USER.
4115	*/
4116	if (lr->initiator == NL80211_REGDOM_SET_BY_USER)
4117	reg_call_notifier(wiphy, request: lr);
4118	}
4119
4120	if (!reg_dev_ignore_cell_hint(wiphy))
4121	reg_num_devs_support_basehint++;
4122
4123	wiphy_update_regulatory(wiphy, initiator: lr->initiator);
4124	wiphy_all_share_dfs_chan_state(wiphy);
4125	reg_process_self_managed_hints();
4126	}
4127
4128	void wiphy_regulatory_deregister(struct wiphy *wiphy)
4129	{
4130	struct wiphy *request_wiphy = NULL;
4131	struct regulatory_request *lr;
4132
4133	lr = get_last_request();
4134
4135	if (!reg_dev_ignore_cell_hint(wiphy))
4136	reg_num_devs_support_basehint--;
4137
4138	rcu_free_regdom(r: get_wiphy_regdom(wiphy));
4139	RCU_INIT_POINTER(wiphy->regd, NULL);
4140
4141	if (lr)
4142	request_wiphy = wiphy_idx_to_wiphy(wiphy_idx: lr->wiphy_idx);
4143
4144	if (!request_wiphy || request_wiphy != wiphy)
4145	return;
4146
4147	lr->wiphy_idx = WIPHY_IDX_INVALID;
4148	lr->country_ie_env = ENVIRON_ANY;
4149	}
4150
4151	/*
4152	* See FCC notices for UNII band definitions
4153	* 5GHz: https://www.fcc.gov/document/5-ghz-unlicensed-spectrum-unii
4154	* 6GHz: https://www.fcc.gov/document/fcc-proposes-more-spectrum-unlicensed-use-0
4155	*/
4156	int cfg80211_get_unii(int freq)
4157	{
4158	/* UNII-1 */
4159	if (freq >= 5150 && freq <= 5250)
4160	return 0;
4161
4162	/* UNII-2A */
4163	if (freq > 5250 && freq <= 5350)
4164	return 1;
4165
4166	/* UNII-2B */
4167	if (freq > 5350 && freq <= 5470)
4168	return 2;
4169
4170	/* UNII-2C */
4171	if (freq > 5470 && freq <= 5725)
4172	return 3;
4173
4174	/* UNII-3 */
4175	if (freq > 5725 && freq <= 5825)
4176	return 4;
4177
4178	/* UNII-5 */
4179	if (freq > 5925 && freq <= 6425)
4180	return 5;
4181
4182	/* UNII-6 */
4183	if (freq > 6425 && freq <= 6525)
4184	return 6;
4185
4186	/* UNII-7 */
4187	if (freq > 6525 && freq <= 6875)
4188	return 7;
4189
4190	/* UNII-8 */
4191	if (freq > 6875 && freq <= 7125)
4192	return 8;
4193
4194	return -EINVAL;
4195	}
4196
4197	bool regulatory_indoor_allowed(void)
4198	{
4199	return reg_is_indoor;
4200	}
4201
4202	bool regulatory_pre_cac_allowed(struct wiphy *wiphy)
4203	{
4204	const struct ieee80211_regdomain *regd = NULL;
4205	const struct ieee80211_regdomain *wiphy_regd = NULL;
4206	bool pre_cac_allowed = false;
4207
4208	rcu_read_lock();
4209
4210	regd = rcu_dereference(cfg80211_regdomain);
4211	wiphy_regd = rcu_dereference(wiphy->regd);
4212	if (!wiphy_regd) {
4213	if (regd->dfs_region == NL80211_DFS_ETSI)
4214	pre_cac_allowed = true;
4215
4216	rcu_read_unlock();
4217
4218	return pre_cac_allowed;
4219	}
4220
4221	if (regd->dfs_region == wiphy_regd->dfs_region &&
4222	wiphy_regd->dfs_region == NL80211_DFS_ETSI)
4223	pre_cac_allowed = true;
4224
4225	rcu_read_unlock();
4226
4227	return pre_cac_allowed;
4228	}
4229	EXPORT_SYMBOL(regulatory_pre_cac_allowed);
4230
4231	static void cfg80211_check_and_end_cac(struct cfg80211_registered_device *rdev)
4232	{
4233	struct wireless_dev *wdev;
4234	/* If we finished CAC or received radar, we should end any
4235	* CAC running on the same channels.
4236	* the check !cfg80211_chandef_dfs_usable contain 2 options:
4237	* either all channels are available - those the CAC_FINISHED
4238	* event has effected another wdev state, or there is a channel
4239	* in unavailable state in wdev chandef - those the RADAR_DETECTED
4240	* event has effected another wdev state.
4241	* In both cases we should end the CAC on the wdev.
4242	*/
4243	list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
4244	struct cfg80211_chan_def *chandef;
4245
4246	if (!wdev->cac_started)
4247	continue;
4248
4249	/* FIXME: radar detection is tied to link 0 for now */
4250	chandef = wdev_chandef(wdev, link_id: 0);
4251	if (!chandef)
4252	continue;
4253
4254	if (!cfg80211_chandef_dfs_usable(wiphy: &rdev->wiphy, chandef))
4255	rdev_end_cac(rdev, dev: wdev->netdev);
4256	}
4257	}
4258
4259	void regulatory_propagate_dfs_state(struct wiphy *wiphy,
4260	struct cfg80211_chan_def *chandef,
4261	enum nl80211_dfs_state dfs_state,
4262	enum nl80211_radar_event event)
4263	{
4264	struct cfg80211_registered_device *rdev;
4265
4266	ASSERT_RTNL();
4267
4268	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
4269	return;
4270
4271	for_each_rdev(rdev) {
4272	if (wiphy == &rdev->wiphy)
4273	continue;
4274
4275	if (!reg_dfs_domain_same(wiphy1: wiphy, wiphy2: &rdev->wiphy))
4276	continue;
4277
4278	if (!ieee80211_get_channel(wiphy: &rdev->wiphy,
4279	freq: chandef->chan->center_freq))
4280	continue;
4281
4282	cfg80211_set_dfs_state(wiphy: &rdev->wiphy, chandef, dfs_state);
4283
4284	if (event == NL80211_RADAR_DETECTED ||
4285	event == NL80211_RADAR_CAC_FINISHED) {
4286	cfg80211_sched_dfs_chan_update(rdev);
4287	cfg80211_check_and_end_cac(rdev);
4288	}
4289
4290	nl80211_radar_notify(rdev, chandef, event, NULL, GFP_KERNEL);
4291	}
4292	}
4293
4294	static int __init regulatory_init_db(void)
4295	{
4296	int err;
4297
4298	/*
4299	* It's possible that - due to other bugs/issues - cfg80211
4300	* never called regulatory_init() below, or that it failed;
4301	* in that case, don't try to do any further work here as
4302	* it's doomed to lead to crashes.
4303	*/
4304	if (IS_ERR_OR_NULL(ptr: reg_pdev))
4305	return -EINVAL;
4306
4307	err = load_builtin_regdb_keys();
4308	if (err) {
4309	platform_device_unregister(reg_pdev);
4310	return err;
4311	}
4312
4313	/* We always try to get an update for the static regdomain */
4314	err = regulatory_hint_core(alpha2: cfg80211_world_regdom->alpha2);
4315	if (err) {
4316	if (err == -ENOMEM) {
4317	platform_device_unregister(reg_pdev);
4318	return err;
4319	}
4320	/*
4321	* N.B. kobject_uevent_env() can fail mainly for when we're out
4322	* memory which is handled and propagated appropriately above
4323	* but it can also fail during a netlink_broadcast() or during
4324	* early boot for call_usermodehelper(). For now treat these
4325	* errors as non-fatal.
4326	*/
4327	pr_err("kobject_uevent_env() was unable to call CRDA during init\n");
4328	}
4329
4330	/*
4331	* Finally, if the user set the module parameter treat it
4332	* as a user hint.
4333	*/
4334	if (!is_world_regdom(alpha2: ieee80211_regdom))
4335	regulatory_hint_user(alpha2: ieee80211_regdom,
4336	user_reg_hint_type: NL80211_USER_REG_HINT_USER);
4337
4338	return 0;
4339	}
4340	#ifndef MODULE
4341	late_initcall(regulatory_init_db);
4342	#endif
4343
4344	int __init regulatory_init(void)
4345	{
4346	reg_pdev = platform_device_register_simple(name: "regulatory", id: 0, NULL, num: 0);
4347	if (IS_ERR(ptr: reg_pdev))
4348	return PTR_ERR(ptr: reg_pdev);
4349
4350	rcu_assign_pointer(cfg80211_regdomain, cfg80211_world_regdom);
4351
4352	user_alpha2[0] = '9';
4353	user_alpha2[1] = '7';
4354
4355	#ifdef MODULE
4356	return regulatory_init_db();
4357	#else
4358	return 0;
4359	#endif
4360	}
4361
4362	void regulatory_exit(void)
4363	{
4364	struct regulatory_request *reg_request, *tmp;
4365	struct reg_beacon *reg_beacon, *btmp;
4366
4367	cancel_work_sync(work: &reg_work);
4368	cancel_crda_timeout_sync();
4369	cancel_delayed_work_sync(dwork: &reg_check_chans);
4370
4371	/* Lock to suppress warnings */
4372	rtnl_lock();
4373	reset_regdomains(full_reset: true, NULL);
4374	rtnl_unlock();
4375
4376	dev_set_uevent_suppress(dev: &reg_pdev->dev, val: true);
4377
4378	platform_device_unregister(reg_pdev);
4379
4380	list_for_each_entry_safe(reg_beacon, btmp, &reg_pending_beacons, list) {
4381	list_del(entry: &reg_beacon->list);
4382	kfree(objp: reg_beacon);
4383	}
4384
4385	list_for_each_entry_safe(reg_beacon, btmp, &reg_beacon_list, list) {
4386	list_del(entry: &reg_beacon->list);
4387	kfree(objp: reg_beacon);
4388	}
4389
4390	list_for_each_entry_safe(reg_request, tmp, &reg_requests_list, list) {
4391	list_del(entry: &reg_request->list);
4392	kfree(objp: reg_request);
4393	}
4394
4395	if (!IS_ERR_OR_NULL(ptr: regdb))
4396	kfree(objp: regdb);
4397	if (!IS_ERR_OR_NULL(ptr: cfg80211_user_regdom))
4398	kfree(objp: cfg80211_user_regdom);
4399
4400	free_regdb_keyring();
4401	}
4402