projects / GitHub / exynos8895 / android_kernel_samsung_universal8895.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
mac80211: remove event.c
[GitHub/exynos8895/android_kernel_samsung_universal8895.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
8318d78a 7 *
3b77d5ec
LR		 8 * Permission to use, copy, modify, and/or distribute this software for any
9 * purpose with or without fee is hereby granted, provided that the above
10 * copyright notice and this permission notice appear in all copies.
11 *
12 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
13 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
14 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
15 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
16 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
18 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
8318d78a
JB		 19 */
20
3b77d5ec 21
b2e1b302
LR		 22/**
23 * DOC: Wireless regulatory infrastructure
8318d78a
JB		 24 *
25 * The usual implementation is for a driver to read a device EEPROM to
26 * determine which regulatory domain it should be operating under, then
27 * looking up the allowable channels in a driver-local table and finally
28 * registering those channels in the wiphy structure.
29 *
b2e1b302
LR		 30 * Another set of compliance enforcement is for drivers to use their
31 * own compliance limits which can be stored on the EEPROM. The host
32 * driver or firmware may ensure these are used.
33 *
34 * In addition to all this we provide an extra layer of regulatory
35 * conformance. For drivers which do not have any regulatory
36 * information CRDA provides the complete regulatory solution.
37 * For others it provides a community effort on further restrictions
38 * to enhance compliance.
39 *
40 * Note: When number of rules --> infinity we will not be able to
41 * index on alpha2 any more, instead we'll probably have to
42 * rely on some SHA1 checksum of the regdomain for example.
43 *
8318d78a 44 */
e9c0268f
JP		 45
46#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
47
8318d78a 48#include <linux/kernel.h>
bc3b2d7f 49#include <linux/export.h>
5a0e3ad6 50#include <linux/slab.h>
b2e1b302 51#include <linux/list.h>
c61029c7 52#include <linux/ctype.h>
b2e1b302
LR		 53#include <linux/nl80211.h>
54#include <linux/platform_device.h>
d9b93842 55#include <linux/moduleparam.h>
b2e1b302 56#include <net/cfg80211.h>
8318d78a 57#include "core.h"
b2e1b302 58#include "reg.h"
ad932f04 59#include "rdev-ops.h"
3b377ea9 60#include "regdb.h"
73d54c9e 61#include "nl80211.h"
8318d78a 62
4113f751 63#ifdef CONFIG_CFG80211_REG_DEBUG
12c5ffb5
JP		 64#define REG_DBG_PRINT(format, args...) \
65 printk(KERN_DEBUG pr_fmt(format), ##args)
4113f751 66#else
8271195e 67#define REG_DBG_PRINT(args...)
4113f751
LR		 68#endif
69
ad932f04
AN		 70/*
71 * Grace period we give before making sure all current interfaces reside on
72 * channels allowed by the current regulatory domain.
73 */
74#define REG_ENFORCE_GRACE_MS 60000
75
52616f2b
IP		 76/**
77 * enum reg_request_treatment - regulatory request treatment
78 *
79 * @REG_REQ_OK: continue processing the regulatory request
80 * @REG_REQ_IGNORE: ignore the regulatory request
81 * @REG_REQ_INTERSECT: the regulatory domain resulting from this request should
82 * be intersected with the current one.
83 * @REG_REQ_ALREADY_SET: the regulatory request will not change the current
84 * regulatory settings, and no further processing is required.
52616f2b 85 */
2f92212b
JB		 86enum reg_request_treatment {
87 REG_REQ_OK,
88 REG_REQ_IGNORE,
89 REG_REQ_INTERSECT,
90 REG_REQ_ALREADY_SET,
91};
92
a042994d
LR		 93static struct regulatory_request core_request_world = {
94 .initiator = NL80211_REGDOM_SET_BY_CORE,
95 .alpha2[0] = '0',
96 .alpha2[1] = '0',
97 .intersect = false,
98 .processed = true,
99 .country_ie_env = ENVIRON_ANY,
100};
101
38fd2143
JB		 102/*
103 * Receipt of information from last regulatory request,
104 * protected by RTNL (and can be accessed with RCU protection)
105 */
c492db37 106static struct regulatory_request __rcu *last_request =
cec3f0ed 107 (void __force __rcu *)&core_request_world;
734366de 108
b2e1b302
LR		 109/* To trigger userspace events */
110static struct platform_device *reg_pdev;
8318d78a 111
fb1fc7ad
LR		 112/*
113 * Central wireless core regulatory domains, we only need two,
734366de 114 * the current one and a world regulatory domain in case we have no
e8da2bb4 115 * information to give us an alpha2.
38fd2143 116 * (protected by RTNL, can be read under RCU)
fb1fc7ad 117 */
458f4f9e 118const struct ieee80211_regdomain __rcu *cfg80211_regdomain;
734366de 119
57b5ce07
LR		 120/*
121 * Number of devices that registered to the core
122 * that support cellular base station regulatory hints
38fd2143 123 * (protected by RTNL)
57b5ce07
LR		 124 */
125static int reg_num_devs_support_basehint;
126
52616f2b
IP		 127/*
128 * State variable indicating if the platform on which the devices
129 * are attached is operating in an indoor environment. The state variable
130 * is relevant for all registered devices.
52616f2b
IP		 131 */
132static bool reg_is_indoor;
05050753
I		 133static spinlock_t reg_indoor_lock;
134
135/* Used to track the userspace process controlling the indoor setting */
136static u32 reg_is_indoor_portid;
52616f2b 137
c37722bd
I		 138/* Max number of consecutive attempts to communicate with CRDA */
139#define REG_MAX_CRDA_TIMEOUTS 10
140
141static u32 reg_crda_timeouts;
142
458f4f9e
JB		 143static const struct ieee80211_regdomain *get_cfg80211_regdom(void)
144{
38fd2143 145 return rtnl_dereference(cfg80211_regdomain);
458f4f9e
JB		 146}
147
ad30ca2c 148const struct ieee80211_regdomain *get_wiphy_regdom(struct wiphy *wiphy)
458f4f9e 149{
38fd2143 150 return rtnl_dereference(wiphy->regd);
458f4f9e
JB		 151}
152
3ef121b5
LR		 153static const char *reg_dfs_region_str(enum nl80211_dfs_regions dfs_region)
154{
155 switch (dfs_region) {
156 case NL80211_DFS_UNSET:
157 return "unset";
158 case NL80211_DFS_FCC:
159 return "FCC";
160 case NL80211_DFS_ETSI:
161 return "ETSI";
162 case NL80211_DFS_JP:
163 return "JP";
164 }
165 return "Unknown";
166}
167
6c474799
LR		 168enum nl80211_dfs_regions reg_get_dfs_region(struct wiphy *wiphy)
169{
170 const struct ieee80211_regdomain *regd = NULL;
171 const struct ieee80211_regdomain *wiphy_regd = NULL;
172
173 regd = get_cfg80211_regdom();
174 if (!wiphy)
175 goto out;
176
177 wiphy_regd = get_wiphy_regdom(wiphy);
178 if (!wiphy_regd)
179 goto out;
180
181 if (wiphy_regd->dfs_region == regd->dfs_region)
182 goto out;
183
184 REG_DBG_PRINT("%s: device specific dfs_region "
185 "(%s) disagrees with cfg80211's "
186 "central dfs_region (%s)\n",
187 dev_name(&wiphy->dev),
188 reg_dfs_region_str(wiphy_regd->dfs_region),
189 reg_dfs_region_str(regd->dfs_region));
190
191out:
192 return regd->dfs_region;
193}
194
458f4f9e
JB		 195static void rcu_free_regdom(const struct ieee80211_regdomain *r)
196{
197 if (!r)
198 return;
199 kfree_rcu((struct ieee80211_regdomain *)r, rcu_head);
200}
201
c492db37
JB		 202static struct regulatory_request *get_last_request(void)
203{
38fd2143 204 return rcu_dereference_rtnl(last_request);
c492db37
JB		 205}
206
e38f8a7a 207/* Used to queue up regulatory hints */
fe33eb39
LR		 208static LIST_HEAD(reg_requests_list);
209static spinlock_t reg_requests_lock;
210
e38f8a7a
LR		 211/* Used to queue up beacon hints for review */
212static LIST_HEAD(reg_pending_beacons);
213static spinlock_t reg_pending_beacons_lock;
214
215/* Used to keep track of processed beacon hints */
216static LIST_HEAD(reg_beacon_list);
217
218struct reg_beacon {
219 struct list_head list;
220 struct ieee80211_channel chan;
221};
222
ad932f04
AN		 223static void reg_check_chans_work(struct work_struct *work);
224static DECLARE_DELAYED_WORK(reg_check_chans, reg_check_chans_work);
225
f333a7a2
LR		 226static void reg_todo(struct work_struct *work);
227static DECLARE_WORK(reg_work, reg_todo);
228
a90c7a31
LR		 229static void reg_timeout_work(struct work_struct *work);
230static DECLARE_DELAYED_WORK(reg_timeout, reg_timeout_work);
231
734366de
JB		 232/* We keep a static world regulatory domain in case of the absence of CRDA */
233static const struct ieee80211_regdomain world_regdom = {
28981e5e 234 .n_reg_rules = 8,
734366de
JB		 235 .alpha2 = "00",
236 .reg_rules = {
68798a62
LR		 237 /* IEEE 802.11b/g, channels 1..11 */
238 REG_RULE(2412-10, 2462+10, 40, 6, 20, 0),
43c771a1
JB		 239 /* IEEE 802.11b/g, channels 12..13. */
240 REG_RULE(2467-10, 2472+10, 40, 6, 20,
8fe02e16 241 NL80211_RRF_NO_IR),
611b6a82
LR		 242 /* IEEE 802.11 channel 14 - Only JP enables
243 * this and for 802.11b only */
244 REG_RULE(2484-10, 2484+10, 20, 6, 20,
8fe02e16 245 NL80211_RRF_NO_IR |
611b6a82
LR		 246 NL80211_RRF_NO_OFDM),
247 /* IEEE 802.11a, channel 36..48 */
131a19bc 248 REG_RULE(5180-10, 5240+10, 160, 6, 20,
8fe02e16 249 NL80211_RRF_NO_IR),
3fc71f77 250
131a19bc
JB		 251 /* IEEE 802.11a, channel 52..64 - DFS required */
252 REG_RULE(5260-10, 5320+10, 160, 6, 20,
8fe02e16 253 NL80211_RRF_NO_IR |
131a19bc
JB		 254 NL80211_RRF_DFS),
255
256 /* IEEE 802.11a, channel 100..144 - DFS required */
257 REG_RULE(5500-10, 5720+10, 160, 6, 20,
8fe02e16 258 NL80211_RRF_NO_IR |
131a19bc 259 NL80211_RRF_DFS),
3fc71f77
LR		 260
261 /* IEEE 802.11a, channel 149..165 */
8ab9d85c 262 REG_RULE(5745-10, 5825+10, 80, 6, 20,
8fe02e16 263 NL80211_RRF_NO_IR),
90cdc6df
VK		 264
265 /* IEEE 802.11ad (60gHz), channels 1..3 */
266 REG_RULE(56160+2160*1-1080, 56160+2160*3+1080, 2160, 0, 0, 0),
734366de
JB		 267 }
268};
269
38fd2143 270/* protected by RTNL */
a3d2eaf0
JB		 271static const struct ieee80211_regdomain *cfg80211_world_regdom =
272 &world_regdom;
734366de 273
6ee7d330 274static char *ieee80211_regdom = "00";
09d989d1 275static char user_alpha2[2];
6ee7d330 276
734366de
JB		 277module_param(ieee80211_regdom, charp, 0444);
278MODULE_PARM_DESC(ieee80211_regdom, "IEEE 802.11 regulatory domain code");
279
c888393b 280static void reg_free_request(struct regulatory_request *request)
5ad6ef5e 281{
c888393b
AN		 282 if (request != get_last_request())
283 kfree(request);
284}
285
286static void reg_free_last_request(void)
287{
288 struct regulatory_request *lr = get_last_request();
289
5ad6ef5e
LR		 290 if (lr != &core_request_world && lr)
291 kfree_rcu(lr, rcu_head);
292}
293
05f1a3ea
LR		 294static void reg_update_last_request(struct regulatory_request *request)
295{
255e25b0
LR		 296 struct regulatory_request *lr;
297
298 lr = get_last_request();
299 if (lr == request)
300 return;
301
c888393b 302 reg_free_last_request();
05f1a3ea
LR		 303 rcu_assign_pointer(last_request, request);
304}
305
379b82f4
JB		 306static void reset_regdomains(bool full_reset,
307 const struct ieee80211_regdomain *new_regdom)
734366de 308{
458f4f9e
JB		 309 const struct ieee80211_regdomain *r;
310
38fd2143 311 ASSERT_RTNL();
e8da2bb4 312
458f4f9e
JB		 313 r = get_cfg80211_regdom();
314
942b25cf 315 /* avoid freeing static information or freeing something twice */
458f4f9e
JB		 316 if (r == cfg80211_world_regdom)
317 r = NULL;
942b25cf
JB		 318 if (cfg80211_world_regdom == &world_regdom)
319 cfg80211_world_regdom = NULL;
458f4f9e
JB		 320 if (r == &world_regdom)
321 r = NULL;
942b25cf 322
458f4f9e
JB		 323 rcu_free_regdom(r);
324 rcu_free_regdom(cfg80211_world_regdom);
734366de 325
a3d2eaf0 326 cfg80211_world_regdom = &world_regdom;
458f4f9e 327 rcu_assign_pointer(cfg80211_regdomain, new_regdom);
a042994d
LR		 328
329 if (!full_reset)
330 return;
331
05f1a3ea 332 reg_update_last_request(&core_request_world);
734366de
JB		 333}
334
fb1fc7ad
LR		 335/*
336 * Dynamic world regulatory domain requested by the wireless
337 * core upon initialization
338 */
a3d2eaf0 339static void update_world_regdomain(const struct ieee80211_regdomain *rd)
734366de 340{
c492db37 341 struct regulatory_request *lr;
734366de 342
c492db37
JB		 343 lr = get_last_request();
344
345 WARN_ON(!lr);
734366de 346
379b82f4 347 reset_regdomains(false, rd);
734366de
JB		 348
349 cfg80211_world_regdom = rd;
734366de 350}
734366de 351
a3d2eaf0 352bool is_world_regdom(const char *alpha2)
b2e1b302
LR		 353{
354 if (!alpha2)
355 return false;
1a919318 356 return alpha2[0] == '0' && alpha2[1] == '0';
b2e1b302 357}
8318d78a 358
a3d2eaf0 359static bool is_alpha2_set(const char *alpha2)
b2e1b302
LR		 360{
361 if (!alpha2)
362 return false;
1a919318 363 return alpha2[0] && alpha2[1];
b2e1b302 364}
8318d78a 365
a3d2eaf0 366static bool is_unknown_alpha2(const char *alpha2)
b2e1b302
LR		 367{
368 if (!alpha2)
369 return false;
fb1fc7ad
LR		 370 /*
371 * Special case where regulatory domain was built by driver
372 * but a specific alpha2 cannot be determined
373 */
1a919318 374 return alpha2[0] == '9' && alpha2[1] == '9';
b2e1b302 375}
8318d78a 376
3f2355cb
LR		 377static bool is_intersected_alpha2(const char *alpha2)
378{
379 if (!alpha2)
380 return false;
fb1fc7ad
LR		 381 /*
382 * Special case where regulatory domain is the
3f2355cb 383 * result of an intersection between two regulatory domain
fb1fc7ad
LR		 384 * structures
385 */
1a919318 386 return alpha2[0] == '9' && alpha2[1] == '8';
3f2355cb
LR		 387}
388
a3d2eaf0 389static bool is_an_alpha2(const char *alpha2)
b2e1b302
LR		 390{
391 if (!alpha2)
392 return false;
1a919318 393 return isalpha(alpha2[0]) && isalpha(alpha2[1]);
b2e1b302 394}
8318d78a 395
a3d2eaf0 396static bool alpha2_equal(const char *alpha2_x, const char *alpha2_y)
b2e1b302
LR		 397{
398 if (!alpha2_x || !alpha2_y)
399 return false;
1a919318 400 return alpha2_x[0] == alpha2_y[0] && alpha2_x[1] == alpha2_y[1];
b2e1b302
LR		 401}
402
69b1572b 403static bool regdom_changes(const char *alpha2)
b2e1b302 404{
458f4f9e 405 const struct ieee80211_regdomain *r = get_cfg80211_regdom();
761cf7ec 406
458f4f9e 407 if (!r)
b2e1b302 408 return true;
458f4f9e 409 return !alpha2_equal(r->alpha2, alpha2);
b2e1b302
LR		 410}
411
09d989d1
LR		 412/*
413 * The NL80211_REGDOM_SET_BY_USER regdom alpha2 is cached, this lets
414 * you know if a valid regulatory hint with NL80211_REGDOM_SET_BY_USER
415 * has ever been issued.
416 */
417static bool is_user_regdom_saved(void)
418{
419 if (user_alpha2[0] == '9' && user_alpha2[1] == '7')
420 return false;
421
422 /* This would indicate a mistake on the design */
1a919318 423 if (WARN(!is_world_regdom(user_alpha2) && !is_an_alpha2(user_alpha2),
09d989d1 424 "Unexpected user alpha2: %c%c\n",
1a919318 425 user_alpha2[0], user_alpha2[1]))
09d989d1
LR		 426 return false;
427
428 return true;
429}
430
e9763c3c
JB		 431static const struct ieee80211_regdomain *
432reg_copy_regd(const struct ieee80211_regdomain *src_regd)
3b377ea9
JL		 433{
434 struct ieee80211_regdomain *regd;
e9763c3c 435 int size_of_regd;
3b377ea9
JL		 436 unsigned int i;
437
82f20856
JB		 438 size_of_regd =
439 sizeof(struct ieee80211_regdomain) +
440 src_regd->n_reg_rules * sizeof(struct ieee80211_reg_rule);
3b377ea9
JL		 441
442 regd = kzalloc(size_of_regd, GFP_KERNEL);
443 if (!regd)
e9763c3c 444 return ERR_PTR(-ENOMEM);
3b377ea9
JL		 445
446 memcpy(regd, src_regd, sizeof(struct ieee80211_regdomain));
447
448 for (i = 0; i < src_regd->n_reg_rules; i++)
449 memcpy(&regd->reg_rules[i], &src_regd->reg_rules[i],
e9763c3c 450 sizeof(struct ieee80211_reg_rule));
3b377ea9 451
e9763c3c 452 return regd;
3b377ea9
JL		 453}
454
455#ifdef CONFIG_CFG80211_INTERNAL_REGDB
456struct reg_regdb_search_request {
457 char alpha2[2];
458 struct list_head list;
459};
460
461static LIST_HEAD(reg_regdb_search_list);
368d06f5 462static DEFINE_MUTEX(reg_regdb_search_mutex);
3b377ea9
JL		 463
464static void reg_regdb_search(struct work_struct *work)
465{
466 struct reg_regdb_search_request *request;
e9763c3c
JB		 467 const struct ieee80211_regdomain *curdom, *regdom = NULL;
468 int i;
a85d0d7f 469
5fe231e8 470 rtnl_lock();
3b377ea9 471
368d06f5 472 mutex_lock(&reg_regdb_search_mutex);
3b377ea9
JL		 473 while (!list_empty(&reg_regdb_search_list)) {
474 request = list_first_entry(&reg_regdb_search_list,
475 struct reg_regdb_search_request,
476 list);
477 list_del(&request->list);
478
1a919318 479 for (i = 0; i < reg_regdb_size; i++) {
3b377ea9
JL		 480 curdom = reg_regdb[i];
481
1a919318 482 if (alpha2_equal(request->alpha2, curdom->alpha2)) {
e9763c3c 483 regdom = reg_copy_regd(curdom);
3b377ea9
JL		 484 break;
485 }
486 }
487
488 kfree(request);
489 }
368d06f5 490 mutex_unlock(&reg_regdb_search_mutex);
a85d0d7f 491
e9763c3c 492 if (!IS_ERR_OR_NULL(regdom))
c37722bd 493 set_regdom(regdom, REGD_SOURCE_INTERNAL_DB);
a85d0d7f 494
5fe231e8 495 rtnl_unlock();
3b377ea9
JL		 496}
497
498static DECLARE_WORK(reg_regdb_work, reg_regdb_search);
499
500static void reg_regdb_query(const char *alpha2)
501{
502 struct reg_regdb_search_request *request;
503
504 if (!alpha2)
505 return;
506
507 request = kzalloc(sizeof(struct reg_regdb_search_request), GFP_KERNEL);
508 if (!request)
509 return;
510
511 memcpy(request->alpha2, alpha2, 2);
512
368d06f5 513 mutex_lock(&reg_regdb_search_mutex);
3b377ea9 514 list_add_tail(&request->list, &reg_regdb_search_list);
368d06f5 515 mutex_unlock(&reg_regdb_search_mutex);
3b377ea9
JL		 516
517 schedule_work(&reg_regdb_work);
518}
80007efe
LR		 519
520/* Feel free to add any other sanity checks here */
521static void reg_regdb_size_check(void)
522{
523 /* We should ideally BUILD_BUG_ON() but then random builds would fail */
524 WARN_ONCE(!reg_regdb_size, "db.txt is empty, you should update it...");
525}
3b377ea9 526#else
80007efe 527static inline void reg_regdb_size_check(void) {}
3b377ea9
JL		 528static inline void reg_regdb_query(const char *alpha2) {}
529#endif /* CONFIG_CFG80211_INTERNAL_REGDB */
530
fb1fc7ad
LR		 531/*
532 * This lets us keep regulatory code which is updated on a regulatory
1226d258 533 * basis in userspace.
fb1fc7ad 534 */
b2e1b302
LR		 535static int call_crda(const char *alpha2)
536{
1226d258
JB		 537 char country[12];
538 char *env[] = { country, NULL };
539
540 snprintf(country, sizeof(country), "COUNTRY=%c%c",
541 alpha2[0], alpha2[1]);
542
c37722bd
I		 543 /* query internal regulatory database (if it exists) */
544 reg_regdb_query(alpha2);
545
546 if (reg_crda_timeouts > REG_MAX_CRDA_TIMEOUTS) {
042ab5fc 547 pr_debug("Exceeded CRDA call max attempts. Not calling CRDA\n");
c37722bd
I		 548 return -EINVAL;
549 }
550
b2e1b302 551 if (!is_world_regdom((char *) alpha2))
042ab5fc 552 pr_debug("Calling CRDA for country: %c%c\n",
b2e1b302
LR		 553 alpha2[0], alpha2[1]);
554 else
042ab5fc 555 pr_debug("Calling CRDA to update world regulatory domain\n");
b2e1b302 556
1226d258 557 return kobject_uevent_env(&reg_pdev->dev.kobj, KOBJ_CHANGE, env);
b2e1b302
LR		 558}
559
fe6631ff
LR		 560static enum reg_request_treatment
561reg_call_crda(struct regulatory_request *request)
562{
563 if (call_crda(request->alpha2))
564 return REG_REQ_IGNORE;
eeca9fce
I		 565
566 queue_delayed_work(system_power_efficient_wq,
567 &reg_timeout, msecs_to_jiffies(3142));
fe6631ff
LR		 568 return REG_REQ_OK;
569}
570
e438768f 571bool reg_is_valid_request(const char *alpha2)
b2e1b302 572{
c492db37 573 struct regulatory_request *lr = get_last_request();
61405e97 574
c492db37 575 if (!lr || lr->processed)
f6037d09
JB		 576 return false;
577
c492db37 578 return alpha2_equal(lr->alpha2, alpha2);
b2e1b302 579}
8318d78a 580
e3961af1
JD		 581static const struct ieee80211_regdomain *reg_get_regdomain(struct wiphy *wiphy)
582{
583 struct regulatory_request *lr = get_last_request();
584
585 /*
586 * Follow the driver's regulatory domain, if present, unless a country
587 * IE has been processed or a user wants to help complaince further
588 */
589 if (lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
590 lr->initiator != NL80211_REGDOM_SET_BY_USER &&
591 wiphy->regd)
592 return get_wiphy_regdom(wiphy);
593
594 return get_cfg80211_regdom();
595}
596
a6d4a534
AN		 597static unsigned int
598reg_get_max_bandwidth_from_range(const struct ieee80211_regdomain *rd,
599 const struct ieee80211_reg_rule *rule)
97524820
JD		 600{
601 const struct ieee80211_freq_range *freq_range = &rule->freq_range;
602 const struct ieee80211_freq_range *freq_range_tmp;
603 const struct ieee80211_reg_rule *tmp;
604 u32 start_freq, end_freq, idx, no;
605
606 for (idx = 0; idx < rd->n_reg_rules; idx++)
607 if (rule == &rd->reg_rules[idx])
608 break;
609
610 if (idx == rd->n_reg_rules)
611 return 0;
612
613 /* get start_freq */
614 no = idx;
615
616 while (no) {
617 tmp = &rd->reg_rules[--no];
618 freq_range_tmp = &tmp->freq_range;
619
620 if (freq_range_tmp->end_freq_khz < freq_range->start_freq_khz)
621 break;
622
97524820
JD		 623 freq_range = freq_range_tmp;
624 }
625
626 start_freq = freq_range->start_freq_khz;
627
628 /* get end_freq */
629 freq_range = &rule->freq_range;
630 no = idx;
631
632 while (no < rd->n_reg_rules - 1) {
633 tmp = &rd->reg_rules[++no];
634 freq_range_tmp = &tmp->freq_range;
635
636 if (freq_range_tmp->start_freq_khz > freq_range->end_freq_khz)
637 break;
638
97524820
JD		 639 freq_range = freq_range_tmp;
640 }
641
642 end_freq = freq_range->end_freq_khz;
643
644 return end_freq - start_freq;
645}
646
a6d4a534
AN		 647unsigned int reg_get_max_bandwidth(const struct ieee80211_regdomain *rd,
648 const struct ieee80211_reg_rule *rule)
649{
650 unsigned int bw = reg_get_max_bandwidth_from_range(rd, rule);
651
652 if (rule->flags & NL80211_RRF_NO_160MHZ)
653 bw = min_t(unsigned int, bw, MHZ_TO_KHZ(80));
654 if (rule->flags & NL80211_RRF_NO_80MHZ)
655 bw = min_t(unsigned int, bw, MHZ_TO_KHZ(40));
656
657 /*
658 * HT40+/HT40- limits are handled per-channel. Only limit BW if both
659 * are not allowed.
660 */
661 if (rule->flags & NL80211_RRF_NO_HT40MINUS &&
662 rule->flags & NL80211_RRF_NO_HT40PLUS)
663 bw = min_t(unsigned int, bw, MHZ_TO_KHZ(20));
664
665 return bw;
666}
667
b2e1b302 668/* Sanity check on a regulatory rule */
a3d2eaf0 669static bool is_valid_reg_rule(const struct ieee80211_reg_rule *rule)
8318d78a 670{
a3d2eaf0 671 const struct ieee80211_freq_range *freq_range = &rule->freq_range;
b2e1b302
LR		 672 u32 freq_diff;
673
91e99004 674 if (freq_range->start_freq_khz <= 0 || freq_range->end_freq_khz <= 0)
b2e1b302
LR		 675 return false;
676
677 if (freq_range->start_freq_khz > freq_range->end_freq_khz)
678 return false;
679
680 freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
681
bd05f28e 682 if (freq_range->end_freq_khz <= freq_range->start_freq_khz ||
1a919318 683 freq_range->max_bandwidth_khz > freq_diff)
b2e1b302
LR		 684 return false;
685
686 return true;
687}
688
a3d2eaf0 689static bool is_valid_rd(const struct ieee80211_regdomain *rd)
b2e1b302 690{
a3d2eaf0 691 const struct ieee80211_reg_rule *reg_rule = NULL;
b2e1b302 692 unsigned int i;
8318d78a 693
b2e1b302
LR		 694 if (!rd->n_reg_rules)
695 return false;
8318d78a 696
88dc1c3f
LR		 697 if (WARN_ON(rd->n_reg_rules > NL80211_MAX_SUPP_REG_RULES))
698 return false;
699
b2e1b302
LR		 700 for (i = 0; i < rd->n_reg_rules; i++) {
701 reg_rule = &rd->reg_rules[i];
702 if (!is_valid_reg_rule(reg_rule))
703 return false;
704 }
705
706 return true;
8318d78a
JB		 707}
708
038659e7 709static bool reg_does_bw_fit(const struct ieee80211_freq_range *freq_range,
fe7ef5e9 710 u32 center_freq_khz, u32 bw_khz)
b2e1b302 711{
038659e7
LR		 712 u32 start_freq_khz, end_freq_khz;
713
714 start_freq_khz = center_freq_khz - (bw_khz/2);
715 end_freq_khz = center_freq_khz + (bw_khz/2);
716
717 if (start_freq_khz >= freq_range->start_freq_khz &&
718 end_freq_khz <= freq_range->end_freq_khz)
719 return true;
720
721 return false;
b2e1b302 722}
8318d78a 723
0c7dc45d
LR		 724/**
725 * freq_in_rule_band - tells us if a frequency is in a frequency band
726 * @freq_range: frequency rule we want to query
727 * @freq_khz: frequency we are inquiring about
728 *
729 * This lets us know if a specific frequency rule is or is not relevant to
730 * a specific frequency's band. Bands are device specific and artificial
64629b9d
VK		 731 * definitions (the "2.4 GHz band", the "5 GHz band" and the "60GHz band"),
732 * however it is safe for now to assume that a frequency rule should not be
733 * part of a frequency's band if the start freq or end freq are off by more
734 * than 2 GHz for the 2.4 and 5 GHz bands, and by more than 10 GHz for the
735 * 60 GHz band.
0c7dc45d
LR		 736 * This resolution can be lowered and should be considered as we add
737 * regulatory rule support for other "bands".
738 **/
739static bool freq_in_rule_band(const struct ieee80211_freq_range *freq_range,
1a919318 740 u32 freq_khz)
0c7dc45d
LR		 741{
742#define ONE_GHZ_IN_KHZ 1000000
64629b9d
VK		 743 /*
744 * From 802.11ad: directional multi-gigabit (DMG):
745 * Pertaining to operation in a frequency band containing a channel
746 * with the Channel starting frequency above 45 GHz.
747 */
748 u32 limit = freq_khz > 45 * ONE_GHZ_IN_KHZ ?
749 10 * ONE_GHZ_IN_KHZ : 2 * ONE_GHZ_IN_KHZ;
750 if (abs(freq_khz - freq_range->start_freq_khz) <= limit)
0c7dc45d 751 return true;
64629b9d 752 if (abs(freq_khz - freq_range->end_freq_khz) <= limit)
0c7dc45d
LR		 753 return true;
754 return false;
755#undef ONE_GHZ_IN_KHZ
756}
757
adbfb058
LR		 758/*
759 * Later on we can perhaps use the more restrictive DFS
760 * region but we don't have information for that yet so
761 * for now simply disallow conflicts.
762 */
763static enum nl80211_dfs_regions
764reg_intersect_dfs_region(const enum nl80211_dfs_regions dfs_region1,
765 const enum nl80211_dfs_regions dfs_region2)
766{
767 if (dfs_region1 != dfs_region2)
768 return NL80211_DFS_UNSET;
769 return dfs_region1;
770}
771
fb1fc7ad
LR		 772/*
773 * Helper for regdom_intersect(), this does the real
774 * mathematical intersection fun
775 */
97524820
JD		 776static int reg_rules_intersect(const struct ieee80211_regdomain *rd1,
777 const struct ieee80211_regdomain *rd2,
778 const struct ieee80211_reg_rule *rule1,
1a919318
JB		 779 const struct ieee80211_reg_rule *rule2,
780 struct ieee80211_reg_rule *intersected_rule)
9c96477d
LR		 781{
782 const struct ieee80211_freq_range *freq_range1, *freq_range2;
783 struct ieee80211_freq_range *freq_range;
784 const struct ieee80211_power_rule *power_rule1, *power_rule2;
785 struct ieee80211_power_rule *power_rule;
97524820 786 u32 freq_diff, max_bandwidth1, max_bandwidth2;
9c96477d
LR		 787
788 freq_range1 = &rule1->freq_range;
789 freq_range2 = &rule2->freq_range;
790 freq_range = &intersected_rule->freq_range;
791
792 power_rule1 = &rule1->power_rule;
793 power_rule2 = &rule2->power_rule;
794 power_rule = &intersected_rule->power_rule;
795
796 freq_range->start_freq_khz = max(freq_range1->start_freq_khz,
1a919318 797 freq_range2->start_freq_khz);
9c96477d 798 freq_range->end_freq_khz = min(freq_range1->end_freq_khz,
1a919318 799 freq_range2->end_freq_khz);
97524820
JD		 800
801 max_bandwidth1 = freq_range1->max_bandwidth_khz;
802 max_bandwidth2 = freq_range2->max_bandwidth_khz;
803
b0dfd2ea
JD		 804 if (rule1->flags & NL80211_RRF_AUTO_BW)
805 max_bandwidth1 = reg_get_max_bandwidth(rd1, rule1);
806 if (rule2->flags & NL80211_RRF_AUTO_BW)
807 max_bandwidth2 = reg_get_max_bandwidth(rd2, rule2);
97524820
JD		 808
809 freq_range->max_bandwidth_khz = min(max_bandwidth1, max_bandwidth2);
9c96477d 810
b0dfd2ea
JD		 811 intersected_rule->flags = rule1->flags | rule2->flags;
812
813 /*
814 * In case NL80211_RRF_AUTO_BW requested for both rules
815 * set AUTO_BW in intersected rule also. Next we will
816 * calculate BW correctly in handle_channel function.
817 * In other case remove AUTO_BW flag while we calculate
818 * maximum bandwidth correctly and auto calculation is
819 * not required.
820 */
821 if ((rule1->flags & NL80211_RRF_AUTO_BW) &&
822 (rule2->flags & NL80211_RRF_AUTO_BW))
823 intersected_rule->flags |= NL80211_RRF_AUTO_BW;
824 else
825 intersected_rule->flags &= ~NL80211_RRF_AUTO_BW;
826
9c96477d
LR		 827 freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
828 if (freq_range->max_bandwidth_khz > freq_diff)
829 freq_range->max_bandwidth_khz = freq_diff;
830
831 power_rule->max_eirp = min(power_rule1->max_eirp,
832 power_rule2->max_eirp);
833 power_rule->max_antenna_gain = min(power_rule1->max_antenna_gain,
834 power_rule2->max_antenna_gain);
835
089027e5
JD		 836 intersected_rule->dfs_cac_ms = max(rule1->dfs_cac_ms,
837 rule2->dfs_cac_ms);
838
9c96477d
LR		 839 if (!is_valid_reg_rule(intersected_rule))
840 return -EINVAL;
841
842 return 0;
843}
844
a62a1aed
EP		 845/* check whether old rule contains new rule */
846static bool rule_contains(struct ieee80211_reg_rule *r1,
847 struct ieee80211_reg_rule *r2)
848{
849 /* for simplicity, currently consider only same flags */
850 if (r1->flags != r2->flags)
851 return false;
852
853 /* verify r1 is more restrictive */
854 if ((r1->power_rule.max_antenna_gain >
855 r2->power_rule.max_antenna_gain) ||
856 r1->power_rule.max_eirp > r2->power_rule.max_eirp)
857 return false;
858
859 /* make sure r2's range is contained within r1 */
860 if (r1->freq_range.start_freq_khz > r2->freq_range.start_freq_khz ||
861 r1->freq_range.end_freq_khz < r2->freq_range.end_freq_khz)
862 return false;
863
864 /* and finally verify that r1.max_bw >= r2.max_bw */
865 if (r1->freq_range.max_bandwidth_khz <
866 r2->freq_range.max_bandwidth_khz)
867 return false;
868
869 return true;
870}
871
872/* add or extend current rules. do nothing if rule is already contained */
873static void add_rule(struct ieee80211_reg_rule *rule,
874 struct ieee80211_reg_rule *reg_rules, u32 *n_rules)
875{
876 struct ieee80211_reg_rule *tmp_rule;
877 int i;
878
879 for (i = 0; i < *n_rules; i++) {
880 tmp_rule = &reg_rules[i];
881 /* rule is already contained - do nothing */
882 if (rule_contains(tmp_rule, rule))
883 return;
884
885 /* extend rule if possible */
886 if (rule_contains(rule, tmp_rule)) {
887 memcpy(tmp_rule, rule, sizeof(*rule));
888 return;
889 }
890 }
891
892 memcpy(&reg_rules[*n_rules], rule, sizeof(*rule));
893 (*n_rules)++;
894}
895
9c96477d
LR		 896/**
897 * regdom_intersect - do the intersection between two regulatory domains
898 * @rd1: first regulatory domain
899 * @rd2: second regulatory domain
900 *
901 * Use this function to get the intersection between two regulatory domains.
902 * Once completed we will mark the alpha2 for the rd as intersected, "98",
903 * as no one single alpha2 can represent this regulatory domain.
904 *
905 * Returns a pointer to the regulatory domain structure which will hold the
906 * resulting intersection of rules between rd1 and rd2. We will
907 * kzalloc() this structure for you.
908 */
1a919318
JB		 909static struct ieee80211_regdomain *
910regdom_intersect(const struct ieee80211_regdomain *rd1,
911 const struct ieee80211_regdomain *rd2)
9c96477d
LR		 912{
913 int r, size_of_regd;
914 unsigned int x, y;
a62a1aed 915 unsigned int num_rules = 0;
9c96477d 916 const struct ieee80211_reg_rule *rule1, *rule2;
a62a1aed 917 struct ieee80211_reg_rule intersected_rule;
9c96477d 918 struct ieee80211_regdomain *rd;
9c96477d
LR		 919
920 if (!rd1 || !rd2)
921 return NULL;
922
fb1fc7ad
LR		 923 /*
924 * First we get a count of the rules we'll need, then we actually
9c96477d
LR		 925 * build them. This is to so we can malloc() and free() a
926 * regdomain once. The reason we use reg_rules_intersect() here
927 * is it will return -EINVAL if the rule computed makes no sense.
fb1fc7ad
LR		 928 * All rules that do check out OK are valid.
929 */
9c96477d
LR		 930
931 for (x = 0; x < rd1->n_reg_rules; x++) {
932 rule1 = &rd1->reg_rules[x];
933 for (y = 0; y < rd2->n_reg_rules; y++) {
934 rule2 = &rd2->reg_rules[y];
97524820 935 if (!reg_rules_intersect(rd1, rd2, rule1, rule2,
a62a1aed 936 &intersected_rule))
9c96477d 937 num_rules++;
9c96477d
LR		 938 }
939 }
940
941 if (!num_rules)
942 return NULL;
943
944 size_of_regd = sizeof(struct ieee80211_regdomain) +
82f20856 945 num_rules * sizeof(struct ieee80211_reg_rule);
9c96477d
LR		 946
947 rd = kzalloc(size_of_regd, GFP_KERNEL);
948 if (!rd)
949 return NULL;
950
a62a1aed 951 for (x = 0; x < rd1->n_reg_rules; x++) {
9c96477d 952 rule1 = &rd1->reg_rules[x];
a62a1aed 953 for (y = 0; y < rd2->n_reg_rules; y++) {
9c96477d 954 rule2 = &rd2->reg_rules[y];
97524820 955 r = reg_rules_intersect(rd1, rd2, rule1, rule2,
a62a1aed 956 &intersected_rule);
fb1fc7ad
LR		 957 /*
958 * No need to memset here the intersected rule here as
959 * we're not using the stack anymore
960 */
9c96477d
LR		 961 if (r)
962 continue;
9c96477d 963
a62a1aed
EP		 964 add_rule(&intersected_rule, rd->reg_rules,
965 &rd->n_reg_rules);
966 }
9c96477d
LR		 967 }
968
9c96477d
LR		 969 rd->alpha2[0] = '9';
970 rd->alpha2[1] = '8';
adbfb058
LR		 971 rd->dfs_region = reg_intersect_dfs_region(rd1->dfs_region,
972 rd2->dfs_region);
9c96477d
LR		 973
974 return rd;
975}
976
fb1fc7ad
LR		 977/*
978 * XXX: add support for the rest of enum nl80211_reg_rule_flags, we may
979 * want to just have the channel structure use these
980 */
b2e1b302
LR		 981static u32 map_regdom_flags(u32 rd_flags)
982{
983 u32 channel_flags = 0;
8fe02e16
LR		 984 if (rd_flags & NL80211_RRF_NO_IR_ALL)
985 channel_flags |= IEEE80211_CHAN_NO_IR;
b2e1b302
LR		 986 if (rd_flags & NL80211_RRF_DFS)
987 channel_flags |= IEEE80211_CHAN_RADAR;
03f6b084
SF		 988 if (rd_flags & NL80211_RRF_NO_OFDM)
989 channel_flags |= IEEE80211_CHAN_NO_OFDM;
570dbde1
DS		 990 if (rd_flags & NL80211_RRF_NO_OUTDOOR)
991 channel_flags |= IEEE80211_CHAN_INDOOR_ONLY;
06f207fc
AN		 992 if (rd_flags & NL80211_RRF_IR_CONCURRENT)
993 channel_flags |= IEEE80211_CHAN_IR_CONCURRENT;
a6d4a534
AN		 994 if (rd_flags & NL80211_RRF_NO_HT40MINUS)
995 channel_flags |= IEEE80211_CHAN_NO_HT40MINUS;
996 if (rd_flags & NL80211_RRF_NO_HT40PLUS)
997 channel_flags |= IEEE80211_CHAN_NO_HT40PLUS;
998 if (rd_flags & NL80211_RRF_NO_80MHZ)
999 channel_flags |= IEEE80211_CHAN_NO_80MHZ;
1000 if (rd_flags & NL80211_RRF_NO_160MHZ)
1001 channel_flags |= IEEE80211_CHAN_NO_160MHZ;
b2e1b302
LR		 1002 return channel_flags;
1003}
1004
361c9c8b
JB		 1005static const struct ieee80211_reg_rule *
1006freq_reg_info_regd(struct wiphy *wiphy, u32 center_freq,
4edd5698 1007 const struct ieee80211_regdomain *regd, u32 bw)
8318d78a
JB		 1008{
1009 int i;
0c7dc45d 1010 bool band_rule_found = false;
038659e7
LR		 1011 bool bw_fits = false;
1012
3e0c3ff3 1013 if (!regd)
361c9c8b 1014 return ERR_PTR(-EINVAL);
b2e1b302 1015
3e0c3ff3 1016 for (i = 0; i < regd->n_reg_rules; i++) {
b2e1b302
LR		 1017 const struct ieee80211_reg_rule *rr;
1018 const struct ieee80211_freq_range *fr = NULL;
b2e1b302 1019
3e0c3ff3 1020 rr = &regd->reg_rules[i];
b2e1b302 1021 fr = &rr->freq_range;
0c7dc45d 1022
fb1fc7ad
LR		 1023 /*
1024 * We only need to know if one frequency rule was
0c7dc45d 1025 * was in center_freq's band, that's enough, so lets
fb1fc7ad
LR		 1026 * not overwrite it once found
1027 */
0c7dc45d
LR		 1028 if (!band_rule_found)
1029 band_rule_found = freq_in_rule_band(fr, center_freq);
1030
4edd5698 1031 bw_fits = reg_does_bw_fit(fr, center_freq, bw);
0c7dc45d 1032
361c9c8b
JB		 1033 if (band_rule_found && bw_fits)
1034 return rr;
8318d78a
JB		 1035 }
1036
0c7dc45d 1037 if (!band_rule_found)
361c9c8b 1038 return ERR_PTR(-ERANGE);
0c7dc45d 1039
361c9c8b 1040 return ERR_PTR(-EINVAL);
b2e1b302
LR		 1041}
1042
8de1c63b
JB		 1043static const struct ieee80211_reg_rule *
1044__freq_reg_info(struct wiphy *wiphy, u32 center_freq, u32 min_bw)
1fa25e41 1045{
4edd5698
MM		 1046 const struct ieee80211_regdomain *regd = reg_get_regdomain(wiphy);
1047 const struct ieee80211_reg_rule *reg_rule = NULL;
1048 u32 bw;
1a919318 1049
4edd5698
MM		 1050 for (bw = MHZ_TO_KHZ(20); bw >= min_bw; bw = bw / 2) {
1051 reg_rule = freq_reg_info_regd(wiphy, center_freq, regd, bw);
1052 if (!IS_ERR(reg_rule))
1053 return reg_rule;
1054 }
5d885b99 1055
4edd5698
MM		 1056 return reg_rule;
1057}
1058
1059const struct ieee80211_reg_rule *freq_reg_info(struct wiphy *wiphy,
1060 u32 center_freq)
1061{
1062 return __freq_reg_info(wiphy, center_freq, MHZ_TO_KHZ(20));
1fa25e41 1063}
4f366c5d 1064EXPORT_SYMBOL(freq_reg_info);
b2e1b302 1065
034c6d6e 1066const char *reg_initiator_name(enum nl80211_reg_initiator initiator)
926a0a09
LR		 1067{
1068 switch (initiator) {
1069 case NL80211_REGDOM_SET_BY_CORE:
034c6d6e 1070 return "core";
926a0a09 1071 case NL80211_REGDOM_SET_BY_USER:
034c6d6e 1072 return "user";
926a0a09 1073 case NL80211_REGDOM_SET_BY_DRIVER:
034c6d6e 1074 return "driver";
926a0a09 1075 case NL80211_REGDOM_SET_BY_COUNTRY_IE:
034c6d6e 1076 return "country IE";
926a0a09
LR		 1077 default:
1078 WARN_ON(1);
034c6d6e 1079 return "bug";
926a0a09
LR		 1080 }
1081}
034c6d6e 1082EXPORT_SYMBOL(reg_initiator_name);
e702d3cf 1083
034c6d6e 1084#ifdef CONFIG_CFG80211_REG_DEBUG
b0dfd2ea
JD		 1085static void chan_reg_rule_print_dbg(const struct ieee80211_regdomain *regd,
1086 struct ieee80211_channel *chan,
e702d3cf
LR		 1087 const struct ieee80211_reg_rule *reg_rule)
1088{
1089 const struct ieee80211_power_rule *power_rule;
1090 const struct ieee80211_freq_range *freq_range;
b0dfd2ea 1091 char max_antenna_gain[32], bw[32];
e702d3cf
LR		 1092
1093 power_rule = &reg_rule->power_rule;
1094 freq_range = &reg_rule->freq_range;
1095
1096 if (!power_rule->max_antenna_gain)
b0dfd2ea 1097 snprintf(max_antenna_gain, sizeof(max_antenna_gain), "N/A");
e702d3cf 1098 else
b0dfd2ea
JD		 1099 snprintf(max_antenna_gain, sizeof(max_antenna_gain), "%d",
1100 power_rule->max_antenna_gain);
1101
1102 if (reg_rule->flags & NL80211_RRF_AUTO_BW)
1103 snprintf(bw, sizeof(bw), "%d KHz, %d KHz AUTO",
1104 freq_range->max_bandwidth_khz,
1105 reg_get_max_bandwidth(regd, reg_rule));
1106 else
1107 snprintf(bw, sizeof(bw), "%d KHz",
1108 freq_range->max_bandwidth_khz);
e702d3cf 1109
fe7ef5e9
JB		 1110 REG_DBG_PRINT("Updating information on frequency %d MHz with regulatory rule:\n",
1111 chan->center_freq);
e702d3cf 1112
b0dfd2ea 1113 REG_DBG_PRINT("%d KHz - %d KHz @ %s), (%s mBi, %d mBm)\n",
1a919318 1114 freq_range->start_freq_khz, freq_range->end_freq_khz,
b0dfd2ea 1115 bw, max_antenna_gain,
e702d3cf
LR		 1116 power_rule->max_eirp);
1117}
1118#else
b0dfd2ea
JD		 1119static void chan_reg_rule_print_dbg(const struct ieee80211_regdomain *regd,
1120 struct ieee80211_channel *chan,
e702d3cf
LR		 1121 const struct ieee80211_reg_rule *reg_rule)
1122{
1123 return;
1124}
926a0a09
LR		 1125#endif
1126
e33e2241
JB		 1127/*
1128 * Note that right now we assume the desired channel bandwidth
1129 * is always 20 MHz for each individual channel (HT40 uses 20 MHz
1130 * per channel, the primary and the extension channel).
038659e7 1131 */
7ca43d03
LR		 1132static void handle_channel(struct wiphy *wiphy,
1133 enum nl80211_reg_initiator initiator,
fdc9d7b2 1134 struct ieee80211_channel *chan)
b2e1b302 1135{
038659e7 1136 u32 flags, bw_flags = 0;
b2e1b302
LR		 1137 const struct ieee80211_reg_rule *reg_rule = NULL;
1138 const struct ieee80211_power_rule *power_rule = NULL;
038659e7 1139 const struct ieee80211_freq_range *freq_range = NULL;
fe33eb39 1140 struct wiphy *request_wiphy = NULL;
c492db37 1141 struct regulatory_request *lr = get_last_request();
97524820
JD		 1142 const struct ieee80211_regdomain *regd;
1143 u32 max_bandwidth_khz;
a92a3ce7 1144
c492db37 1145 request_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx);
a92a3ce7
LR		 1146
1147 flags = chan->orig_flags;
b2e1b302 1148
361c9c8b
JB		 1149 reg_rule = freq_reg_info(wiphy, MHZ_TO_KHZ(chan->center_freq));
1150 if (IS_ERR(reg_rule)) {
ca4ffe8f
LR		 1151 /*
1152 * We will disable all channels that do not match our
25985edc 1153 * received regulatory rule unless the hint is coming
ca4ffe8f
LR		 1154 * from a Country IE and the Country IE had no information
1155 * about a band. The IEEE 802.11 spec allows for an AP
1156 * to send only a subset of the regulatory rules allowed,
1157 * so an AP in the US that only supports 2.4 GHz may only send
1158 * a country IE with information for the 2.4 GHz band
1159 * while 5 GHz is still supported.
1160 */
1161 if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
361c9c8b 1162 PTR_ERR(reg_rule) == -ERANGE)
ca4ffe8f
LR		 1163 return;
1164
cc493e4f
LR		 1165 if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
1166 request_wiphy && request_wiphy == wiphy &&
a2f73b6c 1167 request_wiphy->regulatory_flags & REGULATORY_STRICT_REG) {
cc493e4f
LR		 1168 REG_DBG_PRINT("Disabling freq %d MHz for good\n",
1169 chan->center_freq);
1170 chan->orig_flags |= IEEE80211_CHAN_DISABLED;
1171 chan->flags = chan->orig_flags;
1172 } else {
1173 REG_DBG_PRINT("Disabling freq %d MHz\n",
1174 chan->center_freq);
1175 chan->flags |= IEEE80211_CHAN_DISABLED;
1176 }
8318d78a 1177 return;
ca4ffe8f 1178 }
8318d78a 1179
b0dfd2ea
JD		 1180 regd = reg_get_regdomain(wiphy);
1181 chan_reg_rule_print_dbg(regd, chan, reg_rule);
e702d3cf 1182
b2e1b302 1183 power_rule = &reg_rule->power_rule;
038659e7
LR		 1184 freq_range = &reg_rule->freq_range;
1185
97524820
JD		 1186 max_bandwidth_khz = freq_range->max_bandwidth_khz;
1187 /* Check if auto calculation requested */
b0dfd2ea 1188 if (reg_rule->flags & NL80211_RRF_AUTO_BW)
97524820 1189 max_bandwidth_khz = reg_get_max_bandwidth(regd, reg_rule);
97524820 1190
4edd5698
MM		 1191 /* If we get a reg_rule we can assume that at least 5Mhz fit */
1192 if (!reg_does_bw_fit(freq_range, MHZ_TO_KHZ(chan->center_freq),
1193 MHZ_TO_KHZ(10)))
1194 bw_flags |= IEEE80211_CHAN_NO_10MHZ;
1195 if (!reg_does_bw_fit(freq_range, MHZ_TO_KHZ(chan->center_freq),
1196 MHZ_TO_KHZ(20)))
1197 bw_flags |= IEEE80211_CHAN_NO_20MHZ;
1198
1199 if (max_bandwidth_khz < MHZ_TO_KHZ(10))
1200 bw_flags |= IEEE80211_CHAN_NO_10MHZ;
1201 if (max_bandwidth_khz < MHZ_TO_KHZ(20))
1202 bw_flags |= IEEE80211_CHAN_NO_20MHZ;
97524820 1203 if (max_bandwidth_khz < MHZ_TO_KHZ(40))
4edd5698 1204 bw_flags |= IEEE80211_CHAN_NO_HT40;
97524820 1205 if (max_bandwidth_khz < MHZ_TO_KHZ(80))
c7a6ee27 1206 bw_flags |= IEEE80211_CHAN_NO_80MHZ;
97524820 1207 if (max_bandwidth_khz < MHZ_TO_KHZ(160))
c7a6ee27 1208 bw_flags |= IEEE80211_CHAN_NO_160MHZ;
b2e1b302 1209
c492db37 1210 if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
806a9e39 1211 request_wiphy && request_wiphy == wiphy &&
a2f73b6c 1212 request_wiphy->regulatory_flags & REGULATORY_STRICT_REG) {
fb1fc7ad 1213 /*
25985edc 1214 * This guarantees the driver's requested regulatory domain
f976376d 1215 * will always be used as a base for further regulatory
fb1fc7ad
LR		 1216 * settings
1217 */
f976376d 1218 chan->flags = chan->orig_flags =
038659e7 1219 map_regdom_flags(reg_rule->flags) | bw_flags;
f976376d
LR		 1220 chan->max_antenna_gain = chan->orig_mag =
1221 (int) MBI_TO_DBI(power_rule->max_antenna_gain);
279f0f55 1222 chan->max_reg_power = chan->max_power = chan->orig_mpwr =
f976376d 1223 (int) MBM_TO_DBM(power_rule->max_eirp);
4f267c11
JD		 1224
1225 if (chan->flags & IEEE80211_CHAN_RADAR) {
1226 chan->dfs_cac_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
1227 if (reg_rule->dfs_cac_ms)
1228 chan->dfs_cac_ms = reg_rule->dfs_cac_ms;
1229 }
1230
f976376d
LR		 1231 return;
1232 }
1233
04f39047
SW		 1234 chan->dfs_state = NL80211_DFS_USABLE;
1235 chan->dfs_state_entered = jiffies;
1236
aa3d7eef 1237 chan->beacon_found = false;
038659e7 1238 chan->flags = flags | bw_flags | map_regdom_flags(reg_rule->flags);
1a919318
JB		 1239 chan->max_antenna_gain =
1240 min_t(int, chan->orig_mag,
1241 MBI_TO_DBI(power_rule->max_antenna_gain));
eccc068e 1242 chan->max_reg_power = (int) MBM_TO_DBM(power_rule->max_eirp);
089027e5
JD		 1243
1244 if (chan->flags & IEEE80211_CHAN_RADAR) {
1245 if (reg_rule->dfs_cac_ms)
1246 chan->dfs_cac_ms = reg_rule->dfs_cac_ms;
1247 else
1248 chan->dfs_cac_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
1249 }
1250
5e31fc08
SG		 1251 if (chan->orig_mpwr) {
1252 /*
a09a85a0
LR		 1253 * Devices that use REGULATORY_COUNTRY_IE_FOLLOW_POWER
1254 * will always follow the passed country IE power settings.
5e31fc08
SG		 1255 */
1256 if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
a09a85a0 1257 wiphy->regulatory_flags & REGULATORY_COUNTRY_IE_FOLLOW_POWER)
5e31fc08
SG		 1258 chan->max_power = chan->max_reg_power;
1259 else
1260 chan->max_power = min(chan->orig_mpwr,
1261 chan->max_reg_power);
1262 } else
1263 chan->max_power = chan->max_reg_power;
8318d78a
JB		 1264}
1265
7ca43d03 1266static void handle_band(struct wiphy *wiphy,
fdc9d7b2
JB		 1267 enum nl80211_reg_initiator initiator,
1268 struct ieee80211_supported_band *sband)
8318d78a 1269{
a92a3ce7 1270 unsigned int i;
a92a3ce7 1271
fdc9d7b2
JB		 1272 if (!sband)
1273 return;
8318d78a
JB		 1274
1275 for (i = 0; i < sband->n_channels; i++)
fdc9d7b2 1276 handle_channel(wiphy, initiator, &sband->channels[i]);
8318d78a
JB		 1277}
1278
57b5ce07
LR		 1279static bool reg_request_cell_base(struct regulatory_request *request)
1280{
1281 if (request->initiator != NL80211_REGDOM_SET_BY_USER)
1282 return false;
1a919318 1283 return request->user_reg_hint_type == NL80211_USER_REG_HINT_CELL_BASE;
57b5ce07
LR		 1284}
1285
1286bool reg_last_request_cell_base(void)
1287{
38fd2143 1288 return reg_request_cell_base(get_last_request());
57b5ce07
LR		 1289}
1290
94fc661f 1291#ifdef CONFIG_CFG80211_REG_CELLULAR_HINTS
57b5ce07 1292/* Core specific check */
2f92212b
JB		 1293static enum reg_request_treatment
1294reg_ignore_cell_hint(struct regulatory_request *pending_request)
57b5ce07 1295{
c492db37
JB		 1296 struct regulatory_request *lr = get_last_request();
1297
57b5ce07 1298 if (!reg_num_devs_support_basehint)
2f92212b 1299 return REG_REQ_IGNORE;
57b5ce07 1300
c492db37 1301 if (reg_request_cell_base(lr) &&
1a919318 1302 !regdom_changes(pending_request->alpha2))
2f92212b 1303 return REG_REQ_ALREADY_SET;
1a919318 1304
2f92212b 1305 return REG_REQ_OK;
57b5ce07
LR		 1306}
1307
1308/* Device specific check */
1309static bool reg_dev_ignore_cell_hint(struct wiphy *wiphy)
1310{
1a919318 1311 return !(wiphy->features & NL80211_FEATURE_CELL_BASE_REG_HINTS);
57b5ce07
LR		 1312}
1313#else
1314static int reg_ignore_cell_hint(struct regulatory_request *pending_request)
1315{
2f92212b 1316 return REG_REQ_IGNORE;
57b5ce07 1317}
1a919318
JB		 1318
1319static bool reg_dev_ignore_cell_hint(struct wiphy *wiphy)
57b5ce07
LR		 1320{
1321 return true;
1322}
1323#endif
1324
fa1fb9cb
LR		 1325static bool wiphy_strict_alpha2_regd(struct wiphy *wiphy)
1326{
a2f73b6c
LR		 1327 if (wiphy->regulatory_flags & REGULATORY_STRICT_REG &&
1328 !(wiphy->regulatory_flags & REGULATORY_CUSTOM_REG))
fa1fb9cb
LR		 1329 return true;
1330 return false;
1331}
57b5ce07 1332
7db90f4a
LR		 1333static bool ignore_reg_update(struct wiphy *wiphy,
1334 enum nl80211_reg_initiator initiator)
14b9815a 1335{
c492db37
JB		 1336 struct regulatory_request *lr = get_last_request();
1337
b0d7aa59
JD		 1338 if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED)
1339 return true;
1340
c492db37 1341 if (!lr) {
034c6d6e
LR		 1342 REG_DBG_PRINT("Ignoring regulatory request set by %s "
1343 "since last_request is not set\n",
926a0a09 1344 reg_initiator_name(initiator));
14b9815a 1345 return true;
926a0a09
LR		 1346 }
1347
7db90f4a 1348 if (initiator == NL80211_REGDOM_SET_BY_CORE &&
a2f73b6c 1349 wiphy->regulatory_flags & REGULATORY_CUSTOM_REG) {
034c6d6e
LR		 1350 REG_DBG_PRINT("Ignoring regulatory request set by %s "
1351 "since the driver uses its own custom "
1352 "regulatory domain\n",
926a0a09 1353 reg_initiator_name(initiator));
14b9815a 1354 return true;
926a0a09
LR		 1355 }
1356
fb1fc7ad
LR		 1357 /*
1358 * wiphy->regd will be set once the device has its own
1359 * desired regulatory domain set
1360 */
fa1fb9cb 1361 if (wiphy_strict_alpha2_regd(wiphy) && !wiphy->regd &&
749b527b 1362 initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
c492db37 1363 !is_world_regdom(lr->alpha2)) {
034c6d6e
LR		 1364 REG_DBG_PRINT("Ignoring regulatory request set by %s "
1365 "since the driver requires its own regulatory "
1366 "domain to be set first\n",
926a0a09 1367 reg_initiator_name(initiator));
14b9815a 1368 return true;
926a0a09
LR		 1369 }
1370
c492db37 1371 if (reg_request_cell_base(lr))
57b5ce07
LR		 1372 return reg_dev_ignore_cell_hint(wiphy);
1373
14b9815a
LR		 1374 return false;
1375}
1376
3195e489
LR		 1377static bool reg_is_world_roaming(struct wiphy *wiphy)
1378{
1379 const struct ieee80211_regdomain *cr = get_cfg80211_regdom();
1380 const struct ieee80211_regdomain *wr = get_wiphy_regdom(wiphy);
1381 struct regulatory_request *lr = get_last_request();
1382
1383 if (is_world_regdom(cr->alpha2) || (wr && is_world_regdom(wr->alpha2)))
1384 return true;
1385
1386 if (lr && lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
a2f73b6c 1387 wiphy->regulatory_flags & REGULATORY_CUSTOM_REG)
3195e489
LR		 1388 return true;
1389
1390 return false;
1391}
1392
1a919318 1393static void handle_reg_beacon(struct wiphy *wiphy, unsigned int chan_idx,
e38f8a7a
LR		 1394 struct reg_beacon *reg_beacon)
1395{
e38f8a7a
LR		 1396 struct ieee80211_supported_band *sband;
1397 struct ieee80211_channel *chan;
6bad8766
LR		 1398 bool channel_changed = false;
1399 struct ieee80211_channel chan_before;
e38f8a7a 1400
e38f8a7a
LR		 1401 sband = wiphy->bands[reg_beacon->chan.band];
1402 chan = &sband->channels[chan_idx];
1403
1404 if (likely(chan->center_freq != reg_beacon->chan.center_freq))
1405 return;
1406
6bad8766
LR		 1407 if (chan->beacon_found)
1408 return;
1409
1410 chan->beacon_found = true;
1411
0f500a5f
LR		 1412 if (!reg_is_world_roaming(wiphy))
1413 return;
1414
a2f73b6c 1415 if (wiphy->regulatory_flags & REGULATORY_DISABLE_BEACON_HINTS)
37184244
LR		 1416 return;
1417
6bad8766
LR		 1418 chan_before.center_freq = chan->center_freq;
1419 chan_before.flags = chan->flags;
1420
8fe02e16
LR		 1421 if (chan->flags & IEEE80211_CHAN_NO_IR) {
1422 chan->flags &= ~IEEE80211_CHAN_NO_IR;
6bad8766 1423 channel_changed = true;
e38f8a7a
LR		 1424 }
1425
6bad8766
LR		 1426 if (channel_changed)
1427 nl80211_send_beacon_hint_event(wiphy, &chan_before, chan);
e38f8a7a
LR		 1428}
1429
1430/*
1431 * Called when a scan on a wiphy finds a beacon on
1432 * new channel
1433 */
1434static void wiphy_update_new_beacon(struct wiphy *wiphy,
1435 struct reg_beacon *reg_beacon)
1436{
1437 unsigned int i;
1438 struct ieee80211_supported_band *sband;
1439
e38f8a7a
LR		 1440 if (!wiphy->bands[reg_beacon->chan.band])
1441 return;
1442
1443 sband = wiphy->bands[reg_beacon->chan.band];
1444
1445 for (i = 0; i < sband->n_channels; i++)
1446 handle_reg_beacon(wiphy, i, reg_beacon);
1447}
1448
1449/*
1450 * Called upon reg changes or a new wiphy is added
1451 */
1452static void wiphy_update_beacon_reg(struct wiphy *wiphy)
1453{
1454 unsigned int i;
1455 struct ieee80211_supported_band *sband;
1456 struct reg_beacon *reg_beacon;
1457
e38f8a7a
LR		 1458 list_for_each_entry(reg_beacon, &reg_beacon_list, list) {
1459 if (!wiphy->bands[reg_beacon->chan.band])
1460 continue;
1461 sband = wiphy->bands[reg_beacon->chan.band];
1462 for (i = 0; i < sband->n_channels; i++)
1463 handle_reg_beacon(wiphy, i, reg_beacon);
1464 }
1465}
1466
e38f8a7a
LR		 1467/* Reap the advantages of previously found beacons */
1468static void reg_process_beacons(struct wiphy *wiphy)
1469{
b1ed8ddd
LR		 1470 /*
1471 * Means we are just firing up cfg80211, so no beacons would
1472 * have been processed yet.
1473 */
1474 if (!last_request)
1475 return;
e38f8a7a
LR		 1476 wiphy_update_beacon_reg(wiphy);
1477}
1478
1a919318 1479static bool is_ht40_allowed(struct ieee80211_channel *chan)
038659e7
LR		 1480{
1481 if (!chan)
1a919318 1482 return false;
038659e7 1483 if (chan->flags & IEEE80211_CHAN_DISABLED)
1a919318 1484 return false;
038659e7 1485 /* This would happen when regulatory rules disallow HT40 completely */
55b183ad
FF		 1486 if ((chan->flags & IEEE80211_CHAN_NO_HT40) == IEEE80211_CHAN_NO_HT40)
1487 return false;
1488 return true;
038659e7
LR		 1489}
1490
1491static void reg_process_ht_flags_channel(struct wiphy *wiphy,
fdc9d7b2 1492 struct ieee80211_channel *channel)
038659e7 1493{
fdc9d7b2 1494 struct ieee80211_supported_band *sband = wiphy->bands[channel->band];
038659e7
LR		 1495 struct ieee80211_channel *channel_before = NULL, *channel_after = NULL;
1496 unsigned int i;
1497
1a919318 1498 if (!is_ht40_allowed(channel)) {
038659e7
LR		 1499 channel->flags |= IEEE80211_CHAN_NO_HT40;
1500 return;
1501 }
1502
1503 /*
1504 * We need to ensure the extension channels exist to
1505 * be able to use HT40- or HT40+, this finds them (or not)
1506 */
1507 for (i = 0; i < sband->n_channels; i++) {
1508 struct ieee80211_channel *c = &sband->channels[i];
1a919318 1509
038659e7
LR		 1510 if (c->center_freq == (channel->center_freq - 20))
1511 channel_before = c;
1512 if (c->center_freq == (channel->center_freq + 20))
1513 channel_after = c;
1514 }
1515
1516 /*
1517 * Please note that this assumes target bandwidth is 20 MHz,
1518 * if that ever changes we also need to change the below logic
1519 * to include that as well.
1520 */
1a919318 1521 if (!is_ht40_allowed(channel_before))
689da1b3 1522 channel->flags |= IEEE80211_CHAN_NO_HT40MINUS;
038659e7 1523 else
689da1b3 1524 channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
038659e7 1525
1a919318 1526 if (!is_ht40_allowed(channel_after))
689da1b3 1527 channel->flags |= IEEE80211_CHAN_NO_HT40PLUS;
038659e7 1528 else
689da1b3 1529 channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
038659e7
LR		 1530}
1531
1532static void reg_process_ht_flags_band(struct wiphy *wiphy,
fdc9d7b2 1533 struct ieee80211_supported_band *sband)
038659e7
LR		 1534{
1535 unsigned int i;
038659e7 1536
fdc9d7b2
JB		 1537 if (!sband)
1538 return;
038659e7
LR		 1539
1540 for (i = 0; i < sband->n_channels; i++)
fdc9d7b2 1541 reg_process_ht_flags_channel(wiphy, &sband->channels[i]);
038659e7
LR		 1542}
1543
1544static void reg_process_ht_flags(struct wiphy *wiphy)
1545{
1546 enum ieee80211_band band;
1547
1548 if (!wiphy)
1549 return;
1550
fdc9d7b2
JB		 1551 for (band = 0; band < IEEE80211_NUM_BANDS; band++)
1552 reg_process_ht_flags_band(wiphy, wiphy->bands[band]);
038659e7
LR		 1553}
1554
0e3802db
LR		 1555static void reg_call_notifier(struct wiphy *wiphy,
1556 struct regulatory_request *request)
1557{
1558 if (wiphy->reg_notifier)
1559 wiphy->reg_notifier(wiphy, request);
1560}
1561
ad932f04
AN		 1562static bool reg_wdev_chan_valid(struct wiphy *wiphy, struct wireless_dev *wdev)
1563{
ad932f04
AN		 1564 struct cfg80211_chan_def chandef;
1565 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
20658702 1566 enum nl80211_iftype iftype;
ad932f04
AN		 1567
1568 wdev_lock(wdev);
20658702 1569 iftype = wdev->iftype;
ad932f04 1570
20658702 1571 /* make sure the interface is active */
ad932f04 1572 if (!wdev->netdev || !netif_running(wdev->netdev))
20658702 1573 goto wdev_inactive_unlock;
ad932f04 1574
20658702 1575 switch (iftype) {
ad932f04
AN		 1576 case NL80211_IFTYPE_AP:
1577 case NL80211_IFTYPE_P2P_GO:
1578 if (!wdev->beacon_interval)
20658702
AN		 1579 goto wdev_inactive_unlock;
1580 chandef = wdev->chandef;
185076d6
AN		 1581 break;
1582 case NL80211_IFTYPE_ADHOC:
1583 if (!wdev->ssid_len)
20658702
AN		 1584 goto wdev_inactive_unlock;
1585 chandef = wdev->chandef;
ad932f04
AN		 1586 break;
1587 case NL80211_IFTYPE_STATION:
1588 case NL80211_IFTYPE_P2P_CLIENT:
ad932f04
AN		 1589 if (!wdev->current_bss ||
1590 !wdev->current_bss->pub.channel)
20658702 1591 goto wdev_inactive_unlock;
ad932f04 1592
20658702
AN		 1593 if (!rdev->ops->get_channel ||
1594 rdev_get_channel(rdev, wdev, &chandef))
1595 cfg80211_chandef_create(&chandef,
1596 wdev->current_bss->pub.channel,
1597 NL80211_CHAN_NO_HT);
ad932f04
AN		 1598 break;
1599 case NL80211_IFTYPE_MONITOR:
1600 case NL80211_IFTYPE_AP_VLAN:
1601 case NL80211_IFTYPE_P2P_DEVICE:
1602 /* no enforcement required */
1603 break;
1604 default:
1605 /* others not implemented for now */
1606 WARN_ON(1);
1607 break;
1608 }
1609
ad932f04 1610 wdev_unlock(wdev);
20658702
AN		 1611
1612 switch (iftype) {
1613 case NL80211_IFTYPE_AP:
1614 case NL80211_IFTYPE_P2P_GO:
1615 case NL80211_IFTYPE_ADHOC:
923b352f 1616 return cfg80211_reg_can_beacon_relax(wiphy, &chandef, iftype);
20658702
AN		 1617 case NL80211_IFTYPE_STATION:
1618 case NL80211_IFTYPE_P2P_CLIENT:
1619 return cfg80211_chandef_usable(wiphy, &chandef,
1620 IEEE80211_CHAN_DISABLED);
1621 default:
1622 break;
1623 }
1624
1625 return true;
1626
1627wdev_inactive_unlock:
1628 wdev_unlock(wdev);
1629 return true;
ad932f04
AN		 1630}
1631
1632static void reg_leave_invalid_chans(struct wiphy *wiphy)
1633{
1634 struct wireless_dev *wdev;
1635 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1636
1637 ASSERT_RTNL();
1638
1639 list_for_each_entry(wdev, &rdev->wdev_list, list)
1640 if (!reg_wdev_chan_valid(wiphy, wdev))
1641 cfg80211_leave(rdev, wdev);
1642}
1643
1644static void reg_check_chans_work(struct work_struct *work)
1645{
1646 struct cfg80211_registered_device *rdev;
1647
1648 REG_DBG_PRINT("Verifying active interfaces after reg change\n");
1649 rtnl_lock();
1650
1651 list_for_each_entry(rdev, &cfg80211_rdev_list, list)
1652 if (!(rdev->wiphy.regulatory_flags &
1653 REGULATORY_IGNORE_STALE_KICKOFF))
1654 reg_leave_invalid_chans(&rdev->wiphy);
1655
1656 rtnl_unlock();
1657}
1658
1659static void reg_check_channels(void)
1660{
1661 /*
1662 * Give usermode a chance to do something nicer (move to another
1663 * channel, orderly disconnection), before forcing a disconnection.
1664 */
1665 mod_delayed_work(system_power_efficient_wq,
1666 &reg_check_chans,
1667 msecs_to_jiffies(REG_ENFORCE_GRACE_MS));
1668}
1669
eac03e38
SN		 1670static void wiphy_update_regulatory(struct wiphy *wiphy,
1671 enum nl80211_reg_initiator initiator)
b2e1b302
LR		 1672{
1673 enum ieee80211_band band;
c492db37 1674 struct regulatory_request *lr = get_last_request();
eac03e38 1675
0e3802db
LR		 1676 if (ignore_reg_update(wiphy, initiator)) {
1677 /*
1678 * Regulatory updates set by CORE are ignored for custom
1679 * regulatory cards. Let us notify the changes to the driver,
1680 * as some drivers used this to restore its orig_* reg domain.
1681 */
1682 if (initiator == NL80211_REGDOM_SET_BY_CORE &&
a2f73b6c 1683 wiphy->regulatory_flags & REGULATORY_CUSTOM_REG)
0e3802db 1684 reg_call_notifier(wiphy, lr);
a203c2aa 1685 return;
0e3802db 1686 }
a203c2aa 1687
c492db37 1688 lr->dfs_region = get_cfg80211_regdom()->dfs_region;
b68e6b3b 1689
fdc9d7b2
JB		 1690 for (band = 0; band < IEEE80211_NUM_BANDS; band++)
1691 handle_band(wiphy, initiator, wiphy->bands[band]);
a203c2aa 1692
e38f8a7a 1693 reg_process_beacons(wiphy);
038659e7 1694 reg_process_ht_flags(wiphy);
0e3802db 1695 reg_call_notifier(wiphy, lr);
b2e1b302
LR		 1696}
1697
d7549cbb
SN		 1698static void update_all_wiphy_regulatory(enum nl80211_reg_initiator initiator)
1699{
1700 struct cfg80211_registered_device *rdev;
4a38994f 1701 struct wiphy *wiphy;
d7549cbb 1702
5fe231e8 1703 ASSERT_RTNL();
458f4f9e 1704
4a38994f
RM		 1705 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
1706 wiphy = &rdev->wiphy;
1707 wiphy_update_regulatory(wiphy, initiator);
4a38994f 1708 }
ad932f04
AN		 1709
1710 reg_check_channels();
d7549cbb
SN		 1711}
1712
1fa25e41 1713static void handle_channel_custom(struct wiphy *wiphy,
fdc9d7b2 1714 struct ieee80211_channel *chan,
1fa25e41
LR		 1715 const struct ieee80211_regdomain *regd)
1716{
038659e7 1717 u32 bw_flags = 0;
1fa25e41
LR		 1718 const struct ieee80211_reg_rule *reg_rule = NULL;
1719 const struct ieee80211_power_rule *power_rule = NULL;
038659e7 1720 const struct ieee80211_freq_range *freq_range = NULL;
97524820 1721 u32 max_bandwidth_khz;
4edd5698 1722 u32 bw;
ac46d48e 1723
4edd5698
MM		 1724 for (bw = MHZ_TO_KHZ(20); bw >= MHZ_TO_KHZ(5); bw = bw / 2) {
1725 reg_rule = freq_reg_info_regd(wiphy,
1726 MHZ_TO_KHZ(chan->center_freq),
1727 regd, bw);
1728 if (!IS_ERR(reg_rule))
1729 break;
1730 }
1fa25e41 1731
361c9c8b 1732 if (IS_ERR(reg_rule)) {
fe7ef5e9
JB		 1733 REG_DBG_PRINT("Disabling freq %d MHz as custom regd has no rule that fits it\n",
1734 chan->center_freq);
db8dfee5
AN		 1735 if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED) {
1736 chan->flags |= IEEE80211_CHAN_DISABLED;
1737 } else {
1738 chan->orig_flags |= IEEE80211_CHAN_DISABLED;
1739 chan->flags = chan->orig_flags;
1740 }
1fa25e41
LR		 1741 return;
1742 }
1743
b0dfd2ea 1744 chan_reg_rule_print_dbg(regd, chan, reg_rule);
e702d3cf 1745
1fa25e41 1746 power_rule = &reg_rule->power_rule;
038659e7
LR		 1747 freq_range = &reg_rule->freq_range;
1748
97524820
JD		 1749 max_bandwidth_khz = freq_range->max_bandwidth_khz;
1750 /* Check if auto calculation requested */
b0dfd2ea 1751 if (reg_rule->flags & NL80211_RRF_AUTO_BW)
97524820
JD		 1752 max_bandwidth_khz = reg_get_max_bandwidth(regd, reg_rule);
1753
4edd5698
MM		 1754 /* If we get a reg_rule we can assume that at least 5Mhz fit */
1755 if (!reg_does_bw_fit(freq_range, MHZ_TO_KHZ(chan->center_freq),
1756 MHZ_TO_KHZ(10)))
1757 bw_flags |= IEEE80211_CHAN_NO_10MHZ;
1758 if (!reg_does_bw_fit(freq_range, MHZ_TO_KHZ(chan->center_freq),
1759 MHZ_TO_KHZ(20)))
1760 bw_flags |= IEEE80211_CHAN_NO_20MHZ;
1761
1762 if (max_bandwidth_khz < MHZ_TO_KHZ(10))
1763 bw_flags |= IEEE80211_CHAN_NO_10MHZ;
1764 if (max_bandwidth_khz < MHZ_TO_KHZ(20))
1765 bw_flags |= IEEE80211_CHAN_NO_20MHZ;
97524820 1766 if (max_bandwidth_khz < MHZ_TO_KHZ(40))
4edd5698 1767 bw_flags |= IEEE80211_CHAN_NO_HT40;
97524820 1768 if (max_bandwidth_khz < MHZ_TO_KHZ(80))
c7a6ee27 1769 bw_flags |= IEEE80211_CHAN_NO_80MHZ;
97524820 1770 if (max_bandwidth_khz < MHZ_TO_KHZ(160))
c7a6ee27 1771 bw_flags |= IEEE80211_CHAN_NO_160MHZ;
1fa25e41 1772
2e18b38f 1773 chan->dfs_state_entered = jiffies;
c7ab5081
AN		 1774 chan->dfs_state = NL80211_DFS_USABLE;
1775
1776 chan->beacon_found = false;
db8dfee5
AN		 1777
1778 if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED)
1779 chan->flags = chan->orig_flags | bw_flags |
1780 map_regdom_flags(reg_rule->flags);
1781 else
1782 chan->flags |= map_regdom_flags(reg_rule->flags) | bw_flags;
1783
1fa25e41 1784 chan->max_antenna_gain = (int) MBI_TO_DBI(power_rule->max_antenna_gain);
279f0f55
FF		 1785 chan->max_reg_power = chan->max_power =
1786 (int) MBM_TO_DBM(power_rule->max_eirp);
2e18b38f
AN		 1787
1788 if (chan->flags & IEEE80211_CHAN_RADAR) {
1789 if (reg_rule->dfs_cac_ms)
1790 chan->dfs_cac_ms = reg_rule->dfs_cac_ms;
1791 else
1792 chan->dfs_cac_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
1793 }
1794
1795 chan->max_power = chan->max_reg_power;
1fa25e41
LR		 1796}
1797
fdc9d7b2
JB		 1798static void handle_band_custom(struct wiphy *wiphy,
1799 struct ieee80211_supported_band *sband,
1fa25e41
LR		 1800 const struct ieee80211_regdomain *regd)
1801{
1802 unsigned int i;
1fa25e41 1803
fdc9d7b2
JB		 1804 if (!sband)
1805 return;
1fa25e41
LR		 1806
1807 for (i = 0; i < sband->n_channels; i++)
fdc9d7b2 1808 handle_channel_custom(wiphy, &sband->channels[i], regd);
1fa25e41
LR		 1809}
1810
1811/* Used by drivers prior to wiphy registration */
1812void wiphy_apply_custom_regulatory(struct wiphy *wiphy,
1813 const struct ieee80211_regdomain *regd)
1814{
1815 enum ieee80211_band band;
bbcf3f02 1816 unsigned int bands_set = 0;
ac46d48e 1817
a2f73b6c
LR		 1818 WARN(!(wiphy->regulatory_flags & REGULATORY_CUSTOM_REG),
1819 "wiphy should have REGULATORY_CUSTOM_REG\n");
1820 wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG;
222ea581 1821
1fa25e41 1822 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
bbcf3f02
LR		 1823 if (!wiphy->bands[band])
1824 continue;
fdc9d7b2 1825 handle_band_custom(wiphy, wiphy->bands[band], regd);
bbcf3f02 1826 bands_set++;
b2e1b302 1827 }
bbcf3f02
LR		 1828
1829 /*
1830 * no point in calling this if it won't have any effect
1a919318 1831 * on your device's supported bands.
bbcf3f02
LR		 1832 */
1833 WARN_ON(!bands_set);
b2e1b302 1834}
1fa25e41
LR		 1835EXPORT_SYMBOL(wiphy_apply_custom_regulatory);
1836
b2e253cf
LR		 1837static void reg_set_request_processed(void)
1838{
1839 bool need_more_processing = false;
c492db37 1840 struct regulatory_request *lr = get_last_request();
b2e253cf 1841
c492db37 1842 lr->processed = true;
b2e253cf
LR		 1843
1844 spin_lock(&reg_requests_lock);
1845 if (!list_empty(&reg_requests_list))
1846 need_more_processing = true;
1847 spin_unlock(&reg_requests_lock);
1848
eeca9fce 1849 cancel_delayed_work(&reg_timeout);
a90c7a31 1850
b2e253cf
LR		 1851 if (need_more_processing)
1852 schedule_work(&reg_work);
1853}
1854
b3eb7f3f
LR		 1855/**
1856 * reg_process_hint_core - process core regulatory requests
1857 * @pending_request: a pending core regulatory request
1858 *
1859 * The wireless subsystem can use this function to process
1860 * a regulatory request issued by the regulatory core.
1861 *
1862 * Returns one of the different reg request treatment values.
1863 */
1864static enum reg_request_treatment
1865reg_process_hint_core(struct regulatory_request *core_request)
1866{
b3eb7f3f
LR		 1867
1868 core_request->intersect = false;
1869 core_request->processed = false;
5ad6ef5e 1870
05f1a3ea 1871 reg_update_last_request(core_request);
b3eb7f3f 1872
fe6631ff 1873 return reg_call_crda(core_request);
b3eb7f3f
LR		 1874}
1875
0d97a619
LR		 1876static enum reg_request_treatment
1877__reg_process_hint_user(struct regulatory_request *user_request)
1878{
1879 struct regulatory_request *lr = get_last_request();
1880
1881 if (reg_request_cell_base(user_request))
1882 return reg_ignore_cell_hint(user_request);
1883
1884 if (reg_request_cell_base(lr))
1885 return REG_REQ_IGNORE;
1886
1887 if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE)
1888 return REG_REQ_INTERSECT;
1889 /*
1890 * If the user knows better the user should set the regdom
1891 * to their country before the IE is picked up
1892 */
1893 if (lr->initiator == NL80211_REGDOM_SET_BY_USER &&
1894 lr->intersect)
1895 return REG_REQ_IGNORE;
1896 /*
1897 * Process user requests only after previous user/driver/core
1898 * requests have been processed
1899 */
1900 if ((lr->initiator == NL80211_REGDOM_SET_BY_CORE ||
1901 lr->initiator == NL80211_REGDOM_SET_BY_DRIVER ||
1902 lr->initiator == NL80211_REGDOM_SET_BY_USER) &&
1903 regdom_changes(lr->alpha2))
1904 return REG_REQ_IGNORE;
1905
1906 if (!regdom_changes(user_request->alpha2))
1907 return REG_REQ_ALREADY_SET;
1908
1909 return REG_REQ_OK;
1910}
1911
1912/**
1913 * reg_process_hint_user - process user regulatory requests
1914 * @user_request: a pending user regulatory request
1915 *
1916 * The wireless subsystem can use this function to process
1917 * a regulatory request initiated by userspace.
1918 *
1919 * Returns one of the different reg request treatment values.
1920 */
1921static enum reg_request_treatment
1922reg_process_hint_user(struct regulatory_request *user_request)
1923{
1924 enum reg_request_treatment treatment;
0d97a619
LR		 1925
1926 treatment = __reg_process_hint_user(user_request);
1927 if (treatment == REG_REQ_IGNORE ||
0c4ddcd2 1928 treatment == REG_REQ_ALREADY_SET) {
c888393b 1929 reg_free_request(user_request);
0d97a619
LR		 1930 return treatment;
1931 }
1932
0d97a619
LR		 1933 user_request->intersect = treatment == REG_REQ_INTERSECT;
1934 user_request->processed = false;
5ad6ef5e 1935
05f1a3ea 1936 reg_update_last_request(user_request);
0d97a619
LR		 1937
1938 user_alpha2[0] = user_request->alpha2[0];
1939 user_alpha2[1] = user_request->alpha2[1];
1940
fe6631ff 1941 return reg_call_crda(user_request);
0d97a619
LR		 1942}
1943
21636c7f
LR		 1944static enum reg_request_treatment
1945__reg_process_hint_driver(struct regulatory_request *driver_request)
1946{
1947 struct regulatory_request *lr = get_last_request();
1948
1949 if (lr->initiator == NL80211_REGDOM_SET_BY_CORE) {
1950 if (regdom_changes(driver_request->alpha2))
1951 return REG_REQ_OK;
1952 return REG_REQ_ALREADY_SET;
1953 }
1954
1955 /*
1956 * This would happen if you unplug and plug your card
1957 * back in or if you add a new device for which the previously
1958 * loaded card also agrees on the regulatory domain.
1959 */
1960 if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
1961 !regdom_changes(driver_request->alpha2))
1962 return REG_REQ_ALREADY_SET;
1963
1964 return REG_REQ_INTERSECT;
1965}
1966
1967/**
1968 * reg_process_hint_driver - process driver regulatory requests
1969 * @driver_request: a pending driver regulatory request
1970 *
1971 * The wireless subsystem can use this function to process
1972 * a regulatory request issued by an 802.11 driver.
1973 *
1974 * Returns one of the different reg request treatment values.
1975 */
1976static enum reg_request_treatment
1977reg_process_hint_driver(struct wiphy *wiphy,
1978 struct regulatory_request *driver_request)
1979{
34f05f54 1980 const struct ieee80211_regdomain *regd, *tmp;
21636c7f 1981 enum reg_request_treatment treatment;
21636c7f
LR		 1982
1983 treatment = __reg_process_hint_driver(driver_request);
1984
1985 switch (treatment) {
1986 case REG_REQ_OK:
1987 break;
1988 case REG_REQ_IGNORE:
c888393b 1989 reg_free_request(driver_request);
21636c7f
LR		 1990 return treatment;
1991 case REG_REQ_INTERSECT:
1992 /* fall through */
1993 case REG_REQ_ALREADY_SET:
1994 regd = reg_copy_regd(get_cfg80211_regdom());
1995 if (IS_ERR(regd)) {
c888393b 1996 reg_free_request(driver_request);
21636c7f
LR		 1997 return REG_REQ_IGNORE;
1998 }
34f05f54
AN		 1999
2000 tmp = get_wiphy_regdom(wiphy);
21636c7f 2001 rcu_assign_pointer(wiphy->regd, regd);
34f05f54 2002 rcu_free_regdom(tmp);
21636c7f
LR		 2003 }
2004
21636c7f
LR		 2005
2006 driver_request->intersect = treatment == REG_REQ_INTERSECT;
2007 driver_request->processed = false;
5ad6ef5e 2008
05f1a3ea 2009 reg_update_last_request(driver_request);
21636c7f
LR		 2010
2011 /*
2012 * Since CRDA will not be called in this case as we already
2013 * have applied the requested regulatory domain before we just
2014 * inform userspace we have processed the request
2015 */
2016 if (treatment == REG_REQ_ALREADY_SET) {
2017 nl80211_send_reg_change_event(driver_request);
2018 reg_set_request_processed();
2019 return treatment;
2020 }
2021
fe6631ff 2022 return reg_call_crda(driver_request);
21636c7f
LR		 2023}
2024
b23e7a9e
LR		 2025static enum reg_request_treatment
2026__reg_process_hint_country_ie(struct wiphy *wiphy,
2027 struct regulatory_request *country_ie_request)
2028{
2029 struct wiphy *last_wiphy = NULL;
2030 struct regulatory_request *lr = get_last_request();
2031
2032 if (reg_request_cell_base(lr)) {
2033 /* Trust a Cell base station over the AP's country IE */
2034 if (regdom_changes(country_ie_request->alpha2))
2035 return REG_REQ_IGNORE;
2036 return REG_REQ_ALREADY_SET;
2a901468
LR		 2037 } else {
2038 if (wiphy->regulatory_flags & REGULATORY_COUNTRY_IE_IGNORE)
2039 return REG_REQ_IGNORE;
b23e7a9e
LR		 2040 }
2041
b23e7a9e
LR		 2042 if (unlikely(!is_an_alpha2(country_ie_request->alpha2)))
2043 return -EINVAL;
2f1c6c57
LR		 2044
2045 if (lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE)
2046 return REG_REQ_OK;
2047
2048 last_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx);
2049
2050 if (last_wiphy != wiphy) {
b23e7a9e 2051 /*
2f1c6c57
LR		 2052 * Two cards with two APs claiming different
2053 * Country IE alpha2s. We could
2054 * intersect them, but that seems unlikely
2055 * to be correct. Reject second one for now.
b23e7a9e 2056 */
2f1c6c57
LR		 2057 if (regdom_changes(country_ie_request->alpha2))
2058 return REG_REQ_IGNORE;
b23e7a9e
LR		 2059 return REG_REQ_ALREADY_SET;
2060 }
70dcec5a
EG		 2061
2062 if (regdom_changes(country_ie_request->alpha2))
2f1c6c57
LR		 2063 return REG_REQ_OK;
2064 return REG_REQ_ALREADY_SET;
b23e7a9e
LR		 2065}
2066
d1c96a9a 2067/**
b23e7a9e
LR		 2068 * reg_process_hint_country_ie - process regulatory requests from country IEs
2069 * @country_ie_request: a regulatory request from a country IE
d1c96a9a 2070 *
b23e7a9e
LR		 2071 * The wireless subsystem can use this function to process
2072 * a regulatory request issued by a country Information Element.
d1c96a9a 2073 *
2f92212b 2074 * Returns one of the different reg request treatment values.
d1c96a9a 2075 */
2f92212b 2076static enum reg_request_treatment
b23e7a9e
LR		 2077reg_process_hint_country_ie(struct wiphy *wiphy,
2078 struct regulatory_request *country_ie_request)
b2e1b302 2079{
2f92212b 2080 enum reg_request_treatment treatment;
761cf7ec 2081
b23e7a9e 2082 treatment = __reg_process_hint_country_ie(wiphy, country_ie_request);
9c96477d 2083
2f92212b 2084 switch (treatment) {
2f92212b
JB		 2085 case REG_REQ_OK:
2086 break;
b23e7a9e
LR		 2087 case REG_REQ_IGNORE:
2088 /* fall through */
2089 case REG_REQ_ALREADY_SET:
c888393b 2090 reg_free_request(country_ie_request);
b23e7a9e
LR		 2091 return treatment;
2092 case REG_REQ_INTERSECT:
c888393b 2093 reg_free_request(country_ie_request);
fb1fc7ad 2094 /*
b23e7a9e
LR		 2095 * This doesn't happen yet, not sure we
2096 * ever want to support it for this case.
fb1fc7ad 2097 */
b23e7a9e
LR		 2098 WARN_ONCE(1, "Unexpected intersection for country IEs");
2099 return REG_REQ_IGNORE;
3e0c3ff3 2100 }
b2e1b302 2101
b23e7a9e
LR		 2102 country_ie_request->intersect = false;
2103 country_ie_request->processed = false;
5ad6ef5e 2104
05f1a3ea 2105 reg_update_last_request(country_ie_request);
3e0c3ff3 2106
fe6631ff 2107 return reg_call_crda(country_ie_request);
b2e1b302
LR		 2108}
2109
30a548c7 2110/* This processes *all* regulatory hints */
1daa37c7 2111static void reg_process_hint(struct regulatory_request *reg_request)
fe33eb39 2112{
fe33eb39 2113 struct wiphy *wiphy = NULL;
b3eb7f3f 2114 enum reg_request_treatment treatment;
fe33eb39 2115
f4173766 2116 if (reg_request->wiphy_idx != WIPHY_IDX_INVALID)
fe33eb39
LR		 2117 wiphy = wiphy_idx_to_wiphy(reg_request->wiphy_idx);
2118
b3eb7f3f
LR		 2119 switch (reg_request->initiator) {
2120 case NL80211_REGDOM_SET_BY_CORE:
2121 reg_process_hint_core(reg_request);
2122 return;
2123 case NL80211_REGDOM_SET_BY_USER:
841b351c 2124 reg_process_hint_user(reg_request);
0d97a619 2125 return;
b3eb7f3f 2126 case NL80211_REGDOM_SET_BY_DRIVER:
772f0389
IP		 2127 if (!wiphy)
2128 goto out_free;
21636c7f
LR		 2129 treatment = reg_process_hint_driver(wiphy, reg_request);
2130 break;
b3eb7f3f 2131 case NL80211_REGDOM_SET_BY_COUNTRY_IE:
772f0389
IP		 2132 if (!wiphy)
2133 goto out_free;
b23e7a9e 2134 treatment = reg_process_hint_country_ie(wiphy, reg_request);
b3eb7f3f
LR		 2135 break;
2136 default:
2137 WARN(1, "invalid initiator %d\n", reg_request->initiator);
772f0389 2138 goto out_free;
b3eb7f3f
LR		 2139 }
2140
841b351c
JL		 2141 /* This is required so that the orig_* parameters are saved.
2142 * NOTE: treatment must be set for any case that reaches here!
2143 */
b23e7a9e 2144 if (treatment == REG_REQ_ALREADY_SET && wiphy &&
ad932f04 2145 wiphy->regulatory_flags & REGULATORY_STRICT_REG) {
b23e7a9e 2146 wiphy_update_regulatory(wiphy, reg_request->initiator);
ad932f04
AN		 2147 reg_check_channels();
2148 }
772f0389
IP		 2149
2150 return;
2151
2152out_free:
c888393b 2153 reg_free_request(reg_request);
fe33eb39
LR		 2154}
2155
ef51fb1d
AN		 2156static bool reg_only_self_managed_wiphys(void)
2157{
2158 struct cfg80211_registered_device *rdev;
2159 struct wiphy *wiphy;
2160 bool self_managed_found = false;
2161
2162 ASSERT_RTNL();
2163
2164 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
2165 wiphy = &rdev->wiphy;
2166 if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED)
2167 self_managed_found = true;
2168 else
2169 return false;
2170 }
2171
2172 /* make sure at least one self-managed wiphy exists */
2173 return self_managed_found;
2174}
2175
b2e253cf
LR		 2176/*
2177 * Processes regulatory hints, this is all the NL80211_REGDOM_SET_BY_*
2178 * Regulatory hints come on a first come first serve basis and we
2179 * must process each one atomically.
2180 */
fe33eb39 2181static void reg_process_pending_hints(void)
b0e2880b 2182{
c492db37 2183 struct regulatory_request *reg_request, *lr;
fe33eb39 2184
c492db37 2185 lr = get_last_request();
b0e2880b 2186
b2e253cf 2187 /* When last_request->processed becomes true this will be rescheduled */
c492db37 2188 if (lr && !lr->processed) {
96cce12f 2189 reg_process_hint(lr);
5fe231e8 2190 return;
b2e253cf
LR		 2191 }
2192
fe33eb39 2193 spin_lock(&reg_requests_lock);
fe33eb39 2194
b2e253cf 2195 if (list_empty(&reg_requests_list)) {
d951c1dd 2196 spin_unlock(&reg_requests_lock);
5fe231e8 2197 return;
fe33eb39 2198 }
b2e253cf
LR		 2199
2200 reg_request = list_first_entry(&reg_requests_list,
2201 struct regulatory_request,
2202 list);
2203 list_del_init(&reg_request->list);
2204
fe33eb39 2205 spin_unlock(&reg_requests_lock);
b0e2880b 2206
ef51fb1d
AN		 2207 if (reg_only_self_managed_wiphys()) {
2208 reg_free_request(reg_request);
2209 return;
2210 }
2211
1daa37c7 2212 reg_process_hint(reg_request);
2e54a689
B		 2213
2214 lr = get_last_request();
2215
2216 spin_lock(&reg_requests_lock);
2217 if (!list_empty(&reg_requests_list) && lr && lr->processed)
2218 schedule_work(&reg_work);
2219 spin_unlock(&reg_requests_lock);
fe33eb39
LR		 2220}
2221
e38f8a7a
LR		 2222/* Processes beacon hints -- this has nothing to do with country IEs */
2223static void reg_process_pending_beacon_hints(void)
2224{
79c97e97 2225 struct cfg80211_registered_device *rdev;
e38f8a7a
LR		 2226 struct reg_beacon *pending_beacon, *tmp;
2227
e38f8a7a
LR		 2228 /* This goes through the _pending_ beacon list */
2229 spin_lock_bh(&reg_pending_beacons_lock);
2230
e38f8a7a
LR		 2231 list_for_each_entry_safe(pending_beacon, tmp,
2232 &reg_pending_beacons, list) {
e38f8a7a
LR		 2233 list_del_init(&pending_beacon->list);
2234
2235 /* Applies the beacon hint to current wiphys */
79c97e97
JB		 2236 list_for_each_entry(rdev, &cfg80211_rdev_list, list)
2237 wiphy_update_new_beacon(&rdev->wiphy, pending_beacon);
e38f8a7a
LR		 2238
2239 /* Remembers the beacon hint for new wiphys or reg changes */
2240 list_add_tail(&pending_beacon->list, &reg_beacon_list);
2241 }
2242
2243 spin_unlock_bh(&reg_pending_beacons_lock);
e38f8a7a
LR		 2244}
2245
b0d7aa59
JD		 2246static void reg_process_self_managed_hints(void)
2247{
2248 struct cfg80211_registered_device *rdev;
2249 struct wiphy *wiphy;
2250 const struct ieee80211_regdomain *tmp;
2251 const struct ieee80211_regdomain *regd;
2252 enum ieee80211_band band;
2253 struct regulatory_request request = {};
2254
2255 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
2256 wiphy = &rdev->wiphy;
2257
2258 spin_lock(&reg_requests_lock);
2259 regd = rdev->requested_regd;
2260 rdev->requested_regd = NULL;
2261 spin_unlock(&reg_requests_lock);
2262
2263 if (regd == NULL)
2264 continue;
2265
2266 tmp = get_wiphy_regdom(wiphy);
2267 rcu_assign_pointer(wiphy->regd, regd);
2268 rcu_free_regdom(tmp);
2269
2270 for (band = 0; band < IEEE80211_NUM_BANDS; band++)
2271 handle_band_custom(wiphy, wiphy->bands[band], regd);
2272
2273 reg_process_ht_flags(wiphy);
2274
2275 request.wiphy_idx = get_wiphy_idx(wiphy);
2276 request.alpha2[0] = regd->alpha2[0];
2277 request.alpha2[1] = regd->alpha2[1];
2278 request.initiator = NL80211_REGDOM_SET_BY_DRIVER;
2279
2280 nl80211_send_wiphy_reg_change_event(&request);
2281 }
2282
2283 reg_check_channels();
2284}
2285
fe33eb39
LR		 2286static void reg_todo(struct work_struct *work)
2287{
5fe231e8 2288 rtnl_lock();
fe33eb39 2289 reg_process_pending_hints();
e38f8a7a 2290 reg_process_pending_beacon_hints();
b0d7aa59 2291 reg_process_self_managed_hints();
5fe231e8 2292 rtnl_unlock();
fe33eb39
LR		 2293}
2294
fe33eb39
LR		 2295static void queue_regulatory_request(struct regulatory_request *request)
2296{
d4f2c881
JB		 2297 request->alpha2[0] = toupper(request->alpha2[0]);
2298 request->alpha2[1] = toupper(request->alpha2[1]);
c61029c7 2299
fe33eb39
LR		 2300 spin_lock(&reg_requests_lock);
2301 list_add_tail(&request->list, &reg_requests_list);
2302 spin_unlock(&reg_requests_lock);
2303
2304 schedule_work(&reg_work);
2305}
2306
09d989d1
LR		 2307/*
2308 * Core regulatory hint -- happens during cfg80211_init()
2309 * and when we restore regulatory settings.
2310 */
ba25c141
LR		 2311static int regulatory_hint_core(const char *alpha2)
2312{
2313 struct regulatory_request *request;
2314
1a919318 2315 request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
ba25c141
LR		 2316 if (!request)
2317 return -ENOMEM;
2318
2319 request->alpha2[0] = alpha2[0];
2320 request->alpha2[1] = alpha2[1];
7db90f4a 2321 request->initiator = NL80211_REGDOM_SET_BY_CORE;
ba25c141 2322
31e99729 2323 queue_regulatory_request(request);
5078b2e3 2324
fe33eb39 2325 return 0;
ba25c141
LR		 2326}
2327
fe33eb39 2328/* User hints */
57b5ce07
LR		 2329int regulatory_hint_user(const char *alpha2,
2330 enum nl80211_user_reg_hint_type user_reg_hint_type)
b2e1b302 2331{
fe33eb39
LR		 2332 struct regulatory_request *request;
2333
fdc9d7b2
JB		 2334 if (WARN_ON(!alpha2))
2335 return -EINVAL;
b2e1b302 2336
fe33eb39
LR		 2337 request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
2338 if (!request)
2339 return -ENOMEM;
2340
f4173766 2341 request->wiphy_idx = WIPHY_IDX_INVALID;
fe33eb39
LR		 2342 request->alpha2[0] = alpha2[0];
2343 request->alpha2[1] = alpha2[1];
e12822e1 2344 request->initiator = NL80211_REGDOM_SET_BY_USER;
57b5ce07 2345 request->user_reg_hint_type = user_reg_hint_type;
fe33eb39 2346
c37722bd
I		 2347 /* Allow calling CRDA again */
2348 reg_crda_timeouts = 0;
2349
fe33eb39
LR		 2350 queue_regulatory_request(request);
2351
2352 return 0;
2353}
2354
05050753 2355int regulatory_hint_indoor(bool is_indoor, u32 portid)
52616f2b 2356{
05050753 2357 spin_lock(&reg_indoor_lock);
52616f2b 2358
05050753
I		 2359 /* It is possible that more than one user space process is trying to
2360 * configure the indoor setting. To handle such cases, clear the indoor
2361 * setting in case that some process does not think that the device
2362 * is operating in an indoor environment. In addition, if a user space
2363 * process indicates that it is controlling the indoor setting, save its
2364 * portid, i.e., make it the owner.
2365 */
2366 reg_is_indoor = is_indoor;
2367 if (reg_is_indoor) {
2368 if (!reg_is_indoor_portid)
2369 reg_is_indoor_portid = portid;
2370 } else {
2371 reg_is_indoor_portid = 0;
2372 }
52616f2b 2373
05050753 2374 spin_unlock(&reg_indoor_lock);
52616f2b 2375
05050753
I		 2376 if (!is_indoor)
2377 reg_check_channels();
52616f2b
IP		 2378
2379 return 0;
2380}
2381
05050753
I		 2382void regulatory_netlink_notify(u32 portid)
2383{
2384 spin_lock(&reg_indoor_lock);
2385
2386 if (reg_is_indoor_portid != portid) {
2387 spin_unlock(&reg_indoor_lock);
2388 return;
2389 }
2390
2391 reg_is_indoor = false;
2392 reg_is_indoor_portid = 0;
2393
2394 spin_unlock(&reg_indoor_lock);
2395
2396 reg_check_channels();
2397}
2398
fe33eb39
LR		 2399/* Driver hints */
2400int regulatory_hint(struct wiphy *wiphy, const char *alpha2)
2401{
2402 struct regulatory_request *request;
2403
fdc9d7b2
JB		 2404 if (WARN_ON(!alpha2 || !wiphy))
2405 return -EINVAL;
fe33eb39 2406
4f7b9140
LR		 2407 wiphy->regulatory_flags &= ~REGULATORY_CUSTOM_REG;
2408
fe33eb39
LR		 2409 request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
2410 if (!request)
2411 return -ENOMEM;
2412
2413 request->wiphy_idx = get_wiphy_idx(wiphy);
2414
fe33eb39
LR		 2415 request->alpha2[0] = alpha2[0];
2416 request->alpha2[1] = alpha2[1];
7db90f4a 2417 request->initiator = NL80211_REGDOM_SET_BY_DRIVER;
fe33eb39 2418
c37722bd
I		 2419 /* Allow calling CRDA again */
2420 reg_crda_timeouts = 0;
2421
fe33eb39
LR		 2422 queue_regulatory_request(request);
2423
2424 return 0;
b2e1b302
LR		 2425}
2426EXPORT_SYMBOL(regulatory_hint);
2427
789fd033
LR		 2428void regulatory_hint_country_ie(struct wiphy *wiphy, enum ieee80211_band band,
2429 const u8 *country_ie, u8 country_ie_len)
3f2355cb 2430{
3f2355cb 2431 char alpha2[2];
3f2355cb 2432 enum environment_cap env = ENVIRON_ANY;
db2424c5 2433 struct regulatory_request *request = NULL, *lr;
d335fe63 2434
3f2355cb
LR		 2435 /* IE len must be evenly divisible by 2 */
2436 if (country_ie_len & 0x01)
db2424c5 2437 return;
3f2355cb
LR		 2438
2439 if (country_ie_len < IEEE80211_COUNTRY_IE_MIN_LEN)
db2424c5
JB		 2440 return;
2441
2442 request = kzalloc(sizeof(*request), GFP_KERNEL);
2443 if (!request)
2444 return;
3f2355cb 2445
3f2355cb
LR		 2446 alpha2[0] = country_ie[0];
2447 alpha2[1] = country_ie[1];
2448
2449 if (country_ie[2] == 'I')
2450 env = ENVIRON_INDOOR;
2451 else if (country_ie[2] == 'O')
2452 env = ENVIRON_OUTDOOR;
2453
db2424c5
JB		 2454 rcu_read_lock();
2455 lr = get_last_request();
2456
2457 if (unlikely(!lr))
2458 goto out;
2459
fb1fc7ad 2460 /*
8b19e6ca 2461 * We will run this only upon a successful connection on cfg80211.
4b44c8bc 2462 * We leave conflict resolution to the workqueue, where can hold
5fe231e8 2463 * the RTNL.
fb1fc7ad 2464 */
c492db37
JB		 2465 if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
2466 lr->wiphy_idx != WIPHY_IDX_INVALID)
4b44c8bc 2467 goto out;
3f2355cb 2468
fe33eb39 2469 request->wiphy_idx = get_wiphy_idx(wiphy);
4f366c5d
JL		 2470 request->alpha2[0] = alpha2[0];
2471 request->alpha2[1] = alpha2[1];
7db90f4a 2472 request->initiator = NL80211_REGDOM_SET_BY_COUNTRY_IE;
fe33eb39
LR		 2473 request->country_ie_env = env;
2474
c37722bd
I		 2475 /* Allow calling CRDA again */
2476 reg_crda_timeouts = 0;
2477
fe33eb39 2478 queue_regulatory_request(request);
db2424c5 2479 request = NULL;
3f2355cb 2480out:
db2424c5
JB		 2481 kfree(request);
2482 rcu_read_unlock();
3f2355cb 2483}
b2e1b302 2484
09d989d1
LR		 2485static void restore_alpha2(char *alpha2, bool reset_user)
2486{
2487 /* indicates there is no alpha2 to consider for restoration */
2488 alpha2[0] = '9';
2489 alpha2[1] = '7';
2490
2491 /* The user setting has precedence over the module parameter */
2492 if (is_user_regdom_saved()) {
2493 /* Unless we're asked to ignore it and reset it */
2494 if (reset_user) {
1a919318 2495 REG_DBG_PRINT("Restoring regulatory settings including user preference\n");
09d989d1
LR		 2496 user_alpha2[0] = '9';
2497 user_alpha2[1] = '7';
2498
2499 /*
2500 * If we're ignoring user settings, we still need to
2501 * check the module parameter to ensure we put things
2502 * back as they were for a full restore.
2503 */
2504 if (!is_world_regdom(ieee80211_regdom)) {
1a919318
JB		 2505 REG_DBG_PRINT("Keeping preference on module parameter ieee80211_regdom: %c%c\n",
2506 ieee80211_regdom[0], ieee80211_regdom[1]);
09d989d1
LR		 2507 alpha2[0] = ieee80211_regdom[0];
2508 alpha2[1] = ieee80211_regdom[1];
2509 }
2510 } else {
1a919318
JB		 2511 REG_DBG_PRINT("Restoring regulatory settings while preserving user preference for: %c%c\n",
2512 user_alpha2[0], user_alpha2[1]);
09d989d1
LR		 2513 alpha2[0] = user_alpha2[0];
2514 alpha2[1] = user_alpha2[1];
2515 }
2516 } else if (!is_world_regdom(ieee80211_regdom)) {
1a919318
JB		 2517 REG_DBG_PRINT("Keeping preference on module parameter ieee80211_regdom: %c%c\n",
2518 ieee80211_regdom[0], ieee80211_regdom[1]);
09d989d1
LR		 2519 alpha2[0] = ieee80211_regdom[0];
2520 alpha2[1] = ieee80211_regdom[1];
2521 } else
d91e41b6 2522 REG_DBG_PRINT("Restoring regulatory settings\n");
09d989d1
LR		 2523}
2524
5ce543d1
RM		 2525static void restore_custom_reg_settings(struct wiphy *wiphy)
2526{
2527 struct ieee80211_supported_band *sband;
2528 enum ieee80211_band band;
2529 struct ieee80211_channel *chan;
2530 int i;
2531
2532 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
2533 sband = wiphy->bands[band];
2534 if (!sband)
2535 continue;
2536 for (i = 0; i < sband->n_channels; i++) {
2537 chan = &sband->channels[i];
2538 chan->flags = chan->orig_flags;
2539 chan->max_antenna_gain = chan->orig_mag;
2540 chan->max_power = chan->orig_mpwr;
899852af 2541 chan->beacon_found = false;
5ce543d1
RM		 2542 }
2543 }
2544}
2545
09d989d1
LR		 2546/*
2547 * Restoring regulatory settings involves ingoring any
2548 * possibly stale country IE information and user regulatory
2549 * settings if so desired, this includes any beacon hints
2550 * learned as we could have traveled outside to another country
2551 * after disconnection. To restore regulatory settings we do
2552 * exactly what we did at bootup:
2553 *
2554 * - send a core regulatory hint
2555 * - send a user regulatory hint if applicable
2556 *
2557 * Device drivers that send a regulatory hint for a specific country
2558 * keep their own regulatory domain on wiphy->regd so that does does
2559 * not need to be remembered.
2560 */
2561static void restore_regulatory_settings(bool reset_user)
2562{
2563 char alpha2[2];
cee0bec5 2564 char world_alpha2[2];
09d989d1 2565 struct reg_beacon *reg_beacon, *btmp;
14609555 2566 LIST_HEAD(tmp_reg_req_list);
5ce543d1 2567 struct cfg80211_registered_device *rdev;
09d989d1 2568
5fe231e8
JB		 2569 ASSERT_RTNL();
2570
05050753
I		 2571 /*
2572 * Clear the indoor setting in case that it is not controlled by user
2573 * space, as otherwise there is no guarantee that the device is still
2574 * operating in an indoor environment.
2575 */
2576 spin_lock(&reg_indoor_lock);
2577 if (reg_is_indoor && !reg_is_indoor_portid) {
2578 reg_is_indoor = false;
2579 reg_check_channels();
2580 }
2581 spin_unlock(&reg_indoor_lock);
52616f2b 2582
2d319867 2583 reset_regdomains(true, &world_regdom);
09d989d1
LR		 2584 restore_alpha2(alpha2, reset_user);
2585
14609555
LR		 2586 /*
2587 * If there's any pending requests we simply
2588 * stash them to a temporary pending queue and
2589 * add then after we've restored regulatory
2590 * settings.
2591 */
2592 spin_lock(&reg_requests_lock);
eeca9fce 2593 list_splice_tail_init(&reg_requests_list, &tmp_reg_req_list);
14609555
LR		 2594 spin_unlock(&reg_requests_lock);
2595
09d989d1
LR		 2596 /* Clear beacon hints */
2597 spin_lock_bh(&reg_pending_beacons_lock);
fea9bced
JB		 2598 list_for_each_entry_safe(reg_beacon, btmp, &reg_pending_beacons, list) {
2599 list_del(&reg_beacon->list);
2600 kfree(reg_beacon);
09d989d1
LR		 2601 }
2602 spin_unlock_bh(&reg_pending_beacons_lock);
2603
fea9bced
JB		 2604 list_for_each_entry_safe(reg_beacon, btmp, &reg_beacon_list, list) {
2605 list_del(&reg_beacon->list);
2606 kfree(reg_beacon);
09d989d1
LR		 2607 }
2608
2609 /* First restore to the basic regulatory settings */
379b82f4
JB		 2610 world_alpha2[0] = cfg80211_world_regdom->alpha2[0];
2611 world_alpha2[1] = cfg80211_world_regdom->alpha2[1];
09d989d1 2612
5ce543d1 2613 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
b0d7aa59
JD		 2614 if (rdev->wiphy.regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED)
2615 continue;
a2f73b6c 2616 if (rdev->wiphy.regulatory_flags & REGULATORY_CUSTOM_REG)
5ce543d1
RM		 2617 restore_custom_reg_settings(&rdev->wiphy);
2618 }
2619
cee0bec5 2620 regulatory_hint_core(world_alpha2);
09d989d1
LR		 2621
2622 /*
2623 * This restores the ieee80211_regdom module parameter
2624 * preference or the last user requested regulatory
2625 * settings, user regulatory settings takes precedence.
2626 */
2627 if (is_an_alpha2(alpha2))
549cc1c5 2628 regulatory_hint_user(alpha2, NL80211_USER_REG_HINT_USER);
09d989d1 2629
14609555 2630 spin_lock(&reg_requests_lock);
11cff96c 2631 list_splice_tail_init(&tmp_reg_req_list, &reg_requests_list);
14609555
LR		 2632 spin_unlock(&reg_requests_lock);
2633
14609555
LR		 2634 REG_DBG_PRINT("Kicking the queue\n");
2635
2636 schedule_work(&reg_work);
2637}
09d989d1
LR		 2638
2639void regulatory_hint_disconnect(void)
2640{
1a919318 2641 REG_DBG_PRINT("All devices are disconnected, going to restore regulatory settings\n");
09d989d1
LR		 2642 restore_regulatory_settings(false);
2643}
2644
e38f8a7a
LR		 2645static bool freq_is_chan_12_13_14(u16 freq)
2646{
59eb21a6
BR		 2647 if (freq == ieee80211_channel_to_frequency(12, IEEE80211_BAND_2GHZ) ||
2648 freq == ieee80211_channel_to_frequency(13, IEEE80211_BAND_2GHZ) ||
2649 freq == ieee80211_channel_to_frequency(14, IEEE80211_BAND_2GHZ))
e38f8a7a
LR		 2650 return true;
2651 return false;
2652}
2653
3ebfa6e7
LR		 2654static bool pending_reg_beacon(struct ieee80211_channel *beacon_chan)
2655{
2656 struct reg_beacon *pending_beacon;
2657
2658 list_for_each_entry(pending_beacon, &reg_pending_beacons, list)
2659 if (beacon_chan->center_freq ==
2660 pending_beacon->chan.center_freq)
2661 return true;
2662 return false;
2663}
2664
e38f8a7a
LR		 2665int regulatory_hint_found_beacon(struct wiphy *wiphy,
2666 struct ieee80211_channel *beacon_chan,
2667 gfp_t gfp)
2668{
2669 struct reg_beacon *reg_beacon;
3ebfa6e7 2670 bool processing;
e38f8a7a 2671
1a919318
JB		 2672 if (beacon_chan->beacon_found ||
2673 beacon_chan->flags & IEEE80211_CHAN_RADAR ||
e38f8a7a 2674 (beacon_chan->band == IEEE80211_BAND_2GHZ &&
1a919318 2675 !freq_is_chan_12_13_14(beacon_chan->center_freq)))
e38f8a7a
LR		 2676 return 0;
2677
3ebfa6e7
LR		 2678 spin_lock_bh(&reg_pending_beacons_lock);
2679 processing = pending_reg_beacon(beacon_chan);
2680 spin_unlock_bh(&reg_pending_beacons_lock);
2681
2682 if (processing)
e38f8a7a
LR		 2683 return 0;
2684
2685 reg_beacon = kzalloc(sizeof(struct reg_beacon), gfp);
2686 if (!reg_beacon)
2687 return -ENOMEM;
2688
1a919318 2689 REG_DBG_PRINT("Found new beacon on frequency: %d MHz (Ch %d) on %s\n",
4113f751
LR		 2690 beacon_chan->center_freq,
2691 ieee80211_frequency_to_channel(beacon_chan->center_freq),
2692 wiphy_name(wiphy));
2693
e38f8a7a 2694 memcpy(&reg_beacon->chan, beacon_chan,
1a919318 2695 sizeof(struct ieee80211_channel));
e38f8a7a
LR		 2696
2697 /*
2698 * Since we can be called from BH or and non-BH context
2699 * we must use spin_lock_bh()
2700 */
2701 spin_lock_bh(&reg_pending_beacons_lock);
2702 list_add_tail(&reg_beacon->list, &reg_pending_beacons);
2703 spin_unlock_bh(&reg_pending_beacons_lock);
2704
2705 schedule_work(&reg_work);
2706
2707 return 0;
2708}
2709
a3d2eaf0 2710static void print_rd_rules(const struct ieee80211_regdomain *rd)
b2e1b302
LR		 2711{
2712 unsigned int i;
a3d2eaf0
JB		 2713 const struct ieee80211_reg_rule *reg_rule = NULL;
2714 const struct ieee80211_freq_range *freq_range = NULL;
2715 const struct ieee80211_power_rule *power_rule = NULL;
089027e5 2716 char bw[32], cac_time[32];
b2e1b302 2717
089027e5 2718 pr_info(" (start_freq - end_freq @ bandwidth), (max_antenna_gain, max_eirp), (dfs_cac_time)\n");
b2e1b302
LR		 2719
2720 for (i = 0; i < rd->n_reg_rules; i++) {
2721 reg_rule = &rd->reg_rules[i];
2722 freq_range = &reg_rule->freq_range;
2723 power_rule = &reg_rule->power_rule;
2724
b0dfd2ea
JD		 2725 if (reg_rule->flags & NL80211_RRF_AUTO_BW)
2726 snprintf(bw, sizeof(bw), "%d KHz, %d KHz AUTO",
2727 freq_range->max_bandwidth_khz,
97524820
JD		 2728 reg_get_max_bandwidth(rd, reg_rule));
2729 else
b0dfd2ea 2730 snprintf(bw, sizeof(bw), "%d KHz",
97524820
JD		 2731 freq_range->max_bandwidth_khz);
2732
089027e5
JD		 2733 if (reg_rule->flags & NL80211_RRF_DFS)
2734 scnprintf(cac_time, sizeof(cac_time), "%u s",
2735 reg_rule->dfs_cac_ms/1000);
2736 else
2737 scnprintf(cac_time, sizeof(cac_time), "N/A");
2738
2739
fb1fc7ad
LR		 2740 /*
2741 * There may not be documentation for max antenna gain
2742 * in certain regions
2743 */
b2e1b302 2744 if (power_rule->max_antenna_gain)
089027e5 2745 pr_info(" (%d KHz - %d KHz @ %s), (%d mBi, %d mBm), (%s)\n",
b2e1b302
LR		 2746 freq_range->start_freq_khz,
2747 freq_range->end_freq_khz,
97524820 2748 bw,
b2e1b302 2749 power_rule->max_antenna_gain,
089027e5
JD		 2750 power_rule->max_eirp,
2751 cac_time);
b2e1b302 2752 else
089027e5 2753 pr_info(" (%d KHz - %d KHz @ %s), (N/A, %d mBm), (%s)\n",
b2e1b302
LR		 2754 freq_range->start_freq_khz,
2755 freq_range->end_freq_khz,
97524820 2756 bw,
089027e5
JD		 2757 power_rule->max_eirp,
2758 cac_time);
b2e1b302
LR		 2759 }
2760}
2761
4c7d3982 2762bool reg_supported_dfs_region(enum nl80211_dfs_regions dfs_region)
8b60b078
LR		 2763{
2764 switch (dfs_region) {
2765 case NL80211_DFS_UNSET:
2766 case NL80211_DFS_FCC:
2767 case NL80211_DFS_ETSI:
2768 case NL80211_DFS_JP:
2769 return true;
2770 default:
2771 REG_DBG_PRINT("Ignoring uknown DFS master region: %d\n",
2772 dfs_region);
2773 return false;
2774 }
2775}
2776
a3d2eaf0 2777static void print_regdomain(const struct ieee80211_regdomain *rd)
b2e1b302 2778{
c492db37 2779 struct regulatory_request *lr = get_last_request();
b2e1b302 2780
3f2355cb 2781 if (is_intersected_alpha2(rd->alpha2)) {
c492db37 2782 if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE) {
79c97e97 2783 struct cfg80211_registered_device *rdev;
c492db37 2784 rdev = cfg80211_rdev_by_wiphy_idx(lr->wiphy_idx);
79c97e97 2785 if (rdev) {
e9c0268f 2786 pr_info("Current regulatory domain updated by AP to: %c%c\n",
79c97e97
JB		 2787 rdev->country_ie_alpha2[0],
2788 rdev->country_ie_alpha2[1]);
3f2355cb 2789 } else
e9c0268f 2790 pr_info("Current regulatory domain intersected:\n");
3f2355cb 2791 } else
e9c0268f 2792 pr_info("Current regulatory domain intersected:\n");
1a919318 2793 } else if (is_world_regdom(rd->alpha2)) {
e9c0268f 2794 pr_info("World regulatory domain updated:\n");
1a919318 2795 } else {
b2e1b302 2796 if (is_unknown_alpha2(rd->alpha2))
e9c0268f 2797 pr_info("Regulatory domain changed to driver built-in settings (unknown country)\n");
57b5ce07 2798 else {
c492db37 2799 if (reg_request_cell_base(lr))
1a919318 2800 pr_info("Regulatory domain changed to country: %c%c by Cell Station\n",
57b5ce07
LR		 2801 rd->alpha2[0], rd->alpha2[1]);
2802 else
1a919318 2803 pr_info("Regulatory domain changed to country: %c%c\n",
57b5ce07
LR		 2804 rd->alpha2[0], rd->alpha2[1]);
2805 }
b2e1b302 2806 }
1a919318 2807
3ef121b5 2808 pr_info(" DFS Master region: %s", reg_dfs_region_str(rd->dfs_region));
b2e1b302
LR		 2809 print_rd_rules(rd);
2810}
2811
2df78167 2812static void print_regdomain_info(const struct ieee80211_regdomain *rd)
b2e1b302 2813{
e9c0268f 2814 pr_info("Regulatory domain: %c%c\n", rd->alpha2[0], rd->alpha2[1]);
b2e1b302
LR		 2815 print_rd_rules(rd);
2816}
2817
3b9e5aca
LR		 2818static int reg_set_rd_core(const struct ieee80211_regdomain *rd)
2819{
2820 if (!is_world_regdom(rd->alpha2))
2821 return -EINVAL;
2822 update_world_regdomain(rd);
2823 return 0;
2824}
2825
84721d44
LR		 2826static int reg_set_rd_user(const struct ieee80211_regdomain *rd,
2827 struct regulatory_request *user_request)
2828{
2829 const struct ieee80211_regdomain *intersected_rd = NULL;
2830
84721d44
LR		 2831 if (!regdom_changes(rd->alpha2))
2832 return -EALREADY;
2833
2834 if (!is_valid_rd(rd)) {
2835 pr_err("Invalid regulatory domain detected:\n");
2836 print_regdomain_info(rd);
2837 return -EINVAL;
2838 }
2839
2840 if (!user_request->intersect) {
2841 reset_regdomains(false, rd);
2842 return 0;
2843 }
2844
2845 intersected_rd = regdom_intersect(rd, get_cfg80211_regdom());
2846 if (!intersected_rd)
2847 return -EINVAL;
2848
2849 kfree(rd);
2850 rd = NULL;
2851 reset_regdomains(false, intersected_rd);
2852
2853 return 0;
2854}
2855
f5fe3247
LR		 2856static int reg_set_rd_driver(const struct ieee80211_regdomain *rd,
2857 struct regulatory_request *driver_request)
b2e1b302 2858{
e9763c3c 2859 const struct ieee80211_regdomain *regd;
9c96477d 2860 const struct ieee80211_regdomain *intersected_rd = NULL;
f5fe3247 2861 const struct ieee80211_regdomain *tmp;
806a9e39 2862 struct wiphy *request_wiphy;
6913b49a 2863
f5fe3247 2864 if (is_world_regdom(rd->alpha2))
b2e1b302
LR		 2865 return -EINVAL;
2866
f5fe3247
LR		 2867 if (!regdom_changes(rd->alpha2))
2868 return -EALREADY;
b2e1b302 2869
8375af3b 2870 if (!is_valid_rd(rd)) {
e9c0268f 2871 pr_err("Invalid regulatory domain detected:\n");
8375af3b
LR		 2872 print_regdomain_info(rd);
2873 return -EINVAL;
b2e1b302
LR		 2874 }
2875
f5fe3247
LR		 2876 request_wiphy = wiphy_idx_to_wiphy(driver_request->wiphy_idx);
2877 if (!request_wiphy) {
845f3351
SD		 2878 queue_delayed_work(system_power_efficient_wq,
2879 &reg_timeout, 0);
de3584bd
JB		 2880 return -ENODEV;
2881 }
806a9e39 2882
f5fe3247 2883 if (!driver_request->intersect) {
558f6d32
LR		 2884 if (request_wiphy->regd)
2885 return -EALREADY;
3e0c3ff3 2886
e9763c3c
JB		 2887 regd = reg_copy_regd(rd);
2888 if (IS_ERR(regd))
2889 return PTR_ERR(regd);
3e0c3ff3 2890
458f4f9e 2891 rcu_assign_pointer(request_wiphy->regd, regd);
379b82f4 2892 reset_regdomains(false, rd);
b8295acd
LR		 2893 return 0;
2894 }
2895
f5fe3247
LR		 2896 intersected_rd = regdom_intersect(rd, get_cfg80211_regdom());
2897 if (!intersected_rd)
2898 return -EINVAL;
b8295acd 2899
f5fe3247
LR		 2900 /*
2901 * We can trash what CRDA provided now.
2902 * However if a driver requested this specific regulatory
2903 * domain we keep it for its private use
2904 */
2905 tmp = get_wiphy_regdom(request_wiphy);
2906 rcu_assign_pointer(request_wiphy->regd, rd);
2907 rcu_free_regdom(tmp);
b8295acd 2908
f5fe3247 2909 rd = NULL;
b7566fc3 2910
f5fe3247 2911 reset_regdomains(false, intersected_rd);
3e0c3ff3 2912
f5fe3247
LR		 2913 return 0;
2914}
2915
01992406
LR		 2916static int reg_set_rd_country_ie(const struct ieee80211_regdomain *rd,
2917 struct regulatory_request *country_ie_request)
f5fe3247
LR		 2918{
2919 struct wiphy *request_wiphy;
b8295acd 2920
f5fe3247
LR		 2921 if (!is_alpha2_set(rd->alpha2) && !is_an_alpha2(rd->alpha2) &&
2922 !is_unknown_alpha2(rd->alpha2))
2923 return -EINVAL;
b8295acd 2924
f5fe3247
LR		 2925 /*
2926 * Lets only bother proceeding on the same alpha2 if the current
2927 * rd is non static (it means CRDA was present and was used last)
2928 * and the pending request came in from a country IE
2929 */
2930
2931 if (!is_valid_rd(rd)) {
2932 pr_err("Invalid regulatory domain detected:\n");
2933 print_regdomain_info(rd);
2934 return -EINVAL;
9c96477d
LR		 2935 }
2936
01992406 2937 request_wiphy = wiphy_idx_to_wiphy(country_ie_request->wiphy_idx);
f5fe3247 2938 if (!request_wiphy) {
845f3351
SD		 2939 queue_delayed_work(system_power_efficient_wq,
2940 &reg_timeout, 0);
f5fe3247
LR		 2941 return -ENODEV;
2942 }
b2e1b302 2943
01992406 2944 if (country_ie_request->intersect)
f5fe3247
LR		 2945 return -EINVAL;
2946
2947 reset_regdomains(false, rd);
2948 return 0;
2949}
b2e1b302 2950
fb1fc7ad
LR		 2951/*
2952 * Use this call to set the current regulatory domain. Conflicts with
b2e1b302 2953 * multiple drivers can be ironed out later. Caller must've already
458f4f9e 2954 * kmalloc'd the rd structure.
fb1fc7ad 2955 */
c37722bd
I		 2956int set_regdom(const struct ieee80211_regdomain *rd,
2957 enum ieee80211_regd_source regd_src)
b2e1b302 2958{
c492db37 2959 struct regulatory_request *lr;
092008ab 2960 bool user_reset = false;
b2e1b302
LR		 2961 int r;
2962
3b9e5aca
LR		 2963 if (!reg_is_valid_request(rd->alpha2)) {
2964 kfree(rd);
2965 return -EINVAL;
2966 }
2967
c37722bd
I		 2968 if (regd_src == REGD_SOURCE_CRDA)
2969 reg_crda_timeouts = 0;
2970
c492db37 2971 lr = get_last_request();
abc7381b 2972
b2e1b302 2973 /* Note that this doesn't update the wiphys, this is done below */
3b9e5aca
LR		 2974 switch (lr->initiator) {
2975 case NL80211_REGDOM_SET_BY_CORE:
2976 r = reg_set_rd_core(rd);
2977 break;
2978 case NL80211_REGDOM_SET_BY_USER:
84721d44 2979 r = reg_set_rd_user(rd, lr);
092008ab 2980 user_reset = true;
84721d44 2981 break;
3b9e5aca 2982 case NL80211_REGDOM_SET_BY_DRIVER:
f5fe3247
LR		 2983 r = reg_set_rd_driver(rd, lr);
2984 break;
3b9e5aca 2985 case NL80211_REGDOM_SET_BY_COUNTRY_IE:
01992406 2986 r = reg_set_rd_country_ie(rd, lr);
3b9e5aca
LR		 2987 break;
2988 default:
2989 WARN(1, "invalid initiator %d\n", lr->initiator);
2990 return -EINVAL;
2991 }
2992
d2372b31 2993 if (r) {
092008ab
JD		 2994 switch (r) {
2995 case -EALREADY:
95908535 2996 reg_set_request_processed();
092008ab
JD		 2997 break;
2998 default:
2999 /* Back to world regulatory in case of errors */
3000 restore_regulatory_settings(user_reset);
3001 }
95908535 3002
d2372b31 3003 kfree(rd);
38fd2143 3004 return r;
d2372b31 3005 }
b2e1b302 3006
b2e1b302 3007 /* This would make this whole thing pointless */
38fd2143
JB		 3008 if (WARN_ON(!lr->intersect && rd != get_cfg80211_regdom()))
3009 return -EINVAL;
b2e1b302
LR		 3010
3011 /* update all wiphys now with the new established regulatory domain */
c492db37 3012 update_all_wiphy_regulatory(lr->initiator);
b2e1b302 3013
458f4f9e 3014 print_regdomain(get_cfg80211_regdom());
b2e1b302 3015
c492db37 3016 nl80211_send_reg_change_event(lr);
73d54c9e 3017
b2e253cf
LR		 3018 reg_set_request_processed();
3019
38fd2143 3020 return 0;
b2e1b302
LR		 3021}
3022
2c3e861c
AN		 3023static int __regulatory_set_wiphy_regd(struct wiphy *wiphy,
3024 struct ieee80211_regdomain *rd)
b0d7aa59
JD		 3025{
3026 const struct ieee80211_regdomain *regd;
3027 const struct ieee80211_regdomain *prev_regd;
3028 struct cfg80211_registered_device *rdev;
3029
3030 if (WARN_ON(!wiphy || !rd))
3031 return -EINVAL;
3032
3033 if (WARN(!(wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED),
3034 "wiphy should have REGULATORY_WIPHY_SELF_MANAGED\n"))
3035 return -EPERM;
3036
3037 if (WARN(!is_valid_rd(rd), "Invalid regulatory domain detected\n")) {
3038 print_regdomain_info(rd);
3039 return -EINVAL;
3040 }
3041
3042 regd = reg_copy_regd(rd);
3043 if (IS_ERR(regd))
3044 return PTR_ERR(regd);
3045
3046 rdev = wiphy_to_rdev(wiphy);
3047
3048 spin_lock(&reg_requests_lock);
3049 prev_regd = rdev->requested_regd;
3050 rdev->requested_regd = regd;
3051 spin_unlock(&reg_requests_lock);
3052
3053 kfree(prev_regd);
2c3e861c
AN		 3054 return 0;
3055}
3056
3057int regulatory_set_wiphy_regd(struct wiphy *wiphy,
3058 struct ieee80211_regdomain *rd)
3059{
3060 int ret = __regulatory_set_wiphy_regd(wiphy, rd);
3061
3062 if (ret)
3063 return ret;
b0d7aa59
JD		 3064
3065 schedule_work(&reg_work);
3066 return 0;
3067}
3068EXPORT_SYMBOL(regulatory_set_wiphy_regd);
3069
2c3e861c
AN		 3070int regulatory_set_wiphy_regd_sync_rtnl(struct wiphy *wiphy,
3071 struct ieee80211_regdomain *rd)
3072{
3073 int ret;
3074
3075 ASSERT_RTNL();
3076
3077 ret = __regulatory_set_wiphy_regd(wiphy, rd);
3078 if (ret)
3079 return ret;
3080
3081 /* process the request immediately */
3082 reg_process_self_managed_hints();
3083 return 0;
3084}
3085EXPORT_SYMBOL(regulatory_set_wiphy_regd_sync_rtnl);
3086
57b5ce07
LR		 3087void wiphy_regulatory_register(struct wiphy *wiphy)
3088{
23df0b73
AN		 3089 struct regulatory_request *lr;
3090
b0d7aa59
JD		 3091 /* self-managed devices ignore external hints */
3092 if (wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED)
3093 wiphy->regulatory_flags |= REGULATORY_DISABLE_BEACON_HINTS |
3094 REGULATORY_COUNTRY_IE_IGNORE;
3095
57b5ce07
LR		 3096 if (!reg_dev_ignore_cell_hint(wiphy))
3097 reg_num_devs_support_basehint++;
3098
23df0b73
AN		 3099 lr = get_last_request();
3100 wiphy_update_regulatory(wiphy, lr->initiator);
57b5ce07
LR		 3101}
3102
bfead080 3103void wiphy_regulatory_deregister(struct wiphy *wiphy)
3f2355cb 3104{
0ad8acaf 3105 struct wiphy *request_wiphy = NULL;
c492db37 3106 struct regulatory_request *lr;
761cf7ec 3107
c492db37 3108 lr = get_last_request();
abc7381b 3109
57b5ce07
LR		 3110 if (!reg_dev_ignore_cell_hint(wiphy))
3111 reg_num_devs_support_basehint--;
3112
458f4f9e 3113 rcu_free_regdom(get_wiphy_regdom(wiphy));
34dd886c 3114 RCU_INIT_POINTER(wiphy->regd, NULL);
0ef9ccdd 3115
c492db37
JB		 3116 if (lr)
3117 request_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx);
806a9e39 3118
0ef9ccdd 3119 if (!request_wiphy || request_wiphy != wiphy)
38fd2143 3120 return;
0ef9ccdd 3121
c492db37
JB		 3122 lr->wiphy_idx = WIPHY_IDX_INVALID;
3123 lr->country_ie_env = ENVIRON_ANY;
3f2355cb
LR		 3124}
3125
a90c7a31
LR		 3126static void reg_timeout_work(struct work_struct *work)
3127{
1a919318 3128 REG_DBG_PRINT("Timeout while waiting for CRDA to reply, restoring regulatory settings\n");
f77b86d7 3129 rtnl_lock();
c37722bd 3130 reg_crda_timeouts++;
a90c7a31 3131 restore_regulatory_settings(true);
f77b86d7 3132 rtnl_unlock();
a90c7a31
LR		 3133}
3134
174e0cd2
IP		 3135/*
3136 * See http://www.fcc.gov/document/5-ghz-unlicensed-spectrum-unii, for
3137 * UNII band definitions
3138 */
3139int cfg80211_get_unii(int freq)
3140{
3141 /* UNII-1 */
3142 if (freq >= 5150 && freq <= 5250)
3143 return 0;
3144
3145 /* UNII-2A */
3146 if (freq > 5250 && freq <= 5350)
3147 return 1;
3148
3149 /* UNII-2B */
3150 if (freq > 5350 && freq <= 5470)
3151 return 2;
3152
3153 /* UNII-2C */
3154 if (freq > 5470 && freq <= 5725)
3155 return 3;
3156
3157 /* UNII-3 */
3158 if (freq > 5725 && freq <= 5825)
3159 return 4;
3160
3161 return -EINVAL;
3162}
3163
c8866e55
IP		 3164bool regulatory_indoor_allowed(void)
3165{
3166 return reg_is_indoor;
3167}
3168
2fcc9f73 3169int __init regulatory_init(void)
b2e1b302 3170{
bcf4f99b 3171 int err = 0;
734366de 3172
b2e1b302
LR		 3173 reg_pdev = platform_device_register_simple("regulatory", 0, NULL, 0);
3174 if (IS_ERR(reg_pdev))
3175 return PTR_ERR(reg_pdev);
734366de 3176
fe33eb39 3177 spin_lock_init(&reg_requests_lock);
e38f8a7a 3178 spin_lock_init(&reg_pending_beacons_lock);
05050753 3179 spin_lock_init(&reg_indoor_lock);
fe33eb39 3180
80007efe
LR		 3181 reg_regdb_size_check();
3182
458f4f9e 3183 rcu_assign_pointer(cfg80211_regdomain, cfg80211_world_regdom);
734366de 3184
09d989d1
LR		 3185 user_alpha2[0] = '9';
3186 user_alpha2[1] = '7';
3187
ae9e4b0d 3188 /* We always try to get an update for the static regdomain */
458f4f9e 3189 err = regulatory_hint_core(cfg80211_world_regdom->alpha2);
ba25c141 3190 if (err) {
bcf4f99b
LR		 3191 if (err == -ENOMEM)
3192 return err;
3193 /*
3194 * N.B. kobject_uevent_env() can fail mainly for when we're out
3195 * memory which is handled and propagated appropriately above
3196 * but it can also fail during a netlink_broadcast() or during
3197 * early boot for call_usermodehelper(). For now treat these
3198 * errors as non-fatal.
3199 */
e9c0268f 3200 pr_err("kobject_uevent_env() was unable to call CRDA during init\n");
bcf4f99b 3201 }
734366de 3202
ae9e4b0d
LR		 3203 /*
3204 * Finally, if the user set the module parameter treat it
3205 * as a user hint.
3206 */
3207 if (!is_world_regdom(ieee80211_regdom))
57b5ce07
LR		 3208 regulatory_hint_user(ieee80211_regdom,
3209 NL80211_USER_REG_HINT_USER);
ae9e4b0d 3210
b2e1b302
LR		 3211 return 0;
3212}
3213
1a919318 3214void regulatory_exit(void)
b2e1b302 3215{
fe33eb39 3216 struct regulatory_request *reg_request, *tmp;
e38f8a7a 3217 struct reg_beacon *reg_beacon, *btmp;
fe33eb39
LR		 3218
3219 cancel_work_sync(&reg_work);
a90c7a31 3220 cancel_delayed_work_sync(&reg_timeout);
ad932f04 3221 cancel_delayed_work_sync(&reg_check_chans);
fe33eb39 3222
9027b149 3223 /* Lock to suppress warnings */
38fd2143 3224 rtnl_lock();
379b82f4 3225 reset_regdomains(true, NULL);
38fd2143 3226 rtnl_unlock();
734366de 3227
58ebacc6 3228 dev_set_uevent_suppress(&reg_pdev->dev, true);
f6037d09 3229
b2e1b302 3230 platform_device_unregister(reg_pdev);
734366de 3231
fea9bced
JB		 3232 list_for_each_entry_safe(reg_beacon, btmp, &reg_pending_beacons, list) {
3233 list_del(&reg_beacon->list);
3234 kfree(reg_beacon);
e38f8a7a 3235 }
e38f8a7a 3236
fea9bced
JB		 3237 list_for_each_entry_safe(reg_beacon, btmp, &reg_beacon_list, list) {
3238 list_del(&reg_beacon->list);
3239 kfree(reg_beacon);
e38f8a7a
LR		 3240 }
3241
fea9bced
JB		 3242 list_for_each_entry_safe(reg_request, tmp, &reg_requests_list, list) {
3243 list_del(&reg_request->list);
3244 kfree(reg_request);
fe33eb39 3245 }
8318d78a 3246}