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