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