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