blob: ab29a6135d22edc0e0516fb4674342775f69561f [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. Rodriguezb2e1b302008-09-09 23:19:48 -07005 * Copyright 2008 Luis R. Rodriguez <lrodriguz@atheros.com>
Johannes Berg8318d782008-01-24 19:38:38 +01006 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 */
11
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -070012/**
13 * DOC: Wireless regulatory infrastructure
Johannes Berg8318d782008-01-24 19:38:38 +010014 *
15 * The usual implementation is for a driver to read a device EEPROM to
16 * determine which regulatory domain it should be operating under, then
17 * looking up the allowable channels in a driver-local table and finally
18 * registering those channels in the wiphy structure.
19 *
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -070020 * Another set of compliance enforcement is for drivers to use their
21 * own compliance limits which can be stored on the EEPROM. The host
22 * driver or firmware may ensure these are used.
23 *
24 * In addition to all this we provide an extra layer of regulatory
25 * conformance. For drivers which do not have any regulatory
26 * information CRDA provides the complete regulatory solution.
27 * For others it provides a community effort on further restrictions
28 * to enhance compliance.
29 *
30 * Note: When number of rules --> infinity we will not be able to
31 * index on alpha2 any more, instead we'll probably have to
32 * rely on some SHA1 checksum of the regdomain for example.
33 *
Johannes Berg8318d782008-01-24 19:38:38 +010034 */
35#include <linux/kernel.h>
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -070036#include <linux/list.h>
37#include <linux/random.h>
38#include <linux/nl80211.h>
39#include <linux/platform_device.h>
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -070040#include <net/cfg80211.h>
Johannes Berg8318d782008-01-24 19:38:38 +010041#include "core.h"
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -070042#include "reg.h"
John W. Linville3b377ea2009-12-18 17:59:01 -050043#include "regdb.h"
Luis R. Rodriguez73d54c92009-03-09 22:07:42 -040044#include "nl80211.h"
Johannes Berg8318d782008-01-24 19:38:38 +010045
Luis R. Rodriguez4113f752010-01-04 11:50:11 -050046#ifdef CONFIG_CFG80211_REG_DEBUG
47#define REG_DBG_PRINT(args...) \
48 do { \
49 printk(KERN_DEBUG args); \
50 } while (0)
51#else
52#define REG_DBG_PRINT(args)
53#endif
54
Luis R. Rodriguez5166ccd2008-10-30 13:33:56 -070055/* Receipt of information from last regulatory request */
Johannes Bergf6037d02008-10-21 11:01:33 +020056static struct regulatory_request *last_request;
Johannes Berg734366d2008-09-15 10:56:48 +020057
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -070058/* To trigger userspace events */
59static struct platform_device *reg_pdev;
Johannes Berg8318d782008-01-24 19:38:38 +010060
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -050061/*
62 * Central wireless core regulatory domains, we only need two,
Johannes Berg734366d2008-09-15 10:56:48 +020063 * the current one and a world regulatory domain in case we have no
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -050064 * information to give us an alpha2
65 */
Luis R. Rodriguezf1303472009-01-30 09:26:42 -080066const struct ieee80211_regdomain *cfg80211_regdomain;
Johannes Berg734366d2008-09-15 10:56:48 +020067
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -050068/*
69 * We use this as a place for the rd structure built from the
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -080070 * last parsed country IE to rest until CRDA gets back to us with
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -050071 * what it thinks should apply for the same country
72 */
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -080073static const struct ieee80211_regdomain *country_ie_regdomain;
74
Luis R. Rodriguezabc73812009-07-30 17:38:08 -070075/*
76 * Protects static reg.c components:
77 * - cfg80211_world_regdom
78 * - cfg80211_regdom
79 * - country_ie_regdomain
80 * - last_request
81 */
82DEFINE_MUTEX(reg_mutex);
83#define assert_reg_lock() WARN_ON(!mutex_is_locked(&reg_mutex))
84
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -050085/* Used to queue up regulatory hints */
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -050086static LIST_HEAD(reg_requests_list);
87static spinlock_t reg_requests_lock;
88
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -050089/* Used to queue up beacon hints for review */
90static LIST_HEAD(reg_pending_beacons);
91static spinlock_t reg_pending_beacons_lock;
92
93/* Used to keep track of processed beacon hints */
94static LIST_HEAD(reg_beacon_list);
95
96struct reg_beacon {
97 struct list_head list;
98 struct ieee80211_channel chan;
99};
100
Johannes Berg734366d2008-09-15 10:56:48 +0200101/* We keep a static world regulatory domain in case of the absence of CRDA */
102static const struct ieee80211_regdomain world_regdom = {
Luis R. Rodriguez611b6a82009-03-05 21:19:21 -0800103 .n_reg_rules = 5,
Johannes Berg734366d2008-09-15 10:56:48 +0200104 .alpha2 = "00",
105 .reg_rules = {
Luis R. Rodriguez68798a62009-02-21 00:20:37 -0500106 /* IEEE 802.11b/g, channels 1..11 */
107 REG_RULE(2412-10, 2462+10, 40, 6, 20, 0),
Luis R. Rodriguez611b6a82009-03-05 21:19:21 -0800108 /* IEEE 802.11b/g, channels 12..13. No HT40
109 * channel fits here. */
110 REG_RULE(2467-10, 2472+10, 20, 6, 20,
Luis R. Rodriguez3fc71f72009-02-21 00:20:38 -0500111 NL80211_RRF_PASSIVE_SCAN |
112 NL80211_RRF_NO_IBSS),
Luis R. Rodriguez611b6a82009-03-05 21:19:21 -0800113 /* IEEE 802.11 channel 14 - Only JP enables
114 * this and for 802.11b only */
115 REG_RULE(2484-10, 2484+10, 20, 6, 20,
116 NL80211_RRF_PASSIVE_SCAN |
117 NL80211_RRF_NO_IBSS |
118 NL80211_RRF_NO_OFDM),
119 /* IEEE 802.11a, channel 36..48 */
Luis R. Rodriguezec329ac2009-03-05 21:19:22 -0800120 REG_RULE(5180-10, 5240+10, 40, 6, 20,
Luis R. Rodriguez611b6a82009-03-05 21:19:21 -0800121 NL80211_RRF_PASSIVE_SCAN |
122 NL80211_RRF_NO_IBSS),
Luis R. Rodriguez3fc71f72009-02-21 00:20:38 -0500123
124 /* NB: 5260 MHz - 5700 MHz requies DFS */
125
126 /* IEEE 802.11a, channel 149..165 */
Luis R. Rodriguezec329ac2009-03-05 21:19:22 -0800127 REG_RULE(5745-10, 5825+10, 40, 6, 20,
Luis R. Rodriguez3fc71f72009-02-21 00:20:38 -0500128 NL80211_RRF_PASSIVE_SCAN |
129 NL80211_RRF_NO_IBSS),
Johannes Berg734366d2008-09-15 10:56:48 +0200130 }
131};
132
Johannes Berga3d2eaf2008-09-15 11:10:52 +0200133static const struct ieee80211_regdomain *cfg80211_world_regdom =
134 &world_regdom;
Johannes Berg734366d2008-09-15 10:56:48 +0200135
Luis R. Rodriguez6ee7d332009-03-20 23:53:06 -0400136static char *ieee80211_regdom = "00";
Luis R. Rodriguez6ee7d332009-03-20 23:53:06 -0400137
Johannes Berg734366d2008-09-15 10:56:48 +0200138module_param(ieee80211_regdom, charp, 0444);
139MODULE_PARM_DESC(ieee80211_regdom, "IEEE 802.11 regulatory domain code");
140
Johannes Berg734366d2008-09-15 10:56:48 +0200141static void reset_regdomains(void)
142{
Johannes Berg942b25c2008-09-15 11:26:47 +0200143 /* avoid freeing static information or freeing something twice */
144 if (cfg80211_regdomain == cfg80211_world_regdom)
145 cfg80211_regdomain = NULL;
146 if (cfg80211_world_regdom == &world_regdom)
147 cfg80211_world_regdom = NULL;
148 if (cfg80211_regdomain == &world_regdom)
149 cfg80211_regdomain = NULL;
Johannes Berg942b25c2008-09-15 11:26:47 +0200150
151 kfree(cfg80211_regdomain);
152 kfree(cfg80211_world_regdom);
Johannes Berg734366d2008-09-15 10:56:48 +0200153
Johannes Berga3d2eaf2008-09-15 11:10:52 +0200154 cfg80211_world_regdom = &world_regdom;
Johannes Berg734366d2008-09-15 10:56:48 +0200155 cfg80211_regdomain = NULL;
156}
157
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500158/*
159 * Dynamic world regulatory domain requested by the wireless
160 * core upon initialization
161 */
Johannes Berga3d2eaf2008-09-15 11:10:52 +0200162static void update_world_regdomain(const struct ieee80211_regdomain *rd)
Johannes Berg734366d2008-09-15 10:56:48 +0200163{
Johannes Bergf6037d02008-10-21 11:01:33 +0200164 BUG_ON(!last_request);
Johannes Berg734366d2008-09-15 10:56:48 +0200165
166 reset_regdomains();
167
168 cfg80211_world_regdom = rd;
169 cfg80211_regdomain = rd;
170}
Johannes Berg734366d2008-09-15 10:56:48 +0200171
Johannes Berga3d2eaf2008-09-15 11:10:52 +0200172bool is_world_regdom(const char *alpha2)
Johannes Berg8318d782008-01-24 19:38:38 +0100173{
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700174 if (!alpha2)
175 return false;
176 if (alpha2[0] == '0' && alpha2[1] == '0')
177 return true;
178 return false;
Johannes Berg8318d782008-01-24 19:38:38 +0100179}
180
Johannes Berga3d2eaf2008-09-15 11:10:52 +0200181static bool is_alpha2_set(const char *alpha2)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700182{
183 if (!alpha2)
184 return false;
185 if (alpha2[0] != 0 && alpha2[1] != 0)
186 return true;
187 return false;
188}
Johannes Berg8318d782008-01-24 19:38:38 +0100189
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700190static bool is_alpha_upper(char letter)
191{
192 /* ASCII A - Z */
193 if (letter >= 65 && letter <= 90)
194 return true;
195 return false;
196}
197
Johannes Berga3d2eaf2008-09-15 11:10:52 +0200198static bool is_unknown_alpha2(const char *alpha2)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700199{
200 if (!alpha2)
201 return false;
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500202 /*
203 * Special case where regulatory domain was built by driver
204 * but a specific alpha2 cannot be determined
205 */
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700206 if (alpha2[0] == '9' && alpha2[1] == '9')
207 return true;
208 return false;
209}
210
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -0800211static bool is_intersected_alpha2(const char *alpha2)
212{
213 if (!alpha2)
214 return false;
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500215 /*
216 * Special case where regulatory domain is the
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -0800217 * result of an intersection between two regulatory domain
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500218 * structures
219 */
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -0800220 if (alpha2[0] == '9' && alpha2[1] == '8')
221 return true;
222 return false;
223}
224
Johannes Berga3d2eaf2008-09-15 11:10:52 +0200225static bool is_an_alpha2(const char *alpha2)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700226{
227 if (!alpha2)
228 return false;
229 if (is_alpha_upper(alpha2[0]) && is_alpha_upper(alpha2[1]))
230 return true;
231 return false;
232}
233
Johannes Berga3d2eaf2008-09-15 11:10:52 +0200234static bool alpha2_equal(const char *alpha2_x, const char *alpha2_y)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700235{
236 if (!alpha2_x || !alpha2_y)
237 return false;
238 if (alpha2_x[0] == alpha2_y[0] &&
239 alpha2_x[1] == alpha2_y[1])
240 return true;
241 return false;
242}
243
Luis R. Rodriguez69b15722009-02-21 00:04:33 -0500244static bool regdom_changes(const char *alpha2)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700245{
Luis R. Rodriguez761cf7e2009-02-21 00:04:25 -0500246 assert_cfg80211_lock();
247
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700248 if (!cfg80211_regdomain)
249 return true;
250 if (alpha2_equal(cfg80211_regdomain->alpha2, alpha2))
251 return false;
252 return true;
253}
254
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -0800255/**
256 * country_ie_integrity_changes - tells us if the country IE has changed
257 * @checksum: checksum of country IE of fields we are interested in
258 *
259 * If the country IE has not changed you can ignore it safely. This is
260 * useful to determine if two devices are seeing two different country IEs
261 * even on the same alpha2. Note that this will return false if no IE has
262 * been set on the wireless core yet.
263 */
264static bool country_ie_integrity_changes(u32 checksum)
265{
266 /* If no IE has been set then the checksum doesn't change */
267 if (unlikely(!last_request->country_ie_checksum))
268 return false;
269 if (unlikely(last_request->country_ie_checksum != checksum))
270 return true;
271 return false;
272}
273
John W. Linville3b377ea2009-12-18 17:59:01 -0500274static int reg_copy_regd(const struct ieee80211_regdomain **dst_regd,
275 const struct ieee80211_regdomain *src_regd)
276{
277 struct ieee80211_regdomain *regd;
278 int size_of_regd = 0;
279 unsigned int i;
280
281 size_of_regd = sizeof(struct ieee80211_regdomain) +
282 ((src_regd->n_reg_rules + 1) * sizeof(struct ieee80211_reg_rule));
283
284 regd = kzalloc(size_of_regd, GFP_KERNEL);
285 if (!regd)
286 return -ENOMEM;
287
288 memcpy(regd, src_regd, sizeof(struct ieee80211_regdomain));
289
290 for (i = 0; i < src_regd->n_reg_rules; i++)
291 memcpy(&regd->reg_rules[i], &src_regd->reg_rules[i],
292 sizeof(struct ieee80211_reg_rule));
293
294 *dst_regd = regd;
295 return 0;
296}
297
298#ifdef CONFIG_CFG80211_INTERNAL_REGDB
299struct reg_regdb_search_request {
300 char alpha2[2];
301 struct list_head list;
302};
303
304static LIST_HEAD(reg_regdb_search_list);
305static DEFINE_SPINLOCK(reg_regdb_search_lock);
306
307static void reg_regdb_search(struct work_struct *work)
308{
309 struct reg_regdb_search_request *request;
310 const struct ieee80211_regdomain *curdom, *regdom;
311 int i, r;
312
313 spin_lock(&reg_regdb_search_lock);
314 while (!list_empty(&reg_regdb_search_list)) {
315 request = list_first_entry(&reg_regdb_search_list,
316 struct reg_regdb_search_request,
317 list);
318 list_del(&request->list);
319
320 for (i=0; i<reg_regdb_size; i++) {
321 curdom = reg_regdb[i];
322
323 if (!memcmp(request->alpha2, curdom->alpha2, 2)) {
324 r = reg_copy_regd(&regdom, curdom);
325 if (r)
326 break;
327 spin_unlock(&reg_regdb_search_lock);
328 mutex_lock(&cfg80211_mutex);
329 set_regdom(regdom);
330 mutex_unlock(&cfg80211_mutex);
331 spin_lock(&reg_regdb_search_lock);
332 break;
333 }
334 }
335
336 kfree(request);
337 }
338 spin_unlock(&reg_regdb_search_lock);
339}
340
341static DECLARE_WORK(reg_regdb_work, reg_regdb_search);
342
343static void reg_regdb_query(const char *alpha2)
344{
345 struct reg_regdb_search_request *request;
346
347 if (!alpha2)
348 return;
349
350 request = kzalloc(sizeof(struct reg_regdb_search_request), GFP_KERNEL);
351 if (!request)
352 return;
353
354 memcpy(request->alpha2, alpha2, 2);
355
356 spin_lock(&reg_regdb_search_lock);
357 list_add_tail(&request->list, &reg_regdb_search_list);
358 spin_unlock(&reg_regdb_search_lock);
359
360 schedule_work(&reg_regdb_work);
361}
362#else
363static inline void reg_regdb_query(const char *alpha2) {}
364#endif /* CONFIG_CFG80211_INTERNAL_REGDB */
365
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500366/*
367 * This lets us keep regulatory code which is updated on a regulatory
368 * basis in userspace.
369 */
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700370static int call_crda(const char *alpha2)
371{
372 char country_env[9 + 2] = "COUNTRY=";
373 char *envp[] = {
374 country_env,
375 NULL
376 };
377
378 if (!is_world_regdom((char *) alpha2))
379 printk(KERN_INFO "cfg80211: Calling CRDA for country: %c%c\n",
380 alpha2[0], alpha2[1]);
381 else
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700382 printk(KERN_INFO "cfg80211: Calling CRDA to update world "
383 "regulatory domain\n");
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700384
John W. Linville3b377ea2009-12-18 17:59:01 -0500385 /* query internal regulatory database (if it exists) */
386 reg_regdb_query(alpha2);
387
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700388 country_env[8] = alpha2[0];
389 country_env[9] = alpha2[1];
390
391 return kobject_uevent_env(&reg_pdev->dev.kobj, KOBJ_CHANGE, envp);
392}
393
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700394/* Used by nl80211 before kmalloc'ing our regulatory domain */
Johannes Berga3d2eaf2008-09-15 11:10:52 +0200395bool reg_is_valid_request(const char *alpha2)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700396{
Luis R. Rodriguez61405e92009-05-13 17:04:41 -0400397 assert_cfg80211_lock();
398
Johannes Bergf6037d02008-10-21 11:01:33 +0200399 if (!last_request)
400 return false;
401
402 return alpha2_equal(last_request->alpha2, alpha2);
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700403}
404
405/* Sanity check on a regulatory rule */
Johannes Berga3d2eaf2008-09-15 11:10:52 +0200406static bool is_valid_reg_rule(const struct ieee80211_reg_rule *rule)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700407{
Johannes Berga3d2eaf2008-09-15 11:10:52 +0200408 const struct ieee80211_freq_range *freq_range = &rule->freq_range;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700409 u32 freq_diff;
410
Luis R. Rodriguez91e99002008-11-12 14:21:55 -0800411 if (freq_range->start_freq_khz <= 0 || freq_range->end_freq_khz <= 0)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700412 return false;
413
414 if (freq_range->start_freq_khz > freq_range->end_freq_khz)
415 return false;
416
417 freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
418
Roel Kluinbd05f282009-03-03 22:55:21 +0100419 if (freq_range->end_freq_khz <= freq_range->start_freq_khz ||
420 freq_range->max_bandwidth_khz > freq_diff)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700421 return false;
422
423 return true;
424}
425
Johannes Berga3d2eaf2008-09-15 11:10:52 +0200426static bool is_valid_rd(const struct ieee80211_regdomain *rd)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700427{
Johannes Berga3d2eaf2008-09-15 11:10:52 +0200428 const struct ieee80211_reg_rule *reg_rule = NULL;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700429 unsigned int i;
430
431 if (!rd->n_reg_rules)
432 return false;
433
Luis R. Rodriguez88dc1c32008-11-12 14:22:01 -0800434 if (WARN_ON(rd->n_reg_rules > NL80211_MAX_SUPP_REG_RULES))
435 return false;
436
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700437 for (i = 0; i < rd->n_reg_rules; i++) {
438 reg_rule = &rd->reg_rules[i];
439 if (!is_valid_reg_rule(reg_rule))
440 return false;
441 }
442
443 return true;
444}
445
Luis R. Rodriguez038659e2009-05-02 00:37:17 -0400446static bool reg_does_bw_fit(const struct ieee80211_freq_range *freq_range,
447 u32 center_freq_khz,
448 u32 bw_khz)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700449{
Luis R. Rodriguez038659e2009-05-02 00:37:17 -0400450 u32 start_freq_khz, end_freq_khz;
451
452 start_freq_khz = center_freq_khz - (bw_khz/2);
453 end_freq_khz = center_freq_khz + (bw_khz/2);
454
455 if (start_freq_khz >= freq_range->start_freq_khz &&
456 end_freq_khz <= freq_range->end_freq_khz)
457 return true;
458
459 return false;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700460}
461
Luis R. Rodriguez0c7dc452009-01-07 17:43:36 -0800462/**
463 * freq_in_rule_band - tells us if a frequency is in a frequency band
464 * @freq_range: frequency rule we want to query
465 * @freq_khz: frequency we are inquiring about
466 *
467 * This lets us know if a specific frequency rule is or is not relevant to
468 * a specific frequency's band. Bands are device specific and artificial
469 * definitions (the "2.4 GHz band" and the "5 GHz band"), however it is
470 * safe for now to assume that a frequency rule should not be part of a
471 * frequency's band if the start freq or end freq are off by more than 2 GHz.
472 * This resolution can be lowered and should be considered as we add
473 * regulatory rule support for other "bands".
474 **/
475static bool freq_in_rule_band(const struct ieee80211_freq_range *freq_range,
476 u32 freq_khz)
477{
478#define ONE_GHZ_IN_KHZ 1000000
479 if (abs(freq_khz - freq_range->start_freq_khz) <= (2 * ONE_GHZ_IN_KHZ))
480 return true;
481 if (abs(freq_khz - freq_range->end_freq_khz) <= (2 * ONE_GHZ_IN_KHZ))
482 return true;
483 return false;
484#undef ONE_GHZ_IN_KHZ
485}
486
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500487/*
488 * Converts a country IE to a regulatory domain. A regulatory domain
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -0800489 * structure has a lot of information which the IE doesn't yet have,
490 * so for the other values we use upper max values as we will intersect
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500491 * with our userspace regulatory agent to get lower bounds.
492 */
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -0800493static struct ieee80211_regdomain *country_ie_2_rd(
494 u8 *country_ie,
495 u8 country_ie_len,
496 u32 *checksum)
497{
498 struct ieee80211_regdomain *rd = NULL;
499 unsigned int i = 0;
500 char alpha2[2];
501 u32 flags = 0;
502 u32 num_rules = 0, size_of_regd = 0;
503 u8 *triplets_start = NULL;
504 u8 len_at_triplet = 0;
505 /* the last channel we have registered in a subband (triplet) */
506 int last_sub_max_channel = 0;
507
508 *checksum = 0xDEADBEEF;
509
510 /* Country IE requirements */
511 BUG_ON(country_ie_len < IEEE80211_COUNTRY_IE_MIN_LEN ||
512 country_ie_len & 0x01);
513
514 alpha2[0] = country_ie[0];
515 alpha2[1] = country_ie[1];
516
517 /*
518 * Third octet can be:
519 * 'I' - Indoor
520 * 'O' - Outdoor
521 *
522 * anything else we assume is no restrictions
523 */
524 if (country_ie[2] == 'I')
525 flags = NL80211_RRF_NO_OUTDOOR;
526 else if (country_ie[2] == 'O')
527 flags = NL80211_RRF_NO_INDOOR;
528
529 country_ie += 3;
530 country_ie_len -= 3;
531
532 triplets_start = country_ie;
533 len_at_triplet = country_ie_len;
534
535 *checksum ^= ((flags ^ alpha2[0] ^ alpha2[1]) << 8);
536
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500537 /*
538 * We need to build a reg rule for each triplet, but first we must
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -0800539 * calculate the number of reg rules we will need. We will need one
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500540 * for each channel subband
541 */
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -0800542 while (country_ie_len >= 3) {
Luis R. Rodriguez615aab42009-01-22 15:05:46 -0800543 int end_channel = 0;
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -0800544 struct ieee80211_country_ie_triplet *triplet =
545 (struct ieee80211_country_ie_triplet *) country_ie;
546 int cur_sub_max_channel = 0, cur_channel = 0;
547
548 if (triplet->ext.reg_extension_id >=
549 IEEE80211_COUNTRY_EXTENSION_ID) {
550 country_ie += 3;
551 country_ie_len -= 3;
552 continue;
553 }
554
Luis R. Rodriguez615aab42009-01-22 15:05:46 -0800555 /* 2 GHz */
556 if (triplet->chans.first_channel <= 14)
557 end_channel = triplet->chans.first_channel +
558 triplet->chans.num_channels;
559 else
560 /*
561 * 5 GHz -- For example in country IEs if the first
562 * channel given is 36 and the number of channels is 4
563 * then the individual channel numbers defined for the
564 * 5 GHz PHY by these parameters are: 36, 40, 44, and 48
565 * and not 36, 37, 38, 39.
566 *
567 * See: http://tinyurl.com/11d-clarification
568 */
569 end_channel = triplet->chans.first_channel +
570 (4 * (triplet->chans.num_channels - 1));
571
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -0800572 cur_channel = triplet->chans.first_channel;
Luis R. Rodriguez615aab42009-01-22 15:05:46 -0800573 cur_sub_max_channel = end_channel;
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -0800574
575 /* Basic sanity check */
576 if (cur_sub_max_channel < cur_channel)
577 return NULL;
578
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500579 /*
580 * Do not allow overlapping channels. Also channels
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -0800581 * passed in each subband must be monotonically
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500582 * increasing
583 */
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -0800584 if (last_sub_max_channel) {
585 if (cur_channel <= last_sub_max_channel)
586 return NULL;
587 if (cur_sub_max_channel <= last_sub_max_channel)
588 return NULL;
589 }
590
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500591 /*
592 * When dot11RegulatoryClassesRequired is supported
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -0800593 * we can throw ext triplets as part of this soup,
594 * for now we don't care when those change as we
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500595 * don't support them
596 */
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -0800597 *checksum ^= ((cur_channel ^ cur_sub_max_channel) << 8) |
598 ((cur_sub_max_channel ^ cur_sub_max_channel) << 16) |
599 ((triplet->chans.max_power ^ cur_sub_max_channel) << 24);
600
601 last_sub_max_channel = cur_sub_max_channel;
602
603 country_ie += 3;
604 country_ie_len -= 3;
605 num_rules++;
606
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500607 /*
608 * Note: this is not a IEEE requirement but
609 * simply a memory requirement
610 */
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -0800611 if (num_rules > NL80211_MAX_SUPP_REG_RULES)
612 return NULL;
613 }
614
615 country_ie = triplets_start;
616 country_ie_len = len_at_triplet;
617
618 size_of_regd = sizeof(struct ieee80211_regdomain) +
619 (num_rules * sizeof(struct ieee80211_reg_rule));
620
621 rd = kzalloc(size_of_regd, GFP_KERNEL);
622 if (!rd)
623 return NULL;
624
625 rd->n_reg_rules = num_rules;
626 rd->alpha2[0] = alpha2[0];
627 rd->alpha2[1] = alpha2[1];
628
629 /* This time around we fill in the rd */
630 while (country_ie_len >= 3) {
Luis R. Rodriguez02e68a32009-01-07 17:43:37 -0800631 int end_channel = 0;
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -0800632 struct ieee80211_country_ie_triplet *triplet =
633 (struct ieee80211_country_ie_triplet *) country_ie;
634 struct ieee80211_reg_rule *reg_rule = NULL;
635 struct ieee80211_freq_range *freq_range = NULL;
636 struct ieee80211_power_rule *power_rule = NULL;
637
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500638 /*
639 * Must parse if dot11RegulatoryClassesRequired is true,
640 * we don't support this yet
641 */
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -0800642 if (triplet->ext.reg_extension_id >=
643 IEEE80211_COUNTRY_EXTENSION_ID) {
644 country_ie += 3;
645 country_ie_len -= 3;
646 continue;
647 }
648
649 reg_rule = &rd->reg_rules[i];
650 freq_range = &reg_rule->freq_range;
651 power_rule = &reg_rule->power_rule;
652
653 reg_rule->flags = flags;
654
Luis R. Rodriguez02e68a32009-01-07 17:43:37 -0800655 /* 2 GHz */
656 if (triplet->chans.first_channel <= 14)
657 end_channel = triplet->chans.first_channel +
658 triplet->chans.num_channels;
659 else
Luis R. Rodriguez02e68a32009-01-07 17:43:37 -0800660 end_channel = triplet->chans.first_channel +
661 (4 * (triplet->chans.num_channels - 1));
662
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500663 /*
664 * The +10 is since the regulatory domain expects
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -0800665 * the actual band edge, not the center of freq for
666 * its start and end freqs, assuming 20 MHz bandwidth on
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500667 * the channels passed
668 */
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -0800669 freq_range->start_freq_khz =
670 MHZ_TO_KHZ(ieee80211_channel_to_frequency(
671 triplet->chans.first_channel) - 10);
672 freq_range->end_freq_khz =
673 MHZ_TO_KHZ(ieee80211_channel_to_frequency(
Luis R. Rodriguez02e68a32009-01-07 17:43:37 -0800674 end_channel) + 10);
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -0800675
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500676 /*
677 * These are large arbitrary values we use to intersect later.
678 * Increment this if we ever support >= 40 MHz channels
679 * in IEEE 802.11
680 */
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -0800681 freq_range->max_bandwidth_khz = MHZ_TO_KHZ(40);
682 power_rule->max_antenna_gain = DBI_TO_MBI(100);
683 power_rule->max_eirp = DBM_TO_MBM(100);
684
685 country_ie += 3;
686 country_ie_len -= 3;
687 i++;
688
689 BUG_ON(i > NL80211_MAX_SUPP_REG_RULES);
690 }
691
692 return rd;
693}
694
695
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500696/*
697 * Helper for regdom_intersect(), this does the real
698 * mathematical intersection fun
699 */
Luis R. Rodriguez9c964772008-10-30 13:33:53 -0700700static int reg_rules_intersect(
701 const struct ieee80211_reg_rule *rule1,
702 const struct ieee80211_reg_rule *rule2,
703 struct ieee80211_reg_rule *intersected_rule)
704{
705 const struct ieee80211_freq_range *freq_range1, *freq_range2;
706 struct ieee80211_freq_range *freq_range;
707 const struct ieee80211_power_rule *power_rule1, *power_rule2;
708 struct ieee80211_power_rule *power_rule;
709 u32 freq_diff;
710
711 freq_range1 = &rule1->freq_range;
712 freq_range2 = &rule2->freq_range;
713 freq_range = &intersected_rule->freq_range;
714
715 power_rule1 = &rule1->power_rule;
716 power_rule2 = &rule2->power_rule;
717 power_rule = &intersected_rule->power_rule;
718
719 freq_range->start_freq_khz = max(freq_range1->start_freq_khz,
720 freq_range2->start_freq_khz);
721 freq_range->end_freq_khz = min(freq_range1->end_freq_khz,
722 freq_range2->end_freq_khz);
723 freq_range->max_bandwidth_khz = min(freq_range1->max_bandwidth_khz,
724 freq_range2->max_bandwidth_khz);
725
726 freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
727 if (freq_range->max_bandwidth_khz > freq_diff)
728 freq_range->max_bandwidth_khz = freq_diff;
729
730 power_rule->max_eirp = min(power_rule1->max_eirp,
731 power_rule2->max_eirp);
732 power_rule->max_antenna_gain = min(power_rule1->max_antenna_gain,
733 power_rule2->max_antenna_gain);
734
735 intersected_rule->flags = (rule1->flags | rule2->flags);
736
737 if (!is_valid_reg_rule(intersected_rule))
738 return -EINVAL;
739
740 return 0;
741}
742
743/**
744 * regdom_intersect - do the intersection between two regulatory domains
745 * @rd1: first regulatory domain
746 * @rd2: second regulatory domain
747 *
748 * Use this function to get the intersection between two regulatory domains.
749 * Once completed we will mark the alpha2 for the rd as intersected, "98",
750 * as no one single alpha2 can represent this regulatory domain.
751 *
752 * Returns a pointer to the regulatory domain structure which will hold the
753 * resulting intersection of rules between rd1 and rd2. We will
754 * kzalloc() this structure for you.
755 */
756static struct ieee80211_regdomain *regdom_intersect(
757 const struct ieee80211_regdomain *rd1,
758 const struct ieee80211_regdomain *rd2)
759{
760 int r, size_of_regd;
761 unsigned int x, y;
762 unsigned int num_rules = 0, rule_idx = 0;
763 const struct ieee80211_reg_rule *rule1, *rule2;
764 struct ieee80211_reg_rule *intersected_rule;
765 struct ieee80211_regdomain *rd;
766 /* This is just a dummy holder to help us count */
767 struct ieee80211_reg_rule irule;
768
769 /* Uses the stack temporarily for counter arithmetic */
770 intersected_rule = &irule;
771
772 memset(intersected_rule, 0, sizeof(struct ieee80211_reg_rule));
773
774 if (!rd1 || !rd2)
775 return NULL;
776
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500777 /*
778 * First we get a count of the rules we'll need, then we actually
Luis R. Rodriguez9c964772008-10-30 13:33:53 -0700779 * build them. This is to so we can malloc() and free() a
780 * regdomain once. The reason we use reg_rules_intersect() here
781 * is it will return -EINVAL if the rule computed makes no sense.
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500782 * All rules that do check out OK are valid.
783 */
Luis R. Rodriguez9c964772008-10-30 13:33:53 -0700784
785 for (x = 0; x < rd1->n_reg_rules; x++) {
786 rule1 = &rd1->reg_rules[x];
787 for (y = 0; y < rd2->n_reg_rules; y++) {
788 rule2 = &rd2->reg_rules[y];
789 if (!reg_rules_intersect(rule1, rule2,
790 intersected_rule))
791 num_rules++;
792 memset(intersected_rule, 0,
793 sizeof(struct ieee80211_reg_rule));
794 }
795 }
796
797 if (!num_rules)
798 return NULL;
799
800 size_of_regd = sizeof(struct ieee80211_regdomain) +
801 ((num_rules + 1) * sizeof(struct ieee80211_reg_rule));
802
803 rd = kzalloc(size_of_regd, GFP_KERNEL);
804 if (!rd)
805 return NULL;
806
807 for (x = 0; x < rd1->n_reg_rules; x++) {
808 rule1 = &rd1->reg_rules[x];
809 for (y = 0; y < rd2->n_reg_rules; y++) {
810 rule2 = &rd2->reg_rules[y];
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500811 /*
812 * This time around instead of using the stack lets
Luis R. Rodriguez9c964772008-10-30 13:33:53 -0700813 * write to the target rule directly saving ourselves
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500814 * a memcpy()
815 */
Luis R. Rodriguez9c964772008-10-30 13:33:53 -0700816 intersected_rule = &rd->reg_rules[rule_idx];
817 r = reg_rules_intersect(rule1, rule2,
818 intersected_rule);
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500819 /*
820 * No need to memset here the intersected rule here as
821 * we're not using the stack anymore
822 */
Luis R. Rodriguez9c964772008-10-30 13:33:53 -0700823 if (r)
824 continue;
825 rule_idx++;
826 }
827 }
828
829 if (rule_idx != num_rules) {
830 kfree(rd);
831 return NULL;
832 }
833
834 rd->n_reg_rules = num_rules;
835 rd->alpha2[0] = '9';
836 rd->alpha2[1] = '8';
837
838 return rd;
839}
840
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500841/*
842 * XXX: add support for the rest of enum nl80211_reg_rule_flags, we may
843 * want to just have the channel structure use these
844 */
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700845static u32 map_regdom_flags(u32 rd_flags)
846{
847 u32 channel_flags = 0;
848 if (rd_flags & NL80211_RRF_PASSIVE_SCAN)
849 channel_flags |= IEEE80211_CHAN_PASSIVE_SCAN;
850 if (rd_flags & NL80211_RRF_NO_IBSS)
851 channel_flags |= IEEE80211_CHAN_NO_IBSS;
852 if (rd_flags & NL80211_RRF_DFS)
853 channel_flags |= IEEE80211_CHAN_RADAR;
854 return channel_flags;
855}
856
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -0800857static int freq_reg_info_regd(struct wiphy *wiphy,
858 u32 center_freq,
Luis R. Rodriguez038659e2009-05-02 00:37:17 -0400859 u32 desired_bw_khz,
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -0800860 const struct ieee80211_reg_rule **reg_rule,
861 const struct ieee80211_regdomain *custom_regd)
Johannes Berg8318d782008-01-24 19:38:38 +0100862{
863 int i;
Luis R. Rodriguez0c7dc452009-01-07 17:43:36 -0800864 bool band_rule_found = false;
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -0800865 const struct ieee80211_regdomain *regd;
Luis R. Rodriguez038659e2009-05-02 00:37:17 -0400866 bool bw_fits = false;
867
868 if (!desired_bw_khz)
869 desired_bw_khz = MHZ_TO_KHZ(20);
Johannes Berg8318d782008-01-24 19:38:38 +0100870
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -0800871 regd = custom_regd ? custom_regd : cfg80211_regdomain;
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -0800872
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500873 /*
874 * Follow the driver's regulatory domain, if present, unless a country
875 * IE has been processed or a user wants to help complaince further
876 */
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -0400877 if (last_request->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
878 last_request->initiator != NL80211_REGDOM_SET_BY_USER &&
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -0800879 wiphy->regd)
880 regd = wiphy->regd;
881
882 if (!regd)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700883 return -EINVAL;
884
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -0800885 for (i = 0; i < regd->n_reg_rules; i++) {
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700886 const struct ieee80211_reg_rule *rr;
887 const struct ieee80211_freq_range *fr = NULL;
888 const struct ieee80211_power_rule *pr = NULL;
889
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -0800890 rr = &regd->reg_rules[i];
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700891 fr = &rr->freq_range;
892 pr = &rr->power_rule;
Luis R. Rodriguez0c7dc452009-01-07 17:43:36 -0800893
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500894 /*
895 * We only need to know if one frequency rule was
Luis R. Rodriguez0c7dc452009-01-07 17:43:36 -0800896 * was in center_freq's band, that's enough, so lets
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500897 * not overwrite it once found
898 */
Luis R. Rodriguez0c7dc452009-01-07 17:43:36 -0800899 if (!band_rule_found)
900 band_rule_found = freq_in_rule_band(fr, center_freq);
901
Luis R. Rodriguez038659e2009-05-02 00:37:17 -0400902 bw_fits = reg_does_bw_fit(fr,
903 center_freq,
904 desired_bw_khz);
Luis R. Rodriguez0c7dc452009-01-07 17:43:36 -0800905
Luis R. Rodriguez038659e2009-05-02 00:37:17 -0400906 if (band_rule_found && bw_fits) {
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700907 *reg_rule = rr;
Luis R. Rodriguez038659e2009-05-02 00:37:17 -0400908 return 0;
Johannes Berg8318d782008-01-24 19:38:38 +0100909 }
910 }
911
Luis R. Rodriguez0c7dc452009-01-07 17:43:36 -0800912 if (!band_rule_found)
913 return -ERANGE;
914
Luis R. Rodriguez038659e2009-05-02 00:37:17 -0400915 return -EINVAL;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700916}
Luis R. Rodriguez34f57342009-01-22 15:05:45 -0800917EXPORT_SYMBOL(freq_reg_info);
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700918
Luis R. Rodriguez038659e2009-05-02 00:37:17 -0400919int freq_reg_info(struct wiphy *wiphy,
920 u32 center_freq,
921 u32 desired_bw_khz,
922 const struct ieee80211_reg_rule **reg_rule)
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -0800923{
Luis R. Rodriguezac46d482009-05-01 18:44:50 -0400924 assert_cfg80211_lock();
Luis R. Rodriguez038659e2009-05-02 00:37:17 -0400925 return freq_reg_info_regd(wiphy,
926 center_freq,
927 desired_bw_khz,
928 reg_rule,
929 NULL);
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -0800930}
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700931
Luis R. Rodriguez038659e2009-05-02 00:37:17 -0400932/*
933 * Note that right now we assume the desired channel bandwidth
934 * is always 20 MHz for each individual channel (HT40 uses 20 MHz
935 * per channel, the primary and the extension channel). To support
936 * smaller custom bandwidths such as 5 MHz or 10 MHz we'll need a
937 * new ieee80211_channel.target_bw and re run the regulatory check
938 * on the wiphy with the target_bw specified. Then we can simply use
939 * that below for the desired_bw_khz below.
940 */
Luis R. Rodrigueza92a3ce2009-01-07 17:43:33 -0800941static void handle_channel(struct wiphy *wiphy, enum ieee80211_band band,
942 unsigned int chan_idx)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700943{
944 int r;
Luis R. Rodriguez038659e2009-05-02 00:37:17 -0400945 u32 flags, bw_flags = 0;
946 u32 desired_bw_khz = MHZ_TO_KHZ(20);
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700947 const struct ieee80211_reg_rule *reg_rule = NULL;
948 const struct ieee80211_power_rule *power_rule = NULL;
Luis R. Rodriguez038659e2009-05-02 00:37:17 -0400949 const struct ieee80211_freq_range *freq_range = NULL;
Luis R. Rodrigueza92a3ce2009-01-07 17:43:33 -0800950 struct ieee80211_supported_band *sband;
951 struct ieee80211_channel *chan;
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -0500952 struct wiphy *request_wiphy = NULL;
Luis R. Rodrigueza92a3ce2009-01-07 17:43:33 -0800953
Luis R. Rodriguez761cf7e2009-02-21 00:04:25 -0500954 assert_cfg80211_lock();
955
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -0500956 request_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);
957
Luis R. Rodrigueza92a3ce2009-01-07 17:43:33 -0800958 sband = wiphy->bands[band];
959 BUG_ON(chan_idx >= sband->n_channels);
960 chan = &sband->channels[chan_idx];
961
962 flags = chan->orig_flags;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700963
Luis R. Rodriguez038659e2009-05-02 00:37:17 -0400964 r = freq_reg_info(wiphy,
965 MHZ_TO_KHZ(chan->center_freq),
966 desired_bw_khz,
967 &reg_rule);
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -0700968
969 if (r) {
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500970 /*
971 * This means no regulatory rule was found in the country IE
Luis R. Rodriguez0c7dc452009-01-07 17:43:36 -0800972 * with a frequency range on the center_freq's band, since
973 * IEEE-802.11 allows for a country IE to have a subset of the
974 * regulatory information provided in a country we ignore
975 * disabling the channel unless at least one reg rule was
976 * found on the center_freq's band. For details see this
977 * clarification:
978 *
979 * http://tinyurl.com/11d-clarification
980 */
981 if (r == -ERANGE &&
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -0400982 last_request->initiator ==
983 NL80211_REGDOM_SET_BY_COUNTRY_IE) {
Luis R. Rodriguez4113f752010-01-04 11:50:11 -0500984 REG_DBG_PRINT("cfg80211: Leaving channel %d MHz "
Luis R. Rodriguez0c7dc452009-01-07 17:43:36 -0800985 "intact on %s - no rule found in band on "
986 "Country IE\n",
Luis R. Rodriguez4113f752010-01-04 11:50:11 -0500987 chan->center_freq, wiphy_name(wiphy));
Luis R. Rodriguez0c7dc452009-01-07 17:43:36 -0800988 } else {
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -0500989 /*
990 * In this case we know the country IE has at least one reg rule
991 * for the band so we respect its band definitions
992 */
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -0400993 if (last_request->initiator ==
994 NL80211_REGDOM_SET_BY_COUNTRY_IE)
Luis R. Rodriguez4113f752010-01-04 11:50:11 -0500995 REG_DBG_PRINT("cfg80211: Disabling "
Luis R. Rodriguez0c7dc452009-01-07 17:43:36 -0800996 "channel %d MHz on %s due to "
997 "Country IE\n",
998 chan->center_freq, wiphy_name(wiphy));
Luis R. Rodriguez0c7dc452009-01-07 17:43:36 -0800999 flags |= IEEE80211_CHAN_DISABLED;
1000 chan->flags = flags;
1001 }
Johannes Berg8318d782008-01-24 19:38:38 +01001002 return;
1003 }
1004
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001005 power_rule = &reg_rule->power_rule;
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001006 freq_range = &reg_rule->freq_range;
1007
1008 if (freq_range->max_bandwidth_khz < MHZ_TO_KHZ(40))
1009 bw_flags = IEEE80211_CHAN_NO_HT40;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001010
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001011 if (last_request->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -05001012 request_wiphy && request_wiphy == wiphy &&
Johannes Berg5be83de2009-11-19 00:56:28 +01001013 request_wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY) {
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05001014 /*
1015 * This gaurantees the driver's requested regulatory domain
Luis R. Rodriguezf9763762009-01-22 15:05:52 -08001016 * will always be used as a base for further regulatory
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05001017 * settings
1018 */
Luis R. Rodriguezf9763762009-01-22 15:05:52 -08001019 chan->flags = chan->orig_flags =
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001020 map_regdom_flags(reg_rule->flags) | bw_flags;
Luis R. Rodriguezf9763762009-01-22 15:05:52 -08001021 chan->max_antenna_gain = chan->orig_mag =
1022 (int) MBI_TO_DBI(power_rule->max_antenna_gain);
Luis R. Rodriguezf9763762009-01-22 15:05:52 -08001023 chan->max_power = chan->orig_mpwr =
1024 (int) MBM_TO_DBM(power_rule->max_eirp);
1025 return;
1026 }
1027
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001028 chan->flags = flags | bw_flags | map_regdom_flags(reg_rule->flags);
Johannes Berg8318d782008-01-24 19:38:38 +01001029 chan->max_antenna_gain = min(chan->orig_mag,
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001030 (int) MBI_TO_DBI(power_rule->max_antenna_gain));
John W. Linville253898c2008-04-03 15:32:54 -04001031 if (chan->orig_mpwr)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001032 chan->max_power = min(chan->orig_mpwr,
1033 (int) MBM_TO_DBM(power_rule->max_eirp));
John W. Linville253898c2008-04-03 15:32:54 -04001034 else
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001035 chan->max_power = (int) MBM_TO_DBM(power_rule->max_eirp);
Johannes Berg8318d782008-01-24 19:38:38 +01001036}
1037
Luis R. Rodrigueza92a3ce2009-01-07 17:43:33 -08001038static void handle_band(struct wiphy *wiphy, enum ieee80211_band band)
Johannes Berg8318d782008-01-24 19:38:38 +01001039{
Luis R. Rodrigueza92a3ce2009-01-07 17:43:33 -08001040 unsigned int i;
1041 struct ieee80211_supported_band *sband;
1042
1043 BUG_ON(!wiphy->bands[band]);
1044 sband = wiphy->bands[band];
Johannes Berg8318d782008-01-24 19:38:38 +01001045
1046 for (i = 0; i < sband->n_channels; i++)
Luis R. Rodrigueza92a3ce2009-01-07 17:43:33 -08001047 handle_channel(wiphy, band, i);
Johannes Berg8318d782008-01-24 19:38:38 +01001048}
1049
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001050static bool ignore_reg_update(struct wiphy *wiphy,
1051 enum nl80211_reg_initiator initiator)
Luis R. Rodriguez14b98152008-11-12 14:22:03 -08001052{
1053 if (!last_request)
1054 return true;
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001055 if (initiator == NL80211_REGDOM_SET_BY_CORE &&
Johannes Berg5be83de2009-11-19 00:56:28 +01001056 wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY)
Luis R. Rodriguez14b98152008-11-12 14:22:03 -08001057 return true;
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05001058 /*
1059 * wiphy->regd will be set once the device has its own
1060 * desired regulatory domain set
1061 */
Johannes Berg5be83de2009-11-19 00:56:28 +01001062 if (wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY && !wiphy->regd &&
Luis R. Rodriguezf9763762009-01-22 15:05:52 -08001063 !is_world_regdom(last_request->alpha2))
Luis R. Rodriguez14b98152008-11-12 14:22:03 -08001064 return true;
1065 return false;
1066}
1067
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001068static void update_all_wiphy_regulatory(enum nl80211_reg_initiator initiator)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001069{
Johannes Berg79c97e92009-07-07 03:56:12 +02001070 struct cfg80211_registered_device *rdev;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001071
Johannes Berg79c97e92009-07-07 03:56:12 +02001072 list_for_each_entry(rdev, &cfg80211_rdev_list, list)
1073 wiphy_update_regulatory(&rdev->wiphy, initiator);
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001074}
1075
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001076static void handle_reg_beacon(struct wiphy *wiphy,
1077 unsigned int chan_idx,
1078 struct reg_beacon *reg_beacon)
1079{
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001080 struct ieee80211_supported_band *sband;
1081 struct ieee80211_channel *chan;
Luis R. Rodriguez6bad8762009-04-02 14:08:09 -04001082 bool channel_changed = false;
1083 struct ieee80211_channel chan_before;
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001084
1085 assert_cfg80211_lock();
1086
1087 sband = wiphy->bands[reg_beacon->chan.band];
1088 chan = &sband->channels[chan_idx];
1089
1090 if (likely(chan->center_freq != reg_beacon->chan.center_freq))
1091 return;
1092
Luis R. Rodriguez6bad8762009-04-02 14:08:09 -04001093 if (chan->beacon_found)
1094 return;
1095
1096 chan->beacon_found = true;
1097
Johannes Berg5be83de2009-11-19 00:56:28 +01001098 if (wiphy->flags & WIPHY_FLAG_DISABLE_BEACON_HINTS)
Luis R. Rodriguez37184242009-07-30 17:43:48 -07001099 return;
1100
Luis R. Rodriguez6bad8762009-04-02 14:08:09 -04001101 chan_before.center_freq = chan->center_freq;
1102 chan_before.flags = chan->flags;
1103
Luis R. Rodriguez37184242009-07-30 17:43:48 -07001104 if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN) {
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001105 chan->flags &= ~IEEE80211_CHAN_PASSIVE_SCAN;
Luis R. Rodriguez6bad8762009-04-02 14:08:09 -04001106 channel_changed = true;
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001107 }
1108
Luis R. Rodriguez37184242009-07-30 17:43:48 -07001109 if (chan->flags & IEEE80211_CHAN_NO_IBSS) {
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001110 chan->flags &= ~IEEE80211_CHAN_NO_IBSS;
Luis R. Rodriguez6bad8762009-04-02 14:08:09 -04001111 channel_changed = true;
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001112 }
1113
Luis R. Rodriguez6bad8762009-04-02 14:08:09 -04001114 if (channel_changed)
1115 nl80211_send_beacon_hint_event(wiphy, &chan_before, chan);
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001116}
1117
1118/*
1119 * Called when a scan on a wiphy finds a beacon on
1120 * new channel
1121 */
1122static void wiphy_update_new_beacon(struct wiphy *wiphy,
1123 struct reg_beacon *reg_beacon)
1124{
1125 unsigned int i;
1126 struct ieee80211_supported_band *sband;
1127
1128 assert_cfg80211_lock();
1129
1130 if (!wiphy->bands[reg_beacon->chan.band])
1131 return;
1132
1133 sband = wiphy->bands[reg_beacon->chan.band];
1134
1135 for (i = 0; i < sband->n_channels; i++)
1136 handle_reg_beacon(wiphy, i, reg_beacon);
1137}
1138
1139/*
1140 * Called upon reg changes or a new wiphy is added
1141 */
1142static void wiphy_update_beacon_reg(struct wiphy *wiphy)
1143{
1144 unsigned int i;
1145 struct ieee80211_supported_band *sband;
1146 struct reg_beacon *reg_beacon;
1147
1148 assert_cfg80211_lock();
1149
1150 if (list_empty(&reg_beacon_list))
1151 return;
1152
1153 list_for_each_entry(reg_beacon, &reg_beacon_list, list) {
1154 if (!wiphy->bands[reg_beacon->chan.band])
1155 continue;
1156 sband = wiphy->bands[reg_beacon->chan.band];
1157 for (i = 0; i < sband->n_channels; i++)
1158 handle_reg_beacon(wiphy, i, reg_beacon);
1159 }
1160}
1161
1162static bool reg_is_world_roaming(struct wiphy *wiphy)
1163{
1164 if (is_world_regdom(cfg80211_regdomain->alpha2) ||
1165 (wiphy->regd && is_world_regdom(wiphy->regd->alpha2)))
1166 return true;
Luis R. Rodriguezb1ed8dd2009-05-02 00:34:15 -04001167 if (last_request &&
1168 last_request->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
Johannes Berg5be83de2009-11-19 00:56:28 +01001169 wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY)
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001170 return true;
1171 return false;
1172}
1173
1174/* Reap the advantages of previously found beacons */
1175static void reg_process_beacons(struct wiphy *wiphy)
1176{
Luis R. Rodriguezb1ed8dd2009-05-02 00:34:15 -04001177 /*
1178 * Means we are just firing up cfg80211, so no beacons would
1179 * have been processed yet.
1180 */
1181 if (!last_request)
1182 return;
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001183 if (!reg_is_world_roaming(wiphy))
1184 return;
1185 wiphy_update_beacon_reg(wiphy);
1186}
1187
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001188static bool is_ht40_not_allowed(struct ieee80211_channel *chan)
1189{
1190 if (!chan)
1191 return true;
1192 if (chan->flags & IEEE80211_CHAN_DISABLED)
1193 return true;
1194 /* This would happen when regulatory rules disallow HT40 completely */
1195 if (IEEE80211_CHAN_NO_HT40 == (chan->flags & (IEEE80211_CHAN_NO_HT40)))
1196 return true;
1197 return false;
1198}
1199
1200static void reg_process_ht_flags_channel(struct wiphy *wiphy,
1201 enum ieee80211_band band,
1202 unsigned int chan_idx)
1203{
1204 struct ieee80211_supported_band *sband;
1205 struct ieee80211_channel *channel;
1206 struct ieee80211_channel *channel_before = NULL, *channel_after = NULL;
1207 unsigned int i;
1208
1209 assert_cfg80211_lock();
1210
1211 sband = wiphy->bands[band];
1212 BUG_ON(chan_idx >= sband->n_channels);
1213 channel = &sband->channels[chan_idx];
1214
1215 if (is_ht40_not_allowed(channel)) {
1216 channel->flags |= IEEE80211_CHAN_NO_HT40;
1217 return;
1218 }
1219
1220 /*
1221 * We need to ensure the extension channels exist to
1222 * be able to use HT40- or HT40+, this finds them (or not)
1223 */
1224 for (i = 0; i < sband->n_channels; i++) {
1225 struct ieee80211_channel *c = &sband->channels[i];
1226 if (c->center_freq == (channel->center_freq - 20))
1227 channel_before = c;
1228 if (c->center_freq == (channel->center_freq + 20))
1229 channel_after = c;
1230 }
1231
1232 /*
1233 * Please note that this assumes target bandwidth is 20 MHz,
1234 * if that ever changes we also need to change the below logic
1235 * to include that as well.
1236 */
1237 if (is_ht40_not_allowed(channel_before))
Luis R. Rodriguez689da1b2009-05-02 00:37:18 -04001238 channel->flags |= IEEE80211_CHAN_NO_HT40MINUS;
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001239 else
Luis R. Rodriguez689da1b2009-05-02 00:37:18 -04001240 channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001241
1242 if (is_ht40_not_allowed(channel_after))
Luis R. Rodriguez689da1b2009-05-02 00:37:18 -04001243 channel->flags |= IEEE80211_CHAN_NO_HT40PLUS;
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001244 else
Luis R. Rodriguez689da1b2009-05-02 00:37:18 -04001245 channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001246}
1247
1248static void reg_process_ht_flags_band(struct wiphy *wiphy,
1249 enum ieee80211_band band)
1250{
1251 unsigned int i;
1252 struct ieee80211_supported_band *sband;
1253
1254 BUG_ON(!wiphy->bands[band]);
1255 sband = wiphy->bands[band];
1256
1257 for (i = 0; i < sband->n_channels; i++)
1258 reg_process_ht_flags_channel(wiphy, band, i);
1259}
1260
1261static void reg_process_ht_flags(struct wiphy *wiphy)
1262{
1263 enum ieee80211_band band;
1264
1265 if (!wiphy)
1266 return;
1267
1268 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1269 if (wiphy->bands[band])
1270 reg_process_ht_flags_band(wiphy, band);
1271 }
1272
1273}
1274
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001275void wiphy_update_regulatory(struct wiphy *wiphy,
1276 enum nl80211_reg_initiator initiator)
Johannes Berg8318d782008-01-24 19:38:38 +01001277{
1278 enum ieee80211_band band;
Luis R. Rodriguezd46e5b12009-01-22 15:05:50 -08001279
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001280 if (ignore_reg_update(wiphy, initiator))
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001281 goto out;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001282 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
Johannes Berg8318d782008-01-24 19:38:38 +01001283 if (wiphy->bands[band])
Luis R. Rodrigueza92a3ce2009-01-07 17:43:33 -08001284 handle_band(wiphy, band);
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001285 }
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001286out:
1287 reg_process_beacons(wiphy);
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001288 reg_process_ht_flags(wiphy);
Luis R. Rodriguez560e28e2009-01-07 17:43:32 -08001289 if (wiphy->reg_notifier)
Luis R. Rodriguez716f9392009-01-22 15:05:51 -08001290 wiphy->reg_notifier(wiphy, last_request);
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001291}
1292
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -08001293static void handle_channel_custom(struct wiphy *wiphy,
1294 enum ieee80211_band band,
1295 unsigned int chan_idx,
1296 const struct ieee80211_regdomain *regd)
1297{
1298 int r;
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001299 u32 desired_bw_khz = MHZ_TO_KHZ(20);
1300 u32 bw_flags = 0;
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -08001301 const struct ieee80211_reg_rule *reg_rule = NULL;
1302 const struct ieee80211_power_rule *power_rule = NULL;
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001303 const struct ieee80211_freq_range *freq_range = NULL;
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -08001304 struct ieee80211_supported_band *sband;
1305 struct ieee80211_channel *chan;
1306
Luis R. Rodriguezabc73812009-07-30 17:38:08 -07001307 assert_reg_lock();
Luis R. Rodriguezac46d482009-05-01 18:44:50 -04001308
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -08001309 sband = wiphy->bands[band];
1310 BUG_ON(chan_idx >= sband->n_channels);
1311 chan = &sband->channels[chan_idx];
1312
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001313 r = freq_reg_info_regd(wiphy,
1314 MHZ_TO_KHZ(chan->center_freq),
1315 desired_bw_khz,
1316 &reg_rule,
1317 regd);
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -08001318
1319 if (r) {
1320 chan->flags = IEEE80211_CHAN_DISABLED;
1321 return;
1322 }
1323
1324 power_rule = &reg_rule->power_rule;
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001325 freq_range = &reg_rule->freq_range;
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -08001326
Luis R. Rodriguez038659e2009-05-02 00:37:17 -04001327 if (freq_range->max_bandwidth_khz < MHZ_TO_KHZ(40))
1328 bw_flags = IEEE80211_CHAN_NO_HT40;
1329
1330 chan->flags |= map_regdom_flags(reg_rule->flags) | bw_flags;
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -08001331 chan->max_antenna_gain = (int) MBI_TO_DBI(power_rule->max_antenna_gain);
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -08001332 chan->max_power = (int) MBM_TO_DBM(power_rule->max_eirp);
1333}
1334
1335static void handle_band_custom(struct wiphy *wiphy, enum ieee80211_band band,
1336 const struct ieee80211_regdomain *regd)
1337{
1338 unsigned int i;
1339 struct ieee80211_supported_band *sband;
1340
1341 BUG_ON(!wiphy->bands[band]);
1342 sband = wiphy->bands[band];
1343
1344 for (i = 0; i < sband->n_channels; i++)
1345 handle_channel_custom(wiphy, band, i, regd);
1346}
1347
1348/* Used by drivers prior to wiphy registration */
1349void wiphy_apply_custom_regulatory(struct wiphy *wiphy,
1350 const struct ieee80211_regdomain *regd)
1351{
1352 enum ieee80211_band band;
Luis R. Rodriguezbbcf3f02009-05-19 17:49:47 -04001353 unsigned int bands_set = 0;
Luis R. Rodriguezac46d482009-05-01 18:44:50 -04001354
Luis R. Rodriguezabc73812009-07-30 17:38:08 -07001355 mutex_lock(&reg_mutex);
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -08001356 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
Luis R. Rodriguezbbcf3f02009-05-19 17:49:47 -04001357 if (!wiphy->bands[band])
1358 continue;
1359 handle_band_custom(wiphy, band, regd);
1360 bands_set++;
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -08001361 }
Luis R. Rodriguezabc73812009-07-30 17:38:08 -07001362 mutex_unlock(&reg_mutex);
Luis R. Rodriguezbbcf3f02009-05-19 17:49:47 -04001363
1364 /*
1365 * no point in calling this if it won't have any effect
1366 * on your device's supportd bands.
1367 */
1368 WARN_ON(!bands_set);
Luis R. Rodriguez1fa25e42009-01-22 15:05:44 -08001369}
1370EXPORT_SYMBOL(wiphy_apply_custom_regulatory);
1371
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05001372/*
1373 * Return value which can be used by ignore_request() to indicate
1374 * it has been determined we should intersect two regulatory domains
1375 */
Luis R. Rodriguez9c964772008-10-30 13:33:53 -07001376#define REG_INTERSECT 1
1377
Johannes Berg84fa4f42008-10-24 20:32:23 +02001378/* This has the logic which determines when a new request
1379 * should be ignored. */
Luis R. Rodriguez2f92cd22009-02-21 00:24:16 -05001380static int ignore_request(struct wiphy *wiphy,
1381 struct regulatory_request *pending_request)
Johannes Berg84fa4f42008-10-24 20:32:23 +02001382{
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -05001383 struct wiphy *last_wiphy = NULL;
Luis R. Rodriguez761cf7e2009-02-21 00:04:25 -05001384
1385 assert_cfg80211_lock();
1386
Johannes Berg84fa4f42008-10-24 20:32:23 +02001387 /* All initial requests are respected */
1388 if (!last_request)
1389 return 0;
1390
Luis R. Rodriguez2f92cd22009-02-21 00:24:16 -05001391 switch (pending_request->initiator) {
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001392 case NL80211_REGDOM_SET_BY_CORE:
Luis R. Rodriguezba25c142009-02-21 00:04:23 -05001393 return -EINVAL;
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001394 case NL80211_REGDOM_SET_BY_COUNTRY_IE:
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -05001395
1396 last_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);
1397
Luis R. Rodriguez2f92cd22009-02-21 00:24:16 -05001398 if (unlikely(!is_an_alpha2(pending_request->alpha2)))
Johannes Berg84fa4f42008-10-24 20:32:23 +02001399 return -EINVAL;
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001400 if (last_request->initiator ==
1401 NL80211_REGDOM_SET_BY_COUNTRY_IE) {
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -05001402 if (last_wiphy != wiphy) {
Johannes Berg84fa4f42008-10-24 20:32:23 +02001403 /*
1404 * Two cards with two APs claiming different
Thadeu Lima de Souza Cascardo1fe90b02009-08-11 11:18:42 -03001405 * Country IE alpha2s. We could
Johannes Berg84fa4f42008-10-24 20:32:23 +02001406 * intersect them, but that seems unlikely
1407 * to be correct. Reject second one for now.
1408 */
Luis R. Rodriguez2f92cd22009-02-21 00:24:16 -05001409 if (regdom_changes(pending_request->alpha2))
Johannes Berg84fa4f42008-10-24 20:32:23 +02001410 return -EOPNOTSUPP;
1411 return -EALREADY;
1412 }
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05001413 /*
1414 * Two consecutive Country IE hints on the same wiphy.
1415 * This should be picked up early by the driver/stack
1416 */
Luis R. Rodriguez2f92cd22009-02-21 00:24:16 -05001417 if (WARN_ON(regdom_changes(pending_request->alpha2)))
Johannes Berg84fa4f42008-10-24 20:32:23 +02001418 return 0;
1419 return -EALREADY;
1420 }
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001421 return REG_INTERSECT;
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001422 case NL80211_REGDOM_SET_BY_DRIVER:
1423 if (last_request->initiator == NL80211_REGDOM_SET_BY_CORE) {
Luis R. Rodriguez2f92cd22009-02-21 00:24:16 -05001424 if (regdom_changes(pending_request->alpha2))
Luis R. Rodrigueze74b1e72009-01-22 15:05:48 -08001425 return 0;
Johannes Berg84fa4f42008-10-24 20:32:23 +02001426 return -EALREADY;
Luis R. Rodrigueze74b1e72009-01-22 15:05:48 -08001427 }
Luis R. Rodriguezfff32c02009-02-21 00:04:32 -05001428
1429 /*
1430 * This would happen if you unplug and plug your card
1431 * back in or if you add a new device for which the previously
1432 * loaded card also agrees on the regulatory domain.
1433 */
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001434 if (last_request->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
Luis R. Rodriguez2f92cd22009-02-21 00:24:16 -05001435 !regdom_changes(pending_request->alpha2))
Luis R. Rodriguezfff32c02009-02-21 00:04:32 -05001436 return -EALREADY;
1437
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08001438 return REG_INTERSECT;
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001439 case NL80211_REGDOM_SET_BY_USER:
1440 if (last_request->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE)
Luis R. Rodriguez9c964772008-10-30 13:33:53 -07001441 return REG_INTERSECT;
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05001442 /*
1443 * If the user knows better the user should set the regdom
1444 * to their country before the IE is picked up
1445 */
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001446 if (last_request->initiator == NL80211_REGDOM_SET_BY_USER &&
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001447 last_request->intersect)
1448 return -EOPNOTSUPP;
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05001449 /*
1450 * Process user requests only after previous user/driver/core
1451 * requests have been processed
1452 */
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001453 if (last_request->initiator == NL80211_REGDOM_SET_BY_CORE ||
1454 last_request->initiator == NL80211_REGDOM_SET_BY_DRIVER ||
1455 last_request->initiator == NL80211_REGDOM_SET_BY_USER) {
Luis R. Rodriguez69b15722009-02-21 00:04:33 -05001456 if (regdom_changes(last_request->alpha2))
Luis R. Rodriguez5eebade2009-01-22 15:05:47 -08001457 return -EAGAIN;
1458 }
1459
John W. Linvillebaeb66f2009-12-18 17:59:02 -05001460 if (!regdom_changes(pending_request->alpha2))
Luis R. Rodrigueze74b1e72009-01-22 15:05:48 -08001461 return -EALREADY;
1462
Johannes Berg84fa4f42008-10-24 20:32:23 +02001463 return 0;
1464 }
1465
1466 return -EINVAL;
1467}
1468
Luis R. Rodriguezd1c96a92009-02-21 00:24:13 -05001469/**
1470 * __regulatory_hint - hint to the wireless core a regulatory domain
1471 * @wiphy: if the hint comes from country information from an AP, this
1472 * is required to be set to the wiphy that received the information
Luis R. Rodriguez28da32d2009-02-21 00:24:14 -05001473 * @pending_request: the regulatory request currently being processed
Luis R. Rodriguezd1c96a92009-02-21 00:24:13 -05001474 *
1475 * The Wireless subsystem can use this function to hint to the wireless core
Luis R. Rodriguez28da32d2009-02-21 00:24:14 -05001476 * what it believes should be the current regulatory domain.
Luis R. Rodriguezd1c96a92009-02-21 00:24:13 -05001477 *
1478 * Returns zero if all went fine, %-EALREADY if a regulatory domain had
1479 * already been set or other standard error codes.
1480 *
Luis R. Rodriguezabc73812009-07-30 17:38:08 -07001481 * Caller must hold &cfg80211_mutex and &reg_mutex
Luis R. Rodriguezd1c96a92009-02-21 00:24:13 -05001482 */
Luis R. Rodriguez28da32d2009-02-21 00:24:14 -05001483static int __regulatory_hint(struct wiphy *wiphy,
1484 struct regulatory_request *pending_request)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001485{
Luis R. Rodriguez9c964772008-10-30 13:33:53 -07001486 bool intersect = false;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001487 int r = 0;
1488
Luis R. Rodriguez761cf7e2009-02-21 00:04:25 -05001489 assert_cfg80211_lock();
1490
Luis R. Rodriguez2f92cd22009-02-21 00:24:16 -05001491 r = ignore_request(wiphy, pending_request);
Luis R. Rodriguez9c964772008-10-30 13:33:53 -07001492
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08001493 if (r == REG_INTERSECT) {
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001494 if (pending_request->initiator ==
1495 NL80211_REGDOM_SET_BY_DRIVER) {
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08001496 r = reg_copy_regd(&wiphy->regd, cfg80211_regdomain);
Luis R. Rodriguezd951c1d2009-02-21 00:24:15 -05001497 if (r) {
1498 kfree(pending_request);
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08001499 return r;
Luis R. Rodriguezd951c1d2009-02-21 00:24:15 -05001500 }
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08001501 }
Luis R. Rodriguez9c964772008-10-30 13:33:53 -07001502 intersect = true;
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08001503 } else if (r) {
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05001504 /*
1505 * If the regulatory domain being requested by the
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08001506 * driver has already been set just copy it to the
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05001507 * wiphy
1508 */
Luis R. Rodriguez28da32d2009-02-21 00:24:14 -05001509 if (r == -EALREADY &&
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001510 pending_request->initiator ==
1511 NL80211_REGDOM_SET_BY_DRIVER) {
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08001512 r = reg_copy_regd(&wiphy->regd, cfg80211_regdomain);
Luis R. Rodriguezd951c1d2009-02-21 00:24:15 -05001513 if (r) {
1514 kfree(pending_request);
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08001515 return r;
Luis R. Rodriguezd951c1d2009-02-21 00:24:15 -05001516 }
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08001517 r = -EALREADY;
1518 goto new_request;
1519 }
Luis R. Rodriguezd951c1d2009-02-21 00:24:15 -05001520 kfree(pending_request);
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001521 return r;
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08001522 }
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001523
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08001524new_request:
Luis R. Rodriguez5203cdb2008-11-12 14:21:56 -08001525 kfree(last_request);
Luis R. Rodriguezd951c1d2009-02-21 00:24:15 -05001526
1527 last_request = pending_request;
1528 last_request->intersect = intersect;
1529
1530 pending_request = NULL;
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08001531
1532 /* When r == REG_INTERSECT we do need to call CRDA */
Luis R. Rodriguez73d54c92009-03-09 22:07:42 -04001533 if (r < 0) {
1534 /*
1535 * Since CRDA will not be called in this case as we already
1536 * have applied the requested regulatory domain before we just
1537 * inform userspace we have processed the request
1538 */
1539 if (r == -EALREADY)
1540 nl80211_send_reg_change_event(last_request);
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08001541 return r;
Luis R. Rodriguez73d54c92009-03-09 22:07:42 -04001542 }
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08001543
Luis R. Rodriguezd951c1d2009-02-21 00:24:15 -05001544 return call_crda(last_request->alpha2);
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001545}
1546
Luis R. Rodriguez30a548c2009-05-02 01:17:27 -04001547/* This processes *all* regulatory hints */
Luis R. Rodriguezd951c1d2009-02-21 00:24:15 -05001548static void reg_process_hint(struct regulatory_request *reg_request)
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001549{
1550 int r = 0;
1551 struct wiphy *wiphy = NULL;
1552
1553 BUG_ON(!reg_request->alpha2);
1554
1555 mutex_lock(&cfg80211_mutex);
Luis R. Rodriguezabc73812009-07-30 17:38:08 -07001556 mutex_lock(&reg_mutex);
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001557
1558 if (wiphy_idx_valid(reg_request->wiphy_idx))
1559 wiphy = wiphy_idx_to_wiphy(reg_request->wiphy_idx);
1560
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001561 if (reg_request->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001562 !wiphy) {
Luis R. Rodriguezd951c1d2009-02-21 00:24:15 -05001563 kfree(reg_request);
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001564 goto out;
1565 }
1566
Luis R. Rodriguez28da32d2009-02-21 00:24:14 -05001567 r = __regulatory_hint(wiphy, reg_request);
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001568 /* This is required so that the orig_* parameters are saved */
Johannes Berg5be83de2009-11-19 00:56:28 +01001569 if (r == -EALREADY && wiphy &&
1570 wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY)
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001571 wiphy_update_regulatory(wiphy, reg_request->initiator);
1572out:
Luis R. Rodriguezabc73812009-07-30 17:38:08 -07001573 mutex_unlock(&reg_mutex);
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001574 mutex_unlock(&cfg80211_mutex);
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001575}
1576
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001577/* Processes regulatory hints, this is all the NL80211_REGDOM_SET_BY_* */
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001578static void reg_process_pending_hints(void)
1579 {
1580 struct regulatory_request *reg_request;
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001581
1582 spin_lock(&reg_requests_lock);
1583 while (!list_empty(&reg_requests_list)) {
1584 reg_request = list_first_entry(&reg_requests_list,
1585 struct regulatory_request,
1586 list);
1587 list_del_init(&reg_request->list);
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001588
Luis R. Rodriguezd951c1d2009-02-21 00:24:15 -05001589 spin_unlock(&reg_requests_lock);
1590 reg_process_hint(reg_request);
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001591 spin_lock(&reg_requests_lock);
1592 }
1593 spin_unlock(&reg_requests_lock);
1594}
1595
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001596/* Processes beacon hints -- this has nothing to do with country IEs */
1597static void reg_process_pending_beacon_hints(void)
1598{
Johannes Berg79c97e92009-07-07 03:56:12 +02001599 struct cfg80211_registered_device *rdev;
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001600 struct reg_beacon *pending_beacon, *tmp;
1601
Luis R. Rodriguezabc73812009-07-30 17:38:08 -07001602 /*
1603 * No need to hold the reg_mutex here as we just touch wiphys
1604 * and do not read or access regulatory variables.
1605 */
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001606 mutex_lock(&cfg80211_mutex);
1607
1608 /* This goes through the _pending_ beacon list */
1609 spin_lock_bh(&reg_pending_beacons_lock);
1610
1611 if (list_empty(&reg_pending_beacons)) {
1612 spin_unlock_bh(&reg_pending_beacons_lock);
1613 goto out;
1614 }
1615
1616 list_for_each_entry_safe(pending_beacon, tmp,
1617 &reg_pending_beacons, list) {
1618
1619 list_del_init(&pending_beacon->list);
1620
1621 /* Applies the beacon hint to current wiphys */
Johannes Berg79c97e92009-07-07 03:56:12 +02001622 list_for_each_entry(rdev, &cfg80211_rdev_list, list)
1623 wiphy_update_new_beacon(&rdev->wiphy, pending_beacon);
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001624
1625 /* Remembers the beacon hint for new wiphys or reg changes */
1626 list_add_tail(&pending_beacon->list, &reg_beacon_list);
1627 }
1628
1629 spin_unlock_bh(&reg_pending_beacons_lock);
1630out:
1631 mutex_unlock(&cfg80211_mutex);
1632}
1633
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001634static void reg_todo(struct work_struct *work)
1635{
1636 reg_process_pending_hints();
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001637 reg_process_pending_beacon_hints();
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001638}
1639
1640static DECLARE_WORK(reg_work, reg_todo);
1641
1642static void queue_regulatory_request(struct regulatory_request *request)
1643{
1644 spin_lock(&reg_requests_lock);
1645 list_add_tail(&request->list, &reg_requests_list);
1646 spin_unlock(&reg_requests_lock);
1647
1648 schedule_work(&reg_work);
1649}
1650
1651/* Core regulatory hint -- happens once during cfg80211_init() */
Luis R. Rodriguezba25c142009-02-21 00:04:23 -05001652static int regulatory_hint_core(const char *alpha2)
1653{
1654 struct regulatory_request *request;
1655
1656 BUG_ON(last_request);
1657
1658 request = kzalloc(sizeof(struct regulatory_request),
1659 GFP_KERNEL);
1660 if (!request)
1661 return -ENOMEM;
1662
1663 request->alpha2[0] = alpha2[0];
1664 request->alpha2[1] = alpha2[1];
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001665 request->initiator = NL80211_REGDOM_SET_BY_CORE;
Luis R. Rodriguezba25c142009-02-21 00:04:23 -05001666
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001667 queue_regulatory_request(request);
Luis R. Rodriguezba25c142009-02-21 00:04:23 -05001668
Luis R. Rodriguez5078b2e2009-05-13 17:04:42 -04001669 /*
1670 * This ensures last_request is populated once modules
1671 * come swinging in and calling regulatory hints and
1672 * wiphy_apply_custom_regulatory().
1673 */
1674 flush_scheduled_work();
1675
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001676 return 0;
Luis R. Rodriguezba25c142009-02-21 00:04:23 -05001677}
1678
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001679/* User hints */
1680int regulatory_hint_user(const char *alpha2)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001681{
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001682 struct regulatory_request *request;
1683
Johannes Bergbe3d4812008-10-24 20:32:21 +02001684 BUG_ON(!alpha2);
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001685
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001686 request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
1687 if (!request)
1688 return -ENOMEM;
1689
1690 request->wiphy_idx = WIPHY_IDX_STALE;
1691 request->alpha2[0] = alpha2[0];
1692 request->alpha2[1] = alpha2[1];
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001693 request->initiator = NL80211_REGDOM_SET_BY_USER,
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001694
1695 queue_regulatory_request(request);
1696
1697 return 0;
1698}
1699
1700/* Driver hints */
1701int regulatory_hint(struct wiphy *wiphy, const char *alpha2)
1702{
1703 struct regulatory_request *request;
1704
1705 BUG_ON(!alpha2);
1706 BUG_ON(!wiphy);
1707
1708 request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
1709 if (!request)
1710 return -ENOMEM;
1711
1712 request->wiphy_idx = get_wiphy_idx(wiphy);
1713
1714 /* Must have registered wiphy first */
1715 BUG_ON(!wiphy_idx_valid(request->wiphy_idx));
1716
1717 request->alpha2[0] = alpha2[0];
1718 request->alpha2[1] = alpha2[1];
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001719 request->initiator = NL80211_REGDOM_SET_BY_DRIVER;
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001720
1721 queue_regulatory_request(request);
1722
1723 return 0;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001724}
1725EXPORT_SYMBOL(regulatory_hint);
1726
Luis R. Rodriguezabc73812009-07-30 17:38:08 -07001727/* Caller must hold reg_mutex */
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001728static bool reg_same_country_ie_hint(struct wiphy *wiphy,
1729 u32 country_ie_checksum)
1730{
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -05001731 struct wiphy *request_wiphy;
1732
Luis R. Rodriguezabc73812009-07-30 17:38:08 -07001733 assert_reg_lock();
Luis R. Rodriguez761cf7e2009-02-21 00:04:25 -05001734
Luis R. Rodriguezcc0b6fe2009-03-20 23:53:05 -04001735 if (unlikely(last_request->initiator !=
1736 NL80211_REGDOM_SET_BY_COUNTRY_IE))
1737 return false;
1738
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -05001739 request_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);
1740
1741 if (!request_wiphy)
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001742 return false;
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -05001743
1744 if (likely(request_wiphy != wiphy))
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001745 return !country_ie_integrity_changes(country_ie_checksum);
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05001746 /*
1747 * We should not have let these through at this point, they
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001748 * should have been picked up earlier by the first alpha2 check
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05001749 * on the device
1750 */
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001751 if (WARN_ON(!country_ie_integrity_changes(country_ie_checksum)))
1752 return true;
1753 return false;
1754}
1755
Luis R. Rodriguez4b44c8b2009-07-30 17:38:07 -07001756/*
1757 * We hold wdev_lock() here so we cannot hold cfg80211_mutex() and
1758 * therefore cannot iterate over the rdev list here.
1759 */
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001760void regulatory_hint_11d(struct wiphy *wiphy,
1761 u8 *country_ie,
1762 u8 country_ie_len)
1763{
1764 struct ieee80211_regdomain *rd = NULL;
1765 char alpha2[2];
1766 u32 checksum = 0;
1767 enum environment_cap env = ENVIRON_ANY;
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001768 struct regulatory_request *request;
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001769
Luis R. Rodriguezabc73812009-07-30 17:38:08 -07001770 mutex_lock(&reg_mutex);
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001771
Luis R. Rodriguez9828b012009-07-30 17:38:06 -07001772 if (unlikely(!last_request))
1773 goto out;
Luis R. Rodriguezd335fe62009-02-21 00:04:27 -05001774
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001775 /* IE len must be evenly divisible by 2 */
1776 if (country_ie_len & 0x01)
1777 goto out;
1778
1779 if (country_ie_len < IEEE80211_COUNTRY_IE_MIN_LEN)
1780 goto out;
1781
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05001782 /*
1783 * Pending country IE processing, this can happen after we
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001784 * call CRDA and wait for a response if a beacon was received before
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05001785 * we were able to process the last regulatory_hint_11d() call
1786 */
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001787 if (country_ie_regdomain)
1788 goto out;
1789
1790 alpha2[0] = country_ie[0];
1791 alpha2[1] = country_ie[1];
1792
1793 if (country_ie[2] == 'I')
1794 env = ENVIRON_INDOOR;
1795 else if (country_ie[2] == 'O')
1796 env = ENVIRON_OUTDOOR;
1797
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05001798 /*
Luis R. Rodriguez8b19e6c2009-07-30 17:38:09 -07001799 * We will run this only upon a successful connection on cfg80211.
Luis R. Rodriguez4b44c8b2009-07-30 17:38:07 -07001800 * We leave conflict resolution to the workqueue, where can hold
1801 * cfg80211_mutex.
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05001802 */
Luis R. Rodriguezcc0b6fe2009-03-20 23:53:05 -04001803 if (likely(last_request->initiator ==
1804 NL80211_REGDOM_SET_BY_COUNTRY_IE &&
Luis R. Rodriguez4b44c8b2009-07-30 17:38:07 -07001805 wiphy_idx_valid(last_request->wiphy_idx)))
1806 goto out;
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001807
1808 rd = country_ie_2_rd(country_ie, country_ie_len, &checksum);
1809 if (!rd)
1810 goto out;
1811
Luis R. Rodriguez915278e2009-02-21 00:04:28 -05001812 /*
1813 * This will not happen right now but we leave it here for the
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001814 * the future when we want to add suspend/resume support and having
1815 * the user move to another country after doing so, or having the user
Luis R. Rodriguez915278e2009-02-21 00:04:28 -05001816 * move to another AP. Right now we just trust the first AP.
1817 *
1818 * If we hit this before we add this support we want to be informed of
1819 * it as it would indicate a mistake in the current design
1820 */
1821 if (WARN_ON(reg_same_country_ie_hint(wiphy, checksum)))
Luis R. Rodriguez0441d6f2009-02-21 00:04:29 -05001822 goto free_rd_out;
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001823
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001824 request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
1825 if (!request)
1826 goto free_rd_out;
1827
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05001828 /*
1829 * We keep this around for when CRDA comes back with a response so
1830 * we can intersect with that
1831 */
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001832 country_ie_regdomain = rd;
1833
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001834 request->wiphy_idx = get_wiphy_idx(wiphy);
1835 request->alpha2[0] = rd->alpha2[0];
1836 request->alpha2[1] = rd->alpha2[1];
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001837 request->initiator = NL80211_REGDOM_SET_BY_COUNTRY_IE;
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001838 request->country_ie_checksum = checksum;
1839 request->country_ie_env = env;
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001840
Luis R. Rodriguezabc73812009-07-30 17:38:08 -07001841 mutex_unlock(&reg_mutex);
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05001842
1843 queue_regulatory_request(request);
1844
1845 return;
Luis R. Rodriguez0441d6f2009-02-21 00:04:29 -05001846
1847free_rd_out:
1848 kfree(rd);
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001849out:
Luis R. Rodriguezabc73812009-07-30 17:38:08 -07001850 mutex_unlock(&reg_mutex);
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001851}
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001852
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001853static bool freq_is_chan_12_13_14(u16 freq)
1854{
1855 if (freq == ieee80211_channel_to_frequency(12) ||
1856 freq == ieee80211_channel_to_frequency(13) ||
1857 freq == ieee80211_channel_to_frequency(14))
1858 return true;
1859 return false;
1860}
1861
1862int regulatory_hint_found_beacon(struct wiphy *wiphy,
1863 struct ieee80211_channel *beacon_chan,
1864 gfp_t gfp)
1865{
1866 struct reg_beacon *reg_beacon;
1867
1868 if (likely((beacon_chan->beacon_found ||
1869 (beacon_chan->flags & IEEE80211_CHAN_RADAR) ||
1870 (beacon_chan->band == IEEE80211_BAND_2GHZ &&
1871 !freq_is_chan_12_13_14(beacon_chan->center_freq)))))
1872 return 0;
1873
1874 reg_beacon = kzalloc(sizeof(struct reg_beacon), gfp);
1875 if (!reg_beacon)
1876 return -ENOMEM;
1877
Luis R. Rodriguez4113f752010-01-04 11:50:11 -05001878 REG_DBG_PRINT("cfg80211: Found new beacon on "
1879 "frequency: %d MHz (Ch %d) on %s\n",
1880 beacon_chan->center_freq,
1881 ieee80211_frequency_to_channel(beacon_chan->center_freq),
1882 wiphy_name(wiphy));
1883
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05001884 memcpy(&reg_beacon->chan, beacon_chan,
1885 sizeof(struct ieee80211_channel));
1886
1887
1888 /*
1889 * Since we can be called from BH or and non-BH context
1890 * we must use spin_lock_bh()
1891 */
1892 spin_lock_bh(&reg_pending_beacons_lock);
1893 list_add_tail(&reg_beacon->list, &reg_pending_beacons);
1894 spin_unlock_bh(&reg_pending_beacons_lock);
1895
1896 schedule_work(&reg_work);
1897
1898 return 0;
1899}
1900
Johannes Berga3d2eaf2008-09-15 11:10:52 +02001901static void print_rd_rules(const struct ieee80211_regdomain *rd)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001902{
1903 unsigned int i;
Johannes Berga3d2eaf2008-09-15 11:10:52 +02001904 const struct ieee80211_reg_rule *reg_rule = NULL;
1905 const struct ieee80211_freq_range *freq_range = NULL;
1906 const struct ieee80211_power_rule *power_rule = NULL;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001907
Kalle Valo269ac5f2009-12-01 10:47:15 +02001908 printk(KERN_INFO " (start_freq - end_freq @ bandwidth), "
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001909 "(max_antenna_gain, max_eirp)\n");
1910
1911 for (i = 0; i < rd->n_reg_rules; i++) {
1912 reg_rule = &rd->reg_rules[i];
1913 freq_range = &reg_rule->freq_range;
1914 power_rule = &reg_rule->power_rule;
1915
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05001916 /*
1917 * There may not be documentation for max antenna gain
1918 * in certain regions
1919 */
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001920 if (power_rule->max_antenna_gain)
Kalle Valo269ac5f2009-12-01 10:47:15 +02001921 printk(KERN_INFO " (%d KHz - %d KHz @ %d KHz), "
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001922 "(%d mBi, %d mBm)\n",
1923 freq_range->start_freq_khz,
1924 freq_range->end_freq_khz,
1925 freq_range->max_bandwidth_khz,
1926 power_rule->max_antenna_gain,
1927 power_rule->max_eirp);
1928 else
Kalle Valo269ac5f2009-12-01 10:47:15 +02001929 printk(KERN_INFO " (%d KHz - %d KHz @ %d KHz), "
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001930 "(N/A, %d mBm)\n",
1931 freq_range->start_freq_khz,
1932 freq_range->end_freq_khz,
1933 freq_range->max_bandwidth_khz,
1934 power_rule->max_eirp);
1935 }
1936}
1937
Johannes Berga3d2eaf2008-09-15 11:10:52 +02001938static void print_regdomain(const struct ieee80211_regdomain *rd)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001939{
1940
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001941 if (is_intersected_alpha2(rd->alpha2)) {
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001942
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04001943 if (last_request->initiator ==
1944 NL80211_REGDOM_SET_BY_COUNTRY_IE) {
Johannes Berg79c97e92009-07-07 03:56:12 +02001945 struct cfg80211_registered_device *rdev;
1946 rdev = cfg80211_rdev_by_wiphy_idx(
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -05001947 last_request->wiphy_idx);
Johannes Berg79c97e92009-07-07 03:56:12 +02001948 if (rdev) {
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001949 printk(KERN_INFO "cfg80211: Current regulatory "
1950 "domain updated by AP to: %c%c\n",
Johannes Berg79c97e92009-07-07 03:56:12 +02001951 rdev->country_ie_alpha2[0],
1952 rdev->country_ie_alpha2[1]);
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001953 } else
1954 printk(KERN_INFO "cfg80211: Current regulatory "
1955 "domain intersected: \n");
1956 } else
1957 printk(KERN_INFO "cfg80211: Current regulatory "
Luis R. Rodriguez039498c2009-01-07 17:43:35 -08001958 "domain intersected: \n");
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001959 } else if (is_world_regdom(rd->alpha2))
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001960 printk(KERN_INFO "cfg80211: World regulatory "
1961 "domain updated:\n");
1962 else {
1963 if (is_unknown_alpha2(rd->alpha2))
1964 printk(KERN_INFO "cfg80211: Regulatory domain "
1965 "changed to driver built-in settings "
1966 "(unknown country)\n");
1967 else
1968 printk(KERN_INFO "cfg80211: Regulatory domain "
1969 "changed to country: %c%c\n",
1970 rd->alpha2[0], rd->alpha2[1]);
1971 }
1972 print_rd_rules(rd);
1973}
1974
Johannes Berg2df78162008-10-28 16:49:41 +01001975static void print_regdomain_info(const struct ieee80211_regdomain *rd)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07001976{
1977 printk(KERN_INFO "cfg80211: Regulatory domain: %c%c\n",
1978 rd->alpha2[0], rd->alpha2[1]);
1979 print_rd_rules(rd);
1980}
1981
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001982#ifdef CONFIG_CFG80211_REG_DEBUG
1983static void reg_country_ie_process_debug(
1984 const struct ieee80211_regdomain *rd,
1985 const struct ieee80211_regdomain *country_ie_regdomain,
1986 const struct ieee80211_regdomain *intersected_rd)
1987{
1988 printk(KERN_DEBUG "cfg80211: Received country IE:\n");
1989 print_regdomain_info(country_ie_regdomain);
1990 printk(KERN_DEBUG "cfg80211: CRDA thinks this should applied:\n");
1991 print_regdomain_info(rd);
1992 if (intersected_rd) {
1993 printk(KERN_DEBUG "cfg80211: We intersect both of these "
1994 "and get:\n");
Luis R. Rodriguez667ecd02009-01-22 15:05:43 -08001995 print_regdomain_info(intersected_rd);
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08001996 return;
1997 }
1998 printk(KERN_DEBUG "cfg80211: Intersection between both failed\n");
1999}
2000#else
2001static inline void reg_country_ie_process_debug(
2002 const struct ieee80211_regdomain *rd,
2003 const struct ieee80211_regdomain *country_ie_regdomain,
2004 const struct ieee80211_regdomain *intersected_rd)
2005{
2006}
2007#endif
2008
Johannes Bergd2372b32008-10-24 20:32:20 +02002009/* Takes ownership of rd only if it doesn't fail */
Johannes Berga3d2eaf2008-09-15 11:10:52 +02002010static int __set_regdom(const struct ieee80211_regdomain *rd)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002011{
Luis R. Rodriguez9c964772008-10-30 13:33:53 -07002012 const struct ieee80211_regdomain *intersected_rd = NULL;
Johannes Berg79c97e92009-07-07 03:56:12 +02002013 struct cfg80211_registered_device *rdev = NULL;
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -05002014 struct wiphy *request_wiphy;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002015 /* Some basic sanity checks first */
2016
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002017 if (is_world_regdom(rd->alpha2)) {
Johannes Bergf6037d02008-10-21 11:01:33 +02002018 if (WARN_ON(!reg_is_valid_request(rd->alpha2)))
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002019 return -EINVAL;
2020 update_world_regdomain(rd);
2021 return 0;
2022 }
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002023
2024 if (!is_alpha2_set(rd->alpha2) && !is_an_alpha2(rd->alpha2) &&
2025 !is_unknown_alpha2(rd->alpha2))
2026 return -EINVAL;
2027
Johannes Bergf6037d02008-10-21 11:01:33 +02002028 if (!last_request)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002029 return -EINVAL;
2030
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05002031 /*
2032 * Lets only bother proceeding on the same alpha2 if the current
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08002033 * rd is non static (it means CRDA was present and was used last)
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05002034 * and the pending request came in from a country IE
2035 */
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04002036 if (last_request->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE) {
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05002037 /*
2038 * If someone else asked us to change the rd lets only bother
2039 * checking if the alpha2 changes if CRDA was already called
2040 */
John W. Linvillebaeb66f2009-12-18 17:59:02 -05002041 if (!regdom_changes(rd->alpha2))
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08002042 return -EINVAL;
2043 }
2044
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05002045 /*
2046 * Now lets set the regulatory domain, update all driver channels
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002047 * and finally inform them of what we have done, in case they want
2048 * to review or adjust their own settings based on their own
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05002049 * internal EEPROM data
2050 */
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002051
Johannes Bergf6037d02008-10-21 11:01:33 +02002052 if (WARN_ON(!reg_is_valid_request(rd->alpha2)))
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002053 return -EINVAL;
2054
Luis R. Rodriguez8375af32008-11-12 14:21:57 -08002055 if (!is_valid_rd(rd)) {
2056 printk(KERN_ERR "cfg80211: Invalid "
2057 "regulatory domain detected:\n");
2058 print_regdomain_info(rd);
2059 return -EINVAL;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002060 }
2061
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -05002062 request_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);
2063
Luis R. Rodriguezb8295ac2008-11-12 14:21:58 -08002064 if (!last_request->intersect) {
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08002065 int r;
2066
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04002067 if (last_request->initiator != NL80211_REGDOM_SET_BY_DRIVER) {
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08002068 reset_regdomains();
2069 cfg80211_regdomain = rd;
2070 return 0;
2071 }
2072
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05002073 /*
2074 * For a driver hint, lets copy the regulatory domain the
2075 * driver wanted to the wiphy to deal with conflicts
2076 */
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08002077
Luis R. Rodriguez558f6d32009-06-08 18:54:37 -07002078 /*
2079 * Userspace could have sent two replies with only
2080 * one kernel request.
2081 */
2082 if (request_wiphy->regd)
2083 return -EALREADY;
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08002084
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -05002085 r = reg_copy_regd(&request_wiphy->regd, rd);
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08002086 if (r)
2087 return r;
2088
Luis R. Rodriguezb8295ac2008-11-12 14:21:58 -08002089 reset_regdomains();
2090 cfg80211_regdomain = rd;
2091 return 0;
2092 }
2093
2094 /* Intersection requires a bit more work */
2095
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04002096 if (last_request->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE) {
Luis R. Rodriguezb8295ac2008-11-12 14:21:58 -08002097
Luis R. Rodriguez9c964772008-10-30 13:33:53 -07002098 intersected_rd = regdom_intersect(rd, cfg80211_regdomain);
2099 if (!intersected_rd)
2100 return -EINVAL;
Luis R. Rodriguezb8295ac2008-11-12 14:21:58 -08002101
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05002102 /*
2103 * We can trash what CRDA provided now.
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08002104 * However if a driver requested this specific regulatory
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05002105 * domain we keep it for its private use
2106 */
Luis R. Rodriguez7db90f42009-03-09 22:07:41 -04002107 if (last_request->initiator == NL80211_REGDOM_SET_BY_DRIVER)
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -05002108 request_wiphy->regd = rd;
Luis R. Rodriguez3e0c3ff2009-01-07 17:43:34 -08002109 else
2110 kfree(rd);
2111
Luis R. Rodriguezb8295ac2008-11-12 14:21:58 -08002112 rd = NULL;
2113
2114 reset_regdomains();
2115 cfg80211_regdomain = intersected_rd;
2116
2117 return 0;
Luis R. Rodriguez9c964772008-10-30 13:33:53 -07002118 }
2119
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08002120 /*
2121 * Country IE requests are handled a bit differently, we intersect
2122 * the country IE rd with what CRDA believes that country should have
2123 */
2124
Luis R. Rodriguez729e9c72009-05-31 18:24:34 -04002125 /*
2126 * Userspace could have sent two replies with only
2127 * one kernel request. By the second reply we would have
2128 * already processed and consumed the country_ie_regdomain.
2129 */
2130 if (!country_ie_regdomain)
2131 return -EALREADY;
Luis R. Rodriguez86f04682009-03-20 23:53:07 -04002132 BUG_ON(rd == country_ie_regdomain);
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08002133
Luis R. Rodriguez86f04682009-03-20 23:53:07 -04002134 /*
2135 * Intersect what CRDA returned and our what we
2136 * had built from the Country IE received
2137 */
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08002138
Luis R. Rodriguez86f04682009-03-20 23:53:07 -04002139 intersected_rd = regdom_intersect(rd, country_ie_regdomain);
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08002140
Luis R. Rodriguez86f04682009-03-20 23:53:07 -04002141 reg_country_ie_process_debug(rd,
2142 country_ie_regdomain,
2143 intersected_rd);
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08002144
Luis R. Rodriguez86f04682009-03-20 23:53:07 -04002145 kfree(country_ie_regdomain);
2146 country_ie_regdomain = NULL;
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08002147
2148 if (!intersected_rd)
2149 return -EINVAL;
2150
Johannes Berg79c97e92009-07-07 03:56:12 +02002151 rdev = wiphy_to_dev(request_wiphy);
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08002152
Johannes Berg79c97e92009-07-07 03:56:12 +02002153 rdev->country_ie_alpha2[0] = rd->alpha2[0];
2154 rdev->country_ie_alpha2[1] = rd->alpha2[1];
2155 rdev->env = last_request->country_ie_env;
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08002156
2157 BUG_ON(intersected_rd == rd);
2158
2159 kfree(rd);
2160 rd = NULL;
2161
Luis R. Rodriguezb8295ac2008-11-12 14:21:58 -08002162 reset_regdomains();
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08002163 cfg80211_regdomain = intersected_rd;
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002164
2165 return 0;
2166}
2167
2168
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05002169/*
2170 * Use this call to set the current regulatory domain. Conflicts with
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002171 * multiple drivers can be ironed out later. Caller must've already
Luis R. Rodriguezfb1fc7a2009-02-21 00:04:31 -05002172 * kmalloc'd the rd structure. Caller must hold cfg80211_mutex
2173 */
Johannes Berga3d2eaf2008-09-15 11:10:52 +02002174int set_regdom(const struct ieee80211_regdomain *rd)
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002175{
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002176 int r;
2177
Luis R. Rodriguez761cf7e2009-02-21 00:04:25 -05002178 assert_cfg80211_lock();
2179
Luis R. Rodriguezabc73812009-07-30 17:38:08 -07002180 mutex_lock(&reg_mutex);
2181
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002182 /* Note that this doesn't update the wiphys, this is done below */
2183 r = __set_regdom(rd);
Johannes Bergd2372b32008-10-24 20:32:20 +02002184 if (r) {
2185 kfree(rd);
Luis R. Rodriguezabc73812009-07-30 17:38:08 -07002186 mutex_unlock(&reg_mutex);
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002187 return r;
Johannes Bergd2372b32008-10-24 20:32:20 +02002188 }
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002189
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002190 /* This would make this whole thing pointless */
Luis R. Rodrigueza01ddaf2008-11-12 14:21:59 -08002191 if (!last_request->intersect)
2192 BUG_ON(rd != cfg80211_regdomain);
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002193
2194 /* update all wiphys now with the new established regulatory domain */
Johannes Bergf6037d02008-10-21 11:01:33 +02002195 update_all_wiphy_regulatory(last_request->initiator);
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002196
Luis R. Rodrigueza01ddaf2008-11-12 14:21:59 -08002197 print_regdomain(cfg80211_regdomain);
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002198
Luis R. Rodriguez73d54c92009-03-09 22:07:42 -04002199 nl80211_send_reg_change_event(last_request);
2200
Luis R. Rodriguezabc73812009-07-30 17:38:08 -07002201 mutex_unlock(&reg_mutex);
2202
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002203 return r;
2204}
2205
Luis R. Rodrigueza1794392009-02-21 00:04:21 -05002206/* Caller must hold cfg80211_mutex */
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08002207void reg_device_remove(struct wiphy *wiphy)
2208{
Luis R. Rodriguez0ad8aca2009-03-24 21:21:08 -04002209 struct wiphy *request_wiphy = NULL;
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -05002210
Luis R. Rodriguez761cf7e2009-02-21 00:04:25 -05002211 assert_cfg80211_lock();
2212
Luis R. Rodriguezabc73812009-07-30 17:38:08 -07002213 mutex_lock(&reg_mutex);
2214
Chris Wright0ef9ccd2009-04-24 14:09:31 -07002215 kfree(wiphy->regd);
2216
Luis R. Rodriguez0ad8aca2009-03-24 21:21:08 -04002217 if (last_request)
2218 request_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -05002219
Chris Wright0ef9ccd2009-04-24 14:09:31 -07002220 if (!request_wiphy || request_wiphy != wiphy)
Luis R. Rodriguezabc73812009-07-30 17:38:08 -07002221 goto out;
Chris Wright0ef9ccd2009-04-24 14:09:31 -07002222
Luis R. Rodriguez806a9e32009-02-21 00:04:26 -05002223 last_request->wiphy_idx = WIPHY_IDX_STALE;
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08002224 last_request->country_ie_env = ENVIRON_ANY;
Luis R. Rodriguezabc73812009-07-30 17:38:08 -07002225out:
2226 mutex_unlock(&reg_mutex);
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08002227}
2228
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002229int regulatory_init(void)
2230{
Luis R. Rodriguezbcf4f992009-02-21 00:04:24 -05002231 int err = 0;
Johannes Berg734366d2008-09-15 10:56:48 +02002232
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002233 reg_pdev = platform_device_register_simple("regulatory", 0, NULL, 0);
2234 if (IS_ERR(reg_pdev))
2235 return PTR_ERR(reg_pdev);
Johannes Berg734366d2008-09-15 10:56:48 +02002236
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05002237 spin_lock_init(&reg_requests_lock);
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05002238 spin_lock_init(&reg_pending_beacons_lock);
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05002239
Johannes Berga3d2eaf2008-09-15 11:10:52 +02002240 cfg80211_regdomain = cfg80211_world_regdom;
Johannes Berg734366d2008-09-15 10:56:48 +02002241
Luis R. Rodriguezae9e4b02009-07-14 20:23:15 -04002242 /* We always try to get an update for the static regdomain */
2243 err = regulatory_hint_core(cfg80211_regdomain->alpha2);
Luis R. Rodriguezbcf4f992009-02-21 00:04:24 -05002244 if (err) {
2245 if (err == -ENOMEM)
2246 return err;
2247 /*
2248 * N.B. kobject_uevent_env() can fail mainly for when we're out
2249 * memory which is handled and propagated appropriately above
2250 * but it can also fail during a netlink_broadcast() or during
2251 * early boot for call_usermodehelper(). For now treat these
2252 * errors as non-fatal.
2253 */
2254 printk(KERN_ERR "cfg80211: kobject_uevent_env() was unable "
2255 "to call CRDA during init");
2256#ifdef CONFIG_CFG80211_REG_DEBUG
2257 /* We want to find out exactly why when debugging */
2258 WARN_ON(err);
2259#endif
2260 }
Johannes Berg734366d2008-09-15 10:56:48 +02002261
Luis R. Rodriguezae9e4b02009-07-14 20:23:15 -04002262 /*
2263 * Finally, if the user set the module parameter treat it
2264 * as a user hint.
2265 */
2266 if (!is_world_regdom(ieee80211_regdom))
2267 regulatory_hint_user(ieee80211_regdom);
2268
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002269 return 0;
2270}
2271
2272void regulatory_exit(void)
2273{
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05002274 struct regulatory_request *reg_request, *tmp;
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05002275 struct reg_beacon *reg_beacon, *btmp;
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05002276
2277 cancel_work_sync(&reg_work);
2278
Luis R. Rodrigueza1794392009-02-21 00:04:21 -05002279 mutex_lock(&cfg80211_mutex);
Luis R. Rodriguezabc73812009-07-30 17:38:08 -07002280 mutex_lock(&reg_mutex);
Johannes Berg734366d2008-09-15 10:56:48 +02002281
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002282 reset_regdomains();
Johannes Berg734366d2008-09-15 10:56:48 +02002283
Luis R. Rodriguez3f2355c2008-11-12 14:22:02 -08002284 kfree(country_ie_regdomain);
2285 country_ie_regdomain = NULL;
2286
Johannes Bergf6037d02008-10-21 11:01:33 +02002287 kfree(last_request);
2288
Luis R. Rodriguezb2e1b302008-09-09 23:19:48 -07002289 platform_device_unregister(reg_pdev);
Johannes Berg734366d2008-09-15 10:56:48 +02002290
Luis R. Rodrigueze38f8a72009-02-21 00:20:39 -05002291 spin_lock_bh(&reg_pending_beacons_lock);
2292 if (!list_empty(&reg_pending_beacons)) {
2293 list_for_each_entry_safe(reg_beacon, btmp,
2294 &reg_pending_beacons, list) {
2295 list_del(&reg_beacon->list);
2296 kfree(reg_beacon);
2297 }
2298 }
2299 spin_unlock_bh(&reg_pending_beacons_lock);
2300
2301 if (!list_empty(&reg_beacon_list)) {
2302 list_for_each_entry_safe(reg_beacon, btmp,
2303 &reg_beacon_list, list) {
2304 list_del(&reg_beacon->list);
2305 kfree(reg_beacon);
2306 }
2307 }
2308
Luis R. Rodriguezfe33eb32009-02-21 00:04:30 -05002309 spin_lock(&reg_requests_lock);
2310 if (!list_empty(&reg_requests_list)) {
2311 list_for_each_entry_safe(reg_request, tmp,
2312 &reg_requests_list, list) {
2313 list_del(&reg_request->list);
2314 kfree(reg_request);
2315 }
2316 }
2317 spin_unlock(&reg_requests_lock);
2318
Luis R. Rodriguezabc73812009-07-30 17:38:08 -07002319 mutex_unlock(&reg_mutex);
Luis R. Rodrigueza1794392009-02-21 00:04:21 -05002320 mutex_unlock(&cfg80211_mutex);
Johannes Berg8318d782008-01-24 19:38:38 +01002321}