blob: 04b6fe4b7653e549984b95cce85a8b6f15543834 [file] [log] [blame]
Johannes Berg8318d782008-01-24 19:38:38 +01001/*
2 * Copyright 2002-2005, Instant802 Networks, Inc.
3 * Copyright 2005-2006, Devicescape Software, Inc.
4 * Copyright 2007 Johannes Berg <johannes@sipsolutions.net>
Luis R. Rodriguez3b77d5e2011-12-20 12:23:38 -08005 * Copyright 2008-2011 Luis R. Rodriguez <mcgrof@qca.qualcomm.com>
Johannes Berg8318d782008-01-24 19:38:38 +01006 *
Luis R. Rodriguez3b77d5e2011-12-20 12:23:38 -08007 * Permission to use, copy, modify, and/or distribute this software for any
8 * purpose with or without fee is hereby granted, provided that the above
9 * copyright notice and this permission notice appear in all copies.
10 *
11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
Johannes Berg8318d782008-01-24 19:38:38 +010018 */
19
Luis R. Rodriguez3b77d5e2011-12-20 12:23:38 -080020
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -070021/**
22 * DOC: Wireless regulatory infrastructure
Johannes Berg8318d782008-01-24 19:38:38 +010023 *
24 * The usual implementation is for a driver to read a device EEPROM to
25 * determine which regulatory domain it should be operating under, then
26 * looking up the allowable channels in a driver-local table and finally
27 * registering those channels in the wiphy structure.
28 *
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -070029 * Another set of compliance enforcement is for drivers to use their
30 * own compliance limits which can be stored on the EEPROM. The host
31 * driver or firmware may ensure these are used.
32 *
33 * In addition to all this we provide an extra layer of regulatory
34 * conformance. For drivers which do not have any regulatory
35 * information CRDA provides the complete regulatory solution.
36 * For others it provides a community effort on further restrictions
37 * to enhance compliance.
38 *
39 * Note: When number of rules --> infinity we will not be able to
40 * index on alpha2 any more, instead we'll probably have to
41 * rely on some SHA1 checksum of the regdomain for example.
42 *
Johannes Berg8318d782008-01-24 19:38:38 +010043 */
Joe Perchese9c02682010-11-16 19:56:49 -080044
45#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
46
Johannes Berg8318d782008-01-24 19:38:38 +010047#include <linux/kernel.h>
Paul Gortmakerbc3b2d72011-07-15 11:47:34 -040048#include <linux/export.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090049#include <linux/slab.h>
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -070050#include <linux/list.h>
John W. Linvillec61029c2010-08-05 14:26:24 -040051#include <linux/ctype.h>
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -070052#include <linux/nl80211.h>
53#include <linux/platform_device.h>
Paul Gortmakerd9b93842011-09-18 13:21:27 -040054#include <linux/moduleparam.h>
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -070055#include <net/cfg80211.h>
Johannes Berg8318d782008-01-24 19:38:38 +010056#include "core.h"
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -070057#include "reg.h"
John W. Linville3b377ea2009-12-18 17:59:01 -050058#include "regdb.h"
Luis R. Rodriguez73d54c92009-03-09 22:07:42 -040059#include "nl80211.h"
Johannes Berg8318d782008-01-24 19:38:38 +010060
Luis R. Rodriguez4113f752010-01-04 11:50:11 -050061#ifdef CONFIG_CFG80211_REG_DEBUG
Joe Perches12c5ffb2011-07-29 14:51:25 -070062#define REG_DBG_PRINT(format, args...) \
63 printk(KERN_DEBUG pr_fmt(format), ##args)
Luis R. Rodriguez4113f752010-01-04 11:50:11 -050064#else
John W. Linville82711952010-01-05 17:57:20 -050065#define REG_DBG_PRINT(args...)
Luis R. Rodriguez4113f752010-01-04 11:50:11 -050066#endif
67
Johannes Berg2f922122012-12-03 17:54:55 +010068enum reg_request_treatment {
69 REG_REQ_OK,
70 REG_REQ_IGNORE,
71 REG_REQ_INTERSECT,
72 REG_REQ_ALREADY_SET,
73};
74
Luis R. Rodrigueza0429942011-11-28 16:47:15 -050075static struct regulatory_request core_request_world = {
76 .initiator = NL80211_REGDOM_SET_BY_CORE,
77 .alpha2[0] = '0',
78 .alpha2[1] = '0',
79 .intersect = false,
80 .processed = true,
81 .country_ie_env = ENVIRON_ANY,
82};
83
Johannes Berg38fd2142013-05-10 19:17:17 +020084/*
85 * Receipt of information from last regulatory request,
86 * protected by RTNL (and can be accessed with RCU protection)
87 */
Johannes Bergc492db32012-12-06 16:29:25 +010088static struct regulatory_request __rcu *last_request =
89 (void __rcu *)&core_request_world;
Johannes Berg734366d2008-09-15 10:56:48 +020090
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -070091/* To trigger userspace events */
92static struct platform_device *reg_pdev;
Johannes Berg8318d782008-01-24 19:38:38 +010093
Scott James Remnant4d9d88d2011-03-08 10:45:30 -080094static struct device_type reg_device_type = {
95 .uevent = reg_device_uevent,
96};
97
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -050098/*
99 * Central wireless core regulatory domains, we only need two,
Johannes Berg734366d2008-09-15 10:56:48 +0200100 * the current one and a world regulatory domain in case we have no
Johannes Berge8da2bb2012-12-03 23:00:08 +0100101 * information to give us an alpha2.
Johannes Berg38fd2142013-05-10 19:17:17 +0200102 * (protected by RTNL, can be read under RCU)
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500103 */
Johannes Berg458f4f92012-12-06 15:47:38 +0100104const struct ieee80211_regdomain __rcu *cfg80211_regdomain;
Johannes Berg734366d2008-09-15 10:56:48 +0200105
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500106/*
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -0700107 * Number of devices that registered to the core
108 * that support cellular base station regulatory hints
Johannes Berg38fd2142013-05-10 19:17:17 +0200109 * (protected by RTNL)
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -0700110 */
111static int reg_num_devs_support_basehint;
112
Johannes Berg458f4f92012-12-06 15:47:38 +0100113static const struct ieee80211_regdomain *get_cfg80211_regdom(void)
114{
Johannes Berg38fd2142013-05-10 19:17:17 +0200115 return rtnl_dereference(cfg80211_regdomain);
Johannes Berg458f4f92012-12-06 15:47:38 +0100116}
117
118static const struct ieee80211_regdomain *get_wiphy_regdom(struct wiphy *wiphy)
119{
Johannes Berg38fd2142013-05-10 19:17:17 +0200120 return rtnl_dereference(wiphy->regd);
Johannes Berg458f4f92012-12-06 15:47:38 +0100121}
122
123static void rcu_free_regdom(const struct ieee80211_regdomain *r)
124{
125 if (!r)
126 return;
127 kfree_rcu((struct ieee80211_regdomain *)r, rcu_head);
128}
129
Johannes Bergc492db32012-12-06 16:29:25 +0100130static struct regulatory_request *get_last_request(void)
131{
Johannes Berg38fd2142013-05-10 19:17:17 +0200132 return rcu_dereference_rtnl(last_request);
Johannes Bergc492db32012-12-06 16:29:25 +0100133}
134
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -0500135/* Used to queue up regulatory hints */
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -0500136static LIST_HEAD(reg_requests_list);
137static spinlock_t reg_requests_lock;
138
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -0500139/* Used to queue up beacon hints for review */
140static LIST_HEAD(reg_pending_beacons);
141static spinlock_t reg_pending_beacons_lock;
142
143/* Used to keep track of processed beacon hints */
144static LIST_HEAD(reg_beacon_list);
145
146struct reg_beacon {
147 struct list_head list;
148 struct ieee80211_channel chan;
149};
150
Luis R. Rodriguezf333a7a2010-11-17 21:46:07 -0800151static void reg_todo(struct work_struct *work);
152static DECLARE_WORK(reg_work, reg_todo);
153
Luis R. Rodrigueza90c7a32011-04-05 10:49:04 -0700154static void reg_timeout_work(struct work_struct *work);
155static DECLARE_DELAYED_WORK(reg_timeout, reg_timeout_work);
156
Johannes Berg734366d2008-09-15 10:56:48 +0200157/* We keep a static world regulatory domain in case of the absence of CRDA */
158static const struct ieee80211_regdomain world_regdom = {
Vladimir Kondratiev90cdc6d2012-07-02 09:32:34 +0300159 .n_reg_rules = 6,
Johannes Berg734366d2008-09-15 10:56:48 +0200160 .alpha2 = "00",
161 .reg_rules = {
Luis R. Rodriguez68798a62009-02-21 00:20:37 -0500162 /* IEEE 802.11b/g, channels 1..11 */
163 REG_RULE(2412-10, 2462+10, 40, 6, 20, 0),
Johannes Berg43c771a2012-11-12 10:51:34 +0100164 /* IEEE 802.11b/g, channels 12..13. */
165 REG_RULE(2467-10, 2472+10, 40, 6, 20,
Luis R. Rodriguez8fe02e12013-10-21 19:22:25 +0200166 NL80211_RRF_NO_IR),
Luis R. Rodriguez611b6a82009-03-05 21:19:21 -0800167 /* IEEE 802.11 channel 14 - Only JP enables
168 * this and for 802.11b only */
169 REG_RULE(2484-10, 2484+10, 20, 6, 20,
Luis R. Rodriguez8fe02e12013-10-21 19:22:25 +0200170 NL80211_RRF_NO_IR |
Luis R. Rodriguez611b6a82009-03-05 21:19:21 -0800171 NL80211_RRF_NO_OFDM),
172 /* IEEE 802.11a, channel 36..48 */
Johannes Berg131a19b2013-03-04 20:54:46 +0100173 REG_RULE(5180-10, 5240+10, 160, 6, 20,
Luis R. Rodriguez8fe02e12013-10-21 19:22:25 +0200174 NL80211_RRF_NO_IR),
Luis R. Rodriguez3fc71f72009-02-21 00:20:38 -0500175
Johannes Berg131a19b2013-03-04 20:54:46 +0100176 /* IEEE 802.11a, channel 52..64 - DFS required */
177 REG_RULE(5260-10, 5320+10, 160, 6, 20,
Luis R. Rodriguez8fe02e12013-10-21 19:22:25 +0200178 NL80211_RRF_NO_IR |
Johannes Berg131a19b2013-03-04 20:54:46 +0100179 NL80211_RRF_DFS),
180
181 /* IEEE 802.11a, channel 100..144 - DFS required */
182 REG_RULE(5500-10, 5720+10, 160, 6, 20,
Luis R. Rodriguez8fe02e12013-10-21 19:22:25 +0200183 NL80211_RRF_NO_IR |
Johannes Berg131a19b2013-03-04 20:54:46 +0100184 NL80211_RRF_DFS),
Luis R. Rodriguez3fc71f72009-02-21 00:20:38 -0500185
186 /* IEEE 802.11a, channel 149..165 */
Johannes Berg8ab9d852012-12-03 22:09:22 +0100187 REG_RULE(5745-10, 5825+10, 80, 6, 20,
Luis R. Rodriguez8fe02e12013-10-21 19:22:25 +0200188 NL80211_RRF_NO_IR),
Vladimir Kondratiev90cdc6d2012-07-02 09:32:34 +0300189
190 /* IEEE 802.11ad (60gHz), channels 1..3 */
191 REG_RULE(56160+2160*1-1080, 56160+2160*3+1080, 2160, 0, 0, 0),
Johannes Berg734366d2008-09-15 10:56:48 +0200192 }
193};
194
Johannes Berg38fd2142013-05-10 19:17:17 +0200195/* protected by RTNL */
Johannes Berga3d2eaf2008-09-15 11:10:52 +0200196static const struct ieee80211_regdomain *cfg80211_world_regdom =
197 &world_regdom;
Johannes Berg734366d2008-09-15 10:56:48 +0200198
Luis R. Rodriguez6ee7d332009-03-20 23:53:06 -0400199static char *ieee80211_regdom = "00";
Luis R. Rodriguez09d989d2010-01-29 19:58:57 -0500200static char user_alpha2[2];
Luis R. Rodriguez6ee7d332009-03-20 23:53:06 -0400201
Johannes Berg734366d2008-09-15 10:56:48 +0200202module_param(ieee80211_regdom, charp, 0444);
203MODULE_PARM_DESC(ieee80211_regdom, "IEEE 802.11 regulatory domain code");
204
Johannes Berg379b82f2012-12-06 15:44:07 +0100205static void reset_regdomains(bool full_reset,
206 const struct ieee80211_regdomain *new_regdom)
Johannes Berg734366d2008-09-15 10:56:48 +0200207{
Johannes Berg458f4f92012-12-06 15:47:38 +0100208 const struct ieee80211_regdomain *r;
Johannes Bergc492db32012-12-06 16:29:25 +0100209 struct regulatory_request *lr;
Johannes Berg458f4f92012-12-06 15:47:38 +0100210
Johannes Berg38fd2142013-05-10 19:17:17 +0200211 ASSERT_RTNL();
Johannes Berge8da2bb2012-12-03 23:00:08 +0100212
Johannes Berg458f4f92012-12-06 15:47:38 +0100213 r = get_cfg80211_regdom();
214
Johannes Berg942b25c2008-09-15 11:26:47 +0200215 /* avoid freeing static information or freeing something twice */
Johannes Berg458f4f92012-12-06 15:47:38 +0100216 if (r == cfg80211_world_regdom)
217 r = NULL;
Johannes Berg942b25c2008-09-15 11:26:47 +0200218 if (cfg80211_world_regdom == &world_regdom)
219 cfg80211_world_regdom = NULL;
Johannes Berg458f4f92012-12-06 15:47:38 +0100220 if (r == &world_regdom)
221 r = NULL;
Johannes Berg942b25c2008-09-15 11:26:47 +0200222
Johannes Berg458f4f92012-12-06 15:47:38 +0100223 rcu_free_regdom(r);
224 rcu_free_regdom(cfg80211_world_regdom);
Johannes Berg734366d2008-09-15 10:56:48 +0200225
Johannes Berga3d2eaf2008-09-15 11:10:52 +0200226 cfg80211_world_regdom = &world_regdom;
Johannes Berg458f4f92012-12-06 15:47:38 +0100227 rcu_assign_pointer(cfg80211_regdomain, new_regdom);
Luis R. Rodrigueza0429942011-11-28 16:47:15 -0500228
229 if (!full_reset)
230 return;
231
Johannes Bergc492db32012-12-06 16:29:25 +0100232 lr = get_last_request();
233 if (lr != &core_request_world && lr)
234 kfree_rcu(lr, rcu_head);
235 rcu_assign_pointer(last_request, &core_request_world);
Johannes Berg734366d2008-09-15 10:56:48 +0200236}
237
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500238/*
239 * Dynamic world regulatory domain requested by the wireless
240 * core upon initialization
241 */
Johannes Berga3d2eaf2008-09-15 11:10:52 +0200242static void update_world_regdomain(const struct ieee80211_regdomain *rd)
Johannes Berg734366d2008-09-15 10:56:48 +0200243{
Johannes Bergc492db32012-12-06 16:29:25 +0100244 struct regulatory_request *lr;
Johannes Berg734366d2008-09-15 10:56:48 +0200245
Johannes Bergc492db32012-12-06 16:29:25 +0100246 lr = get_last_request();
247
248 WARN_ON(!lr);
Johannes Berge8da2bb2012-12-03 23:00:08 +0100249
Johannes Berg379b82f2012-12-06 15:44:07 +0100250 reset_regdomains(false, rd);
Johannes Berg734366d2008-09-15 10:56:48 +0200251
252 cfg80211_world_regdom = rd;
Johannes Berg734366d2008-09-15 10:56:48 +0200253}
Johannes Berg734366d2008-09-15 10:56:48 +0200254
Johannes Berga3d2eaf2008-09-15 11:10:52 +0200255bool is_world_regdom(const char *alpha2)
Johannes Berg8318d782008-01-24 19:38:38 +0100256{
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700257 if (!alpha2)
258 return false;
Johannes Berg1a919312012-12-03 17:21:11 +0100259 return alpha2[0] == '0' && alpha2[1] == '0';
Johannes Berg8318d782008-01-24 19:38:38 +0100260}
261
Johannes Berga3d2eaf2008-09-15 11:10:52 +0200262static bool is_alpha2_set(const char *alpha2)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700263{
264 if (!alpha2)
265 return false;
Johannes Berg1a919312012-12-03 17:21:11 +0100266 return alpha2[0] && alpha2[1];
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700267}
Johannes Berg8318d782008-01-24 19:38:38 +0100268
Johannes Berga3d2eaf2008-09-15 11:10:52 +0200269static bool is_unknown_alpha2(const char *alpha2)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700270{
271 if (!alpha2)
272 return false;
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500273 /*
274 * Special case where regulatory domain was built by driver
275 * but a specific alpha2 cannot be determined
276 */
Johannes Berg1a919312012-12-03 17:21:11 +0100277 return alpha2[0] == '9' && alpha2[1] == '9';
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700278}
279
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -0800280static bool is_intersected_alpha2(const char *alpha2)
281{
282 if (!alpha2)
283 return false;
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500284 /*
285 * Special case where regulatory domain is the
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -0800286 * result of an intersection between two regulatory domain
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500287 * structures
288 */
Johannes Berg1a919312012-12-03 17:21:11 +0100289 return alpha2[0] == '9' && alpha2[1] == '8';
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -0800290}
291
Johannes Berga3d2eaf2008-09-15 11:10:52 +0200292static bool is_an_alpha2(const char *alpha2)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700293{
294 if (!alpha2)
295 return false;
Johannes Berg1a919312012-12-03 17:21:11 +0100296 return isalpha(alpha2[0]) && isalpha(alpha2[1]);
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700297}
298
Johannes Berga3d2eaf2008-09-15 11:10:52 +0200299static bool alpha2_equal(const char *alpha2_x, const char *alpha2_y)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700300{
301 if (!alpha2_x || !alpha2_y)
302 return false;
Johannes Berg1a919312012-12-03 17:21:11 +0100303 return alpha2_x[0] == alpha2_y[0] && alpha2_x[1] == alpha2_y[1];
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700304}
305
Luis R. Rodriguez69b15722009-02-21 00:04:33 -0500306static bool regdom_changes(const char *alpha2)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700307{
Johannes Berg458f4f92012-12-06 15:47:38 +0100308 const struct ieee80211_regdomain *r = get_cfg80211_regdom();
Luis R. Rodriguez761cf7e2009-02-21 00:04:25 -0500309
Johannes Berg458f4f92012-12-06 15:47:38 +0100310 if (!r)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700311 return true;
Johannes Berg458f4f92012-12-06 15:47:38 +0100312 return !alpha2_equal(r->alpha2, alpha2);
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700313}
314
Luis R. Rodriguez09d989d2010-01-29 19:58:57 -0500315/*
316 * The NL80211_REGDOM_SET_BY_USER regdom alpha2 is cached, this lets
317 * you know if a valid regulatory hint with NL80211_REGDOM_SET_BY_USER
318 * has ever been issued.
319 */
320static bool is_user_regdom_saved(void)
321{
322 if (user_alpha2[0] == '9' && user_alpha2[1] == '7')
323 return false;
324
325 /* This would indicate a mistake on the design */
Johannes Berg1a919312012-12-03 17:21:11 +0100326 if (WARN(!is_world_regdom(user_alpha2) && !is_an_alpha2(user_alpha2),
Luis R. Rodriguez09d989d2010-01-29 19:58:57 -0500327 "Unexpected user alpha2: %c%c\n",
Johannes Berg1a919312012-12-03 17:21:11 +0100328 user_alpha2[0], user_alpha2[1]))
Luis R. Rodriguez09d989d2010-01-29 19:58:57 -0500329 return false;
330
331 return true;
332}
333
Johannes Berge9763c32012-12-03 16:59:46 +0100334static const struct ieee80211_regdomain *
335reg_copy_regd(const struct ieee80211_regdomain *src_regd)
John W. Linville3b377ea2009-12-18 17:59:01 -0500336{
337 struct ieee80211_regdomain *regd;
Johannes Berge9763c32012-12-03 16:59:46 +0100338 int size_of_regd;
John W. Linville3b377ea2009-12-18 17:59:01 -0500339 unsigned int i;
340
Johannes Berg82f20852012-12-04 12:49:16 +0100341 size_of_regd =
342 sizeof(struct ieee80211_regdomain) +
343 src_regd->n_reg_rules * sizeof(struct ieee80211_reg_rule);
John W. Linville3b377ea2009-12-18 17:59:01 -0500344
345 regd = kzalloc(size_of_regd, GFP_KERNEL);
346 if (!regd)
Johannes Berge9763c32012-12-03 16:59:46 +0100347 return ERR_PTR(-ENOMEM);
John W. Linville3b377ea2009-12-18 17:59:01 -0500348
349 memcpy(regd, src_regd, sizeof(struct ieee80211_regdomain));
350
351 for (i = 0; i < src_regd->n_reg_rules; i++)
352 memcpy(&regd->reg_rules[i], &src_regd->reg_rules[i],
Johannes Berge9763c32012-12-03 16:59:46 +0100353 sizeof(struct ieee80211_reg_rule));
John W. Linville3b377ea2009-12-18 17:59:01 -0500354
Johannes Berge9763c32012-12-03 16:59:46 +0100355 return regd;
John W. Linville3b377ea2009-12-18 17:59:01 -0500356}
357
358#ifdef CONFIG_CFG80211_INTERNAL_REGDB
359struct reg_regdb_search_request {
360 char alpha2[2];
361 struct list_head list;
362};
363
364static LIST_HEAD(reg_regdb_search_list);
John W. Linville368d06f2010-03-16 15:40:59 -0400365static DEFINE_MUTEX(reg_regdb_search_mutex);
John W. Linville3b377ea2009-12-18 17:59:01 -0500366
367static void reg_regdb_search(struct work_struct *work)
368{
369 struct reg_regdb_search_request *request;
Johannes Berge9763c32012-12-03 16:59:46 +0100370 const struct ieee80211_regdomain *curdom, *regdom = NULL;
371 int i;
Luis R. Rodrigueza85d0d72012-09-14 15:36:57 -0700372
Johannes Berg5fe231e2013-05-08 21:45:15 +0200373 rtnl_lock();
John W. Linville3b377ea2009-12-18 17:59:01 -0500374
John W. Linville368d06f2010-03-16 15:40:59 -0400375 mutex_lock(&reg_regdb_search_mutex);
John W. Linville3b377ea2009-12-18 17:59:01 -0500376 while (!list_empty(&reg_regdb_search_list)) {
377 request = list_first_entry(&reg_regdb_search_list,
378 struct reg_regdb_search_request,
379 list);
380 list_del(&request->list);
381
Johannes Berg1a919312012-12-03 17:21:11 +0100382 for (i = 0; i < reg_regdb_size; i++) {
John W. Linville3b377ea2009-12-18 17:59:01 -0500383 curdom = reg_regdb[i];
384
Johannes Berg1a919312012-12-03 17:21:11 +0100385 if (alpha2_equal(request->alpha2, curdom->alpha2)) {
Johannes Berge9763c32012-12-03 16:59:46 +0100386 regdom = reg_copy_regd(curdom);
John W. Linville3b377ea2009-12-18 17:59:01 -0500387 break;
388 }
389 }
390
391 kfree(request);
392 }
John W. Linville368d06f2010-03-16 15:40:59 -0400393 mutex_unlock(&reg_regdb_search_mutex);
Luis R. Rodrigueza85d0d72012-09-14 15:36:57 -0700394
Johannes Berge9763c32012-12-03 16:59:46 +0100395 if (!IS_ERR_OR_NULL(regdom))
Luis R. Rodrigueza85d0d72012-09-14 15:36:57 -0700396 set_regdom(regdom);
397
Johannes Berg5fe231e2013-05-08 21:45:15 +0200398 rtnl_unlock();
John W. Linville3b377ea2009-12-18 17:59:01 -0500399}
400
401static DECLARE_WORK(reg_regdb_work, reg_regdb_search);
402
403static void reg_regdb_query(const char *alpha2)
404{
405 struct reg_regdb_search_request *request;
406
407 if (!alpha2)
408 return;
409
410 request = kzalloc(sizeof(struct reg_regdb_search_request), GFP_KERNEL);
411 if (!request)
412 return;
413
414 memcpy(request->alpha2, alpha2, 2);
415
John W. Linville368d06f2010-03-16 15:40:59 -0400416 mutex_lock(&reg_regdb_search_mutex);
John W. Linville3b377ea2009-12-18 17:59:01 -0500417 list_add_tail(&request->list, &reg_regdb_search_list);
John W. Linville368d06f2010-03-16 15:40:59 -0400418 mutex_unlock(&reg_regdb_search_mutex);
John W. Linville3b377ea2009-12-18 17:59:01 -0500419
420 schedule_work(&reg_regdb_work);
421}
Luis R. Rodriguez80007ef2012-03-23 07:23:31 -0700422
423/* Feel free to add any other sanity checks here */
424static void reg_regdb_size_check(void)
425{
426 /* We should ideally BUILD_BUG_ON() but then random builds would fail */
427 WARN_ONCE(!reg_regdb_size, "db.txt is empty, you should update it...");
428}
John W. Linville3b377ea2009-12-18 17:59:01 -0500429#else
Luis R. Rodriguez80007ef2012-03-23 07:23:31 -0700430static inline void reg_regdb_size_check(void) {}
John W. Linville3b377ea2009-12-18 17:59:01 -0500431static inline void reg_regdb_query(const char *alpha2) {}
432#endif /* CONFIG_CFG80211_INTERNAL_REGDB */
433
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500434/*
435 * This lets us keep regulatory code which is updated on a regulatory
Scott James Remnant4d9d88d2011-03-08 10:45:30 -0800436 * basis in userspace. Country information is filled in by
437 * reg_device_uevent
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500438 */
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700439static int call_crda(const char *alpha2)
440{
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700441 if (!is_world_regdom((char *) alpha2))
Joe Perchese9c02682010-11-16 19:56:49 -0800442 pr_info("Calling CRDA for country: %c%c\n",
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700443 alpha2[0], alpha2[1]);
444 else
Joe Perchese9c02682010-11-16 19:56:49 -0800445 pr_info("Calling CRDA to update world regulatory domain\n");
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700446
John W. Linville3b377ea2009-12-18 17:59:01 -0500447 /* query internal regulatory database (if it exists) */
448 reg_regdb_query(alpha2);
449
Scott James Remnant4d9d88d2011-03-08 10:45:30 -0800450 return kobject_uevent(&reg_pdev->dev.kobj, KOBJ_CHANGE);
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700451}
452
Johannes Berg6913b492012-12-04 00:48:59 +0100453static bool reg_is_valid_request(const char *alpha2)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700454{
Johannes Bergc492db32012-12-06 16:29:25 +0100455 struct regulatory_request *lr = get_last_request();
Luis R. Rodriguez61405e92009-05-13 17:04:41 -0400456
Johannes Bergc492db32012-12-06 16:29:25 +0100457 if (!lr || lr->processed)
Johannes Bergf6037d02008-10-21 11:01:33 +0200458 return false;
459
Johannes Bergc492db32012-12-06 16:29:25 +0100460 return alpha2_equal(lr->alpha2, alpha2);
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700461}
462
463/* Sanity check on a regulatory rule */
Johannes Berga3d2eaf2008-09-15 11:10:52 +0200464static bool is_valid_reg_rule(const struct ieee80211_reg_rule *rule)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700465{
Johannes Berga3d2eaf2008-09-15 11:10:52 +0200466 const struct ieee80211_freq_range *freq_range = &rule->freq_range;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700467 u32 freq_diff;
468
Luis R. Rodriguez91e99002008-11-12 14:21:55 -0800469 if (freq_range->start_freq_khz <= 0 || freq_range->end_freq_khz <= 0)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700470 return false;
471
472 if (freq_range->start_freq_khz > freq_range->end_freq_khz)
473 return false;
474
475 freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
476
Roel Kluinbd05f282009-03-03 22:55:21 +0100477 if (freq_range->end_freq_khz <= freq_range->start_freq_khz ||
Johannes Berg1a919312012-12-03 17:21:11 +0100478 freq_range->max_bandwidth_khz > freq_diff)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700479 return false;
480
481 return true;
482}
483
Johannes Berga3d2eaf2008-09-15 11:10:52 +0200484static bool is_valid_rd(const struct ieee80211_regdomain *rd)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700485{
Johannes Berga3d2eaf2008-09-15 11:10:52 +0200486 const struct ieee80211_reg_rule *reg_rule = NULL;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700487 unsigned int i;
488
489 if (!rd->n_reg_rules)
490 return false;
491
Luis R. Rodriguez88dc1c32008-11-12 14:22:01 -0800492 if (WARN_ON(rd->n_reg_rules > NL80211_MAX_SUPP_REG_RULES))
493 return false;
494
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700495 for (i = 0; i < rd->n_reg_rules; i++) {
496 reg_rule = &rd->reg_rules[i];
497 if (!is_valid_reg_rule(reg_rule))
498 return false;
499 }
500
501 return true;
502}
503
Luis R. Rodriguez038659e2009-05-02 00:37:17 -0400504static bool reg_does_bw_fit(const struct ieee80211_freq_range *freq_range,
Johannes Bergfe7ef5e2012-12-04 15:07:34 +0100505 u32 center_freq_khz, u32 bw_khz)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700506{
Luis R. Rodriguez038659e2009-05-02 00:37:17 -0400507 u32 start_freq_khz, end_freq_khz;
508
509 start_freq_khz = center_freq_khz - (bw_khz/2);
510 end_freq_khz = center_freq_khz + (bw_khz/2);
511
512 if (start_freq_khz >= freq_range->start_freq_khz &&
513 end_freq_khz <= freq_range->end_freq_khz)
514 return true;
515
516 return false;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700517}
518
Luis R. Rodriguez0c7dc452009-01-07 17:43:36 -0800519/**
520 * freq_in_rule_band - tells us if a frequency is in a frequency band
521 * @freq_range: frequency rule we want to query
522 * @freq_khz: frequency we are inquiring about
523 *
524 * This lets us know if a specific frequency rule is or is not relevant to
525 * a specific frequency's band. Bands are device specific and artificial
Vladimir Kondratiev64629b92012-09-23 09:49:54 +0200526 * definitions (the "2.4 GHz band", the "5 GHz band" and the "60GHz band"),
527 * however it is safe for now to assume that a frequency rule should not be
528 * part of a frequency's band if the start freq or end freq are off by more
529 * than 2 GHz for the 2.4 and 5 GHz bands, and by more than 10 GHz for the
530 * 60 GHz band.
Luis R. Rodriguez0c7dc452009-01-07 17:43:36 -0800531 * This resolution can be lowered and should be considered as we add
532 * regulatory rule support for other "bands".
533 **/
534static bool freq_in_rule_band(const struct ieee80211_freq_range *freq_range,
Johannes Berg1a919312012-12-03 17:21:11 +0100535 u32 freq_khz)
Luis R. Rodriguez0c7dc452009-01-07 17:43:36 -0800536{
537#define ONE_GHZ_IN_KHZ 1000000
Vladimir Kondratiev64629b92012-09-23 09:49:54 +0200538 /*
539 * From 802.11ad: directional multi-gigabit (DMG):
540 * Pertaining to operation in a frequency band containing a channel
541 * with the Channel starting frequency above 45 GHz.
542 */
543 u32 limit = freq_khz > 45 * ONE_GHZ_IN_KHZ ?
544 10 * ONE_GHZ_IN_KHZ : 2 * ONE_GHZ_IN_KHZ;
545 if (abs(freq_khz - freq_range->start_freq_khz) <= limit)
Luis R. Rodriguez0c7dc452009-01-07 17:43:36 -0800546 return true;
Vladimir Kondratiev64629b92012-09-23 09:49:54 +0200547 if (abs(freq_khz - freq_range->end_freq_khz) <= limit)
Luis R. Rodriguez0c7dc452009-01-07 17:43:36 -0800548 return true;
549 return false;
550#undef ONE_GHZ_IN_KHZ
551}
552
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500553/*
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500554 * Helper for regdom_intersect(), this does the real
555 * mathematical intersection fun
556 */
Johannes Berg1a919312012-12-03 17:21:11 +0100557static int reg_rules_intersect(const struct ieee80211_reg_rule *rule1,
558 const struct ieee80211_reg_rule *rule2,
559 struct ieee80211_reg_rule *intersected_rule)
Luis R. Rodriguez9c964772008-10-30 13:33:53 -0700560{
561 const struct ieee80211_freq_range *freq_range1, *freq_range2;
562 struct ieee80211_freq_range *freq_range;
563 const struct ieee80211_power_rule *power_rule1, *power_rule2;
564 struct ieee80211_power_rule *power_rule;
565 u32 freq_diff;
566
567 freq_range1 = &rule1->freq_range;
568 freq_range2 = &rule2->freq_range;
569 freq_range = &intersected_rule->freq_range;
570
571 power_rule1 = &rule1->power_rule;
572 power_rule2 = &rule2->power_rule;
573 power_rule = &intersected_rule->power_rule;
574
575 freq_range->start_freq_khz = max(freq_range1->start_freq_khz,
Johannes Berg1a919312012-12-03 17:21:11 +0100576 freq_range2->start_freq_khz);
Luis R. Rodriguez9c964772008-10-30 13:33:53 -0700577 freq_range->end_freq_khz = min(freq_range1->end_freq_khz,
Johannes Berg1a919312012-12-03 17:21:11 +0100578 freq_range2->end_freq_khz);
Luis R. Rodriguez9c964772008-10-30 13:33:53 -0700579 freq_range->max_bandwidth_khz = min(freq_range1->max_bandwidth_khz,
Johannes Berg1a919312012-12-03 17:21:11 +0100580 freq_range2->max_bandwidth_khz);
Luis R. Rodriguez9c964772008-10-30 13:33:53 -0700581
582 freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
583 if (freq_range->max_bandwidth_khz > freq_diff)
584 freq_range->max_bandwidth_khz = freq_diff;
585
586 power_rule->max_eirp = min(power_rule1->max_eirp,
587 power_rule2->max_eirp);
588 power_rule->max_antenna_gain = min(power_rule1->max_antenna_gain,
589 power_rule2->max_antenna_gain);
590
Johannes Berg1a919312012-12-03 17:21:11 +0100591 intersected_rule->flags = rule1->flags | rule2->flags;
Luis R. Rodriguez9c964772008-10-30 13:33:53 -0700592
593 if (!is_valid_reg_rule(intersected_rule))
594 return -EINVAL;
595
596 return 0;
597}
598
599/**
600 * regdom_intersect - do the intersection between two regulatory domains
601 * @rd1: first regulatory domain
602 * @rd2: second regulatory domain
603 *
604 * Use this function to get the intersection between two regulatory domains.
605 * Once completed we will mark the alpha2 for the rd as intersected, "98",
606 * as no one single alpha2 can represent this regulatory domain.
607 *
608 * Returns a pointer to the regulatory domain structure which will hold the
609 * resulting intersection of rules between rd1 and rd2. We will
610 * kzalloc() this structure for you.
611 */
Johannes Berg1a919312012-12-03 17:21:11 +0100612static struct ieee80211_regdomain *
613regdom_intersect(const struct ieee80211_regdomain *rd1,
614 const struct ieee80211_regdomain *rd2)
Luis R. Rodriguez9c964772008-10-30 13:33:53 -0700615{
616 int r, size_of_regd;
617 unsigned int x, y;
618 unsigned int num_rules = 0, rule_idx = 0;
619 const struct ieee80211_reg_rule *rule1, *rule2;
620 struct ieee80211_reg_rule *intersected_rule;
621 struct ieee80211_regdomain *rd;
622 /* This is just a dummy holder to help us count */
Johannes Berg74f53cd2012-12-06 17:26:17 +0100623 struct ieee80211_reg_rule dummy_rule;
Luis R. Rodriguez9c964772008-10-30 13:33:53 -0700624
625 if (!rd1 || !rd2)
626 return NULL;
627
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500628 /*
629 * First we get a count of the rules we'll need, then we actually
Luis R. Rodriguez9c964772008-10-30 13:33:53 -0700630 * build them. This is to so we can malloc() and free() a
631 * regdomain once. The reason we use reg_rules_intersect() here
632 * is it will return -EINVAL if the rule computed makes no sense.
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500633 * All rules that do check out OK are valid.
634 */
Luis R. Rodriguez9c964772008-10-30 13:33:53 -0700635
636 for (x = 0; x < rd1->n_reg_rules; x++) {
637 rule1 = &rd1->reg_rules[x];
638 for (y = 0; y < rd2->n_reg_rules; y++) {
639 rule2 = &rd2->reg_rules[y];
Johannes Berg74f53cd2012-12-06 17:26:17 +0100640 if (!reg_rules_intersect(rule1, rule2, &dummy_rule))
Luis R. Rodriguez9c964772008-10-30 13:33:53 -0700641 num_rules++;
Luis R. Rodriguez9c964772008-10-30 13:33:53 -0700642 }
643 }
644
645 if (!num_rules)
646 return NULL;
647
648 size_of_regd = sizeof(struct ieee80211_regdomain) +
Johannes Berg82f20852012-12-04 12:49:16 +0100649 num_rules * sizeof(struct ieee80211_reg_rule);
Luis R. Rodriguez9c964772008-10-30 13:33:53 -0700650
651 rd = kzalloc(size_of_regd, GFP_KERNEL);
652 if (!rd)
653 return NULL;
654
Johannes Berg8a57fff2012-12-06 17:03:17 +0100655 for (x = 0; x < rd1->n_reg_rules && rule_idx < num_rules; x++) {
Luis R. Rodriguez9c964772008-10-30 13:33:53 -0700656 rule1 = &rd1->reg_rules[x];
Johannes Berg8a57fff2012-12-06 17:03:17 +0100657 for (y = 0; y < rd2->n_reg_rules && rule_idx < num_rules; y++) {
Luis R. Rodriguez9c964772008-10-30 13:33:53 -0700658 rule2 = &rd2->reg_rules[y];
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500659 /*
660 * This time around instead of using the stack lets
Luis R. Rodriguez9c964772008-10-30 13:33:53 -0700661 * write to the target rule directly saving ourselves
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500662 * a memcpy()
663 */
Luis R. Rodriguez9c964772008-10-30 13:33:53 -0700664 intersected_rule = &rd->reg_rules[rule_idx];
Johannes Berg1a919312012-12-03 17:21:11 +0100665 r = reg_rules_intersect(rule1, rule2, intersected_rule);
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500666 /*
667 * No need to memset here the intersected rule here as
668 * we're not using the stack anymore
669 */
Luis R. Rodriguez9c964772008-10-30 13:33:53 -0700670 if (r)
671 continue;
672 rule_idx++;
673 }
674 }
675
676 if (rule_idx != num_rules) {
677 kfree(rd);
678 return NULL;
679 }
680
681 rd->n_reg_rules = num_rules;
682 rd->alpha2[0] = '9';
683 rd->alpha2[1] = '8';
684
685 return rd;
686}
687
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500688/*
689 * XXX: add support for the rest of enum nl80211_reg_rule_flags, we may
690 * want to just have the channel structure use these
691 */
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700692static u32 map_regdom_flags(u32 rd_flags)
693{
694 u32 channel_flags = 0;
Luis R. Rodriguez8fe02e12013-10-21 19:22:25 +0200695 if (rd_flags & NL80211_RRF_NO_IR_ALL)
696 channel_flags |= IEEE80211_CHAN_NO_IR;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700697 if (rd_flags & NL80211_RRF_DFS)
698 channel_flags |= IEEE80211_CHAN_RADAR;
Seth Forshee03f6b082012-08-01 15:58:42 -0500699 if (rd_flags & NL80211_RRF_NO_OFDM)
700 channel_flags |= IEEE80211_CHAN_NO_OFDM;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700701 return channel_flags;
702}
703
Johannes Berg361c9c82012-12-06 15:57:14 +0100704static const struct ieee80211_reg_rule *
705freq_reg_info_regd(struct wiphy *wiphy, u32 center_freq,
706 const struct ieee80211_regdomain *regd)
Johannes Berg8318d782008-01-24 19:38:38 +0100707{
708 int i;
Luis R. Rodriguez0c7dc452009-01-07 17:43:36 -0800709 bool band_rule_found = false;
Luis R. Rodriguez038659e2009-05-02 00:37:17 -0400710 bool bw_fits = false;
711
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -0800712 if (!regd)
Johannes Berg361c9c82012-12-06 15:57:14 +0100713 return ERR_PTR(-EINVAL);
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700714
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -0800715 for (i = 0; i < regd->n_reg_rules; i++) {
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700716 const struct ieee80211_reg_rule *rr;
717 const struct ieee80211_freq_range *fr = NULL;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700718
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -0800719 rr = &regd->reg_rules[i];
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700720 fr = &rr->freq_range;
Luis R. Rodriguez0c7dc452009-01-07 17:43:36 -0800721
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500722 /*
723 * We only need to know if one frequency rule was
Luis R. Rodriguez0c7dc452009-01-07 17:43:36 -0800724 * was in center_freq's band, that's enough, so lets
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500725 * not overwrite it once found
726 */
Luis R. Rodriguez0c7dc452009-01-07 17:43:36 -0800727 if (!band_rule_found)
728 band_rule_found = freq_in_rule_band(fr, center_freq);
729
Johannes Bergfe7ef5e2012-12-04 15:07:34 +0100730 bw_fits = reg_does_bw_fit(fr, center_freq, MHZ_TO_KHZ(20));
Luis R. Rodriguez0c7dc452009-01-07 17:43:36 -0800731
Johannes Berg361c9c82012-12-06 15:57:14 +0100732 if (band_rule_found && bw_fits)
733 return rr;
Johannes Berg8318d782008-01-24 19:38:38 +0100734 }
735
Luis R. Rodriguez0c7dc452009-01-07 17:43:36 -0800736 if (!band_rule_found)
Johannes Berg361c9c82012-12-06 15:57:14 +0100737 return ERR_PTR(-ERANGE);
Luis R. Rodriguez0c7dc452009-01-07 17:43:36 -0800738
Johannes Berg361c9c82012-12-06 15:57:14 +0100739 return ERR_PTR(-EINVAL);
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700740}
741
Johannes Berg361c9c82012-12-06 15:57:14 +0100742const struct ieee80211_reg_rule *freq_reg_info(struct wiphy *wiphy,
743 u32 center_freq)
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -0800744{
Johannes Berg5d885b92012-12-04 00:14:17 +0100745 const struct ieee80211_regdomain *regd;
Johannes Bergc492db32012-12-06 16:29:25 +0100746 struct regulatory_request *lr = get_last_request();
Johannes Berg1a919312012-12-03 17:21:11 +0100747
Johannes Berg5d885b92012-12-04 00:14:17 +0100748 /*
749 * Follow the driver's regulatory domain, if present, unless a country
750 * IE has been processed or a user wants to help complaince further
751 */
Johannes Bergc492db32012-12-06 16:29:25 +0100752 if (lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
753 lr->initiator != NL80211_REGDOM_SET_BY_USER &&
Johannes Berg5d885b92012-12-04 00:14:17 +0100754 wiphy->regd)
Johannes Berg458f4f92012-12-06 15:47:38 +0100755 regd = get_wiphy_regdom(wiphy);
Johannes Berg5d885b92012-12-04 00:14:17 +0100756 else
Johannes Berg458f4f92012-12-06 15:47:38 +0100757 regd = get_cfg80211_regdom();
Johannes Berg5d885b92012-12-04 00:14:17 +0100758
Johannes Berg361c9c82012-12-06 15:57:14 +0100759 return freq_reg_info_regd(wiphy, center_freq, regd);
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -0800760}
John W. Linville4f366c52010-07-15 14:57:33 -0400761EXPORT_SYMBOL(freq_reg_info);
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700762
Luis R. Rodriguez034c6d62013-10-14 17:42:06 -0700763const char *reg_initiator_name(enum nl80211_reg_initiator initiator)
Luis R. Rodriguez926a0a02010-10-21 19:17:03 +0530764{
765 switch (initiator) {
766 case NL80211_REGDOM_SET_BY_CORE:
Luis R. Rodriguez034c6d62013-10-14 17:42:06 -0700767 return "core";
Luis R. Rodriguez926a0a02010-10-21 19:17:03 +0530768 case NL80211_REGDOM_SET_BY_USER:
Luis R. Rodriguez034c6d62013-10-14 17:42:06 -0700769 return "user";
Luis R. Rodriguez926a0a02010-10-21 19:17:03 +0530770 case NL80211_REGDOM_SET_BY_DRIVER:
Luis R. Rodriguez034c6d62013-10-14 17:42:06 -0700771 return "driver";
Luis R. Rodriguez926a0a02010-10-21 19:17:03 +0530772 case NL80211_REGDOM_SET_BY_COUNTRY_IE:
Luis R. Rodriguez034c6d62013-10-14 17:42:06 -0700773 return "country IE";
Luis R. Rodriguez926a0a02010-10-21 19:17:03 +0530774 default:
775 WARN_ON(1);
Luis R. Rodriguez034c6d62013-10-14 17:42:06 -0700776 return "bug";
Luis R. Rodriguez926a0a02010-10-21 19:17:03 +0530777 }
778}
Luis R. Rodriguez034c6d62013-10-14 17:42:06 -0700779EXPORT_SYMBOL(reg_initiator_name);
Luis R. Rodrigueze702d3c2010-10-21 19:17:04 +0530780
Luis R. Rodriguez034c6d62013-10-14 17:42:06 -0700781#ifdef CONFIG_CFG80211_REG_DEBUG
Luis R. Rodrigueze702d3c2010-10-21 19:17:04 +0530782static void chan_reg_rule_print_dbg(struct ieee80211_channel *chan,
Luis R. Rodrigueze702d3c2010-10-21 19:17:04 +0530783 const struct ieee80211_reg_rule *reg_rule)
784{
785 const struct ieee80211_power_rule *power_rule;
786 const struct ieee80211_freq_range *freq_range;
787 char max_antenna_gain[32];
788
789 power_rule = &reg_rule->power_rule;
790 freq_range = &reg_rule->freq_range;
791
792 if (!power_rule->max_antenna_gain)
793 snprintf(max_antenna_gain, 32, "N/A");
794 else
795 snprintf(max_antenna_gain, 32, "%d", power_rule->max_antenna_gain);
796
Johannes Bergfe7ef5e2012-12-04 15:07:34 +0100797 REG_DBG_PRINT("Updating information on frequency %d MHz with regulatory rule:\n",
798 chan->center_freq);
Luis R. Rodrigueze702d3c2010-10-21 19:17:04 +0530799
Pavel Roskin56e67862011-09-01 11:54:12 -0400800 REG_DBG_PRINT("%d KHz - %d KHz @ %d KHz), (%s mBi, %d mBm)\n",
Johannes Berg1a919312012-12-03 17:21:11 +0100801 freq_range->start_freq_khz, freq_range->end_freq_khz,
802 freq_range->max_bandwidth_khz, max_antenna_gain,
Luis R. Rodrigueze702d3c2010-10-21 19:17:04 +0530803 power_rule->max_eirp);
804}
805#else
806static void chan_reg_rule_print_dbg(struct ieee80211_channel *chan,
Luis R. Rodrigueze702d3c2010-10-21 19:17:04 +0530807 const struct ieee80211_reg_rule *reg_rule)
808{
809 return;
810}
Luis R. Rodriguez926a0a02010-10-21 19:17:03 +0530811#endif
812
Luis R. Rodriguez038659e2009-05-02 00:37:17 -0400813/*
814 * Note that right now we assume the desired channel bandwidth
815 * is always 20 MHz for each individual channel (HT40 uses 20 MHz
Johannes Bergfe7ef5e2012-12-04 15:07:34 +0100816 * per channel, the primary and the extension channel).
Luis R. Rodriguez038659e2009-05-02 00:37:17 -0400817 */
Luis R. Rodriguez7ca43d02010-10-20 10:18:53 -0700818static void handle_channel(struct wiphy *wiphy,
819 enum nl80211_reg_initiator initiator,
Johannes Bergfdc9d7b2012-12-03 18:36:09 +0100820 struct ieee80211_channel *chan)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700821{
Luis R. Rodriguez038659e2009-05-02 00:37:17 -0400822 u32 flags, bw_flags = 0;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700823 const struct ieee80211_reg_rule *reg_rule = NULL;
824 const struct ieee80211_power_rule *power_rule = NULL;
Luis R. Rodriguez038659e2009-05-02 00:37:17 -0400825 const struct ieee80211_freq_range *freq_range = NULL;
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -0500826 struct wiphy *request_wiphy = NULL;
Johannes Bergc492db32012-12-06 16:29:25 +0100827 struct regulatory_request *lr = get_last_request();
Luis R. Rodrigueza92a3ce2009-01-07 17:43:33 -0800828
Johannes Bergc492db32012-12-06 16:29:25 +0100829 request_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx);
Luis R. Rodrigueza92a3ce2009-01-07 17:43:33 -0800830
831 flags = chan->orig_flags;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700832
Johannes Berg361c9c82012-12-06 15:57:14 +0100833 reg_rule = freq_reg_info(wiphy, MHZ_TO_KHZ(chan->center_freq));
834 if (IS_ERR(reg_rule)) {
Luis R. Rodriguezca4ffe82010-10-20 10:18:55 -0700835 /*
836 * We will disable all channels that do not match our
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300837 * received regulatory rule unless the hint is coming
Luis R. Rodriguezca4ffe82010-10-20 10:18:55 -0700838 * from a Country IE and the Country IE had no information
839 * about a band. The IEEE 802.11 spec allows for an AP
840 * to send only a subset of the regulatory rules allowed,
841 * so an AP in the US that only supports 2.4 GHz may only send
842 * a country IE with information for the 2.4 GHz band
843 * while 5 GHz is still supported.
844 */
845 if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
Johannes Berg361c9c82012-12-06 15:57:14 +0100846 PTR_ERR(reg_rule) == -ERANGE)
Luis R. Rodriguezca4ffe82010-10-20 10:18:55 -0700847 return;
848
Luis R. Rodriguezd91e41b2010-10-20 10:18:59 -0700849 REG_DBG_PRINT("Disabling freq %d MHz\n", chan->center_freq);
Johannes Berg990de492013-04-16 14:32:26 +0200850 chan->flags |= IEEE80211_CHAN_DISABLED;
Johannes Berg8318d782008-01-24 19:38:38 +0100851 return;
Luis R. Rodriguezca4ffe82010-10-20 10:18:55 -0700852 }
Johannes Berg8318d782008-01-24 19:38:38 +0100853
Johannes Bergfe7ef5e2012-12-04 15:07:34 +0100854 chan_reg_rule_print_dbg(chan, reg_rule);
Luis R. Rodrigueze702d3c2010-10-21 19:17:04 +0530855
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700856 power_rule = &reg_rule->power_rule;
Luis R. Rodriguez038659e2009-05-02 00:37:17 -0400857 freq_range = &reg_rule->freq_range;
858
859 if (freq_range->max_bandwidth_khz < MHZ_TO_KHZ(40))
860 bw_flags = IEEE80211_CHAN_NO_HT40;
Johannes Bergc7a6ee22012-12-12 17:50:39 +0100861 if (freq_range->max_bandwidth_khz < MHZ_TO_KHZ(80))
862 bw_flags |= IEEE80211_CHAN_NO_80MHZ;
863 if (freq_range->max_bandwidth_khz < MHZ_TO_KHZ(160))
864 bw_flags |= IEEE80211_CHAN_NO_160MHZ;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700865
Johannes Bergc492db32012-12-06 16:29:25 +0100866 if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -0500867 request_wiphy && request_wiphy == wiphy &&
Johannes Berg5be83de2009-11-19 00:56:28 +0100868 request_wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY) {
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500869 /*
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300870 * This guarantees the driver's requested regulatory domain
Luis R. Rodriguezf9763762009-01-22 15:05:52 -0800871 * will always be used as a base for further regulatory
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500872 * settings
873 */
Luis R. Rodriguezf9763762009-01-22 15:05:52 -0800874 chan->flags = chan->orig_flags =
Luis R. Rodriguez038659e2009-05-02 00:37:17 -0400875 map_regdom_flags(reg_rule->flags) | bw_flags;
Luis R. Rodriguezf9763762009-01-22 15:05:52 -0800876 chan->max_antenna_gain = chan->orig_mag =
877 (int) MBI_TO_DBI(power_rule->max_antenna_gain);
Felix Fietkau279f0f52012-10-17 13:56:20 +0200878 chan->max_reg_power = chan->max_power = chan->orig_mpwr =
Luis R. Rodriguezf9763762009-01-22 15:05:52 -0800879 (int) MBM_TO_DBM(power_rule->max_eirp);
880 return;
881 }
882
Simon Wunderlich04f39042013-02-08 18:16:19 +0100883 chan->dfs_state = NL80211_DFS_USABLE;
884 chan->dfs_state_entered = jiffies;
885
Rajkumar Manoharanaa3d7ee2011-09-14 14:28:17 +0530886 chan->beacon_found = false;
Luis R. Rodriguez038659e2009-05-02 00:37:17 -0400887 chan->flags = flags | bw_flags | map_regdom_flags(reg_rule->flags);
Johannes Berg1a919312012-12-03 17:21:11 +0100888 chan->max_antenna_gain =
889 min_t(int, chan->orig_mag,
890 MBI_TO_DBI(power_rule->max_antenna_gain));
Hong Wueccc0682012-01-11 20:33:39 +0200891 chan->max_reg_power = (int) MBM_TO_DBM(power_rule->max_eirp);
Stanislaw Gruszka5e31fc02012-07-24 08:35:39 +0200892 if (chan->orig_mpwr) {
893 /*
894 * Devices that have their own custom regulatory domain
895 * but also use WIPHY_FLAG_STRICT_REGULATORY will follow the
896 * passed country IE power settings.
897 */
898 if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
899 wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY &&
900 wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY)
901 chan->max_power = chan->max_reg_power;
902 else
903 chan->max_power = min(chan->orig_mpwr,
904 chan->max_reg_power);
905 } else
906 chan->max_power = chan->max_reg_power;
Johannes Berg8318d782008-01-24 19:38:38 +0100907}
908
Luis R. Rodriguez7ca43d02010-10-20 10:18:53 -0700909static void handle_band(struct wiphy *wiphy,
Johannes Bergfdc9d7b2012-12-03 18:36:09 +0100910 enum nl80211_reg_initiator initiator,
911 struct ieee80211_supported_band *sband)
Johannes Berg8318d782008-01-24 19:38:38 +0100912{
Luis R. Rodrigueza92a3ce2009-01-07 17:43:33 -0800913 unsigned int i;
Luis R. Rodrigueza92a3ce2009-01-07 17:43:33 -0800914
Johannes Bergfdc9d7b2012-12-03 18:36:09 +0100915 if (!sband)
916 return;
Johannes Berg8318d782008-01-24 19:38:38 +0100917
918 for (i = 0; i < sband->n_channels; i++)
Johannes Bergfdc9d7b2012-12-03 18:36:09 +0100919 handle_channel(wiphy, initiator, &sband->channels[i]);
Johannes Berg8318d782008-01-24 19:38:38 +0100920}
921
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -0700922static bool reg_request_cell_base(struct regulatory_request *request)
923{
924 if (request->initiator != NL80211_REGDOM_SET_BY_USER)
925 return false;
Johannes Berg1a919312012-12-03 17:21:11 +0100926 return request->user_reg_hint_type == NL80211_USER_REG_HINT_CELL_BASE;
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -0700927}
928
929bool reg_last_request_cell_base(void)
930{
Johannes Berg38fd2142013-05-10 19:17:17 +0200931 return reg_request_cell_base(get_last_request());
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -0700932}
933
934#ifdef CONFIG_CFG80211_CERTIFICATION_ONUS
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -0700935/* Core specific check */
Johannes Berg2f922122012-12-03 17:54:55 +0100936static enum reg_request_treatment
937reg_ignore_cell_hint(struct regulatory_request *pending_request)
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -0700938{
Johannes Bergc492db32012-12-06 16:29:25 +0100939 struct regulatory_request *lr = get_last_request();
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -0700940
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -0700941 if (!reg_num_devs_support_basehint)
Johannes Berg2f922122012-12-03 17:54:55 +0100942 return REG_REQ_IGNORE;
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -0700943
Johannes Bergc492db32012-12-06 16:29:25 +0100944 if (reg_request_cell_base(lr) &&
Johannes Berg1a919312012-12-03 17:21:11 +0100945 !regdom_changes(pending_request->alpha2))
Johannes Berg2f922122012-12-03 17:54:55 +0100946 return REG_REQ_ALREADY_SET;
Johannes Berg1a919312012-12-03 17:21:11 +0100947
Johannes Berg2f922122012-12-03 17:54:55 +0100948 return REG_REQ_OK;
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -0700949}
950
951/* Device specific check */
952static bool reg_dev_ignore_cell_hint(struct wiphy *wiphy)
953{
Johannes Berg1a919312012-12-03 17:21:11 +0100954 return !(wiphy->features & NL80211_FEATURE_CELL_BASE_REG_HINTS);
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -0700955}
956#else
957static int reg_ignore_cell_hint(struct regulatory_request *pending_request)
958{
Johannes Berg2f922122012-12-03 17:54:55 +0100959 return REG_REQ_IGNORE;
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -0700960}
Johannes Berg1a919312012-12-03 17:21:11 +0100961
962static bool reg_dev_ignore_cell_hint(struct wiphy *wiphy)
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -0700963{
964 return true;
965}
966#endif
967
Luis R. Rodriguezfa1fb9c2013-10-02 18:33:10 -0700968static bool wiphy_strict_alpha2_regd(struct wiphy *wiphy)
969{
970 if (wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY &&
971 !(wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY))
972 return true;
973 return false;
974}
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -0700975
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -0400976static bool ignore_reg_update(struct wiphy *wiphy,
977 enum nl80211_reg_initiator initiator)
Luis R. Rodriguez14b98152008-11-12 14:22:03 -0800978{
Johannes Bergc492db32012-12-06 16:29:25 +0100979 struct regulatory_request *lr = get_last_request();
980
981 if (!lr) {
Luis R. Rodriguez034c6d62013-10-14 17:42:06 -0700982 REG_DBG_PRINT("Ignoring regulatory request set by %s "
983 "since last_request is not set\n",
Luis R. Rodriguez926a0a02010-10-21 19:17:03 +0530984 reg_initiator_name(initiator));
Luis R. Rodriguez14b98152008-11-12 14:22:03 -0800985 return true;
Luis R. Rodriguez926a0a02010-10-21 19:17:03 +0530986 }
987
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -0400988 if (initiator == NL80211_REGDOM_SET_BY_CORE &&
Luis R. Rodriguez926a0a02010-10-21 19:17:03 +0530989 wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY) {
Luis R. Rodriguez034c6d62013-10-14 17:42:06 -0700990 REG_DBG_PRINT("Ignoring regulatory request set by %s "
991 "since the driver uses its own custom "
992 "regulatory domain\n",
Luis R. Rodriguez926a0a02010-10-21 19:17:03 +0530993 reg_initiator_name(initiator));
Luis R. Rodriguez14b98152008-11-12 14:22:03 -0800994 return true;
Luis R. Rodriguez926a0a02010-10-21 19:17:03 +0530995 }
996
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500997 /*
998 * wiphy->regd will be set once the device has its own
999 * desired regulatory domain set
1000 */
Luis R. Rodriguezfa1fb9c2013-10-02 18:33:10 -07001001 if (wiphy_strict_alpha2_regd(wiphy) && !wiphy->regd &&
Luis R. Rodriguez749b5272010-10-20 10:18:54 -07001002 initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
Johannes Bergc492db32012-12-06 16:29:25 +01001003 !is_world_regdom(lr->alpha2)) {
Luis R. Rodriguez034c6d62013-10-14 17:42:06 -07001004 REG_DBG_PRINT("Ignoring regulatory request set by %s "
1005 "since the driver requires its own regulatory "
1006 "domain to be set first\n",
Luis R. Rodriguez926a0a02010-10-21 19:17:03 +05301007 reg_initiator_name(initiator));
Luis R. Rodriguez14b98152008-11-12 14:22:03 -08001008 return true;
Luis R. Rodriguez926a0a02010-10-21 19:17:03 +05301009 }
1010
Johannes Bergc492db32012-12-06 16:29:25 +01001011 if (reg_request_cell_base(lr))
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -07001012 return reg_dev_ignore_cell_hint(wiphy);
1013
Luis R. Rodriguez14b98152008-11-12 14:22:03 -08001014 return false;
1015}
1016
Luis R. Rodriguez3195e482012-12-19 10:53:03 -08001017static bool reg_is_world_roaming(struct wiphy *wiphy)
1018{
1019 const struct ieee80211_regdomain *cr = get_cfg80211_regdom();
1020 const struct ieee80211_regdomain *wr = get_wiphy_regdom(wiphy);
1021 struct regulatory_request *lr = get_last_request();
1022
1023 if (is_world_regdom(cr->alpha2) || (wr && is_world_regdom(wr->alpha2)))
1024 return true;
1025
1026 if (lr && lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
1027 wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY)
1028 return true;
1029
1030 return false;
1031}
1032
Johannes Berg1a919312012-12-03 17:21:11 +01001033static void handle_reg_beacon(struct wiphy *wiphy, unsigned int chan_idx,
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001034 struct reg_beacon *reg_beacon)
1035{
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001036 struct ieee80211_supported_band *sband;
1037 struct ieee80211_channel *chan;
Luis R. Rodriguez6bad8762009-04-02 14:08:09 -04001038 bool channel_changed = false;
1039 struct ieee80211_channel chan_before;
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001040
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001041 sband = wiphy->bands[reg_beacon->chan.band];
1042 chan = &sband->channels[chan_idx];
1043
1044 if (likely(chan->center_freq != reg_beacon->chan.center_freq))
1045 return;
1046
Luis R. Rodriguez6bad8762009-04-02 14:08:09 -04001047 if (chan->beacon_found)
1048 return;
1049
1050 chan->beacon_found = true;
1051
Luis R. Rodriguez0f500a52012-12-19 10:53:04 -08001052 if (!reg_is_world_roaming(wiphy))
1053 return;
1054
Johannes Berg5be83de2009-11-19 00:56:28 +01001055 if (wiphy->flags & WIPHY_FLAG_DISABLE_BEACON_HINTS)
Luis R. Rodriguez37184242009-07-30 17:43:48 -07001056 return;
1057
Luis R. Rodriguez6bad8762009-04-02 14:08:09 -04001058 chan_before.center_freq = chan->center_freq;
1059 chan_before.flags = chan->flags;
1060
Luis R. Rodriguez8fe02e12013-10-21 19:22:25 +02001061 if (chan->flags & IEEE80211_CHAN_NO_IR) {
1062 chan->flags &= ~IEEE80211_CHAN_NO_IR;
Luis R. Rodriguez6bad8762009-04-02 14:08:09 -04001063 channel_changed = true;
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001064 }
1065
Luis R. Rodriguez6bad8762009-04-02 14:08:09 -04001066 if (channel_changed)
1067 nl80211_send_beacon_hint_event(wiphy, &chan_before, chan);
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001068}
1069
1070/*
1071 * Called when a scan on a wiphy finds a beacon on
1072 * new channel
1073 */
1074static void wiphy_update_new_beacon(struct wiphy *wiphy,
1075 struct reg_beacon *reg_beacon)
1076{
1077 unsigned int i;
1078 struct ieee80211_supported_band *sband;
1079
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001080 if (!wiphy->bands[reg_beacon->chan.band])
1081 return;
1082
1083 sband = wiphy->bands[reg_beacon->chan.band];
1084
1085 for (i = 0; i < sband->n_channels; i++)
1086 handle_reg_beacon(wiphy, i, reg_beacon);
1087}
1088
1089/*
1090 * Called upon reg changes or a new wiphy is added
1091 */
1092static void wiphy_update_beacon_reg(struct wiphy *wiphy)
1093{
1094 unsigned int i;
1095 struct ieee80211_supported_band *sband;
1096 struct reg_beacon *reg_beacon;
1097
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001098 list_for_each_entry(reg_beacon, &reg_beacon_list, list) {
1099 if (!wiphy->bands[reg_beacon->chan.band])
1100 continue;
1101 sband = wiphy->bands[reg_beacon->chan.band];
1102 for (i = 0; i < sband->n_channels; i++)
1103 handle_reg_beacon(wiphy, i, reg_beacon);
1104 }
1105}
1106
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001107/* Reap the advantages of previously found beacons */
1108static void reg_process_beacons(struct wiphy *wiphy)
1109{
Luis R. Rodriguezb1ed8dd2009-05-02 00:34:15 -04001110 /*
1111 * Means we are just firing up cfg80211, so no beacons would
1112 * have been processed yet.
1113 */
1114 if (!last_request)
1115 return;
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001116 wiphy_update_beacon_reg(wiphy);
1117}
1118
Johannes Berg1a919312012-12-03 17:21:11 +01001119static bool is_ht40_allowed(struct ieee80211_channel *chan)
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001120{
1121 if (!chan)
Johannes Berg1a919312012-12-03 17:21:11 +01001122 return false;
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001123 if (chan->flags & IEEE80211_CHAN_DISABLED)
Johannes Berg1a919312012-12-03 17:21:11 +01001124 return false;
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001125 /* This would happen when regulatory rules disallow HT40 completely */
Felix Fietkau55b183a2013-01-11 14:22:58 +01001126 if ((chan->flags & IEEE80211_CHAN_NO_HT40) == IEEE80211_CHAN_NO_HT40)
1127 return false;
1128 return true;
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001129}
1130
1131static void reg_process_ht_flags_channel(struct wiphy *wiphy,
Johannes Bergfdc9d7b2012-12-03 18:36:09 +01001132 struct ieee80211_channel *channel)
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001133{
Johannes Bergfdc9d7b2012-12-03 18:36:09 +01001134 struct ieee80211_supported_band *sband = wiphy->bands[channel->band];
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001135 struct ieee80211_channel *channel_before = NULL, *channel_after = NULL;
1136 unsigned int i;
1137
Johannes Berg1a919312012-12-03 17:21:11 +01001138 if (!is_ht40_allowed(channel)) {
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001139 channel->flags |= IEEE80211_CHAN_NO_HT40;
1140 return;
1141 }
1142
1143 /*
1144 * We need to ensure the extension channels exist to
1145 * be able to use HT40- or HT40+, this finds them (or not)
1146 */
1147 for (i = 0; i < sband->n_channels; i++) {
1148 struct ieee80211_channel *c = &sband->channels[i];
Johannes Berg1a919312012-12-03 17:21:11 +01001149
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001150 if (c->center_freq == (channel->center_freq - 20))
1151 channel_before = c;
1152 if (c->center_freq == (channel->center_freq + 20))
1153 channel_after = c;
1154 }
1155
1156 /*
1157 * Please note that this assumes target bandwidth is 20 MHz,
1158 * if that ever changes we also need to change the below logic
1159 * to include that as well.
1160 */
Johannes Berg1a919312012-12-03 17:21:11 +01001161 if (!is_ht40_allowed(channel_before))
Luis R. Rodriguez689da1b2009-05-02 00:37:18 -04001162 channel->flags |= IEEE80211_CHAN_NO_HT40MINUS;
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001163 else
Luis R. Rodriguez689da1b2009-05-02 00:37:18 -04001164 channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001165
Johannes Berg1a919312012-12-03 17:21:11 +01001166 if (!is_ht40_allowed(channel_after))
Luis R. Rodriguez689da1b2009-05-02 00:37:18 -04001167 channel->flags |= IEEE80211_CHAN_NO_HT40PLUS;
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001168 else
Luis R. Rodriguez689da1b2009-05-02 00:37:18 -04001169 channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001170}
1171
1172static void reg_process_ht_flags_band(struct wiphy *wiphy,
Johannes Bergfdc9d7b2012-12-03 18:36:09 +01001173 struct ieee80211_supported_band *sband)
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001174{
1175 unsigned int i;
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001176
Johannes Bergfdc9d7b2012-12-03 18:36:09 +01001177 if (!sband)
1178 return;
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001179
1180 for (i = 0; i < sband->n_channels; i++)
Johannes Bergfdc9d7b2012-12-03 18:36:09 +01001181 reg_process_ht_flags_channel(wiphy, &sband->channels[i]);
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001182}
1183
1184static void reg_process_ht_flags(struct wiphy *wiphy)
1185{
1186 enum ieee80211_band band;
1187
1188 if (!wiphy)
1189 return;
1190
Johannes Bergfdc9d7b2012-12-03 18:36:09 +01001191 for (band = 0; band < IEEE80211_NUM_BANDS; band++)
1192 reg_process_ht_flags_band(wiphy, wiphy->bands[band]);
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001193}
1194
Sven Neumanneac03e32011-08-30 23:38:53 +02001195static void wiphy_update_regulatory(struct wiphy *wiphy,
1196 enum nl80211_reg_initiator initiator)
Johannes Berg8318d782008-01-24 19:38:38 +01001197{
1198 enum ieee80211_band band;
Johannes Bergc492db32012-12-06 16:29:25 +01001199 struct regulatory_request *lr = get_last_request();
Sven Neumanneac03e32011-08-30 23:38:53 +02001200
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001201 if (ignore_reg_update(wiphy, initiator))
Sven Neumanna203c2a2011-07-12 15:52:07 +02001202 return;
1203
Johannes Bergc492db32012-12-06 16:29:25 +01001204 lr->dfs_region = get_cfg80211_regdom()->dfs_region;
Luis R. Rodriguezb68e6b32011-10-11 10:59:03 -07001205
Johannes Bergfdc9d7b2012-12-03 18:36:09 +01001206 for (band = 0; band < IEEE80211_NUM_BANDS; band++)
1207 handle_band(wiphy, initiator, wiphy->bands[band]);
Sven Neumanna203c2a2011-07-12 15:52:07 +02001208
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001209 reg_process_beacons(wiphy);
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001210 reg_process_ht_flags(wiphy);
Johannes Berg1a919312012-12-03 17:21:11 +01001211
Luis R. Rodriguez560e28e2009-01-07 17:43:32 -08001212 if (wiphy->reg_notifier)
Johannes Bergc492db32012-12-06 16:29:25 +01001213 wiphy->reg_notifier(wiphy, lr);
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001214}
1215
Sven Neumannd7549cb2011-08-30 23:38:54 +02001216static void update_all_wiphy_regulatory(enum nl80211_reg_initiator initiator)
1217{
1218 struct cfg80211_registered_device *rdev;
Rajkumar Manoharan4a389942011-12-08 23:59:26 +05301219 struct wiphy *wiphy;
Sven Neumannd7549cb2011-08-30 23:38:54 +02001220
Johannes Berg5fe231e2013-05-08 21:45:15 +02001221 ASSERT_RTNL();
Johannes Berg458f4f92012-12-06 15:47:38 +01001222
Rajkumar Manoharan4a389942011-12-08 23:59:26 +05301223 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
1224 wiphy = &rdev->wiphy;
1225 wiphy_update_regulatory(wiphy, initiator);
1226 /*
1227 * Regulatory updates set by CORE are ignored for custom
1228 * regulatory cards. Let us notify the changes to the driver,
1229 * as some drivers used this to restore its orig_* reg domain.
1230 */
1231 if (initiator == NL80211_REGDOM_SET_BY_CORE &&
1232 wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY &&
1233 wiphy->reg_notifier)
Johannes Bergc492db32012-12-06 16:29:25 +01001234 wiphy->reg_notifier(wiphy, get_last_request());
Rajkumar Manoharan4a389942011-12-08 23:59:26 +05301235 }
Sven Neumannd7549cb2011-08-30 23:38:54 +02001236}
1237
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -08001238static void handle_channel_custom(struct wiphy *wiphy,
Johannes Bergfdc9d7b2012-12-03 18:36:09 +01001239 struct ieee80211_channel *chan,
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -08001240 const struct ieee80211_regdomain *regd)
1241{
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001242 u32 bw_flags = 0;
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -08001243 const struct ieee80211_reg_rule *reg_rule = NULL;
1244 const struct ieee80211_power_rule *power_rule = NULL;
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001245 const struct ieee80211_freq_range *freq_range = NULL;
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -08001246
Johannes Berg361c9c82012-12-06 15:57:14 +01001247 reg_rule = freq_reg_info_regd(wiphy, MHZ_TO_KHZ(chan->center_freq),
1248 regd);
Luis R. Rodriguezac46d482009-05-01 18:44:50 -04001249
Johannes Berg361c9c82012-12-06 15:57:14 +01001250 if (IS_ERR(reg_rule)) {
Johannes Bergfe7ef5e2012-12-04 15:07:34 +01001251 REG_DBG_PRINT("Disabling freq %d MHz as custom regd has no rule that fits it\n",
1252 chan->center_freq);
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -08001253 chan->flags = IEEE80211_CHAN_DISABLED;
1254 return;
1255 }
1256
Johannes Bergfe7ef5e2012-12-04 15:07:34 +01001257 chan_reg_rule_print_dbg(chan, reg_rule);
Luis R. Rodrigueze702d3c2010-10-21 19:17:04 +05301258
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -08001259 power_rule = &reg_rule->power_rule;
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001260 freq_range = &reg_rule->freq_range;
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -08001261
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001262 if (freq_range->max_bandwidth_khz < MHZ_TO_KHZ(40))
1263 bw_flags = IEEE80211_CHAN_NO_HT40;
Johannes Bergc7a6ee22012-12-12 17:50:39 +01001264 if (freq_range->max_bandwidth_khz < MHZ_TO_KHZ(80))
1265 bw_flags |= IEEE80211_CHAN_NO_80MHZ;
1266 if (freq_range->max_bandwidth_khz < MHZ_TO_KHZ(160))
1267 bw_flags |= IEEE80211_CHAN_NO_160MHZ;
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001268
1269 chan->flags |= map_regdom_flags(reg_rule->flags) | bw_flags;
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -08001270 chan->max_antenna_gain = (int) MBI_TO_DBI(power_rule->max_antenna_gain);
Felix Fietkau279f0f52012-10-17 13:56:20 +02001271 chan->max_reg_power = chan->max_power =
1272 (int) MBM_TO_DBM(power_rule->max_eirp);
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -08001273}
1274
Johannes Bergfdc9d7b2012-12-03 18:36:09 +01001275static void handle_band_custom(struct wiphy *wiphy,
1276 struct ieee80211_supported_band *sband,
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -08001277 const struct ieee80211_regdomain *regd)
1278{
1279 unsigned int i;
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -08001280
Johannes Bergfdc9d7b2012-12-03 18:36:09 +01001281 if (!sband)
1282 return;
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -08001283
1284 for (i = 0; i < sband->n_channels; i++)
Johannes Bergfdc9d7b2012-12-03 18:36:09 +01001285 handle_channel_custom(wiphy, &sband->channels[i], regd);
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -08001286}
1287
1288/* Used by drivers prior to wiphy registration */
1289void wiphy_apply_custom_regulatory(struct wiphy *wiphy,
1290 const struct ieee80211_regdomain *regd)
1291{
1292 enum ieee80211_band band;
Luis R. Rodriguezbbcf3f02009-05-19 17:49:47 -04001293 unsigned int bands_set = 0;
Luis R. Rodriguezac46d482009-05-01 18:44:50 -04001294
Luis R. Rodriguez222ea582013-11-05 09:18:00 -08001295 WARN(!(wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY),
1296 "wiphy should have WIPHY_FLAG_CUSTOM_REGULATORY\n");
1297 wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY;
1298
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -08001299 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
Luis R. Rodriguezbbcf3f02009-05-19 17:49:47 -04001300 if (!wiphy->bands[band])
1301 continue;
Johannes Bergfdc9d7b2012-12-03 18:36:09 +01001302 handle_band_custom(wiphy, wiphy->bands[band], regd);
Luis R. Rodriguezbbcf3f02009-05-19 17:49:47 -04001303 bands_set++;
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -08001304 }
Luis R. Rodriguezbbcf3f02009-05-19 17:49:47 -04001305
1306 /*
1307 * no point in calling this if it won't have any effect
Johannes Berg1a919312012-12-03 17:21:11 +01001308 * on your device's supported bands.
Luis R. Rodriguezbbcf3f02009-05-19 17:49:47 -04001309 */
1310 WARN_ON(!bands_set);
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -08001311}
1312EXPORT_SYMBOL(wiphy_apply_custom_regulatory);
1313
Johannes Berg84fa4f42008-10-24 20:32:23 +02001314/* This has the logic which determines when a new request
1315 * should be ignored. */
Johannes Berg2f922122012-12-03 17:54:55 +01001316static enum reg_request_treatment
1317get_reg_request_treatment(struct wiphy *wiphy,
Luis R. Rodriguez2f92cd22009-02-21 00:24:16 -05001318 struct regulatory_request *pending_request)
Johannes Berg84fa4f42008-10-24 20:32:23 +02001319{
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -05001320 struct wiphy *last_wiphy = NULL;
Johannes Bergc492db32012-12-06 16:29:25 +01001321 struct regulatory_request *lr = get_last_request();
Luis R. Rodriguez761cf7e2009-02-21 00:04:25 -05001322
Johannes Berg84fa4f42008-10-24 20:32:23 +02001323 /* All initial requests are respected */
Johannes Bergc492db32012-12-06 16:29:25 +01001324 if (!lr)
Johannes Berg2f922122012-12-03 17:54:55 +01001325 return REG_REQ_OK;
Johannes Berg84fa4f42008-10-24 20:32:23 +02001326
Luis R. Rodriguez2f92cd22009-02-21 00:24:16 -05001327 switch (pending_request->initiator) {
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001328 case NL80211_REGDOM_SET_BY_CORE:
Johannes Berg2f922122012-12-03 17:54:55 +01001329 return REG_REQ_OK;
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001330 case NL80211_REGDOM_SET_BY_COUNTRY_IE:
Johannes Bergc492db32012-12-06 16:29:25 +01001331 if (reg_request_cell_base(lr)) {
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -07001332 /* Trust a Cell base station over the AP's country IE */
1333 if (regdom_changes(pending_request->alpha2))
Johannes Berg2f922122012-12-03 17:54:55 +01001334 return REG_REQ_IGNORE;
1335 return REG_REQ_ALREADY_SET;
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -07001336 }
1337
Johannes Bergc492db32012-12-06 16:29:25 +01001338 last_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx);
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -05001339
Luis R. Rodriguez2f92cd22009-02-21 00:24:16 -05001340 if (unlikely(!is_an_alpha2(pending_request->alpha2)))
Johannes Berg84fa4f42008-10-24 20:32:23 +02001341 return -EINVAL;
Johannes Bergc492db32012-12-06 16:29:25 +01001342 if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE) {
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -05001343 if (last_wiphy != wiphy) {
Johannes Berg84fa4f42008-10-24 20:32:23 +02001344 /*
1345 * Two cards with two APs claiming different
Thadeu Lima de Souza Cascardo1fe90b02009-08-11 11:18:42 -03001346 * Country IE alpha2s. We could
Johannes Berg84fa4f42008-10-24 20:32:23 +02001347 * intersect them, but that seems unlikely
1348 * to be correct. Reject second one for now.
1349 */
Luis R. Rodriguez2f92cd22009-02-21 00:24:16 -05001350 if (regdom_changes(pending_request->alpha2))
Johannes Berg2f922122012-12-03 17:54:55 +01001351 return REG_REQ_IGNORE;
1352 return REG_REQ_ALREADY_SET;
Johannes Berg84fa4f42008-10-24 20:32:23 +02001353 }
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05001354 /*
1355 * Two consecutive Country IE hints on the same wiphy.
1356 * This should be picked up early by the driver/stack
1357 */
Luis R. Rodriguez2f92cd22009-02-21 00:24:16 -05001358 if (WARN_ON(regdom_changes(pending_request->alpha2)))
Johannes Berg2f922122012-12-03 17:54:55 +01001359 return REG_REQ_OK;
1360 return REG_REQ_ALREADY_SET;
Johannes Berg84fa4f42008-10-24 20:32:23 +02001361 }
Johannes Berg34301402013-06-04 14:35:07 +02001362 return REG_REQ_OK;
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001363 case NL80211_REGDOM_SET_BY_DRIVER:
Johannes Bergc492db32012-12-06 16:29:25 +01001364 if (lr->initiator == NL80211_REGDOM_SET_BY_CORE) {
Luis R. Rodriguez2f92cd22009-02-21 00:24:16 -05001365 if (regdom_changes(pending_request->alpha2))
Johannes Berg2f922122012-12-03 17:54:55 +01001366 return REG_REQ_OK;
1367 return REG_REQ_ALREADY_SET;
Luis R. Rodrigueze74b1e72009-01-22 15:05:48 -08001368 }
Luis R. Rodriguezfff32c02009-02-21 00:04:32 -05001369
1370 /*
1371 * This would happen if you unplug and plug your card
1372 * back in or if you add a new device for which the previously
1373 * loaded card also agrees on the regulatory domain.
1374 */
Johannes Bergc492db32012-12-06 16:29:25 +01001375 if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
Luis R. Rodriguez2f92cd22009-02-21 00:24:16 -05001376 !regdom_changes(pending_request->alpha2))
Johannes Berg2f922122012-12-03 17:54:55 +01001377 return REG_REQ_ALREADY_SET;
Luis R. Rodriguezfff32c02009-02-21 00:04:32 -05001378
Johannes Berg2f922122012-12-03 17:54:55 +01001379 return REG_REQ_INTERSECT;
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001380 case NL80211_REGDOM_SET_BY_USER:
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -07001381 if (reg_request_cell_base(pending_request))
1382 return reg_ignore_cell_hint(pending_request);
1383
Johannes Bergc492db32012-12-06 16:29:25 +01001384 if (reg_request_cell_base(lr))
Johannes Berg2f922122012-12-03 17:54:55 +01001385 return REG_REQ_IGNORE;
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -07001386
Johannes Bergc492db32012-12-06 16:29:25 +01001387 if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE)
Johannes Berg2f922122012-12-03 17:54:55 +01001388 return REG_REQ_INTERSECT;
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05001389 /*
1390 * If the user knows better the user should set the regdom
1391 * to their country before the IE is picked up
1392 */
Johannes Bergc492db32012-12-06 16:29:25 +01001393 if (lr->initiator == NL80211_REGDOM_SET_BY_USER &&
1394 lr->intersect)
Johannes Berg2f922122012-12-03 17:54:55 +01001395 return REG_REQ_IGNORE;
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05001396 /*
1397 * Process user requests only after previous user/driver/core
1398 * requests have been processed
1399 */
Johannes Bergc492db32012-12-06 16:29:25 +01001400 if ((lr->initiator == NL80211_REGDOM_SET_BY_CORE ||
1401 lr->initiator == NL80211_REGDOM_SET_BY_DRIVER ||
1402 lr->initiator == NL80211_REGDOM_SET_BY_USER) &&
1403 regdom_changes(lr->alpha2))
Johannes Berg2f922122012-12-03 17:54:55 +01001404 return REG_REQ_IGNORE;
Luis R. Rodriguez5eebade2009-01-22 15:05:47 -08001405
John W. Linvillebaeb66f2009-12-18 17:59:02 -05001406 if (!regdom_changes(pending_request->alpha2))
Johannes Berg2f922122012-12-03 17:54:55 +01001407 return REG_REQ_ALREADY_SET;
Luis R. Rodrigueze74b1e72009-01-22 15:05:48 -08001408
Johannes Berg2f922122012-12-03 17:54:55 +01001409 return REG_REQ_OK;
Johannes Berg84fa4f42008-10-24 20:32:23 +02001410 }
1411
Johannes Berg2f922122012-12-03 17:54:55 +01001412 return REG_REQ_IGNORE;
Johannes Berg84fa4f42008-10-24 20:32:23 +02001413}
1414
Luis R. Rodriguezb2e253c2010-11-17 21:46:09 -08001415static void reg_set_request_processed(void)
1416{
1417 bool need_more_processing = false;
Johannes Bergc492db32012-12-06 16:29:25 +01001418 struct regulatory_request *lr = get_last_request();
Luis R. Rodriguezb2e253c2010-11-17 21:46:09 -08001419
Johannes Bergc492db32012-12-06 16:29:25 +01001420 lr->processed = true;
Luis R. Rodriguezb2e253c2010-11-17 21:46:09 -08001421
1422 spin_lock(&reg_requests_lock);
1423 if (!list_empty(&reg_requests_list))
1424 need_more_processing = true;
1425 spin_unlock(&reg_requests_lock);
1426
Johannes Bergc492db32012-12-06 16:29:25 +01001427 if (lr->initiator == NL80211_REGDOM_SET_BY_USER)
Eliad Pellerfe20b392012-06-12 12:53:13 +03001428 cancel_delayed_work(&reg_timeout);
Luis R. Rodrigueza90c7a32011-04-05 10:49:04 -07001429
Luis R. Rodriguezb2e253c2010-11-17 21:46:09 -08001430 if (need_more_processing)
1431 schedule_work(&reg_work);
1432}
1433
Luis R. Rodriguezd1c96a92009-02-21 00:24:13 -05001434/**
1435 * __regulatory_hint - hint to the wireless core a regulatory domain
1436 * @wiphy: if the hint comes from country information from an AP, this
1437 * is required to be set to the wiphy that received the information
Luis R. Rodriguez28da32d2009-02-21 00:24:14 -05001438 * @pending_request: the regulatory request currently being processed
Luis R. Rodriguezd1c96a92009-02-21 00:24:13 -05001439 *
1440 * The Wireless subsystem can use this function to hint to the wireless core
Luis R. Rodriguez28da32d2009-02-21 00:24:14 -05001441 * what it believes should be the current regulatory domain.
Luis R. Rodriguezd1c96a92009-02-21 00:24:13 -05001442 *
Johannes Berg2f922122012-12-03 17:54:55 +01001443 * Returns one of the different reg request treatment values.
Luis R. Rodriguezd1c96a92009-02-21 00:24:13 -05001444 */
Johannes Berg2f922122012-12-03 17:54:55 +01001445static enum reg_request_treatment
1446__regulatory_hint(struct wiphy *wiphy,
1447 struct regulatory_request *pending_request)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001448{
Johannes Berge9763c32012-12-03 16:59:46 +01001449 const struct ieee80211_regdomain *regd;
Luis R. Rodriguez9c964772008-10-30 13:33:53 -07001450 bool intersect = false;
Johannes Berg2f922122012-12-03 17:54:55 +01001451 enum reg_request_treatment treatment;
Johannes Bergc492db32012-12-06 16:29:25 +01001452 struct regulatory_request *lr;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001453
Johannes Berg2f922122012-12-03 17:54:55 +01001454 treatment = get_reg_request_treatment(wiphy, pending_request);
Luis R. Rodriguez761cf7e2009-02-21 00:04:25 -05001455
Johannes Berg2f922122012-12-03 17:54:55 +01001456 switch (treatment) {
1457 case REG_REQ_INTERSECT:
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001458 if (pending_request->initiator ==
1459 NL80211_REGDOM_SET_BY_DRIVER) {
Johannes Berg458f4f92012-12-06 15:47:38 +01001460 regd = reg_copy_regd(get_cfg80211_regdom());
Johannes Berge9763c32012-12-03 16:59:46 +01001461 if (IS_ERR(regd)) {
Luis R. Rodriguezd951c1d2009-02-21 00:24:15 -05001462 kfree(pending_request);
Johannes Berge9763c32012-12-03 16:59:46 +01001463 return PTR_ERR(regd);
Luis R. Rodriguezd951c1d2009-02-21 00:24:15 -05001464 }
Johannes Berg458f4f92012-12-06 15:47:38 +01001465 rcu_assign_pointer(wiphy->regd, regd);
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08001466 }
Luis R. Rodriguez9c964772008-10-30 13:33:53 -07001467 intersect = true;
Johannes Berg2f922122012-12-03 17:54:55 +01001468 break;
1469 case REG_REQ_OK:
1470 break;
1471 default:
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05001472 /*
1473 * If the regulatory domain being requested by the
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08001474 * driver has already been set just copy it to the
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05001475 * wiphy
1476 */
Johannes Berg2f922122012-12-03 17:54:55 +01001477 if (treatment == REG_REQ_ALREADY_SET &&
1478 pending_request->initiator == NL80211_REGDOM_SET_BY_DRIVER) {
Johannes Berg458f4f92012-12-06 15:47:38 +01001479 regd = reg_copy_regd(get_cfg80211_regdom());
Johannes Berge9763c32012-12-03 16:59:46 +01001480 if (IS_ERR(regd)) {
Luis R. Rodriguezd951c1d2009-02-21 00:24:15 -05001481 kfree(pending_request);
Johannes Berg2f922122012-12-03 17:54:55 +01001482 return REG_REQ_IGNORE;
Luis R. Rodriguezd951c1d2009-02-21 00:24:15 -05001483 }
Johannes Berg2f922122012-12-03 17:54:55 +01001484 treatment = REG_REQ_ALREADY_SET;
Johannes Berg458f4f92012-12-06 15:47:38 +01001485 rcu_assign_pointer(wiphy->regd, regd);
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08001486 goto new_request;
1487 }
Luis R. Rodriguezd951c1d2009-02-21 00:24:15 -05001488 kfree(pending_request);
Johannes Berg2f922122012-12-03 17:54:55 +01001489 return treatment;
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08001490 }
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001491
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08001492new_request:
Johannes Bergc492db32012-12-06 16:29:25 +01001493 lr = get_last_request();
1494 if (lr != &core_request_world && lr)
1495 kfree_rcu(lr, rcu_head);
Luis R. Rodriguezd951c1d2009-02-21 00:24:15 -05001496
Johannes Bergc492db32012-12-06 16:29:25 +01001497 pending_request->intersect = intersect;
1498 pending_request->processed = false;
1499 rcu_assign_pointer(last_request, pending_request);
1500 lr = pending_request;
Luis R. Rodriguezd951c1d2009-02-21 00:24:15 -05001501
1502 pending_request = NULL;
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08001503
Johannes Bergc492db32012-12-06 16:29:25 +01001504 if (lr->initiator == NL80211_REGDOM_SET_BY_USER) {
1505 user_alpha2[0] = lr->alpha2[0];
1506 user_alpha2[1] = lr->alpha2[1];
Luis R. Rodriguez09d989d2010-01-29 19:58:57 -05001507 }
1508
Johannes Berg2f922122012-12-03 17:54:55 +01001509 /* When r == REG_REQ_INTERSECT we do need to call CRDA */
1510 if (treatment != REG_REQ_OK && treatment != REG_REQ_INTERSECT) {
Luis R. Rodriguez73d54c92009-03-09 22:07:42 -04001511 /*
1512 * Since CRDA will not be called in this case as we already
1513 * have applied the requested regulatory domain before we just
1514 * inform userspace we have processed the request
1515 */
Johannes Berg2f922122012-12-03 17:54:55 +01001516 if (treatment == REG_REQ_ALREADY_SET) {
Johannes Bergc492db32012-12-06 16:29:25 +01001517 nl80211_send_reg_change_event(lr);
Luis R. Rodriguezb2e253c2010-11-17 21:46:09 -08001518 reg_set_request_processed();
1519 }
Johannes Berg2f922122012-12-03 17:54:55 +01001520 return treatment;
Luis R. Rodriguez73d54c92009-03-09 22:07:42 -04001521 }
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08001522
Johannes Bergc492db32012-12-06 16:29:25 +01001523 if (call_crda(lr->alpha2))
Johannes Berg2f922122012-12-03 17:54:55 +01001524 return REG_REQ_IGNORE;
1525 return REG_REQ_OK;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001526}
1527
Luis R. Rodriguez30a548c2009-05-02 01:17:27 -04001528/* This processes *all* regulatory hints */
Luis R. Rodriguez8848bef2011-12-20 12:23:36 -08001529static void reg_process_hint(struct regulatory_request *reg_request,
1530 enum nl80211_reg_initiator reg_initiator)
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001531{
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001532 struct wiphy *wiphy = NULL;
1533
Johannes Bergfdc9d7b2012-12-03 18:36:09 +01001534 if (WARN_ON(!reg_request->alpha2))
1535 return;
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001536
Johannes Bergf4173762012-12-03 18:23:37 +01001537 if (reg_request->wiphy_idx != WIPHY_IDX_INVALID)
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001538 wiphy = wiphy_idx_to_wiphy(reg_request->wiphy_idx);
1539
Johannes Berg1a919312012-12-03 17:21:11 +01001540 if (reg_initiator == NL80211_REGDOM_SET_BY_DRIVER && !wiphy) {
Luis R. Rodriguezd951c1d2009-02-21 00:24:15 -05001541 kfree(reg_request);
Luis R. Rodriguezb0e28802010-11-17 21:46:08 -08001542 return;
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001543 }
1544
Johannes Berg2f922122012-12-03 17:54:55 +01001545 switch (__regulatory_hint(wiphy, reg_request)) {
1546 case REG_REQ_ALREADY_SET:
1547 /* This is required so that the orig_* parameters are saved */
1548 if (wiphy && wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY)
1549 wiphy_update_regulatory(wiphy, reg_initiator);
1550 break;
1551 default:
1552 if (reg_initiator == NL80211_REGDOM_SET_BY_USER)
1553 schedule_delayed_work(&reg_timeout,
1554 msecs_to_jiffies(3142));
1555 break;
Luis R. Rodrigueza90c7a32011-04-05 10:49:04 -07001556 }
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001557}
1558
Luis R. Rodriguezb2e253c2010-11-17 21:46:09 -08001559/*
1560 * Processes regulatory hints, this is all the NL80211_REGDOM_SET_BY_*
1561 * Regulatory hints come on a first come first serve basis and we
1562 * must process each one atomically.
1563 */
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001564static void reg_process_pending_hints(void)
Luis R. Rodriguezb0e28802010-11-17 21:46:08 -08001565{
Johannes Bergc492db32012-12-06 16:29:25 +01001566 struct regulatory_request *reg_request, *lr;
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001567
Johannes Bergc492db32012-12-06 16:29:25 +01001568 lr = get_last_request();
Luis R. Rodriguezb0e28802010-11-17 21:46:08 -08001569
Luis R. Rodriguezb2e253c2010-11-17 21:46:09 -08001570 /* When last_request->processed becomes true this will be rescheduled */
Johannes Bergc492db32012-12-06 16:29:25 +01001571 if (lr && !lr->processed) {
Johannes Berg1a919312012-12-03 17:21:11 +01001572 REG_DBG_PRINT("Pending regulatory request, waiting for it to be processed...\n");
Johannes Berg5fe231e2013-05-08 21:45:15 +02001573 return;
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001574 }
Luis R. Rodriguezb2e253c2010-11-17 21:46:09 -08001575
1576 spin_lock(&reg_requests_lock);
1577
1578 if (list_empty(&reg_requests_list)) {
1579 spin_unlock(&reg_requests_lock);
Johannes Berg5fe231e2013-05-08 21:45:15 +02001580 return;
Luis R. Rodriguezb2e253c2010-11-17 21:46:09 -08001581 }
1582
1583 reg_request = list_first_entry(&reg_requests_list,
1584 struct regulatory_request,
1585 list);
1586 list_del_init(&reg_request->list);
1587
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001588 spin_unlock(&reg_requests_lock);
Luis R. Rodriguezb0e28802010-11-17 21:46:08 -08001589
Luis R. Rodriguez8848bef2011-12-20 12:23:36 -08001590 reg_process_hint(reg_request, reg_request->initiator);
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001591}
1592
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001593/* Processes beacon hints -- this has nothing to do with country IEs */
1594static void reg_process_pending_beacon_hints(void)
1595{
Johannes Berg79c97e92009-07-07 03:56:12 +02001596 struct cfg80211_registered_device *rdev;
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001597 struct reg_beacon *pending_beacon, *tmp;
1598
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001599 /* This goes through the _pending_ beacon list */
1600 spin_lock_bh(&reg_pending_beacons_lock);
1601
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001602 list_for_each_entry_safe(pending_beacon, tmp,
1603 &reg_pending_beacons, list) {
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001604 list_del_init(&pending_beacon->list);
1605
1606 /* Applies the beacon hint to current wiphys */
Johannes Berg79c97e92009-07-07 03:56:12 +02001607 list_for_each_entry(rdev, &cfg80211_rdev_list, list)
1608 wiphy_update_new_beacon(&rdev->wiphy, pending_beacon);
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001609
1610 /* Remembers the beacon hint for new wiphys or reg changes */
1611 list_add_tail(&pending_beacon->list, &reg_beacon_list);
1612 }
1613
1614 spin_unlock_bh(&reg_pending_beacons_lock);
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001615}
1616
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001617static void reg_todo(struct work_struct *work)
1618{
Johannes Berg5fe231e2013-05-08 21:45:15 +02001619 rtnl_lock();
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001620 reg_process_pending_hints();
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001621 reg_process_pending_beacon_hints();
Johannes Berg5fe231e2013-05-08 21:45:15 +02001622 rtnl_unlock();
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001623}
1624
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001625static void queue_regulatory_request(struct regulatory_request *request)
1626{
Johannes Bergd4f2c882012-12-03 18:59:58 +01001627 request->alpha2[0] = toupper(request->alpha2[0]);
1628 request->alpha2[1] = toupper(request->alpha2[1]);
John W. Linvillec61029c2010-08-05 14:26:24 -04001629
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001630 spin_lock(&reg_requests_lock);
1631 list_add_tail(&request->list, &reg_requests_list);
1632 spin_unlock(&reg_requests_lock);
1633
1634 schedule_work(&reg_work);
1635}
1636
Luis R. Rodriguez09d989d2010-01-29 19:58:57 -05001637/*
1638 * Core regulatory hint -- happens during cfg80211_init()
1639 * and when we restore regulatory settings.
1640 */
Luis R. Rodriguezba25c142009-02-21 00:04:23 -05001641static int regulatory_hint_core(const char *alpha2)
1642{
1643 struct regulatory_request *request;
1644
Johannes Berg1a919312012-12-03 17:21:11 +01001645 request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
Luis R. Rodriguezba25c142009-02-21 00:04:23 -05001646 if (!request)
1647 return -ENOMEM;
1648
1649 request->alpha2[0] = alpha2[0];
1650 request->alpha2[1] = alpha2[1];
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001651 request->initiator = NL80211_REGDOM_SET_BY_CORE;
Luis R. Rodriguezba25c142009-02-21 00:04:23 -05001652
Luis R. Rodriguez31e99722010-11-17 21:46:06 -08001653 queue_regulatory_request(request);
Luis R. Rodriguez5078b2e2009-05-13 17:04:42 -04001654
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001655 return 0;
Luis R. Rodriguezba25c142009-02-21 00:04:23 -05001656}
1657
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001658/* User hints */
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -07001659int regulatory_hint_user(const char *alpha2,
1660 enum nl80211_user_reg_hint_type user_reg_hint_type)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001661{
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001662 struct regulatory_request *request;
1663
Johannes Bergfdc9d7b2012-12-03 18:36:09 +01001664 if (WARN_ON(!alpha2))
1665 return -EINVAL;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001666
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001667 request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
1668 if (!request)
1669 return -ENOMEM;
1670
Johannes Bergf4173762012-12-03 18:23:37 +01001671 request->wiphy_idx = WIPHY_IDX_INVALID;
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001672 request->alpha2[0] = alpha2[0];
1673 request->alpha2[1] = alpha2[1];
Luis R. Rodrigueze12822e2010-01-04 11:37:39 -05001674 request->initiator = NL80211_REGDOM_SET_BY_USER;
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -07001675 request->user_reg_hint_type = user_reg_hint_type;
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001676
1677 queue_regulatory_request(request);
1678
1679 return 0;
1680}
1681
1682/* Driver hints */
1683int regulatory_hint(struct wiphy *wiphy, const char *alpha2)
1684{
1685 struct regulatory_request *request;
1686
Johannes Bergfdc9d7b2012-12-03 18:36:09 +01001687 if (WARN_ON(!alpha2 || !wiphy))
1688 return -EINVAL;
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001689
1690 request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
1691 if (!request)
1692 return -ENOMEM;
1693
1694 request->wiphy_idx = get_wiphy_idx(wiphy);
1695
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001696 request->alpha2[0] = alpha2[0];
1697 request->alpha2[1] = alpha2[1];
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001698 request->initiator = NL80211_REGDOM_SET_BY_DRIVER;
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001699
1700 queue_regulatory_request(request);
1701
1702 return 0;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001703}
1704EXPORT_SYMBOL(regulatory_hint);
1705
Luis R. Rodriguez789fd032013-10-04 18:07:24 -07001706void regulatory_hint_country_ie(struct wiphy *wiphy, enum ieee80211_band band,
1707 const u8 *country_ie, u8 country_ie_len)
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001708{
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001709 char alpha2[2];
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001710 enum environment_cap env = ENVIRON_ANY;
Johannes Bergdb2424c2013-05-10 19:07:52 +02001711 struct regulatory_request *request = NULL, *lr;
Luis R. Rodriguezd335fe62009-02-21 00:04:27 -05001712
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001713 /* IE len must be evenly divisible by 2 */
1714 if (country_ie_len & 0x01)
Johannes Bergdb2424c2013-05-10 19:07:52 +02001715 return;
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001716
1717 if (country_ie_len < IEEE80211_COUNTRY_IE_MIN_LEN)
Johannes Bergdb2424c2013-05-10 19:07:52 +02001718 return;
1719
1720 request = kzalloc(sizeof(*request), GFP_KERNEL);
1721 if (!request)
1722 return;
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001723
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001724 alpha2[0] = country_ie[0];
1725 alpha2[1] = country_ie[1];
1726
1727 if (country_ie[2] == 'I')
1728 env = ENVIRON_INDOOR;
1729 else if (country_ie[2] == 'O')
1730 env = ENVIRON_OUTDOOR;
1731
Johannes Bergdb2424c2013-05-10 19:07:52 +02001732 rcu_read_lock();
1733 lr = get_last_request();
1734
1735 if (unlikely(!lr))
1736 goto out;
1737
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05001738 /*
Luis R. Rodriguez8b19e6c2009-07-30 17:38:09 -07001739 * We will run this only upon a successful connection on cfg80211.
Luis R. Rodriguez4b44c8b2009-07-30 17:38:07 -07001740 * We leave conflict resolution to the workqueue, where can hold
Johannes Berg5fe231e2013-05-08 21:45:15 +02001741 * the RTNL.
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05001742 */
Johannes Bergc492db32012-12-06 16:29:25 +01001743 if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
1744 lr->wiphy_idx != WIPHY_IDX_INVALID)
Luis R. Rodriguez4b44c8b2009-07-30 17:38:07 -07001745 goto out;
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001746
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001747 request->wiphy_idx = get_wiphy_idx(wiphy);
John W. Linville4f366c52010-07-15 14:57:33 -04001748 request->alpha2[0] = alpha2[0];
1749 request->alpha2[1] = alpha2[1];
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001750 request->initiator = NL80211_REGDOM_SET_BY_COUNTRY_IE;
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001751 request->country_ie_env = env;
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001752
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001753 queue_regulatory_request(request);
Johannes Bergdb2424c2013-05-10 19:07:52 +02001754 request = NULL;
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001755out:
Johannes Bergdb2424c2013-05-10 19:07:52 +02001756 kfree(request);
1757 rcu_read_unlock();
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001758}
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001759
Luis R. Rodriguez09d989d2010-01-29 19:58:57 -05001760static void restore_alpha2(char *alpha2, bool reset_user)
1761{
1762 /* indicates there is no alpha2 to consider for restoration */
1763 alpha2[0] = '9';
1764 alpha2[1] = '7';
1765
1766 /* The user setting has precedence over the module parameter */
1767 if (is_user_regdom_saved()) {
1768 /* Unless we're asked to ignore it and reset it */
1769 if (reset_user) {
Johannes Berg1a919312012-12-03 17:21:11 +01001770 REG_DBG_PRINT("Restoring regulatory settings including user preference\n");
Luis R. Rodriguez09d989d2010-01-29 19:58:57 -05001771 user_alpha2[0] = '9';
1772 user_alpha2[1] = '7';
1773
1774 /*
1775 * If we're ignoring user settings, we still need to
1776 * check the module parameter to ensure we put things
1777 * back as they were for a full restore.
1778 */
1779 if (!is_world_regdom(ieee80211_regdom)) {
Johannes Berg1a919312012-12-03 17:21:11 +01001780 REG_DBG_PRINT("Keeping preference on module parameter ieee80211_regdom: %c%c\n",
1781 ieee80211_regdom[0], ieee80211_regdom[1]);
Luis R. Rodriguez09d989d2010-01-29 19:58:57 -05001782 alpha2[0] = ieee80211_regdom[0];
1783 alpha2[1] = ieee80211_regdom[1];
1784 }
1785 } else {
Johannes Berg1a919312012-12-03 17:21:11 +01001786 REG_DBG_PRINT("Restoring regulatory settings while preserving user preference for: %c%c\n",
1787 user_alpha2[0], user_alpha2[1]);
Luis R. Rodriguez09d989d2010-01-29 19:58:57 -05001788 alpha2[0] = user_alpha2[0];
1789 alpha2[1] = user_alpha2[1];
1790 }
1791 } else if (!is_world_regdom(ieee80211_regdom)) {
Johannes Berg1a919312012-12-03 17:21:11 +01001792 REG_DBG_PRINT("Keeping preference on module parameter ieee80211_regdom: %c%c\n",
1793 ieee80211_regdom[0], ieee80211_regdom[1]);
Luis R. Rodriguez09d989d2010-01-29 19:58:57 -05001794 alpha2[0] = ieee80211_regdom[0];
1795 alpha2[1] = ieee80211_regdom[1];
1796 } else
Luis R. Rodriguezd91e41b2010-10-20 10:18:59 -07001797 REG_DBG_PRINT("Restoring regulatory settings\n");
Luis R. Rodriguez09d989d2010-01-29 19:58:57 -05001798}
1799
Rajkumar Manoharan5ce543d2011-12-07 21:50:08 +05301800static void restore_custom_reg_settings(struct wiphy *wiphy)
1801{
1802 struct ieee80211_supported_band *sband;
1803 enum ieee80211_band band;
1804 struct ieee80211_channel *chan;
1805 int i;
1806
1807 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1808 sband = wiphy->bands[band];
1809 if (!sband)
1810 continue;
1811 for (i = 0; i < sband->n_channels; i++) {
1812 chan = &sband->channels[i];
1813 chan->flags = chan->orig_flags;
1814 chan->max_antenna_gain = chan->orig_mag;
1815 chan->max_power = chan->orig_mpwr;
Paul Stewart899852a2012-08-01 16:54:42 -07001816 chan->beacon_found = false;
Rajkumar Manoharan5ce543d2011-12-07 21:50:08 +05301817 }
1818 }
1819}
1820
Luis R. Rodriguez09d989d2010-01-29 19:58:57 -05001821/*
1822 * Restoring regulatory settings involves ingoring any
1823 * possibly stale country IE information and user regulatory
1824 * settings if so desired, this includes any beacon hints
1825 * learned as we could have traveled outside to another country
1826 * after disconnection. To restore regulatory settings we do
1827 * exactly what we did at bootup:
1828 *
1829 * - send a core regulatory hint
1830 * - send a user regulatory hint if applicable
1831 *
1832 * Device drivers that send a regulatory hint for a specific country
1833 * keep their own regulatory domain on wiphy->regd so that does does
1834 * not need to be remembered.
1835 */
1836static void restore_regulatory_settings(bool reset_user)
1837{
1838 char alpha2[2];
Dmitry Shmidtcee0bec2011-12-19 12:32:21 -08001839 char world_alpha2[2];
Luis R. Rodriguez09d989d2010-01-29 19:58:57 -05001840 struct reg_beacon *reg_beacon, *btmp;
Luis R. Rodriguez14609552011-04-05 10:49:03 -07001841 struct regulatory_request *reg_request, *tmp;
1842 LIST_HEAD(tmp_reg_req_list);
Rajkumar Manoharan5ce543d2011-12-07 21:50:08 +05301843 struct cfg80211_registered_device *rdev;
Luis R. Rodriguez09d989d2010-01-29 19:58:57 -05001844
Johannes Berg5fe231e2013-05-08 21:45:15 +02001845 ASSERT_RTNL();
1846
Johannes Berg2d319862013-01-09 12:01:38 +01001847 reset_regdomains(true, &world_regdom);
Luis R. Rodriguez09d989d2010-01-29 19:58:57 -05001848 restore_alpha2(alpha2, reset_user);
1849
Luis R. Rodriguez14609552011-04-05 10:49:03 -07001850 /*
1851 * If there's any pending requests we simply
1852 * stash them to a temporary pending queue and
1853 * add then after we've restored regulatory
1854 * settings.
1855 */
1856 spin_lock(&reg_requests_lock);
Johannes Bergfea9bce2012-12-03 17:32:01 +01001857 list_for_each_entry_safe(reg_request, tmp, &reg_requests_list, list) {
1858 if (reg_request->initiator != NL80211_REGDOM_SET_BY_USER)
1859 continue;
1860 list_move_tail(&reg_request->list, &tmp_reg_req_list);
Luis R. Rodriguez14609552011-04-05 10:49:03 -07001861 }
1862 spin_unlock(&reg_requests_lock);
1863
Luis R. Rodriguez09d989d2010-01-29 19:58:57 -05001864 /* Clear beacon hints */
1865 spin_lock_bh(&reg_pending_beacons_lock);
Johannes Bergfea9bce2012-12-03 17:32:01 +01001866 list_for_each_entry_safe(reg_beacon, btmp, &reg_pending_beacons, list) {
1867 list_del(&reg_beacon->list);
1868 kfree(reg_beacon);
Luis R. Rodriguez09d989d2010-01-29 19:58:57 -05001869 }
1870 spin_unlock_bh(&reg_pending_beacons_lock);
1871
Johannes Bergfea9bce2012-12-03 17:32:01 +01001872 list_for_each_entry_safe(reg_beacon, btmp, &reg_beacon_list, list) {
1873 list_del(&reg_beacon->list);
1874 kfree(reg_beacon);
Luis R. Rodriguez09d989d2010-01-29 19:58:57 -05001875 }
1876
1877 /* First restore to the basic regulatory settings */
Johannes Berg379b82f2012-12-06 15:44:07 +01001878 world_alpha2[0] = cfg80211_world_regdom->alpha2[0];
1879 world_alpha2[1] = cfg80211_world_regdom->alpha2[1];
Luis R. Rodriguez09d989d2010-01-29 19:58:57 -05001880
Rajkumar Manoharan5ce543d2011-12-07 21:50:08 +05301881 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
1882 if (rdev->wiphy.flags & WIPHY_FLAG_CUSTOM_REGULATORY)
1883 restore_custom_reg_settings(&rdev->wiphy);
1884 }
1885
Dmitry Shmidtcee0bec2011-12-19 12:32:21 -08001886 regulatory_hint_core(world_alpha2);
Luis R. Rodriguez09d989d2010-01-29 19:58:57 -05001887
1888 /*
1889 * This restores the ieee80211_regdom module parameter
1890 * preference or the last user requested regulatory
1891 * settings, user regulatory settings takes precedence.
1892 */
1893 if (is_an_alpha2(alpha2))
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -07001894 regulatory_hint_user(user_alpha2, NL80211_USER_REG_HINT_USER);
Luis R. Rodriguez09d989d2010-01-29 19:58:57 -05001895
Luis R. Rodriguez14609552011-04-05 10:49:03 -07001896 spin_lock(&reg_requests_lock);
Johannes Berg11cff962012-12-03 18:56:41 +01001897 list_splice_tail_init(&tmp_reg_req_list, &reg_requests_list);
Luis R. Rodriguez14609552011-04-05 10:49:03 -07001898 spin_unlock(&reg_requests_lock);
1899
Luis R. Rodriguez14609552011-04-05 10:49:03 -07001900 REG_DBG_PRINT("Kicking the queue\n");
1901
1902 schedule_work(&reg_work);
1903}
Luis R. Rodriguez09d989d2010-01-29 19:58:57 -05001904
1905void regulatory_hint_disconnect(void)
1906{
Johannes Berg1a919312012-12-03 17:21:11 +01001907 REG_DBG_PRINT("All devices are disconnected, going to restore regulatory settings\n");
Luis R. Rodriguez09d989d2010-01-29 19:58:57 -05001908 restore_regulatory_settings(false);
1909}
1910
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001911static bool freq_is_chan_12_13_14(u16 freq)
1912{
Bruno Randolf59eb21a2011-01-17 13:37:28 +09001913 if (freq == ieee80211_channel_to_frequency(12, IEEE80211_BAND_2GHZ) ||
1914 freq == ieee80211_channel_to_frequency(13, IEEE80211_BAND_2GHZ) ||
1915 freq == ieee80211_channel_to_frequency(14, IEEE80211_BAND_2GHZ))
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001916 return true;
1917 return false;
1918}
1919
Luis R. Rodriguez3ebfa6e2012-12-19 10:53:02 -08001920static bool pending_reg_beacon(struct ieee80211_channel *beacon_chan)
1921{
1922 struct reg_beacon *pending_beacon;
1923
1924 list_for_each_entry(pending_beacon, &reg_pending_beacons, list)
1925 if (beacon_chan->center_freq ==
1926 pending_beacon->chan.center_freq)
1927 return true;
1928 return false;
1929}
1930
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001931int regulatory_hint_found_beacon(struct wiphy *wiphy,
1932 struct ieee80211_channel *beacon_chan,
1933 gfp_t gfp)
1934{
1935 struct reg_beacon *reg_beacon;
Luis R. Rodriguez3ebfa6e2012-12-19 10:53:02 -08001936 bool processing;
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001937
Johannes Berg1a919312012-12-03 17:21:11 +01001938 if (beacon_chan->beacon_found ||
1939 beacon_chan->flags & IEEE80211_CHAN_RADAR ||
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001940 (beacon_chan->band == IEEE80211_BAND_2GHZ &&
Johannes Berg1a919312012-12-03 17:21:11 +01001941 !freq_is_chan_12_13_14(beacon_chan->center_freq)))
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001942 return 0;
1943
Luis R. Rodriguez3ebfa6e2012-12-19 10:53:02 -08001944 spin_lock_bh(&reg_pending_beacons_lock);
1945 processing = pending_reg_beacon(beacon_chan);
1946 spin_unlock_bh(&reg_pending_beacons_lock);
1947
1948 if (processing)
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001949 return 0;
1950
1951 reg_beacon = kzalloc(sizeof(struct reg_beacon), gfp);
1952 if (!reg_beacon)
1953 return -ENOMEM;
1954
Johannes Berg1a919312012-12-03 17:21:11 +01001955 REG_DBG_PRINT("Found new beacon on frequency: %d MHz (Ch %d) on %s\n",
Luis R. Rodriguez4113f752010-01-04 11:50:11 -05001956 beacon_chan->center_freq,
1957 ieee80211_frequency_to_channel(beacon_chan->center_freq),
1958 wiphy_name(wiphy));
1959
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001960 memcpy(&reg_beacon->chan, beacon_chan,
Johannes Berg1a919312012-12-03 17:21:11 +01001961 sizeof(struct ieee80211_channel));
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001962
1963 /*
1964 * Since we can be called from BH or and non-BH context
1965 * we must use spin_lock_bh()
1966 */
1967 spin_lock_bh(&reg_pending_beacons_lock);
1968 list_add_tail(&reg_beacon->list, &reg_pending_beacons);
1969 spin_unlock_bh(&reg_pending_beacons_lock);
1970
1971 schedule_work(&reg_work);
1972
1973 return 0;
1974}
1975
Johannes Berga3d2eaf2008-09-15 11:10:52 +02001976static void print_rd_rules(const struct ieee80211_regdomain *rd)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001977{
1978 unsigned int i;
Johannes Berga3d2eaf2008-09-15 11:10:52 +02001979 const struct ieee80211_reg_rule *reg_rule = NULL;
1980 const struct ieee80211_freq_range *freq_range = NULL;
1981 const struct ieee80211_power_rule *power_rule = NULL;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001982
Luis R. Rodriguez66533252011-12-20 12:23:37 -08001983 pr_info(" (start_freq - end_freq @ bandwidth), (max_antenna_gain, max_eirp)\n");
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001984
1985 for (i = 0; i < rd->n_reg_rules; i++) {
1986 reg_rule = &rd->reg_rules[i];
1987 freq_range = &reg_rule->freq_range;
1988 power_rule = &reg_rule->power_rule;
1989
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05001990 /*
1991 * There may not be documentation for max antenna gain
1992 * in certain regions
1993 */
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001994 if (power_rule->max_antenna_gain)
Luis R. Rodriguez66533252011-12-20 12:23:37 -08001995 pr_info(" (%d KHz - %d KHz @ %d KHz), (%d mBi, %d mBm)\n",
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001996 freq_range->start_freq_khz,
1997 freq_range->end_freq_khz,
1998 freq_range->max_bandwidth_khz,
1999 power_rule->max_antenna_gain,
2000 power_rule->max_eirp);
2001 else
Luis R. Rodriguez66533252011-12-20 12:23:37 -08002002 pr_info(" (%d KHz - %d KHz @ %d KHz), (N/A, %d mBm)\n",
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002003 freq_range->start_freq_khz,
2004 freq_range->end_freq_khz,
2005 freq_range->max_bandwidth_khz,
2006 power_rule->max_eirp);
2007 }
2008}
2009
Luis R. Rodriguez8b60b072011-10-11 10:59:02 -07002010bool reg_supported_dfs_region(u8 dfs_region)
2011{
2012 switch (dfs_region) {
2013 case NL80211_DFS_UNSET:
2014 case NL80211_DFS_FCC:
2015 case NL80211_DFS_ETSI:
2016 case NL80211_DFS_JP:
2017 return true;
2018 default:
2019 REG_DBG_PRINT("Ignoring uknown DFS master region: %d\n",
2020 dfs_region);
2021 return false;
2022 }
2023}
2024
2025static void print_dfs_region(u8 dfs_region)
2026{
2027 if (!dfs_region)
2028 return;
2029
2030 switch (dfs_region) {
2031 case NL80211_DFS_FCC:
2032 pr_info(" DFS Master region FCC");
2033 break;
2034 case NL80211_DFS_ETSI:
2035 pr_info(" DFS Master region ETSI");
2036 break;
2037 case NL80211_DFS_JP:
2038 pr_info(" DFS Master region JP");
2039 break;
2040 default:
Johannes Berg1a919312012-12-03 17:21:11 +01002041 pr_info(" DFS Master region Unknown");
Luis R. Rodriguez8b60b072011-10-11 10:59:02 -07002042 break;
2043 }
2044}
2045
Johannes Berga3d2eaf2008-09-15 11:10:52 +02002046static void print_regdomain(const struct ieee80211_regdomain *rd)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002047{
Johannes Bergc492db32012-12-06 16:29:25 +01002048 struct regulatory_request *lr = get_last_request();
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002049
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08002050 if (is_intersected_alpha2(rd->alpha2)) {
Johannes Bergc492db32012-12-06 16:29:25 +01002051 if (lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE) {
Johannes Berg79c97e92009-07-07 03:56:12 +02002052 struct cfg80211_registered_device *rdev;
Johannes Bergc492db32012-12-06 16:29:25 +01002053 rdev = cfg80211_rdev_by_wiphy_idx(lr->wiphy_idx);
Johannes Berg79c97e92009-07-07 03:56:12 +02002054 if (rdev) {
Joe Perchese9c02682010-11-16 19:56:49 -08002055 pr_info("Current regulatory domain updated by AP to: %c%c\n",
Johannes Berg79c97e92009-07-07 03:56:12 +02002056 rdev->country_ie_alpha2[0],
2057 rdev->country_ie_alpha2[1]);
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08002058 } else
Joe Perchese9c02682010-11-16 19:56:49 -08002059 pr_info("Current regulatory domain intersected:\n");
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08002060 } else
Joe Perchese9c02682010-11-16 19:56:49 -08002061 pr_info("Current regulatory domain intersected:\n");
Johannes Berg1a919312012-12-03 17:21:11 +01002062 } else if (is_world_regdom(rd->alpha2)) {
Joe Perchese9c02682010-11-16 19:56:49 -08002063 pr_info("World regulatory domain updated:\n");
Johannes Berg1a919312012-12-03 17:21:11 +01002064 } else {
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002065 if (is_unknown_alpha2(rd->alpha2))
Joe Perchese9c02682010-11-16 19:56:49 -08002066 pr_info("Regulatory domain changed to driver built-in settings (unknown country)\n");
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -07002067 else {
Johannes Bergc492db32012-12-06 16:29:25 +01002068 if (reg_request_cell_base(lr))
Johannes Berg1a919312012-12-03 17:21:11 +01002069 pr_info("Regulatory domain changed to country: %c%c by Cell Station\n",
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -07002070 rd->alpha2[0], rd->alpha2[1]);
2071 else
Johannes Berg1a919312012-12-03 17:21:11 +01002072 pr_info("Regulatory domain changed to country: %c%c\n",
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -07002073 rd->alpha2[0], rd->alpha2[1]);
2074 }
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002075 }
Johannes Berg1a919312012-12-03 17:21:11 +01002076
Luis R. Rodriguez8b60b072011-10-11 10:59:02 -07002077 print_dfs_region(rd->dfs_region);
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002078 print_rd_rules(rd);
2079}
2080
Johannes Berg2df78162008-10-28 16:49:41 +01002081static void print_regdomain_info(const struct ieee80211_regdomain *rd)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002082{
Joe Perchese9c02682010-11-16 19:56:49 -08002083 pr_info("Regulatory domain: %c%c\n", rd->alpha2[0], rd->alpha2[1]);
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002084 print_rd_rules(rd);
2085}
2086
Johannes Bergd2372b32008-10-24 20:32:20 +02002087/* Takes ownership of rd only if it doesn't fail */
Johannes Berga3d2eaf2008-09-15 11:10:52 +02002088static int __set_regdom(const struct ieee80211_regdomain *rd)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002089{
Johannes Berge9763c32012-12-03 16:59:46 +01002090 const struct ieee80211_regdomain *regd;
Luis R. Rodriguez9c964772008-10-30 13:33:53 -07002091 const struct ieee80211_regdomain *intersected_rd = NULL;
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -05002092 struct wiphy *request_wiphy;
Johannes Bergc492db32012-12-06 16:29:25 +01002093 struct regulatory_request *lr = get_last_request();
Johannes Berg6913b492012-12-04 00:48:59 +01002094
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002095 /* Some basic sanity checks first */
2096
Johannes Berg6913b492012-12-04 00:48:59 +01002097 if (!reg_is_valid_request(rd->alpha2))
2098 return -EINVAL;
2099
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002100 if (is_world_regdom(rd->alpha2)) {
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002101 update_world_regdomain(rd);
2102 return 0;
2103 }
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002104
2105 if (!is_alpha2_set(rd->alpha2) && !is_an_alpha2(rd->alpha2) &&
Johannes Berg1a919312012-12-03 17:21:11 +01002106 !is_unknown_alpha2(rd->alpha2))
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002107 return -EINVAL;
2108
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05002109 /*
2110 * Lets only bother proceeding on the same alpha2 if the current
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08002111 * rd is non static (it means CRDA was present and was used last)
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05002112 * and the pending request came in from a country IE
2113 */
Johannes Bergc492db32012-12-06 16:29:25 +01002114 if (lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE) {
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05002115 /*
2116 * If someone else asked us to change the rd lets only bother
2117 * checking if the alpha2 changes if CRDA was already called
2118 */
John W. Linvillebaeb66f2009-12-18 17:59:02 -05002119 if (!regdom_changes(rd->alpha2))
Kalle Valo95908532012-07-12 15:33:58 +03002120 return -EALREADY;
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08002121 }
2122
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05002123 /*
2124 * Now lets set the regulatory domain, update all driver channels
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002125 * and finally inform them of what we have done, in case they want
2126 * to review or adjust their own settings based on their own
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05002127 * internal EEPROM data
2128 */
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002129
Luis R. Rodriguez8375af32008-11-12 14:21:57 -08002130 if (!is_valid_rd(rd)) {
Joe Perchese9c02682010-11-16 19:56:49 -08002131 pr_err("Invalid regulatory domain detected:\n");
Luis R. Rodriguez8375af32008-11-12 14:21:57 -08002132 print_regdomain_info(rd);
2133 return -EINVAL;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002134 }
2135
Johannes Bergc492db32012-12-06 16:29:25 +01002136 request_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx);
Luis R. Rodriguez0bac71a2011-11-28 16:47:16 -05002137 if (!request_wiphy &&
Johannes Bergc492db32012-12-06 16:29:25 +01002138 (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER ||
2139 lr->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE)) {
Luis R. Rodriguez0bac71a2011-11-28 16:47:16 -05002140 schedule_delayed_work(&reg_timeout, 0);
Johannes Bergde3584b2011-11-21 10:44:00 +01002141 return -ENODEV;
2142 }
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -05002143
Johannes Bergc492db32012-12-06 16:29:25 +01002144 if (!lr->intersect) {
2145 if (lr->initiator != NL80211_REGDOM_SET_BY_DRIVER) {
Johannes Berg379b82f2012-12-06 15:44:07 +01002146 reset_regdomains(false, rd);
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08002147 return 0;
2148 }
2149
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05002150 /*
2151 * For a driver hint, lets copy the regulatory domain the
2152 * driver wanted to the wiphy to deal with conflicts
2153 */
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08002154
Luis R. Rodriguez558f6d32009-06-08 18:54:37 -07002155 /*
2156 * Userspace could have sent two replies with only
2157 * one kernel request.
2158 */
2159 if (request_wiphy->regd)
2160 return -EALREADY;
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08002161
Johannes Berge9763c32012-12-03 16:59:46 +01002162 regd = reg_copy_regd(rd);
2163 if (IS_ERR(regd))
2164 return PTR_ERR(regd);
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08002165
Johannes Berg458f4f92012-12-06 15:47:38 +01002166 rcu_assign_pointer(request_wiphy->regd, regd);
Johannes Berg379b82f2012-12-06 15:44:07 +01002167 reset_regdomains(false, rd);
Luis R. Rodriguezb8295ac2008-11-12 14:21:58 -08002168 return 0;
2169 }
2170
2171 /* Intersection requires a bit more work */
2172
Johannes Bergc492db32012-12-06 16:29:25 +01002173 if (lr->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE) {
Johannes Berg458f4f92012-12-06 15:47:38 +01002174 intersected_rd = regdom_intersect(rd, get_cfg80211_regdom());
Luis R. Rodriguez9c964772008-10-30 13:33:53 -07002175 if (!intersected_rd)
2176 return -EINVAL;
Luis R. Rodriguezb8295ac2008-11-12 14:21:58 -08002177
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05002178 /*
2179 * We can trash what CRDA provided now.
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08002180 * However if a driver requested this specific regulatory
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05002181 * domain we keep it for its private use
2182 */
Larry Fingerb7566fc2013-02-04 15:33:44 -06002183 if (lr->initiator == NL80211_REGDOM_SET_BY_DRIVER) {
2184 const struct ieee80211_regdomain *tmp;
2185
2186 tmp = get_wiphy_regdom(request_wiphy);
Johannes Berg458f4f92012-12-06 15:47:38 +01002187 rcu_assign_pointer(request_wiphy->regd, rd);
Larry Fingerb7566fc2013-02-04 15:33:44 -06002188 rcu_free_regdom(tmp);
2189 } else {
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08002190 kfree(rd);
Larry Fingerb7566fc2013-02-04 15:33:44 -06002191 }
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08002192
Luis R. Rodriguezb8295ac2008-11-12 14:21:58 -08002193 rd = NULL;
2194
Johannes Berg379b82f2012-12-06 15:44:07 +01002195 reset_regdomains(false, intersected_rd);
Luis R. Rodriguezb8295ac2008-11-12 14:21:58 -08002196
2197 return 0;
Luis R. Rodriguez9c964772008-10-30 13:33:53 -07002198 }
2199
Alan Coxf3baed52012-09-17 11:54:15 +01002200 return -EINVAL;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002201}
2202
2203
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05002204/*
2205 * Use this call to set the current regulatory domain. Conflicts with
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002206 * multiple drivers can be ironed out later. Caller must've already
Johannes Berg458f4f92012-12-06 15:47:38 +01002207 * kmalloc'd the rd structure.
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05002208 */
Johannes Berga3d2eaf2008-09-15 11:10:52 +02002209int set_regdom(const struct ieee80211_regdomain *rd)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002210{
Johannes Bergc492db32012-12-06 16:29:25 +01002211 struct regulatory_request *lr;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002212 int r;
2213
Johannes Bergc492db32012-12-06 16:29:25 +01002214 lr = get_last_request();
Luis R. Rodriguezabc73812009-07-30 17:38:08 -07002215
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002216 /* Note that this doesn't update the wiphys, this is done below */
2217 r = __set_regdom(rd);
Johannes Bergd2372b32008-10-24 20:32:20 +02002218 if (r) {
Kalle Valo95908532012-07-12 15:33:58 +03002219 if (r == -EALREADY)
2220 reg_set_request_processed();
2221
Johannes Bergd2372b32008-10-24 20:32:20 +02002222 kfree(rd);
Johannes Berg38fd2142013-05-10 19:17:17 +02002223 return r;
Johannes Bergd2372b32008-10-24 20:32:20 +02002224 }
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002225
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002226 /* This would make this whole thing pointless */
Johannes Berg38fd2142013-05-10 19:17:17 +02002227 if (WARN_ON(!lr->intersect && rd != get_cfg80211_regdom()))
2228 return -EINVAL;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002229
2230 /* update all wiphys now with the new established regulatory domain */
Johannes Bergc492db32012-12-06 16:29:25 +01002231 update_all_wiphy_regulatory(lr->initiator);
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002232
Johannes Berg458f4f92012-12-06 15:47:38 +01002233 print_regdomain(get_cfg80211_regdom());
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002234
Johannes Bergc492db32012-12-06 16:29:25 +01002235 nl80211_send_reg_change_event(lr);
Luis R. Rodriguez73d54c92009-03-09 22:07:42 -04002236
Luis R. Rodriguezb2e253c2010-11-17 21:46:09 -08002237 reg_set_request_processed();
2238
Johannes Berg38fd2142013-05-10 19:17:17 +02002239 return 0;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002240}
2241
Scott James Remnant4d9d88d2011-03-08 10:45:30 -08002242int reg_device_uevent(struct device *dev, struct kobj_uevent_env *env)
2243{
Johannes Berg4a484cf2013-01-09 10:22:07 +01002244 struct regulatory_request *lr;
2245 u8 alpha2[2];
2246 bool add = false;
Scott James Remnant4d9d88d2011-03-08 10:45:30 -08002247
Johannes Berg4a484cf2013-01-09 10:22:07 +01002248 rcu_read_lock();
2249 lr = get_last_request();
Johannes Bergc492db32012-12-06 16:29:25 +01002250 if (lr && !lr->processed) {
Johannes Berg4a484cf2013-01-09 10:22:07 +01002251 memcpy(alpha2, lr->alpha2, 2);
2252 add = true;
Scott James Remnant4d9d88d2011-03-08 10:45:30 -08002253 }
Johannes Berg4a484cf2013-01-09 10:22:07 +01002254 rcu_read_unlock();
Scott James Remnant4d9d88d2011-03-08 10:45:30 -08002255
Johannes Berg4a484cf2013-01-09 10:22:07 +01002256 if (add)
2257 return add_uevent_var(env, "COUNTRY=%c%c",
2258 alpha2[0], alpha2[1]);
Scott James Remnant4d9d88d2011-03-08 10:45:30 -08002259 return 0;
2260}
Scott James Remnant4d9d88d2011-03-08 10:45:30 -08002261
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -07002262void wiphy_regulatory_register(struct wiphy *wiphy)
2263{
Arik Nemtsov23df0b72013-07-21 16:36:48 +03002264 struct regulatory_request *lr;
2265
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -07002266 if (!reg_dev_ignore_cell_hint(wiphy))
2267 reg_num_devs_support_basehint++;
2268
Arik Nemtsov23df0b72013-07-21 16:36:48 +03002269 lr = get_last_request();
2270 wiphy_update_regulatory(wiphy, lr->initiator);
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -07002271}
2272
Luis R. Rodriguezbfead082012-07-12 11:49:19 -07002273void wiphy_regulatory_deregister(struct wiphy *wiphy)
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08002274{
Luis R. Rodriguez0ad8aca2009-03-24 21:21:08 -04002275 struct wiphy *request_wiphy = NULL;
Johannes Bergc492db32012-12-06 16:29:25 +01002276 struct regulatory_request *lr;
Luis R. Rodriguez761cf7e2009-02-21 00:04:25 -05002277
Johannes Bergc492db32012-12-06 16:29:25 +01002278 lr = get_last_request();
Luis R. Rodriguezabc73812009-07-30 17:38:08 -07002279
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -07002280 if (!reg_dev_ignore_cell_hint(wiphy))
2281 reg_num_devs_support_basehint--;
2282
Johannes Berg458f4f92012-12-06 15:47:38 +01002283 rcu_free_regdom(get_wiphy_regdom(wiphy));
2284 rcu_assign_pointer(wiphy->regd, NULL);
Chris Wright0ef9ccd2009-04-24 14:09:31 -07002285
Johannes Bergc492db32012-12-06 16:29:25 +01002286 if (lr)
2287 request_wiphy = wiphy_idx_to_wiphy(lr->wiphy_idx);
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -05002288
Chris Wright0ef9ccd2009-04-24 14:09:31 -07002289 if (!request_wiphy || request_wiphy != wiphy)
Johannes Berg38fd2142013-05-10 19:17:17 +02002290 return;
Chris Wright0ef9ccd2009-04-24 14:09:31 -07002291
Johannes Bergc492db32012-12-06 16:29:25 +01002292 lr->wiphy_idx = WIPHY_IDX_INVALID;
2293 lr->country_ie_env = ENVIRON_ANY;
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08002294}
2295
Luis R. Rodrigueza90c7a32011-04-05 10:49:04 -07002296static void reg_timeout_work(struct work_struct *work)
2297{
Johannes Berg1a919312012-12-03 17:21:11 +01002298 REG_DBG_PRINT("Timeout while waiting for CRDA to reply, restoring regulatory settings\n");
Johannes Bergf77b86d2013-06-24 15:43:38 +02002299 rtnl_lock();
Luis R. Rodrigueza90c7a32011-04-05 10:49:04 -07002300 restore_regulatory_settings(true);
Johannes Bergf77b86d2013-06-24 15:43:38 +02002301 rtnl_unlock();
Luis R. Rodrigueza90c7a32011-04-05 10:49:04 -07002302}
2303
Uwe Kleine-König2fcc9f72010-06-18 09:38:55 +02002304int __init regulatory_init(void)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002305{
Luis R. Rodriguezbcf4f992009-02-21 00:04:24 -05002306 int err = 0;
Johannes Berg734366d2008-09-15 10:56:48 +02002307
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002308 reg_pdev = platform_device_register_simple("regulatory", 0, NULL, 0);
2309 if (IS_ERR(reg_pdev))
2310 return PTR_ERR(reg_pdev);
Johannes Berg734366d2008-09-15 10:56:48 +02002311
Scott James Remnant4d9d88d2011-03-08 10:45:30 -08002312 reg_pdev->dev.type = &reg_device_type;
2313
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05002314 spin_lock_init(&reg_requests_lock);
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05002315 spin_lock_init(&reg_pending_beacons_lock);
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05002316
Luis R. Rodriguez80007ef2012-03-23 07:23:31 -07002317 reg_regdb_size_check();
2318
Johannes Berg458f4f92012-12-06 15:47:38 +01002319 rcu_assign_pointer(cfg80211_regdomain, cfg80211_world_regdom);
Johannes Berg734366d2008-09-15 10:56:48 +02002320
Luis R. Rodriguez09d989d2010-01-29 19:58:57 -05002321 user_alpha2[0] = '9';
2322 user_alpha2[1] = '7';
2323
Luis R. Rodriguezae9e4b02009-07-14 20:23:15 -04002324 /* We always try to get an update for the static regdomain */
Johannes Berg458f4f92012-12-06 15:47:38 +01002325 err = regulatory_hint_core(cfg80211_world_regdom->alpha2);
Luis R. Rodriguezbcf4f992009-02-21 00:04:24 -05002326 if (err) {
2327 if (err == -ENOMEM)
2328 return err;
2329 /*
2330 * N.B. kobject_uevent_env() can fail mainly for when we're out
2331 * memory which is handled and propagated appropriately above
2332 * but it can also fail during a netlink_broadcast() or during
2333 * early boot for call_usermodehelper(). For now treat these
2334 * errors as non-fatal.
2335 */
Joe Perchese9c02682010-11-16 19:56:49 -08002336 pr_err("kobject_uevent_env() was unable to call CRDA during init\n");
Luis R. Rodriguezbcf4f992009-02-21 00:04:24 -05002337 }
Johannes Berg734366d2008-09-15 10:56:48 +02002338
Luis R. Rodriguezae9e4b02009-07-14 20:23:15 -04002339 /*
2340 * Finally, if the user set the module parameter treat it
2341 * as a user hint.
2342 */
2343 if (!is_world_regdom(ieee80211_regdom))
Luis R. Rodriguez57b5ce02012-07-12 11:49:18 -07002344 regulatory_hint_user(ieee80211_regdom,
2345 NL80211_USER_REG_HINT_USER);
Luis R. Rodriguezae9e4b02009-07-14 20:23:15 -04002346
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002347 return 0;
2348}
2349
Johannes Berg1a919312012-12-03 17:21:11 +01002350void regulatory_exit(void)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002351{
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05002352 struct regulatory_request *reg_request, *tmp;
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05002353 struct reg_beacon *reg_beacon, *btmp;
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05002354
2355 cancel_work_sync(&reg_work);
Luis R. Rodrigueza90c7a32011-04-05 10:49:04 -07002356 cancel_delayed_work_sync(&reg_timeout);
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05002357
Johannes Berg9027b142012-12-03 17:59:24 +01002358 /* Lock to suppress warnings */
Johannes Berg38fd2142013-05-10 19:17:17 +02002359 rtnl_lock();
Johannes Berg379b82f2012-12-06 15:44:07 +01002360 reset_regdomains(true, NULL);
Johannes Berg38fd2142013-05-10 19:17:17 +02002361 rtnl_unlock();
Johannes Berg734366d2008-09-15 10:56:48 +02002362
Luis R. Rodriguez58ebacc2011-11-08 14:28:06 -08002363 dev_set_uevent_suppress(&reg_pdev->dev, true);
Johannes Bergf6037d02008-10-21 11:01:33 +02002364
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002365 platform_device_unregister(reg_pdev);
Johannes Berg734366d2008-09-15 10:56:48 +02002366
Johannes Bergfea9bce2012-12-03 17:32:01 +01002367 list_for_each_entry_safe(reg_beacon, btmp, &reg_pending_beacons, list) {
2368 list_del(&reg_beacon->list);
2369 kfree(reg_beacon);
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05002370 }
2371
Johannes Bergfea9bce2012-12-03 17:32:01 +01002372 list_for_each_entry_safe(reg_beacon, btmp, &reg_beacon_list, list) {
2373 list_del(&reg_beacon->list);
2374 kfree(reg_beacon);
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05002375 }
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05002376
Johannes Bergfea9bce2012-12-03 17:32:01 +01002377 list_for_each_entry_safe(reg_request, tmp, &reg_requests_list, list) {
2378 list_del(&reg_request->list);
2379 kfree(reg_request);
Johannes Berg8318d782008-01-24 19:38:38 +01002380 }
Johannes Berg8318d782008-01-24 19:38:38 +01002381}