2008-01-25 02:38:38 +08:00
|
|
|
/*
|
|
|
|
* Copyright 2002-2005, Instant802 Networks, Inc.
|
|
|
|
* Copyright 2005-2006, Devicescape Software, Inc.
|
|
|
|
* Copyright 2007 Johannes Berg <johannes@sipsolutions.net>
|
cfg80211: relicense reg.c reg.h and genregdb.awk to ISC
Following the tradition we have had with ath5k, ath9k, CRDA,
wireless-regdb I'd like to license this code under the permissive ISC
license for the code sharing purposes with other OSes, it'd sure be nice
to help the landscape in this area. Although I am %82.89 owner of the
regulatory code I have asked every contributor to the regulatory code
and have receieved positive Acked-bys from everyone except two deceased
entities:
o Frans Pop RIP 2010 [0]
- Frans Pop <elendil@planet.nl>
- Frans Pop <fjp@debian.org>
o Nokia RIP February, 11, 2011 [1], [2]
- ext-yuri.ershov@nokia.com
- kalle.valo@nokia.com
Frans Pop's contribution was a simple patch 55f98938, titled,
"wireless: remove trailing space in messages" which just add a \n
to some printk lines. I'm going to treat these additions as
uncopyrightable.
As for the contributions made by employees on behalf of Nokia
my contact point was Petri Karhula <petri.karhula@nokia.com> but
after one month he noted he had not been able to get traction from the
legal department on this request, as such it I proceeded by replacing
their contributions in previous patches.
The end goal is to help a clean rewrite that starts in userspace
that is shared under ISC license which currently is taking place with
the regulatory simulator [3].
[0] http://lists.debian.org/debian-devel/2011/12/msg00263.html
[1] http://press.nokia.com/2011/02/11/nokia-outlines-new-strategy-introduces-new-leadership-operational-structure/
[2] http://NokiaPlanB.com
[3] git://github.com/mcgrof/regsim.git
Acked-by: Thadeu Lima de Souza Cascardo <cascardo@holoscopio.com>
Acked-by: Dan Carpenter <error27@gmail.com>
Acked-by: Mihai Moldovan <ionic@ionic.de>
Acked-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
Acked-by: Sven Neumann <s.neumann@raumfeld.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Acked-by: Tomas Winkler <tomas.winkler@intel.com>
Acked-by: Tony Vroon <tony@linx.net>
Acked-by: Pavel Roskin <proski@gnu.org>
Acked-by: Bob Copeland <me@bobcopeland.com>
Acked-by: Lucas De Marchi <lucas.demarchi@profusion.mobi>
Acked-by: Pat Erley <pat-lkml@erley.org>
Acked-by: Tejun Heo <tj@kernel.org>
Acked-by: John W. Linville <linville@tuxdriver.com>
Acked-by: Chris Wright <chrisw@sous-sol.org>
Acked-by: Joe Perches <joe@perches.com>
Acked-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Acked-by: John Gordon <john@devicescape.com>
Acked-by: Simon Barber <protocolmagic@gmail.com>
Acked-by: Rajkumar Manoharan <rmanohar@qca.qualcomm.com>
Acked-by: Jiri Benc <jbenc@upir.cz>
Acked-by: Bruno Randolf <br1@einfach.org>
Acked-by: Scott James Remnant <keybuk@google.com>
Acked-by: Roel Kluin <roel.kluin@gmail.com>
Signed-off-by: Luis R. Rodriguez <mcgrof@qca.qualcomm.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2011-12-21 04:23:38 +08:00
|
|
|
* Copyright 2008-2011 Luis R. Rodriguez <mcgrof@qca.qualcomm.com>
|
2008-01-25 02:38:38 +08:00
|
|
|
*
|
cfg80211: relicense reg.c reg.h and genregdb.awk to ISC
Following the tradition we have had with ath5k, ath9k, CRDA,
wireless-regdb I'd like to license this code under the permissive ISC
license for the code sharing purposes with other OSes, it'd sure be nice
to help the landscape in this area. Although I am %82.89 owner of the
regulatory code I have asked every contributor to the regulatory code
and have receieved positive Acked-bys from everyone except two deceased
entities:
o Frans Pop RIP 2010 [0]
- Frans Pop <elendil@planet.nl>
- Frans Pop <fjp@debian.org>
o Nokia RIP February, 11, 2011 [1], [2]
- ext-yuri.ershov@nokia.com
- kalle.valo@nokia.com
Frans Pop's contribution was a simple patch 55f98938, titled,
"wireless: remove trailing space in messages" which just add a \n
to some printk lines. I'm going to treat these additions as
uncopyrightable.
As for the contributions made by employees on behalf of Nokia
my contact point was Petri Karhula <petri.karhula@nokia.com> but
after one month he noted he had not been able to get traction from the
legal department on this request, as such it I proceeded by replacing
their contributions in previous patches.
The end goal is to help a clean rewrite that starts in userspace
that is shared under ISC license which currently is taking place with
the regulatory simulator [3].
[0] http://lists.debian.org/debian-devel/2011/12/msg00263.html
[1] http://press.nokia.com/2011/02/11/nokia-outlines-new-strategy-introduces-new-leadership-operational-structure/
[2] http://NokiaPlanB.com
[3] git://github.com/mcgrof/regsim.git
Acked-by: Thadeu Lima de Souza Cascardo <cascardo@holoscopio.com>
Acked-by: Dan Carpenter <error27@gmail.com>
Acked-by: Mihai Moldovan <ionic@ionic.de>
Acked-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
Acked-by: Sven Neumann <s.neumann@raumfeld.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Acked-by: Tomas Winkler <tomas.winkler@intel.com>
Acked-by: Tony Vroon <tony@linx.net>
Acked-by: Pavel Roskin <proski@gnu.org>
Acked-by: Bob Copeland <me@bobcopeland.com>
Acked-by: Lucas De Marchi <lucas.demarchi@profusion.mobi>
Acked-by: Pat Erley <pat-lkml@erley.org>
Acked-by: Tejun Heo <tj@kernel.org>
Acked-by: John W. Linville <linville@tuxdriver.com>
Acked-by: Chris Wright <chrisw@sous-sol.org>
Acked-by: Joe Perches <joe@perches.com>
Acked-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Acked-by: John Gordon <john@devicescape.com>
Acked-by: Simon Barber <protocolmagic@gmail.com>
Acked-by: Rajkumar Manoharan <rmanohar@qca.qualcomm.com>
Acked-by: Jiri Benc <jbenc@upir.cz>
Acked-by: Bruno Randolf <br1@einfach.org>
Acked-by: Scott James Remnant <keybuk@google.com>
Acked-by: Roel Kluin <roel.kluin@gmail.com>
Signed-off-by: Luis R. Rodriguez <mcgrof@qca.qualcomm.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2011-12-21 04:23:38 +08:00
|
|
|
* Permission to use, copy, modify, and/or distribute this software for any
|
|
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
|
|
* copyright notice and this permission notice appear in all copies.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
|
|
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
|
|
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
|
|
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
|
|
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
|
|
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
2008-01-25 02:38:38 +08:00
|
|
|
*/
|
|
|
|
|
cfg80211: relicense reg.c reg.h and genregdb.awk to ISC
Following the tradition we have had with ath5k, ath9k, CRDA,
wireless-regdb I'd like to license this code under the permissive ISC
license for the code sharing purposes with other OSes, it'd sure be nice
to help the landscape in this area. Although I am %82.89 owner of the
regulatory code I have asked every contributor to the regulatory code
and have receieved positive Acked-bys from everyone except two deceased
entities:
o Frans Pop RIP 2010 [0]
- Frans Pop <elendil@planet.nl>
- Frans Pop <fjp@debian.org>
o Nokia RIP February, 11, 2011 [1], [2]
- ext-yuri.ershov@nokia.com
- kalle.valo@nokia.com
Frans Pop's contribution was a simple patch 55f98938, titled,
"wireless: remove trailing space in messages" which just add a \n
to some printk lines. I'm going to treat these additions as
uncopyrightable.
As for the contributions made by employees on behalf of Nokia
my contact point was Petri Karhula <petri.karhula@nokia.com> but
after one month he noted he had not been able to get traction from the
legal department on this request, as such it I proceeded by replacing
their contributions in previous patches.
The end goal is to help a clean rewrite that starts in userspace
that is shared under ISC license which currently is taking place with
the regulatory simulator [3].
[0] http://lists.debian.org/debian-devel/2011/12/msg00263.html
[1] http://press.nokia.com/2011/02/11/nokia-outlines-new-strategy-introduces-new-leadership-operational-structure/
[2] http://NokiaPlanB.com
[3] git://github.com/mcgrof/regsim.git
Acked-by: Thadeu Lima de Souza Cascardo <cascardo@holoscopio.com>
Acked-by: Dan Carpenter <error27@gmail.com>
Acked-by: Mihai Moldovan <ionic@ionic.de>
Acked-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
Acked-by: Sven Neumann <s.neumann@raumfeld.com>
Acked-by: Johannes Berg <johannes@sipsolutions.net>
Acked-by: Tomas Winkler <tomas.winkler@intel.com>
Acked-by: Tony Vroon <tony@linx.net>
Acked-by: Pavel Roskin <proski@gnu.org>
Acked-by: Bob Copeland <me@bobcopeland.com>
Acked-by: Lucas De Marchi <lucas.demarchi@profusion.mobi>
Acked-by: Pat Erley <pat-lkml@erley.org>
Acked-by: Tejun Heo <tj@kernel.org>
Acked-by: John W. Linville <linville@tuxdriver.com>
Acked-by: Chris Wright <chrisw@sous-sol.org>
Acked-by: Joe Perches <joe@perches.com>
Acked-by: Paul Gortmaker <paul.gortmaker@windriver.com>
Acked-by: John Gordon <john@devicescape.com>
Acked-by: Simon Barber <protocolmagic@gmail.com>
Acked-by: Rajkumar Manoharan <rmanohar@qca.qualcomm.com>
Acked-by: Jiri Benc <jbenc@upir.cz>
Acked-by: Bruno Randolf <br1@einfach.org>
Acked-by: Scott James Remnant <keybuk@google.com>
Acked-by: Roel Kluin <roel.kluin@gmail.com>
Signed-off-by: Luis R. Rodriguez <mcgrof@qca.qualcomm.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2011-12-21 04:23:38 +08:00
|
|
|
|
2008-09-10 14:19:48 +08:00
|
|
|
/**
|
|
|
|
* DOC: Wireless regulatory infrastructure
|
2008-01-25 02:38:38 +08:00
|
|
|
*
|
|
|
|
* The usual implementation is for a driver to read a device EEPROM to
|
|
|
|
* determine which regulatory domain it should be operating under, then
|
|
|
|
* looking up the allowable channels in a driver-local table and finally
|
|
|
|
* registering those channels in the wiphy structure.
|
|
|
|
*
|
2008-09-10 14:19:48 +08:00
|
|
|
* Another set of compliance enforcement is for drivers to use their
|
|
|
|
* own compliance limits which can be stored on the EEPROM. The host
|
|
|
|
* driver or firmware may ensure these are used.
|
|
|
|
*
|
|
|
|
* In addition to all this we provide an extra layer of regulatory
|
|
|
|
* conformance. For drivers which do not have any regulatory
|
|
|
|
* information CRDA provides the complete regulatory solution.
|
|
|
|
* For others it provides a community effort on further restrictions
|
|
|
|
* to enhance compliance.
|
|
|
|
*
|
|
|
|
* Note: When number of rules --> infinity we will not be able to
|
|
|
|
* index on alpha2 any more, instead we'll probably have to
|
|
|
|
* rely on some SHA1 checksum of the regdomain for example.
|
|
|
|
*
|
2008-01-25 02:38:38 +08:00
|
|
|
*/
|
2010-11-17 11:56:49 +08:00
|
|
|
|
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2008-01-25 02:38:38 +08:00
|
|
|
#include <linux/kernel.h>
|
2011-07-15 23:47:34 +08:00
|
|
|
#include <linux/export.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 16:04:11 +08:00
|
|
|
#include <linux/slab.h>
|
2008-09-10 14:19:48 +08:00
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/random.h>
|
2010-08-06 02:26:24 +08:00
|
|
|
#include <linux/ctype.h>
|
2008-09-10 14:19:48 +08:00
|
|
|
#include <linux/nl80211.h>
|
|
|
|
#include <linux/platform_device.h>
|
2011-09-19 01:21:27 +08:00
|
|
|
#include <linux/moduleparam.h>
|
2008-09-10 14:19:48 +08:00
|
|
|
#include <net/cfg80211.h>
|
2008-01-25 02:38:38 +08:00
|
|
|
#include "core.h"
|
2008-09-10 14:19:48 +08:00
|
|
|
#include "reg.h"
|
2009-12-19 06:59:01 +08:00
|
|
|
#include "regdb.h"
|
2009-03-10 10:07:42 +08:00
|
|
|
#include "nl80211.h"
|
2008-01-25 02:38:38 +08:00
|
|
|
|
2010-01-05 00:50:11 +08:00
|
|
|
#ifdef CONFIG_CFG80211_REG_DEBUG
|
2011-07-30 05:51:25 +08:00
|
|
|
#define REG_DBG_PRINT(format, args...) \
|
|
|
|
printk(KERN_DEBUG pr_fmt(format), ##args)
|
2010-01-05 00:50:11 +08:00
|
|
|
#else
|
2010-01-06 06:57:20 +08:00
|
|
|
#define REG_DBG_PRINT(args...)
|
2010-01-05 00:50:11 +08:00
|
|
|
#endif
|
|
|
|
|
2011-11-29 05:47:15 +08:00
|
|
|
static struct regulatory_request core_request_world = {
|
|
|
|
.initiator = NL80211_REGDOM_SET_BY_CORE,
|
|
|
|
.alpha2[0] = '0',
|
|
|
|
.alpha2[1] = '0',
|
|
|
|
.intersect = false,
|
|
|
|
.processed = true,
|
|
|
|
.country_ie_env = ENVIRON_ANY,
|
|
|
|
};
|
|
|
|
|
2008-10-31 04:33:56 +08:00
|
|
|
/* Receipt of information from last regulatory request */
|
2011-11-29 05:47:15 +08:00
|
|
|
static struct regulatory_request *last_request = &core_request_world;
|
2008-09-15 16:56:48 +08:00
|
|
|
|
2008-09-10 14:19:48 +08:00
|
|
|
/* To trigger userspace events */
|
|
|
|
static struct platform_device *reg_pdev;
|
2008-01-25 02:38:38 +08:00
|
|
|
|
2011-03-09 02:45:30 +08:00
|
|
|
static struct device_type reg_device_type = {
|
|
|
|
.uevent = reg_device_uevent,
|
|
|
|
};
|
|
|
|
|
2009-02-21 13:04:31 +08:00
|
|
|
/*
|
|
|
|
* Central wireless core regulatory domains, we only need two,
|
2008-09-15 16:56:48 +08:00
|
|
|
* the current one and a world regulatory domain in case we have no
|
2009-02-21 13:04:31 +08:00
|
|
|
* information to give us an alpha2
|
|
|
|
*/
|
2009-01-31 01:26:42 +08:00
|
|
|
const struct ieee80211_regdomain *cfg80211_regdomain;
|
2008-09-15 16:56:48 +08:00
|
|
|
|
2009-07-31 08:38:08 +08:00
|
|
|
/*
|
|
|
|
* Protects static reg.c components:
|
|
|
|
* - cfg80211_world_regdom
|
|
|
|
* - cfg80211_regdom
|
|
|
|
* - last_request
|
2012-07-13 02:49:18 +08:00
|
|
|
* - reg_num_devs_support_basehint
|
2009-07-31 08:38:08 +08:00
|
|
|
*/
|
2010-06-24 23:26:31 +08:00
|
|
|
static DEFINE_MUTEX(reg_mutex);
|
2010-09-15 19:28:15 +08:00
|
|
|
|
2012-07-13 02:49:18 +08:00
|
|
|
/*
|
|
|
|
* Number of devices that registered to the core
|
|
|
|
* that support cellular base station regulatory hints
|
|
|
|
*/
|
|
|
|
static int reg_num_devs_support_basehint;
|
|
|
|
|
2010-09-15 19:28:15 +08:00
|
|
|
static inline void assert_reg_lock(void)
|
|
|
|
{
|
|
|
|
lockdep_assert_held(®_mutex);
|
|
|
|
}
|
2009-07-31 08:38:08 +08:00
|
|
|
|
2009-02-21 13:20:39 +08:00
|
|
|
/* Used to queue up regulatory hints */
|
2009-02-21 13:04:30 +08:00
|
|
|
static LIST_HEAD(reg_requests_list);
|
|
|
|
static spinlock_t reg_requests_lock;
|
|
|
|
|
2009-02-21 13:20:39 +08:00
|
|
|
/* Used to queue up beacon hints for review */
|
|
|
|
static LIST_HEAD(reg_pending_beacons);
|
|
|
|
static spinlock_t reg_pending_beacons_lock;
|
|
|
|
|
|
|
|
/* Used to keep track of processed beacon hints */
|
|
|
|
static LIST_HEAD(reg_beacon_list);
|
|
|
|
|
|
|
|
struct reg_beacon {
|
|
|
|
struct list_head list;
|
|
|
|
struct ieee80211_channel chan;
|
|
|
|
};
|
|
|
|
|
2010-11-18 13:46:07 +08:00
|
|
|
static void reg_todo(struct work_struct *work);
|
|
|
|
static DECLARE_WORK(reg_work, reg_todo);
|
|
|
|
|
2011-04-06 01:49:04 +08:00
|
|
|
static void reg_timeout_work(struct work_struct *work);
|
|
|
|
static DECLARE_DELAYED_WORK(reg_timeout, reg_timeout_work);
|
|
|
|
|
2008-09-15 16:56:48 +08:00
|
|
|
/* We keep a static world regulatory domain in case of the absence of CRDA */
|
|
|
|
static const struct ieee80211_regdomain world_regdom = {
|
2012-07-02 14:32:34 +08:00
|
|
|
.n_reg_rules = 6,
|
2008-09-15 16:56:48 +08:00
|
|
|
.alpha2 = "00",
|
|
|
|
.reg_rules = {
|
2009-02-21 13:20:37 +08:00
|
|
|
/* IEEE 802.11b/g, channels 1..11 */
|
|
|
|
REG_RULE(2412-10, 2462+10, 40, 6, 20, 0),
|
2009-03-06 13:19:21 +08:00
|
|
|
/* IEEE 802.11b/g, channels 12..13. No HT40
|
|
|
|
* channel fits here. */
|
|
|
|
REG_RULE(2467-10, 2472+10, 20, 6, 20,
|
2009-02-21 13:20:38 +08:00
|
|
|
NL80211_RRF_PASSIVE_SCAN |
|
|
|
|
NL80211_RRF_NO_IBSS),
|
2009-03-06 13:19:21 +08:00
|
|
|
/* IEEE 802.11 channel 14 - Only JP enables
|
|
|
|
* this and for 802.11b only */
|
|
|
|
REG_RULE(2484-10, 2484+10, 20, 6, 20,
|
|
|
|
NL80211_RRF_PASSIVE_SCAN |
|
|
|
|
NL80211_RRF_NO_IBSS |
|
|
|
|
NL80211_RRF_NO_OFDM),
|
|
|
|
/* IEEE 802.11a, channel 36..48 */
|
2009-03-06 13:19:22 +08:00
|
|
|
REG_RULE(5180-10, 5240+10, 40, 6, 20,
|
2009-03-06 13:19:21 +08:00
|
|
|
NL80211_RRF_PASSIVE_SCAN |
|
|
|
|
NL80211_RRF_NO_IBSS),
|
2009-02-21 13:20:38 +08:00
|
|
|
|
|
|
|
/* NB: 5260 MHz - 5700 MHz requies DFS */
|
|
|
|
|
|
|
|
/* IEEE 802.11a, channel 149..165 */
|
2009-03-06 13:19:22 +08:00
|
|
|
REG_RULE(5745-10, 5825+10, 40, 6, 20,
|
2009-02-21 13:20:38 +08:00
|
|
|
NL80211_RRF_PASSIVE_SCAN |
|
|
|
|
NL80211_RRF_NO_IBSS),
|
2012-07-02 14:32:34 +08:00
|
|
|
|
|
|
|
/* IEEE 802.11ad (60gHz), channels 1..3 */
|
|
|
|
REG_RULE(56160+2160*1-1080, 56160+2160*3+1080, 2160, 0, 0, 0),
|
2008-09-15 16:56:48 +08:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2008-09-15 17:10:52 +08:00
|
|
|
static const struct ieee80211_regdomain *cfg80211_world_regdom =
|
|
|
|
&world_regdom;
|
2008-09-15 16:56:48 +08:00
|
|
|
|
2009-03-21 11:53:06 +08:00
|
|
|
static char *ieee80211_regdom = "00";
|
2010-01-30 08:58:57 +08:00
|
|
|
static char user_alpha2[2];
|
2009-03-21 11:53:06 +08:00
|
|
|
|
2008-09-15 16:56:48 +08:00
|
|
|
module_param(ieee80211_regdom, charp, 0444);
|
|
|
|
MODULE_PARM_DESC(ieee80211_regdom, "IEEE 802.11 regulatory domain code");
|
|
|
|
|
2011-11-29 05:47:15 +08:00
|
|
|
static void reset_regdomains(bool full_reset)
|
2008-09-15 16:56:48 +08:00
|
|
|
{
|
2008-09-15 17:26:47 +08:00
|
|
|
/* avoid freeing static information or freeing something twice */
|
|
|
|
if (cfg80211_regdomain == cfg80211_world_regdom)
|
|
|
|
cfg80211_regdomain = NULL;
|
|
|
|
if (cfg80211_world_regdom == &world_regdom)
|
|
|
|
cfg80211_world_regdom = NULL;
|
|
|
|
if (cfg80211_regdomain == &world_regdom)
|
|
|
|
cfg80211_regdomain = NULL;
|
|
|
|
|
|
|
|
kfree(cfg80211_regdomain);
|
|
|
|
kfree(cfg80211_world_regdom);
|
2008-09-15 16:56:48 +08:00
|
|
|
|
2008-09-15 17:10:52 +08:00
|
|
|
cfg80211_world_regdom = &world_regdom;
|
2008-09-15 16:56:48 +08:00
|
|
|
cfg80211_regdomain = NULL;
|
2011-11-29 05:47:15 +08:00
|
|
|
|
|
|
|
if (!full_reset)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (last_request != &core_request_world)
|
|
|
|
kfree(last_request);
|
|
|
|
last_request = &core_request_world;
|
2008-09-15 16:56:48 +08:00
|
|
|
}
|
|
|
|
|
2009-02-21 13:04:31 +08:00
|
|
|
/*
|
|
|
|
* Dynamic world regulatory domain requested by the wireless
|
|
|
|
* core upon initialization
|
|
|
|
*/
|
2008-09-15 17:10:52 +08:00
|
|
|
static void update_world_regdomain(const struct ieee80211_regdomain *rd)
|
2008-09-15 16:56:48 +08:00
|
|
|
{
|
2008-10-21 17:01:33 +08:00
|
|
|
BUG_ON(!last_request);
|
2008-09-15 16:56:48 +08:00
|
|
|
|
2011-11-29 05:47:15 +08:00
|
|
|
reset_regdomains(false);
|
2008-09-15 16:56:48 +08:00
|
|
|
|
|
|
|
cfg80211_world_regdom = rd;
|
|
|
|
cfg80211_regdomain = rd;
|
|
|
|
}
|
|
|
|
|
2008-09-15 17:10:52 +08:00
|
|
|
bool is_world_regdom(const char *alpha2)
|
2008-09-10 14:19:48 +08:00
|
|
|
{
|
|
|
|
if (!alpha2)
|
|
|
|
return false;
|
|
|
|
if (alpha2[0] == '0' && alpha2[1] == '0')
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
2008-01-25 02:38:38 +08:00
|
|
|
|
2008-09-15 17:10:52 +08:00
|
|
|
static bool is_alpha2_set(const char *alpha2)
|
2008-09-10 14:19:48 +08:00
|
|
|
{
|
|
|
|
if (!alpha2)
|
|
|
|
return false;
|
|
|
|
if (alpha2[0] != 0 && alpha2[1] != 0)
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
2008-01-25 02:38:38 +08:00
|
|
|
|
2008-09-15 17:10:52 +08:00
|
|
|
static bool is_unknown_alpha2(const char *alpha2)
|
2008-09-10 14:19:48 +08:00
|
|
|
{
|
|
|
|
if (!alpha2)
|
|
|
|
return false;
|
2009-02-21 13:04:31 +08:00
|
|
|
/*
|
|
|
|
* Special case where regulatory domain was built by driver
|
|
|
|
* but a specific alpha2 cannot be determined
|
|
|
|
*/
|
2008-09-10 14:19:48 +08:00
|
|
|
if (alpha2[0] == '9' && alpha2[1] == '9')
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
2008-01-25 02:38:38 +08:00
|
|
|
|
2008-11-13 06:22:02 +08:00
|
|
|
static bool is_intersected_alpha2(const char *alpha2)
|
|
|
|
{
|
|
|
|
if (!alpha2)
|
|
|
|
return false;
|
2009-02-21 13:04:31 +08:00
|
|
|
/*
|
|
|
|
* Special case where regulatory domain is the
|
2008-11-13 06:22:02 +08:00
|
|
|
* result of an intersection between two regulatory domain
|
2009-02-21 13:04:31 +08:00
|
|
|
* structures
|
|
|
|
*/
|
2008-11-13 06:22:02 +08:00
|
|
|
if (alpha2[0] == '9' && alpha2[1] == '8')
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2008-09-15 17:10:52 +08:00
|
|
|
static bool is_an_alpha2(const char *alpha2)
|
2008-09-10 14:19:48 +08:00
|
|
|
{
|
|
|
|
if (!alpha2)
|
|
|
|
return false;
|
2010-08-06 02:26:24 +08:00
|
|
|
if (isalpha(alpha2[0]) && isalpha(alpha2[1]))
|
2008-09-10 14:19:48 +08:00
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
2008-01-25 02:38:38 +08:00
|
|
|
|
2008-09-15 17:10:52 +08:00
|
|
|
static bool alpha2_equal(const char *alpha2_x, const char *alpha2_y)
|
2008-09-10 14:19:48 +08:00
|
|
|
{
|
|
|
|
if (!alpha2_x || !alpha2_y)
|
|
|
|
return false;
|
|
|
|
if (alpha2_x[0] == alpha2_y[0] &&
|
|
|
|
alpha2_x[1] == alpha2_y[1])
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-02-21 13:04:33 +08:00
|
|
|
static bool regdom_changes(const char *alpha2)
|
2008-09-10 14:19:48 +08:00
|
|
|
{
|
2009-02-21 13:04:25 +08:00
|
|
|
assert_cfg80211_lock();
|
|
|
|
|
2008-09-10 14:19:48 +08:00
|
|
|
if (!cfg80211_regdomain)
|
|
|
|
return true;
|
|
|
|
if (alpha2_equal(cfg80211_regdomain->alpha2, alpha2))
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2010-01-30 08:58:57 +08:00
|
|
|
/*
|
|
|
|
* The NL80211_REGDOM_SET_BY_USER regdom alpha2 is cached, this lets
|
|
|
|
* you know if a valid regulatory hint with NL80211_REGDOM_SET_BY_USER
|
|
|
|
* has ever been issued.
|
|
|
|
*/
|
|
|
|
static bool is_user_regdom_saved(void)
|
|
|
|
{
|
|
|
|
if (user_alpha2[0] == '9' && user_alpha2[1] == '7')
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/* This would indicate a mistake on the design */
|
|
|
|
if (WARN((!is_world_regdom(user_alpha2) &&
|
|
|
|
!is_an_alpha2(user_alpha2)),
|
|
|
|
"Unexpected user alpha2: %c%c\n",
|
|
|
|
user_alpha2[0],
|
|
|
|
user_alpha2[1]))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2009-12-19 06:59:01 +08:00
|
|
|
static int reg_copy_regd(const struct ieee80211_regdomain **dst_regd,
|
|
|
|
const struct ieee80211_regdomain *src_regd)
|
|
|
|
{
|
|
|
|
struct ieee80211_regdomain *regd;
|
|
|
|
int size_of_regd = 0;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
size_of_regd = sizeof(struct ieee80211_regdomain) +
|
|
|
|
((src_regd->n_reg_rules + 1) * sizeof(struct ieee80211_reg_rule));
|
|
|
|
|
|
|
|
regd = kzalloc(size_of_regd, GFP_KERNEL);
|
|
|
|
if (!regd)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
memcpy(regd, src_regd, sizeof(struct ieee80211_regdomain));
|
|
|
|
|
|
|
|
for (i = 0; i < src_regd->n_reg_rules; i++)
|
|
|
|
memcpy(®d->reg_rules[i], &src_regd->reg_rules[i],
|
|
|
|
sizeof(struct ieee80211_reg_rule));
|
|
|
|
|
|
|
|
*dst_regd = regd;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_CFG80211_INTERNAL_REGDB
|
|
|
|
struct reg_regdb_search_request {
|
|
|
|
char alpha2[2];
|
|
|
|
struct list_head list;
|
|
|
|
};
|
|
|
|
|
|
|
|
static LIST_HEAD(reg_regdb_search_list);
|
2010-03-17 03:40:59 +08:00
|
|
|
static DEFINE_MUTEX(reg_regdb_search_mutex);
|
2009-12-19 06:59:01 +08:00
|
|
|
|
|
|
|
static void reg_regdb_search(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct reg_regdb_search_request *request;
|
|
|
|
const struct ieee80211_regdomain *curdom, *regdom;
|
|
|
|
int i, r;
|
2012-09-15 06:36:57 +08:00
|
|
|
bool set_reg = false;
|
|
|
|
|
|
|
|
mutex_lock(&cfg80211_mutex);
|
2009-12-19 06:59:01 +08:00
|
|
|
|
2010-03-17 03:40:59 +08:00
|
|
|
mutex_lock(®_regdb_search_mutex);
|
2009-12-19 06:59:01 +08:00
|
|
|
while (!list_empty(®_regdb_search_list)) {
|
|
|
|
request = list_first_entry(®_regdb_search_list,
|
|
|
|
struct reg_regdb_search_request,
|
|
|
|
list);
|
|
|
|
list_del(&request->list);
|
|
|
|
|
|
|
|
for (i=0; i<reg_regdb_size; i++) {
|
|
|
|
curdom = reg_regdb[i];
|
|
|
|
|
|
|
|
if (!memcmp(request->alpha2, curdom->alpha2, 2)) {
|
|
|
|
r = reg_copy_regd(®dom, curdom);
|
|
|
|
if (r)
|
|
|
|
break;
|
2012-09-15 06:36:57 +08:00
|
|
|
set_reg = true;
|
2009-12-19 06:59:01 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
kfree(request);
|
|
|
|
}
|
2010-03-17 03:40:59 +08:00
|
|
|
mutex_unlock(®_regdb_search_mutex);
|
2012-09-15 06:36:57 +08:00
|
|
|
|
|
|
|
if (set_reg)
|
|
|
|
set_regdom(regdom);
|
|
|
|
|
|
|
|
mutex_unlock(&cfg80211_mutex);
|
2009-12-19 06:59:01 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static DECLARE_WORK(reg_regdb_work, reg_regdb_search);
|
|
|
|
|
|
|
|
static void reg_regdb_query(const char *alpha2)
|
|
|
|
{
|
|
|
|
struct reg_regdb_search_request *request;
|
|
|
|
|
|
|
|
if (!alpha2)
|
|
|
|
return;
|
|
|
|
|
|
|
|
request = kzalloc(sizeof(struct reg_regdb_search_request), GFP_KERNEL);
|
|
|
|
if (!request)
|
|
|
|
return;
|
|
|
|
|
|
|
|
memcpy(request->alpha2, alpha2, 2);
|
|
|
|
|
2010-03-17 03:40:59 +08:00
|
|
|
mutex_lock(®_regdb_search_mutex);
|
2009-12-19 06:59:01 +08:00
|
|
|
list_add_tail(&request->list, ®_regdb_search_list);
|
2010-03-17 03:40:59 +08:00
|
|
|
mutex_unlock(®_regdb_search_mutex);
|
2009-12-19 06:59:01 +08:00
|
|
|
|
|
|
|
schedule_work(®_regdb_work);
|
|
|
|
}
|
2012-03-23 22:23:31 +08:00
|
|
|
|
|
|
|
/* Feel free to add any other sanity checks here */
|
|
|
|
static void reg_regdb_size_check(void)
|
|
|
|
{
|
|
|
|
/* We should ideally BUILD_BUG_ON() but then random builds would fail */
|
|
|
|
WARN_ONCE(!reg_regdb_size, "db.txt is empty, you should update it...");
|
|
|
|
}
|
2009-12-19 06:59:01 +08:00
|
|
|
#else
|
2012-03-23 22:23:31 +08:00
|
|
|
static inline void reg_regdb_size_check(void) {}
|
2009-12-19 06:59:01 +08:00
|
|
|
static inline void reg_regdb_query(const char *alpha2) {}
|
|
|
|
#endif /* CONFIG_CFG80211_INTERNAL_REGDB */
|
|
|
|
|
2009-02-21 13:04:31 +08:00
|
|
|
/*
|
|
|
|
* This lets us keep regulatory code which is updated on a regulatory
|
2011-03-09 02:45:30 +08:00
|
|
|
* basis in userspace. Country information is filled in by
|
|
|
|
* reg_device_uevent
|
2009-02-21 13:04:31 +08:00
|
|
|
*/
|
2008-09-10 14:19:48 +08:00
|
|
|
static int call_crda(const char *alpha2)
|
|
|
|
{
|
|
|
|
if (!is_world_regdom((char *) alpha2))
|
2010-11-17 11:56:49 +08:00
|
|
|
pr_info("Calling CRDA for country: %c%c\n",
|
2008-09-10 14:19:48 +08:00
|
|
|
alpha2[0], alpha2[1]);
|
|
|
|
else
|
2010-11-17 11:56:49 +08:00
|
|
|
pr_info("Calling CRDA to update world regulatory domain\n");
|
2008-09-10 14:19:48 +08:00
|
|
|
|
2009-12-19 06:59:01 +08:00
|
|
|
/* query internal regulatory database (if it exists) */
|
|
|
|
reg_regdb_query(alpha2);
|
|
|
|
|
2011-03-09 02:45:30 +08:00
|
|
|
return kobject_uevent(®_pdev->dev.kobj, KOBJ_CHANGE);
|
2008-09-10 14:19:48 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Used by nl80211 before kmalloc'ing our regulatory domain */
|
2008-09-15 17:10:52 +08:00
|
|
|
bool reg_is_valid_request(const char *alpha2)
|
2008-09-10 14:19:48 +08:00
|
|
|
{
|
2009-05-14 05:04:41 +08:00
|
|
|
assert_cfg80211_lock();
|
|
|
|
|
2008-10-21 17:01:33 +08:00
|
|
|
if (!last_request)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return alpha2_equal(last_request->alpha2, alpha2);
|
2008-09-10 14:19:48 +08:00
|
|
|
}
|
2008-01-25 02:38:38 +08:00
|
|
|
|
2008-09-10 14:19:48 +08:00
|
|
|
/* Sanity check on a regulatory rule */
|
2008-09-15 17:10:52 +08:00
|
|
|
static bool is_valid_reg_rule(const struct ieee80211_reg_rule *rule)
|
2008-01-25 02:38:38 +08:00
|
|
|
{
|
2008-09-15 17:10:52 +08:00
|
|
|
const struct ieee80211_freq_range *freq_range = &rule->freq_range;
|
2008-09-10 14:19:48 +08:00
|
|
|
u32 freq_diff;
|
|
|
|
|
2008-11-13 06:21:55 +08:00
|
|
|
if (freq_range->start_freq_khz <= 0 || freq_range->end_freq_khz <= 0)
|
2008-09-10 14:19:48 +08:00
|
|
|
return false;
|
|
|
|
|
|
|
|
if (freq_range->start_freq_khz > freq_range->end_freq_khz)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
|
|
|
|
|
2009-03-04 05:55:21 +08:00
|
|
|
if (freq_range->end_freq_khz <= freq_range->start_freq_khz ||
|
|
|
|
freq_range->max_bandwidth_khz > freq_diff)
|
2008-09-10 14:19:48 +08:00
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2008-09-15 17:10:52 +08:00
|
|
|
static bool is_valid_rd(const struct ieee80211_regdomain *rd)
|
2008-09-10 14:19:48 +08:00
|
|
|
{
|
2008-09-15 17:10:52 +08:00
|
|
|
const struct ieee80211_reg_rule *reg_rule = NULL;
|
2008-09-10 14:19:48 +08:00
|
|
|
unsigned int i;
|
2008-01-25 02:38:38 +08:00
|
|
|
|
2008-09-10 14:19:48 +08:00
|
|
|
if (!rd->n_reg_rules)
|
|
|
|
return false;
|
2008-01-25 02:38:38 +08:00
|
|
|
|
2008-11-13 06:22:01 +08:00
|
|
|
if (WARN_ON(rd->n_reg_rules > NL80211_MAX_SUPP_REG_RULES))
|
|
|
|
return false;
|
|
|
|
|
2008-09-10 14:19:48 +08:00
|
|
|
for (i = 0; i < rd->n_reg_rules; i++) {
|
|
|
|
reg_rule = &rd->reg_rules[i];
|
|
|
|
if (!is_valid_reg_rule(reg_rule))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
2008-01-25 02:38:38 +08:00
|
|
|
}
|
|
|
|
|
2009-05-02 12:37:17 +08:00
|
|
|
static bool reg_does_bw_fit(const struct ieee80211_freq_range *freq_range,
|
|
|
|
u32 center_freq_khz,
|
|
|
|
u32 bw_khz)
|
2008-09-10 14:19:48 +08:00
|
|
|
{
|
2009-05-02 12:37:17 +08:00
|
|
|
u32 start_freq_khz, end_freq_khz;
|
|
|
|
|
|
|
|
start_freq_khz = center_freq_khz - (bw_khz/2);
|
|
|
|
end_freq_khz = center_freq_khz + (bw_khz/2);
|
|
|
|
|
|
|
|
if (start_freq_khz >= freq_range->start_freq_khz &&
|
|
|
|
end_freq_khz <= freq_range->end_freq_khz)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
2008-09-10 14:19:48 +08:00
|
|
|
}
|
2008-01-25 02:38:38 +08:00
|
|
|
|
2009-01-08 09:43:36 +08:00
|
|
|
/**
|
|
|
|
* freq_in_rule_band - tells us if a frequency is in a frequency band
|
|
|
|
* @freq_range: frequency rule we want to query
|
|
|
|
* @freq_khz: frequency we are inquiring about
|
|
|
|
*
|
|
|
|
* This lets us know if a specific frequency rule is or is not relevant to
|
|
|
|
* a specific frequency's band. Bands are device specific and artificial
|
2012-09-23 15:49:54 +08:00
|
|
|
* definitions (the "2.4 GHz band", the "5 GHz band" and the "60GHz band"),
|
|
|
|
* however it is safe for now to assume that a frequency rule should not be
|
|
|
|
* part of a frequency's band if the start freq or end freq are off by more
|
|
|
|
* than 2 GHz for the 2.4 and 5 GHz bands, and by more than 10 GHz for the
|
|
|
|
* 60 GHz band.
|
2009-01-08 09:43:36 +08:00
|
|
|
* This resolution can be lowered and should be considered as we add
|
|
|
|
* regulatory rule support for other "bands".
|
|
|
|
**/
|
|
|
|
static bool freq_in_rule_band(const struct ieee80211_freq_range *freq_range,
|
|
|
|
u32 freq_khz)
|
|
|
|
{
|
|
|
|
#define ONE_GHZ_IN_KHZ 1000000
|
2012-09-23 15:49:54 +08:00
|
|
|
/*
|
|
|
|
* From 802.11ad: directional multi-gigabit (DMG):
|
|
|
|
* Pertaining to operation in a frequency band containing a channel
|
|
|
|
* with the Channel starting frequency above 45 GHz.
|
|
|
|
*/
|
|
|
|
u32 limit = freq_khz > 45 * ONE_GHZ_IN_KHZ ?
|
|
|
|
10 * ONE_GHZ_IN_KHZ : 2 * ONE_GHZ_IN_KHZ;
|
|
|
|
if (abs(freq_khz - freq_range->start_freq_khz) <= limit)
|
2009-01-08 09:43:36 +08:00
|
|
|
return true;
|
2012-09-23 15:49:54 +08:00
|
|
|
if (abs(freq_khz - freq_range->end_freq_khz) <= limit)
|
2009-01-08 09:43:36 +08:00
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
#undef ONE_GHZ_IN_KHZ
|
|
|
|
}
|
|
|
|
|
2009-02-21 13:04:31 +08:00
|
|
|
/*
|
|
|
|
* Helper for regdom_intersect(), this does the real
|
|
|
|
* mathematical intersection fun
|
|
|
|
*/
|
2008-10-31 04:33:53 +08:00
|
|
|
static int reg_rules_intersect(
|
|
|
|
const struct ieee80211_reg_rule *rule1,
|
|
|
|
const struct ieee80211_reg_rule *rule2,
|
|
|
|
struct ieee80211_reg_rule *intersected_rule)
|
|
|
|
{
|
|
|
|
const struct ieee80211_freq_range *freq_range1, *freq_range2;
|
|
|
|
struct ieee80211_freq_range *freq_range;
|
|
|
|
const struct ieee80211_power_rule *power_rule1, *power_rule2;
|
|
|
|
struct ieee80211_power_rule *power_rule;
|
|
|
|
u32 freq_diff;
|
|
|
|
|
|
|
|
freq_range1 = &rule1->freq_range;
|
|
|
|
freq_range2 = &rule2->freq_range;
|
|
|
|
freq_range = &intersected_rule->freq_range;
|
|
|
|
|
|
|
|
power_rule1 = &rule1->power_rule;
|
|
|
|
power_rule2 = &rule2->power_rule;
|
|
|
|
power_rule = &intersected_rule->power_rule;
|
|
|
|
|
|
|
|
freq_range->start_freq_khz = max(freq_range1->start_freq_khz,
|
|
|
|
freq_range2->start_freq_khz);
|
|
|
|
freq_range->end_freq_khz = min(freq_range1->end_freq_khz,
|
|
|
|
freq_range2->end_freq_khz);
|
|
|
|
freq_range->max_bandwidth_khz = min(freq_range1->max_bandwidth_khz,
|
|
|
|
freq_range2->max_bandwidth_khz);
|
|
|
|
|
|
|
|
freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
|
|
|
|
if (freq_range->max_bandwidth_khz > freq_diff)
|
|
|
|
freq_range->max_bandwidth_khz = freq_diff;
|
|
|
|
|
|
|
|
power_rule->max_eirp = min(power_rule1->max_eirp,
|
|
|
|
power_rule2->max_eirp);
|
|
|
|
power_rule->max_antenna_gain = min(power_rule1->max_antenna_gain,
|
|
|
|
power_rule2->max_antenna_gain);
|
|
|
|
|
|
|
|
intersected_rule->flags = (rule1->flags | rule2->flags);
|
|
|
|
|
|
|
|
if (!is_valid_reg_rule(intersected_rule))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regdom_intersect - do the intersection between two regulatory domains
|
|
|
|
* @rd1: first regulatory domain
|
|
|
|
* @rd2: second regulatory domain
|
|
|
|
*
|
|
|
|
* Use this function to get the intersection between two regulatory domains.
|
|
|
|
* Once completed we will mark the alpha2 for the rd as intersected, "98",
|
|
|
|
* as no one single alpha2 can represent this regulatory domain.
|
|
|
|
*
|
|
|
|
* Returns a pointer to the regulatory domain structure which will hold the
|
|
|
|
* resulting intersection of rules between rd1 and rd2. We will
|
|
|
|
* kzalloc() this structure for you.
|
|
|
|
*/
|
|
|
|
static struct ieee80211_regdomain *regdom_intersect(
|
|
|
|
const struct ieee80211_regdomain *rd1,
|
|
|
|
const struct ieee80211_regdomain *rd2)
|
|
|
|
{
|
|
|
|
int r, size_of_regd;
|
|
|
|
unsigned int x, y;
|
|
|
|
unsigned int num_rules = 0, rule_idx = 0;
|
|
|
|
const struct ieee80211_reg_rule *rule1, *rule2;
|
|
|
|
struct ieee80211_reg_rule *intersected_rule;
|
|
|
|
struct ieee80211_regdomain *rd;
|
|
|
|
/* This is just a dummy holder to help us count */
|
|
|
|
struct ieee80211_reg_rule irule;
|
|
|
|
|
|
|
|
/* Uses the stack temporarily for counter arithmetic */
|
|
|
|
intersected_rule = &irule;
|
|
|
|
|
|
|
|
memset(intersected_rule, 0, sizeof(struct ieee80211_reg_rule));
|
|
|
|
|
|
|
|
if (!rd1 || !rd2)
|
|
|
|
return NULL;
|
|
|
|
|
2009-02-21 13:04:31 +08:00
|
|
|
/*
|
|
|
|
* First we get a count of the rules we'll need, then we actually
|
2008-10-31 04:33:53 +08:00
|
|
|
* build them. This is to so we can malloc() and free() a
|
|
|
|
* regdomain once. The reason we use reg_rules_intersect() here
|
|
|
|
* is it will return -EINVAL if the rule computed makes no sense.
|
2009-02-21 13:04:31 +08:00
|
|
|
* All rules that do check out OK are valid.
|
|
|
|
*/
|
2008-10-31 04:33:53 +08:00
|
|
|
|
|
|
|
for (x = 0; x < rd1->n_reg_rules; x++) {
|
|
|
|
rule1 = &rd1->reg_rules[x];
|
|
|
|
for (y = 0; y < rd2->n_reg_rules; y++) {
|
|
|
|
rule2 = &rd2->reg_rules[y];
|
|
|
|
if (!reg_rules_intersect(rule1, rule2,
|
|
|
|
intersected_rule))
|
|
|
|
num_rules++;
|
|
|
|
memset(intersected_rule, 0,
|
|
|
|
sizeof(struct ieee80211_reg_rule));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!num_rules)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
size_of_regd = sizeof(struct ieee80211_regdomain) +
|
|
|
|
((num_rules + 1) * sizeof(struct ieee80211_reg_rule));
|
|
|
|
|
|
|
|
rd = kzalloc(size_of_regd, GFP_KERNEL);
|
|
|
|
if (!rd)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
for (x = 0; x < rd1->n_reg_rules; x++) {
|
|
|
|
rule1 = &rd1->reg_rules[x];
|
|
|
|
for (y = 0; y < rd2->n_reg_rules; y++) {
|
|
|
|
rule2 = &rd2->reg_rules[y];
|
2009-02-21 13:04:31 +08:00
|
|
|
/*
|
|
|
|
* This time around instead of using the stack lets
|
2008-10-31 04:33:53 +08:00
|
|
|
* write to the target rule directly saving ourselves
|
2009-02-21 13:04:31 +08:00
|
|
|
* a memcpy()
|
|
|
|
*/
|
2008-10-31 04:33:53 +08:00
|
|
|
intersected_rule = &rd->reg_rules[rule_idx];
|
|
|
|
r = reg_rules_intersect(rule1, rule2,
|
|
|
|
intersected_rule);
|
2009-02-21 13:04:31 +08:00
|
|
|
/*
|
|
|
|
* No need to memset here the intersected rule here as
|
|
|
|
* we're not using the stack anymore
|
|
|
|
*/
|
2008-10-31 04:33:53 +08:00
|
|
|
if (r)
|
|
|
|
continue;
|
|
|
|
rule_idx++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rule_idx != num_rules) {
|
|
|
|
kfree(rd);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
rd->n_reg_rules = num_rules;
|
|
|
|
rd->alpha2[0] = '9';
|
|
|
|
rd->alpha2[1] = '8';
|
|
|
|
|
|
|
|
return rd;
|
|
|
|
}
|
|
|
|
|
2009-02-21 13:04:31 +08:00
|
|
|
/*
|
|
|
|
* XXX: add support for the rest of enum nl80211_reg_rule_flags, we may
|
|
|
|
* want to just have the channel structure use these
|
|
|
|
*/
|
2008-09-10 14:19:48 +08:00
|
|
|
static u32 map_regdom_flags(u32 rd_flags)
|
|
|
|
{
|
|
|
|
u32 channel_flags = 0;
|
|
|
|
if (rd_flags & NL80211_RRF_PASSIVE_SCAN)
|
|
|
|
channel_flags |= IEEE80211_CHAN_PASSIVE_SCAN;
|
|
|
|
if (rd_flags & NL80211_RRF_NO_IBSS)
|
|
|
|
channel_flags |= IEEE80211_CHAN_NO_IBSS;
|
|
|
|
if (rd_flags & NL80211_RRF_DFS)
|
|
|
|
channel_flags |= IEEE80211_CHAN_RADAR;
|
2012-08-02 04:58:42 +08:00
|
|
|
if (rd_flags & NL80211_RRF_NO_OFDM)
|
|
|
|
channel_flags |= IEEE80211_CHAN_NO_OFDM;
|
2008-09-10 14:19:48 +08:00
|
|
|
return channel_flags;
|
|
|
|
}
|
|
|
|
|
2009-01-23 07:05:44 +08:00
|
|
|
static int freq_reg_info_regd(struct wiphy *wiphy,
|
|
|
|
u32 center_freq,
|
2009-05-02 12:37:17 +08:00
|
|
|
u32 desired_bw_khz,
|
2009-01-23 07:05:44 +08:00
|
|
|
const struct ieee80211_reg_rule **reg_rule,
|
|
|
|
const struct ieee80211_regdomain *custom_regd)
|
2008-01-25 02:38:38 +08:00
|
|
|
{
|
|
|
|
int i;
|
2009-01-08 09:43:36 +08:00
|
|
|
bool band_rule_found = false;
|
2009-01-08 09:43:34 +08:00
|
|
|
const struct ieee80211_regdomain *regd;
|
2009-05-02 12:37:17 +08:00
|
|
|
bool bw_fits = false;
|
|
|
|
|
|
|
|
if (!desired_bw_khz)
|
|
|
|
desired_bw_khz = MHZ_TO_KHZ(20);
|
2008-01-25 02:38:38 +08:00
|
|
|
|
2009-01-23 07:05:44 +08:00
|
|
|
regd = custom_regd ? custom_regd : cfg80211_regdomain;
|
2009-01-08 09:43:34 +08:00
|
|
|
|
2009-02-21 13:04:31 +08:00
|
|
|
/*
|
|
|
|
* Follow the driver's regulatory domain, if present, unless a country
|
|
|
|
* IE has been processed or a user wants to help complaince further
|
|
|
|
*/
|
2010-12-16 11:24:11 +08:00
|
|
|
if (!custom_regd &&
|
|
|
|
last_request->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
|
2009-03-10 10:07:41 +08:00
|
|
|
last_request->initiator != NL80211_REGDOM_SET_BY_USER &&
|
2009-01-08 09:43:34 +08:00
|
|
|
wiphy->regd)
|
|
|
|
regd = wiphy->regd;
|
|
|
|
|
|
|
|
if (!regd)
|
2008-09-10 14:19:48 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2009-01-08 09:43:34 +08:00
|
|
|
for (i = 0; i < regd->n_reg_rules; i++) {
|
2008-09-10 14:19:48 +08:00
|
|
|
const struct ieee80211_reg_rule *rr;
|
|
|
|
const struct ieee80211_freq_range *fr = NULL;
|
|
|
|
|
2009-01-08 09:43:34 +08:00
|
|
|
rr = ®d->reg_rules[i];
|
2008-09-10 14:19:48 +08:00
|
|
|
fr = &rr->freq_range;
|
2009-01-08 09:43:36 +08:00
|
|
|
|
2009-02-21 13:04:31 +08:00
|
|
|
/*
|
|
|
|
* We only need to know if one frequency rule was
|
2009-01-08 09:43:36 +08:00
|
|
|
* was in center_freq's band, that's enough, so lets
|
2009-02-21 13:04:31 +08:00
|
|
|
* not overwrite it once found
|
|
|
|
*/
|
2009-01-08 09:43:36 +08:00
|
|
|
if (!band_rule_found)
|
|
|
|
band_rule_found = freq_in_rule_band(fr, center_freq);
|
|
|
|
|
2009-05-02 12:37:17 +08:00
|
|
|
bw_fits = reg_does_bw_fit(fr,
|
|
|
|
center_freq,
|
|
|
|
desired_bw_khz);
|
2009-01-08 09:43:36 +08:00
|
|
|
|
2009-05-02 12:37:17 +08:00
|
|
|
if (band_rule_found && bw_fits) {
|
2008-09-10 14:19:48 +08:00
|
|
|
*reg_rule = rr;
|
2009-05-02 12:37:17 +08:00
|
|
|
return 0;
|
2008-01-25 02:38:38 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-08 09:43:36 +08:00
|
|
|
if (!band_rule_found)
|
|
|
|
return -ERANGE;
|
|
|
|
|
2009-05-02 12:37:17 +08:00
|
|
|
return -EINVAL;
|
2008-09-10 14:19:48 +08:00
|
|
|
}
|
|
|
|
|
2009-05-02 12:37:17 +08:00
|
|
|
int freq_reg_info(struct wiphy *wiphy,
|
|
|
|
u32 center_freq,
|
|
|
|
u32 desired_bw_khz,
|
|
|
|
const struct ieee80211_reg_rule **reg_rule)
|
2009-01-23 07:05:44 +08:00
|
|
|
{
|
2009-05-02 06:44:50 +08:00
|
|
|
assert_cfg80211_lock();
|
2009-05-02 12:37:17 +08:00
|
|
|
return freq_reg_info_regd(wiphy,
|
|
|
|
center_freq,
|
|
|
|
desired_bw_khz,
|
|
|
|
reg_rule,
|
|
|
|
NULL);
|
2009-01-23 07:05:44 +08:00
|
|
|
}
|
2010-07-16 02:57:33 +08:00
|
|
|
EXPORT_SYMBOL(freq_reg_info);
|
2008-09-10 14:19:48 +08:00
|
|
|
|
2010-10-21 21:47:03 +08:00
|
|
|
#ifdef CONFIG_CFG80211_REG_DEBUG
|
|
|
|
static const char *reg_initiator_name(enum nl80211_reg_initiator initiator)
|
|
|
|
{
|
|
|
|
switch (initiator) {
|
|
|
|
case NL80211_REGDOM_SET_BY_CORE:
|
|
|
|
return "Set by core";
|
|
|
|
case NL80211_REGDOM_SET_BY_USER:
|
|
|
|
return "Set by user";
|
|
|
|
case NL80211_REGDOM_SET_BY_DRIVER:
|
|
|
|
return "Set by driver";
|
|
|
|
case NL80211_REGDOM_SET_BY_COUNTRY_IE:
|
|
|
|
return "Set by country IE";
|
|
|
|
default:
|
|
|
|
WARN_ON(1);
|
|
|
|
return "Set by bug";
|
|
|
|
}
|
|
|
|
}
|
2010-10-21 21:47:04 +08:00
|
|
|
|
|
|
|
static void chan_reg_rule_print_dbg(struct ieee80211_channel *chan,
|
|
|
|
u32 desired_bw_khz,
|
|
|
|
const struct ieee80211_reg_rule *reg_rule)
|
|
|
|
{
|
|
|
|
const struct ieee80211_power_rule *power_rule;
|
|
|
|
const struct ieee80211_freq_range *freq_range;
|
|
|
|
char max_antenna_gain[32];
|
|
|
|
|
|
|
|
power_rule = ®_rule->power_rule;
|
|
|
|
freq_range = ®_rule->freq_range;
|
|
|
|
|
|
|
|
if (!power_rule->max_antenna_gain)
|
|
|
|
snprintf(max_antenna_gain, 32, "N/A");
|
|
|
|
else
|
|
|
|
snprintf(max_antenna_gain, 32, "%d", power_rule->max_antenna_gain);
|
|
|
|
|
2010-10-21 01:18:59 +08:00
|
|
|
REG_DBG_PRINT("Updating information on frequency %d MHz "
|
2010-12-30 06:09:02 +08:00
|
|
|
"for a %d MHz width channel with regulatory rule:\n",
|
2010-10-21 21:47:04 +08:00
|
|
|
chan->center_freq,
|
|
|
|
KHZ_TO_MHZ(desired_bw_khz));
|
|
|
|
|
2011-09-01 23:54:12 +08:00
|
|
|
REG_DBG_PRINT("%d KHz - %d KHz @ %d KHz), (%s mBi, %d mBm)\n",
|
2010-10-21 21:47:04 +08:00
|
|
|
freq_range->start_freq_khz,
|
|
|
|
freq_range->end_freq_khz,
|
2011-09-01 23:54:12 +08:00
|
|
|
freq_range->max_bandwidth_khz,
|
2010-10-21 21:47:04 +08:00
|
|
|
max_antenna_gain,
|
|
|
|
power_rule->max_eirp);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static void chan_reg_rule_print_dbg(struct ieee80211_channel *chan,
|
|
|
|
u32 desired_bw_khz,
|
|
|
|
const struct ieee80211_reg_rule *reg_rule)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
2010-10-21 21:47:03 +08:00
|
|
|
#endif
|
|
|
|
|
2009-05-02 12:37:17 +08:00
|
|
|
/*
|
|
|
|
* Note that right now we assume the desired channel bandwidth
|
|
|
|
* is always 20 MHz for each individual channel (HT40 uses 20 MHz
|
|
|
|
* per channel, the primary and the extension channel). To support
|
|
|
|
* smaller custom bandwidths such as 5 MHz or 10 MHz we'll need a
|
|
|
|
* new ieee80211_channel.target_bw and re run the regulatory check
|
|
|
|
* on the wiphy with the target_bw specified. Then we can simply use
|
|
|
|
* that below for the desired_bw_khz below.
|
|
|
|
*/
|
2010-10-21 01:18:53 +08:00
|
|
|
static void handle_channel(struct wiphy *wiphy,
|
|
|
|
enum nl80211_reg_initiator initiator,
|
|
|
|
enum ieee80211_band band,
|
2009-01-08 09:43:33 +08:00
|
|
|
unsigned int chan_idx)
|
2008-09-10 14:19:48 +08:00
|
|
|
{
|
|
|
|
int r;
|
2009-05-02 12:37:17 +08:00
|
|
|
u32 flags, bw_flags = 0;
|
|
|
|
u32 desired_bw_khz = MHZ_TO_KHZ(20);
|
2008-09-10 14:19:48 +08:00
|
|
|
const struct ieee80211_reg_rule *reg_rule = NULL;
|
|
|
|
const struct ieee80211_power_rule *power_rule = NULL;
|
2009-05-02 12:37:17 +08:00
|
|
|
const struct ieee80211_freq_range *freq_range = NULL;
|
2009-01-08 09:43:33 +08:00
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
struct ieee80211_channel *chan;
|
2009-02-21 13:04:30 +08:00
|
|
|
struct wiphy *request_wiphy = NULL;
|
2009-01-08 09:43:33 +08:00
|
|
|
|
2009-02-21 13:04:25 +08:00
|
|
|
assert_cfg80211_lock();
|
|
|
|
|
2009-02-21 13:04:26 +08:00
|
|
|
request_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);
|
|
|
|
|
2009-01-08 09:43:33 +08:00
|
|
|
sband = wiphy->bands[band];
|
|
|
|
BUG_ON(chan_idx >= sband->n_channels);
|
|
|
|
chan = &sband->channels[chan_idx];
|
|
|
|
|
|
|
|
flags = chan->orig_flags;
|
2008-09-10 14:19:48 +08:00
|
|
|
|
2009-05-02 12:37:17 +08:00
|
|
|
r = freq_reg_info(wiphy,
|
|
|
|
MHZ_TO_KHZ(chan->center_freq),
|
|
|
|
desired_bw_khz,
|
|
|
|
®_rule);
|
2008-09-10 14:19:48 +08:00
|
|
|
|
2010-10-21 01:18:55 +08:00
|
|
|
if (r) {
|
|
|
|
/*
|
|
|
|
* We will disable all channels that do not match our
|
2011-03-31 09:57:33 +08:00
|
|
|
* received regulatory rule unless the hint is coming
|
2010-10-21 01:18:55 +08:00
|
|
|
* from a Country IE and the Country IE had no information
|
|
|
|
* about a band. The IEEE 802.11 spec allows for an AP
|
|
|
|
* to send only a subset of the regulatory rules allowed,
|
|
|
|
* so an AP in the US that only supports 2.4 GHz may only send
|
|
|
|
* a country IE with information for the 2.4 GHz band
|
|
|
|
* while 5 GHz is still supported.
|
|
|
|
*/
|
|
|
|
if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
|
|
|
|
r == -ERANGE)
|
|
|
|
return;
|
|
|
|
|
2010-10-21 01:18:59 +08:00
|
|
|
REG_DBG_PRINT("Disabling freq %d MHz\n", chan->center_freq);
|
2010-10-21 01:18:55 +08:00
|
|
|
chan->flags = IEEE80211_CHAN_DISABLED;
|
2008-01-25 02:38:38 +08:00
|
|
|
return;
|
2010-10-21 01:18:55 +08:00
|
|
|
}
|
2008-01-25 02:38:38 +08:00
|
|
|
|
2010-10-21 21:47:04 +08:00
|
|
|
chan_reg_rule_print_dbg(chan, desired_bw_khz, reg_rule);
|
|
|
|
|
2008-09-10 14:19:48 +08:00
|
|
|
power_rule = ®_rule->power_rule;
|
2009-05-02 12:37:17 +08:00
|
|
|
freq_range = ®_rule->freq_range;
|
|
|
|
|
|
|
|
if (freq_range->max_bandwidth_khz < MHZ_TO_KHZ(40))
|
|
|
|
bw_flags = IEEE80211_CHAN_NO_HT40;
|
2008-09-10 14:19:48 +08:00
|
|
|
|
2009-03-10 10:07:41 +08:00
|
|
|
if (last_request->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
|
2009-02-21 13:04:26 +08:00
|
|
|
request_wiphy && request_wiphy == wiphy &&
|
2009-11-19 07:56:28 +08:00
|
|
|
request_wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY) {
|
2009-02-21 13:04:31 +08:00
|
|
|
/*
|
2011-03-31 09:57:33 +08:00
|
|
|
* This guarantees the driver's requested regulatory domain
|
2009-01-23 07:05:52 +08:00
|
|
|
* will always be used as a base for further regulatory
|
2009-02-21 13:04:31 +08:00
|
|
|
* settings
|
|
|
|
*/
|
2009-01-23 07:05:52 +08:00
|
|
|
chan->flags = chan->orig_flags =
|
2009-05-02 12:37:17 +08:00
|
|
|
map_regdom_flags(reg_rule->flags) | bw_flags;
|
2009-01-23 07:05:52 +08:00
|
|
|
chan->max_antenna_gain = chan->orig_mag =
|
|
|
|
(int) MBI_TO_DBI(power_rule->max_antenna_gain);
|
|
|
|
chan->max_power = chan->orig_mpwr =
|
|
|
|
(int) MBM_TO_DBM(power_rule->max_eirp);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-09-14 16:58:17 +08:00
|
|
|
chan->beacon_found = false;
|
2009-05-02 12:37:17 +08:00
|
|
|
chan->flags = flags | bw_flags | map_regdom_flags(reg_rule->flags);
|
2008-01-25 02:38:38 +08:00
|
|
|
chan->max_antenna_gain = min(chan->orig_mag,
|
2008-09-10 14:19:48 +08:00
|
|
|
(int) MBI_TO_DBI(power_rule->max_antenna_gain));
|
2012-01-12 02:33:39 +08:00
|
|
|
chan->max_reg_power = (int) MBM_TO_DBM(power_rule->max_eirp);
|
2012-07-24 14:35:39 +08:00
|
|
|
if (chan->orig_mpwr) {
|
|
|
|
/*
|
|
|
|
* Devices that have their own custom regulatory domain
|
|
|
|
* but also use WIPHY_FLAG_STRICT_REGULATORY will follow the
|
|
|
|
* passed country IE power settings.
|
|
|
|
*/
|
|
|
|
if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
|
|
|
|
wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY &&
|
|
|
|
wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY)
|
|
|
|
chan->max_power = chan->max_reg_power;
|
|
|
|
else
|
|
|
|
chan->max_power = min(chan->orig_mpwr,
|
|
|
|
chan->max_reg_power);
|
|
|
|
} else
|
|
|
|
chan->max_power = chan->max_reg_power;
|
2008-01-25 02:38:38 +08:00
|
|
|
}
|
|
|
|
|
2010-10-21 01:18:53 +08:00
|
|
|
static void handle_band(struct wiphy *wiphy,
|
|
|
|
enum ieee80211_band band,
|
|
|
|
enum nl80211_reg_initiator initiator)
|
2008-01-25 02:38:38 +08:00
|
|
|
{
|
2009-01-08 09:43:33 +08:00
|
|
|
unsigned int i;
|
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
|
|
|
|
BUG_ON(!wiphy->bands[band]);
|
|
|
|
sband = wiphy->bands[band];
|
2008-01-25 02:38:38 +08:00
|
|
|
|
|
|
|
for (i = 0; i < sband->n_channels; i++)
|
2010-10-21 01:18:53 +08:00
|
|
|
handle_channel(wiphy, initiator, band, i);
|
2008-01-25 02:38:38 +08:00
|
|
|
}
|
|
|
|
|
2012-07-13 02:49:18 +08:00
|
|
|
static bool reg_request_cell_base(struct regulatory_request *request)
|
|
|
|
{
|
|
|
|
if (request->initiator != NL80211_REGDOM_SET_BY_USER)
|
|
|
|
return false;
|
|
|
|
if (request->user_reg_hint_type != NL80211_USER_REG_HINT_CELL_BASE)
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool reg_last_request_cell_base(void)
|
|
|
|
{
|
2012-07-18 20:41:29 +08:00
|
|
|
bool val;
|
2012-07-13 02:49:18 +08:00
|
|
|
assert_cfg80211_lock();
|
|
|
|
|
|
|
|
mutex_lock(®_mutex);
|
2012-07-18 20:41:29 +08:00
|
|
|
val = reg_request_cell_base(last_request);
|
2012-07-13 02:49:18 +08:00
|
|
|
mutex_unlock(®_mutex);
|
2012-07-18 20:41:29 +08:00
|
|
|
return val;
|
2012-07-13 02:49:18 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_CFG80211_CERTIFICATION_ONUS
|
|
|
|
|
|
|
|
/* Core specific check */
|
|
|
|
static int reg_ignore_cell_hint(struct regulatory_request *pending_request)
|
|
|
|
{
|
|
|
|
if (!reg_num_devs_support_basehint)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
if (reg_request_cell_base(last_request)) {
|
|
|
|
if (!regdom_changes(pending_request->alpha2))
|
|
|
|
return -EALREADY;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Device specific check */
|
|
|
|
static bool reg_dev_ignore_cell_hint(struct wiphy *wiphy)
|
|
|
|
{
|
|
|
|
if (!(wiphy->features & NL80211_FEATURE_CELL_BASE_REG_HINTS))
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static int reg_ignore_cell_hint(struct regulatory_request *pending_request)
|
|
|
|
{
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
}
|
|
|
|
static int reg_dev_ignore_cell_hint(struct wiphy *wiphy)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2009-03-10 10:07:41 +08:00
|
|
|
static bool ignore_reg_update(struct wiphy *wiphy,
|
|
|
|
enum nl80211_reg_initiator initiator)
|
2008-11-13 06:22:03 +08:00
|
|
|
{
|
2010-10-21 21:47:03 +08:00
|
|
|
if (!last_request) {
|
2010-10-21 01:18:59 +08:00
|
|
|
REG_DBG_PRINT("Ignoring regulatory request %s since "
|
2010-10-21 21:47:03 +08:00
|
|
|
"last_request is not set\n",
|
|
|
|
reg_initiator_name(initiator));
|
2008-11-13 06:22:03 +08:00
|
|
|
return true;
|
2010-10-21 21:47:03 +08:00
|
|
|
}
|
|
|
|
|
2009-03-10 10:07:41 +08:00
|
|
|
if (initiator == NL80211_REGDOM_SET_BY_CORE &&
|
2010-10-21 21:47:03 +08:00
|
|
|
wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY) {
|
2010-10-21 01:18:59 +08:00
|
|
|
REG_DBG_PRINT("Ignoring regulatory request %s "
|
2010-10-21 21:47:03 +08:00
|
|
|
"since the driver uses its own custom "
|
2011-07-30 05:51:25 +08:00
|
|
|
"regulatory domain\n",
|
2010-10-21 21:47:03 +08:00
|
|
|
reg_initiator_name(initiator));
|
2008-11-13 06:22:03 +08:00
|
|
|
return true;
|
2010-10-21 21:47:03 +08:00
|
|
|
}
|
|
|
|
|
2009-02-21 13:04:31 +08:00
|
|
|
/*
|
|
|
|
* wiphy->regd will be set once the device has its own
|
|
|
|
* desired regulatory domain set
|
|
|
|
*/
|
2009-11-19 07:56:28 +08:00
|
|
|
if (wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY && !wiphy->regd &&
|
2010-10-21 01:18:54 +08:00
|
|
|
initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
|
2010-10-21 21:47:03 +08:00
|
|
|
!is_world_regdom(last_request->alpha2)) {
|
2010-10-21 01:18:59 +08:00
|
|
|
REG_DBG_PRINT("Ignoring regulatory request %s "
|
2011-07-25 17:18:58 +08:00
|
|
|
"since the driver requires its own regulatory "
|
2011-07-30 05:51:25 +08:00
|
|
|
"domain to be set first\n",
|
2010-10-21 21:47:03 +08:00
|
|
|
reg_initiator_name(initiator));
|
2008-11-13 06:22:03 +08:00
|
|
|
return true;
|
2010-10-21 21:47:03 +08:00
|
|
|
}
|
|
|
|
|
2012-07-13 02:49:18 +08:00
|
|
|
if (reg_request_cell_base(last_request))
|
|
|
|
return reg_dev_ignore_cell_hint(wiphy);
|
|
|
|
|
2008-11-13 06:22:03 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2009-02-21 13:20:39 +08:00
|
|
|
static void handle_reg_beacon(struct wiphy *wiphy,
|
|
|
|
unsigned int chan_idx,
|
|
|
|
struct reg_beacon *reg_beacon)
|
|
|
|
{
|
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
struct ieee80211_channel *chan;
|
2009-04-03 02:08:09 +08:00
|
|
|
bool channel_changed = false;
|
|
|
|
struct ieee80211_channel chan_before;
|
2009-02-21 13:20:39 +08:00
|
|
|
|
|
|
|
assert_cfg80211_lock();
|
|
|
|
|
|
|
|
sband = wiphy->bands[reg_beacon->chan.band];
|
|
|
|
chan = &sband->channels[chan_idx];
|
|
|
|
|
|
|
|
if (likely(chan->center_freq != reg_beacon->chan.center_freq))
|
|
|
|
return;
|
|
|
|
|
2009-04-03 02:08:09 +08:00
|
|
|
if (chan->beacon_found)
|
|
|
|
return;
|
|
|
|
|
|
|
|
chan->beacon_found = true;
|
|
|
|
|
2009-11-19 07:56:28 +08:00
|
|
|
if (wiphy->flags & WIPHY_FLAG_DISABLE_BEACON_HINTS)
|
2009-07-31 08:43:48 +08:00
|
|
|
return;
|
|
|
|
|
2009-04-03 02:08:09 +08:00
|
|
|
chan_before.center_freq = chan->center_freq;
|
|
|
|
chan_before.flags = chan->flags;
|
|
|
|
|
2009-07-31 08:43:48 +08:00
|
|
|
if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN) {
|
2009-02-21 13:20:39 +08:00
|
|
|
chan->flags &= ~IEEE80211_CHAN_PASSIVE_SCAN;
|
2009-04-03 02:08:09 +08:00
|
|
|
channel_changed = true;
|
2009-02-21 13:20:39 +08:00
|
|
|
}
|
|
|
|
|
2009-07-31 08:43:48 +08:00
|
|
|
if (chan->flags & IEEE80211_CHAN_NO_IBSS) {
|
2009-02-21 13:20:39 +08:00
|
|
|
chan->flags &= ~IEEE80211_CHAN_NO_IBSS;
|
2009-04-03 02:08:09 +08:00
|
|
|
channel_changed = true;
|
2009-02-21 13:20:39 +08:00
|
|
|
}
|
|
|
|
|
2009-04-03 02:08:09 +08:00
|
|
|
if (channel_changed)
|
|
|
|
nl80211_send_beacon_hint_event(wiphy, &chan_before, chan);
|
2009-02-21 13:20:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Called when a scan on a wiphy finds a beacon on
|
|
|
|
* new channel
|
|
|
|
*/
|
|
|
|
static void wiphy_update_new_beacon(struct wiphy *wiphy,
|
|
|
|
struct reg_beacon *reg_beacon)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
|
|
|
|
assert_cfg80211_lock();
|
|
|
|
|
|
|
|
if (!wiphy->bands[reg_beacon->chan.band])
|
|
|
|
return;
|
|
|
|
|
|
|
|
sband = wiphy->bands[reg_beacon->chan.band];
|
|
|
|
|
|
|
|
for (i = 0; i < sband->n_channels; i++)
|
|
|
|
handle_reg_beacon(wiphy, i, reg_beacon);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Called upon reg changes or a new wiphy is added
|
|
|
|
*/
|
|
|
|
static void wiphy_update_beacon_reg(struct wiphy *wiphy)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
struct reg_beacon *reg_beacon;
|
|
|
|
|
|
|
|
assert_cfg80211_lock();
|
|
|
|
|
|
|
|
if (list_empty(®_beacon_list))
|
|
|
|
return;
|
|
|
|
|
|
|
|
list_for_each_entry(reg_beacon, ®_beacon_list, list) {
|
|
|
|
if (!wiphy->bands[reg_beacon->chan.band])
|
|
|
|
continue;
|
|
|
|
sband = wiphy->bands[reg_beacon->chan.band];
|
|
|
|
for (i = 0; i < sband->n_channels; i++)
|
|
|
|
handle_reg_beacon(wiphy, i, reg_beacon);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool reg_is_world_roaming(struct wiphy *wiphy)
|
|
|
|
{
|
|
|
|
if (is_world_regdom(cfg80211_regdomain->alpha2) ||
|
|
|
|
(wiphy->regd && is_world_regdom(wiphy->regd->alpha2)))
|
|
|
|
return true;
|
2009-05-02 12:34:15 +08:00
|
|
|
if (last_request &&
|
|
|
|
last_request->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
|
2009-11-19 07:56:28 +08:00
|
|
|
wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY)
|
2009-02-21 13:20:39 +08:00
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Reap the advantages of previously found beacons */
|
|
|
|
static void reg_process_beacons(struct wiphy *wiphy)
|
|
|
|
{
|
2009-05-02 12:34:15 +08:00
|
|
|
/*
|
|
|
|
* Means we are just firing up cfg80211, so no beacons would
|
|
|
|
* have been processed yet.
|
|
|
|
*/
|
|
|
|
if (!last_request)
|
|
|
|
return;
|
2009-02-21 13:20:39 +08:00
|
|
|
if (!reg_is_world_roaming(wiphy))
|
|
|
|
return;
|
|
|
|
wiphy_update_beacon_reg(wiphy);
|
|
|
|
}
|
|
|
|
|
2009-05-02 12:37:17 +08:00
|
|
|
static bool is_ht40_not_allowed(struct ieee80211_channel *chan)
|
|
|
|
{
|
|
|
|
if (!chan)
|
|
|
|
return true;
|
|
|
|
if (chan->flags & IEEE80211_CHAN_DISABLED)
|
|
|
|
return true;
|
|
|
|
/* This would happen when regulatory rules disallow HT40 completely */
|
|
|
|
if (IEEE80211_CHAN_NO_HT40 == (chan->flags & (IEEE80211_CHAN_NO_HT40)))
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void reg_process_ht_flags_channel(struct wiphy *wiphy,
|
|
|
|
enum ieee80211_band band,
|
|
|
|
unsigned int chan_idx)
|
|
|
|
{
|
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
struct ieee80211_channel *channel;
|
|
|
|
struct ieee80211_channel *channel_before = NULL, *channel_after = NULL;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
assert_cfg80211_lock();
|
|
|
|
|
|
|
|
sband = wiphy->bands[band];
|
|
|
|
BUG_ON(chan_idx >= sband->n_channels);
|
|
|
|
channel = &sband->channels[chan_idx];
|
|
|
|
|
|
|
|
if (is_ht40_not_allowed(channel)) {
|
|
|
|
channel->flags |= IEEE80211_CHAN_NO_HT40;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We need to ensure the extension channels exist to
|
|
|
|
* be able to use HT40- or HT40+, this finds them (or not)
|
|
|
|
*/
|
|
|
|
for (i = 0; i < sband->n_channels; i++) {
|
|
|
|
struct ieee80211_channel *c = &sband->channels[i];
|
|
|
|
if (c->center_freq == (channel->center_freq - 20))
|
|
|
|
channel_before = c;
|
|
|
|
if (c->center_freq == (channel->center_freq + 20))
|
|
|
|
channel_after = c;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Please note that this assumes target bandwidth is 20 MHz,
|
|
|
|
* if that ever changes we also need to change the below logic
|
|
|
|
* to include that as well.
|
|
|
|
*/
|
|
|
|
if (is_ht40_not_allowed(channel_before))
|
2009-05-02 12:37:18 +08:00
|
|
|
channel->flags |= IEEE80211_CHAN_NO_HT40MINUS;
|
2009-05-02 12:37:17 +08:00
|
|
|
else
|
2009-05-02 12:37:18 +08:00
|
|
|
channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
|
2009-05-02 12:37:17 +08:00
|
|
|
|
|
|
|
if (is_ht40_not_allowed(channel_after))
|
2009-05-02 12:37:18 +08:00
|
|
|
channel->flags |= IEEE80211_CHAN_NO_HT40PLUS;
|
2009-05-02 12:37:17 +08:00
|
|
|
else
|
2009-05-02 12:37:18 +08:00
|
|
|
channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
|
2009-05-02 12:37:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void reg_process_ht_flags_band(struct wiphy *wiphy,
|
|
|
|
enum ieee80211_band band)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
|
|
|
|
BUG_ON(!wiphy->bands[band]);
|
|
|
|
sband = wiphy->bands[band];
|
|
|
|
|
|
|
|
for (i = 0; i < sband->n_channels; i++)
|
|
|
|
reg_process_ht_flags_channel(wiphy, band, i);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void reg_process_ht_flags(struct wiphy *wiphy)
|
|
|
|
{
|
|
|
|
enum ieee80211_band band;
|
|
|
|
|
|
|
|
if (!wiphy)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
|
|
|
|
if (wiphy->bands[band])
|
|
|
|
reg_process_ht_flags_band(wiphy, band);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2011-08-31 05:38:53 +08:00
|
|
|
static void wiphy_update_regulatory(struct wiphy *wiphy,
|
|
|
|
enum nl80211_reg_initiator initiator)
|
2008-09-10 14:19:48 +08:00
|
|
|
{
|
|
|
|
enum ieee80211_band band;
|
2009-01-23 07:05:50 +08:00
|
|
|
|
2011-08-31 05:38:53 +08:00
|
|
|
assert_reg_lock();
|
|
|
|
|
2009-03-10 10:07:41 +08:00
|
|
|
if (ignore_reg_update(wiphy, initiator))
|
2011-07-12 21:52:07 +08:00
|
|
|
return;
|
|
|
|
|
2011-10-12 01:59:03 +08:00
|
|
|
last_request->dfs_region = cfg80211_regdomain->dfs_region;
|
|
|
|
|
2008-09-10 14:19:48 +08:00
|
|
|
for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
|
2008-01-25 02:38:38 +08:00
|
|
|
if (wiphy->bands[band])
|
2010-10-21 01:18:53 +08:00
|
|
|
handle_band(wiphy, band, initiator);
|
2008-09-10 14:19:48 +08:00
|
|
|
}
|
2011-07-12 21:52:07 +08:00
|
|
|
|
2009-02-21 13:20:39 +08:00
|
|
|
reg_process_beacons(wiphy);
|
2009-05-02 12:37:17 +08:00
|
|
|
reg_process_ht_flags(wiphy);
|
2009-01-08 09:43:32 +08:00
|
|
|
if (wiphy->reg_notifier)
|
2009-01-23 07:05:51 +08:00
|
|
|
wiphy->reg_notifier(wiphy, last_request);
|
2008-09-10 14:19:48 +08:00
|
|
|
}
|
|
|
|
|
2011-08-31 05:38:54 +08:00
|
|
|
static void update_all_wiphy_regulatory(enum nl80211_reg_initiator initiator)
|
|
|
|
{
|
|
|
|
struct cfg80211_registered_device *rdev;
|
2011-12-09 02:29:26 +08:00
|
|
|
struct wiphy *wiphy;
|
2011-08-31 05:38:54 +08:00
|
|
|
|
2011-12-09 02:29:26 +08:00
|
|
|
list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
|
|
|
|
wiphy = &rdev->wiphy;
|
|
|
|
wiphy_update_regulatory(wiphy, initiator);
|
|
|
|
/*
|
|
|
|
* Regulatory updates set by CORE are ignored for custom
|
|
|
|
* regulatory cards. Let us notify the changes to the driver,
|
|
|
|
* as some drivers used this to restore its orig_* reg domain.
|
|
|
|
*/
|
|
|
|
if (initiator == NL80211_REGDOM_SET_BY_CORE &&
|
|
|
|
wiphy->flags & WIPHY_FLAG_CUSTOM_REGULATORY &&
|
|
|
|
wiphy->reg_notifier)
|
|
|
|
wiphy->reg_notifier(wiphy, last_request);
|
|
|
|
}
|
2011-08-31 05:38:54 +08:00
|
|
|
}
|
|
|
|
|
2009-01-23 07:05:44 +08:00
|
|
|
static void handle_channel_custom(struct wiphy *wiphy,
|
|
|
|
enum ieee80211_band band,
|
|
|
|
unsigned int chan_idx,
|
|
|
|
const struct ieee80211_regdomain *regd)
|
|
|
|
{
|
|
|
|
int r;
|
2009-05-02 12:37:17 +08:00
|
|
|
u32 desired_bw_khz = MHZ_TO_KHZ(20);
|
|
|
|
u32 bw_flags = 0;
|
2009-01-23 07:05:44 +08:00
|
|
|
const struct ieee80211_reg_rule *reg_rule = NULL;
|
|
|
|
const struct ieee80211_power_rule *power_rule = NULL;
|
2009-05-02 12:37:17 +08:00
|
|
|
const struct ieee80211_freq_range *freq_range = NULL;
|
2009-01-23 07:05:44 +08:00
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
struct ieee80211_channel *chan;
|
|
|
|
|
2009-07-31 08:38:08 +08:00
|
|
|
assert_reg_lock();
|
2009-05-02 06:44:50 +08:00
|
|
|
|
2009-01-23 07:05:44 +08:00
|
|
|
sband = wiphy->bands[band];
|
|
|
|
BUG_ON(chan_idx >= sband->n_channels);
|
|
|
|
chan = &sband->channels[chan_idx];
|
|
|
|
|
2009-05-02 12:37:17 +08:00
|
|
|
r = freq_reg_info_regd(wiphy,
|
|
|
|
MHZ_TO_KHZ(chan->center_freq),
|
|
|
|
desired_bw_khz,
|
|
|
|
®_rule,
|
|
|
|
regd);
|
2009-01-23 07:05:44 +08:00
|
|
|
|
|
|
|
if (r) {
|
2010-10-21 01:18:59 +08:00
|
|
|
REG_DBG_PRINT("Disabling freq %d MHz as custom "
|
2010-10-21 01:18:57 +08:00
|
|
|
"regd has no rule that fits a %d MHz "
|
|
|
|
"wide channel\n",
|
|
|
|
chan->center_freq,
|
|
|
|
KHZ_TO_MHZ(desired_bw_khz));
|
2009-01-23 07:05:44 +08:00
|
|
|
chan->flags = IEEE80211_CHAN_DISABLED;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-10-21 21:47:04 +08:00
|
|
|
chan_reg_rule_print_dbg(chan, desired_bw_khz, reg_rule);
|
|
|
|
|
2009-01-23 07:05:44 +08:00
|
|
|
power_rule = ®_rule->power_rule;
|
2009-05-02 12:37:17 +08:00
|
|
|
freq_range = ®_rule->freq_range;
|
|
|
|
|
|
|
|
if (freq_range->max_bandwidth_khz < MHZ_TO_KHZ(40))
|
|
|
|
bw_flags = IEEE80211_CHAN_NO_HT40;
|
2009-01-23 07:05:44 +08:00
|
|
|
|
2009-05-02 12:37:17 +08:00
|
|
|
chan->flags |= map_regdom_flags(reg_rule->flags) | bw_flags;
|
2009-01-23 07:05:44 +08:00
|
|
|
chan->max_antenna_gain = (int) MBI_TO_DBI(power_rule->max_antenna_gain);
|
|
|
|
chan->max_power = (int) MBM_TO_DBM(power_rule->max_eirp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void handle_band_custom(struct wiphy *wiphy, enum ieee80211_band band,
|
|
|
|
const struct ieee80211_regdomain *regd)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
|
|
|
|
BUG_ON(!wiphy->bands[band]);
|
|
|
|
sband = wiphy->bands[band];
|
|
|
|
|
|
|
|
for (i = 0; i < sband->n_channels; i++)
|
|
|
|
handle_channel_custom(wiphy, band, i, regd);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Used by drivers prior to wiphy registration */
|
|
|
|
void wiphy_apply_custom_regulatory(struct wiphy *wiphy,
|
|
|
|
const struct ieee80211_regdomain *regd)
|
|
|
|
{
|
|
|
|
enum ieee80211_band band;
|
2009-05-20 05:49:47 +08:00
|
|
|
unsigned int bands_set = 0;
|
2009-05-02 06:44:50 +08:00
|
|
|
|
2009-07-31 08:38:08 +08:00
|
|
|
mutex_lock(®_mutex);
|
2009-01-23 07:05:44 +08:00
|
|
|
for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
|
2009-05-20 05:49:47 +08:00
|
|
|
if (!wiphy->bands[band])
|
|
|
|
continue;
|
|
|
|
handle_band_custom(wiphy, band, regd);
|
|
|
|
bands_set++;
|
2008-09-10 14:19:48 +08:00
|
|
|
}
|
2009-07-31 08:38:08 +08:00
|
|
|
mutex_unlock(®_mutex);
|
2009-05-20 05:49:47 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* no point in calling this if it won't have any effect
|
|
|
|
* on your device's supportd bands.
|
|
|
|
*/
|
|
|
|
WARN_ON(!bands_set);
|
2008-09-10 14:19:48 +08:00
|
|
|
}
|
2009-01-23 07:05:44 +08:00
|
|
|
EXPORT_SYMBOL(wiphy_apply_custom_regulatory);
|
|
|
|
|
2009-02-21 13:04:31 +08:00
|
|
|
/*
|
|
|
|
* Return value which can be used by ignore_request() to indicate
|
|
|
|
* it has been determined we should intersect two regulatory domains
|
|
|
|
*/
|
2008-10-31 04:33:53 +08:00
|
|
|
#define REG_INTERSECT 1
|
|
|
|
|
2008-10-25 02:32:23 +08:00
|
|
|
/* This has the logic which determines when a new request
|
|
|
|
* should be ignored. */
|
2009-02-21 13:24:16 +08:00
|
|
|
static int ignore_request(struct wiphy *wiphy,
|
|
|
|
struct regulatory_request *pending_request)
|
2008-10-25 02:32:23 +08:00
|
|
|
{
|
2009-02-21 13:04:26 +08:00
|
|
|
struct wiphy *last_wiphy = NULL;
|
2009-02-21 13:04:25 +08:00
|
|
|
|
|
|
|
assert_cfg80211_lock();
|
|
|
|
|
2008-10-25 02:32:23 +08:00
|
|
|
/* All initial requests are respected */
|
|
|
|
if (!last_request)
|
|
|
|
return 0;
|
|
|
|
|
2009-02-21 13:24:16 +08:00
|
|
|
switch (pending_request->initiator) {
|
2009-03-10 10:07:41 +08:00
|
|
|
case NL80211_REGDOM_SET_BY_CORE:
|
2010-01-30 08:58:57 +08:00
|
|
|
return 0;
|
2009-03-10 10:07:41 +08:00
|
|
|
case NL80211_REGDOM_SET_BY_COUNTRY_IE:
|
2009-02-21 13:04:26 +08:00
|
|
|
|
2012-07-13 02:49:18 +08:00
|
|
|
if (reg_request_cell_base(last_request)) {
|
|
|
|
/* Trust a Cell base station over the AP's country IE */
|
|
|
|
if (regdom_changes(pending_request->alpha2))
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
return -EALREADY;
|
|
|
|
}
|
|
|
|
|
2009-02-21 13:04:26 +08:00
|
|
|
last_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);
|
|
|
|
|
2009-02-21 13:24:16 +08:00
|
|
|
if (unlikely(!is_an_alpha2(pending_request->alpha2)))
|
2008-10-25 02:32:23 +08:00
|
|
|
return -EINVAL;
|
2009-03-10 10:07:41 +08:00
|
|
|
if (last_request->initiator ==
|
|
|
|
NL80211_REGDOM_SET_BY_COUNTRY_IE) {
|
2009-02-21 13:04:26 +08:00
|
|
|
if (last_wiphy != wiphy) {
|
2008-10-25 02:32:23 +08:00
|
|
|
/*
|
|
|
|
* Two cards with two APs claiming different
|
2009-08-11 22:18:42 +08:00
|
|
|
* Country IE alpha2s. We could
|
2008-10-25 02:32:23 +08:00
|
|
|
* intersect them, but that seems unlikely
|
|
|
|
* to be correct. Reject second one for now.
|
|
|
|
*/
|
2009-02-21 13:24:16 +08:00
|
|
|
if (regdom_changes(pending_request->alpha2))
|
2008-10-25 02:32:23 +08:00
|
|
|
return -EOPNOTSUPP;
|
|
|
|
return -EALREADY;
|
|
|
|
}
|
2009-02-21 13:04:31 +08:00
|
|
|
/*
|
|
|
|
* Two consecutive Country IE hints on the same wiphy.
|
|
|
|
* This should be picked up early by the driver/stack
|
|
|
|
*/
|
2009-02-21 13:24:16 +08:00
|
|
|
if (WARN_ON(regdom_changes(pending_request->alpha2)))
|
2008-10-25 02:32:23 +08:00
|
|
|
return 0;
|
|
|
|
return -EALREADY;
|
|
|
|
}
|
2010-10-19 08:44:51 +08:00
|
|
|
return 0;
|
2009-03-10 10:07:41 +08:00
|
|
|
case NL80211_REGDOM_SET_BY_DRIVER:
|
|
|
|
if (last_request->initiator == NL80211_REGDOM_SET_BY_CORE) {
|
2009-02-21 13:24:16 +08:00
|
|
|
if (regdom_changes(pending_request->alpha2))
|
2009-01-23 07:05:48 +08:00
|
|
|
return 0;
|
2008-10-25 02:32:23 +08:00
|
|
|
return -EALREADY;
|
2009-01-23 07:05:48 +08:00
|
|
|
}
|
2009-02-21 13:04:32 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This would happen if you unplug and plug your card
|
|
|
|
* back in or if you add a new device for which the previously
|
|
|
|
* loaded card also agrees on the regulatory domain.
|
|
|
|
*/
|
2009-03-10 10:07:41 +08:00
|
|
|
if (last_request->initiator == NL80211_REGDOM_SET_BY_DRIVER &&
|
2009-02-21 13:24:16 +08:00
|
|
|
!regdom_changes(pending_request->alpha2))
|
2009-02-21 13:04:32 +08:00
|
|
|
return -EALREADY;
|
|
|
|
|
2009-01-08 09:43:34 +08:00
|
|
|
return REG_INTERSECT;
|
2009-03-10 10:07:41 +08:00
|
|
|
case NL80211_REGDOM_SET_BY_USER:
|
2012-07-13 02:49:18 +08:00
|
|
|
if (reg_request_cell_base(pending_request))
|
|
|
|
return reg_ignore_cell_hint(pending_request);
|
|
|
|
|
|
|
|
if (reg_request_cell_base(last_request))
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2009-03-10 10:07:41 +08:00
|
|
|
if (last_request->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE)
|
2008-10-31 04:33:53 +08:00
|
|
|
return REG_INTERSECT;
|
2009-02-21 13:04:31 +08:00
|
|
|
/*
|
|
|
|
* If the user knows better the user should set the regdom
|
|
|
|
* to their country before the IE is picked up
|
|
|
|
*/
|
2009-03-10 10:07:41 +08:00
|
|
|
if (last_request->initiator == NL80211_REGDOM_SET_BY_USER &&
|
2008-11-13 06:22:02 +08:00
|
|
|
last_request->intersect)
|
|
|
|
return -EOPNOTSUPP;
|
2009-02-21 13:04:31 +08:00
|
|
|
/*
|
|
|
|
* Process user requests only after previous user/driver/core
|
|
|
|
* requests have been processed
|
|
|
|
*/
|
2009-03-10 10:07:41 +08:00
|
|
|
if (last_request->initiator == NL80211_REGDOM_SET_BY_CORE ||
|
|
|
|
last_request->initiator == NL80211_REGDOM_SET_BY_DRIVER ||
|
|
|
|
last_request->initiator == NL80211_REGDOM_SET_BY_USER) {
|
2009-02-21 13:04:33 +08:00
|
|
|
if (regdom_changes(last_request->alpha2))
|
2009-01-23 07:05:47 +08:00
|
|
|
return -EAGAIN;
|
|
|
|
}
|
|
|
|
|
2009-12-19 06:59:02 +08:00
|
|
|
if (!regdom_changes(pending_request->alpha2))
|
2009-01-23 07:05:48 +08:00
|
|
|
return -EALREADY;
|
|
|
|
|
2008-10-25 02:32:23 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2010-11-18 13:46:09 +08:00
|
|
|
static void reg_set_request_processed(void)
|
|
|
|
{
|
|
|
|
bool need_more_processing = false;
|
|
|
|
|
|
|
|
last_request->processed = true;
|
|
|
|
|
|
|
|
spin_lock(®_requests_lock);
|
|
|
|
if (!list_empty(®_requests_list))
|
|
|
|
need_more_processing = true;
|
|
|
|
spin_unlock(®_requests_lock);
|
|
|
|
|
2011-04-06 01:49:04 +08:00
|
|
|
if (last_request->initiator == NL80211_REGDOM_SET_BY_USER)
|
cfg80211: fix potential deadlock in regulatory
reg_timeout_work() calls restore_regulatory_settings() which
takes cfg80211_mutex.
reg_set_request_processed() already holds cfg80211_mutex
before calling cancel_delayed_work_sync(reg_timeout),
so it might deadlock.
Call the async cancel_delayed_work instead, in order
to avoid the potential deadlock.
This is the relevant lockdep warning:
cfg80211: Calling CRDA for country: XX
======================================================
[ INFO: possible circular locking dependency detected ]
3.4.0-rc5-wl+ #26 Not tainted
-------------------------------------------------------
kworker/0:2/1391 is trying to acquire lock:
(cfg80211_mutex){+.+.+.}, at: [<bf28ae00>] restore_regulatory_settings+0x34/0x418 [cfg80211]
but task is already holding lock:
((reg_timeout).work){+.+...}, at: [<c0059e94>] process_one_work+0x1f0/0x480
which lock already depends on the new lock.
the existing dependency chain (in reverse order) is:
-> #2 ((reg_timeout).work){+.+...}:
[<c008fd44>] validate_chain+0xb94/0x10f0
[<c0090b68>] __lock_acquire+0x8c8/0x9b0
[<c0090d40>] lock_acquire+0xf0/0x114
[<c005b600>] wait_on_work+0x4c/0x154
[<c005c000>] __cancel_work_timer+0xd4/0x11c
[<c005c064>] cancel_delayed_work_sync+0x1c/0x20
[<bf28b274>] reg_set_request_processed+0x50/0x78 [cfg80211]
[<bf28bd84>] set_regdom+0x550/0x600 [cfg80211]
[<bf294cd8>] nl80211_set_reg+0x218/0x258 [cfg80211]
[<c03c7738>] genl_rcv_msg+0x1a8/0x1e8
[<c03c6a00>] netlink_rcv_skb+0x5c/0xc0
[<c03c7584>] genl_rcv+0x28/0x34
[<c03c6720>] netlink_unicast+0x15c/0x228
[<c03c6c7c>] netlink_sendmsg+0x218/0x298
[<c03933c8>] sock_sendmsg+0xa4/0xc0
[<c039406c>] __sys_sendmsg+0x1e4/0x268
[<c0394228>] sys_sendmsg+0x4c/0x70
[<c0013840>] ret_fast_syscall+0x0/0x3c
-> #1 (reg_mutex){+.+.+.}:
[<c008fd44>] validate_chain+0xb94/0x10f0
[<c0090b68>] __lock_acquire+0x8c8/0x9b0
[<c0090d40>] lock_acquire+0xf0/0x114
[<c04734dc>] mutex_lock_nested+0x48/0x320
[<bf28b2cc>] reg_todo+0x30/0x538 [cfg80211]
[<c0059f44>] process_one_work+0x2a0/0x480
[<c005a4b4>] worker_thread+0x1bc/0x2bc
[<c0061148>] kthread+0x98/0xa4
[<c0014af4>] kernel_thread_exit+0x0/0x8
-> #0 (cfg80211_mutex){+.+.+.}:
[<c008ed58>] print_circular_bug+0x68/0x2cc
[<c008fb28>] validate_chain+0x978/0x10f0
[<c0090b68>] __lock_acquire+0x8c8/0x9b0
[<c0090d40>] lock_acquire+0xf0/0x114
[<c04734dc>] mutex_lock_nested+0x48/0x320
[<bf28ae00>] restore_regulatory_settings+0x34/0x418 [cfg80211]
[<bf28b200>] reg_timeout_work+0x1c/0x20 [cfg80211]
[<c0059f44>] process_one_work+0x2a0/0x480
[<c005a4b4>] worker_thread+0x1bc/0x2bc
[<c0061148>] kthread+0x98/0xa4
[<c0014af4>] kernel_thread_exit+0x0/0x8
other info that might help us debug this:
Chain exists of:
cfg80211_mutex --> reg_mutex --> (reg_timeout).work
Possible unsafe locking scenario:
CPU0 CPU1
---- ----
lock((reg_timeout).work);
lock(reg_mutex);
lock((reg_timeout).work);
lock(cfg80211_mutex);
*** DEADLOCK ***
2 locks held by kworker/0:2/1391:
#0: (events){.+.+.+}, at: [<c0059e94>] process_one_work+0x1f0/0x480
#1: ((reg_timeout).work){+.+...}, at: [<c0059e94>] process_one_work+0x1f0/0x480
stack backtrace:
[<c001b928>] (unwind_backtrace+0x0/0x12c) from [<c0471d3c>] (dump_stack+0x20/0x24)
[<c0471d3c>] (dump_stack+0x20/0x24) from [<c008ef70>] (print_circular_bug+0x280/0x2cc)
[<c008ef70>] (print_circular_bug+0x280/0x2cc) from [<c008fb28>] (validate_chain+0x978/0x10f0)
[<c008fb28>] (validate_chain+0x978/0x10f0) from [<c0090b68>] (__lock_acquire+0x8c8/0x9b0)
[<c0090b68>] (__lock_acquire+0x8c8/0x9b0) from [<c0090d40>] (lock_acquire+0xf0/0x114)
[<c0090d40>] (lock_acquire+0xf0/0x114) from [<c04734dc>] (mutex_lock_nested+0x48/0x320)
[<c04734dc>] (mutex_lock_nested+0x48/0x320) from [<bf28ae00>] (restore_regulatory_settings+0x34/0x418 [cfg80211])
[<bf28ae00>] (restore_regulatory_settings+0x34/0x418 [cfg80211]) from [<bf28b200>] (reg_timeout_work+0x1c/0x20 [cfg80211])
[<bf28b200>] (reg_timeout_work+0x1c/0x20 [cfg80211]) from [<c0059f44>] (process_one_work+0x2a0/0x480)
[<c0059f44>] (process_one_work+0x2a0/0x480) from [<c005a4b4>] (worker_thread+0x1bc/0x2bc)
[<c005a4b4>] (worker_thread+0x1bc/0x2bc) from [<c0061148>] (kthread+0x98/0xa4)
[<c0061148>] (kthread+0x98/0xa4) from [<c0014af4>] (kernel_thread_exit+0x0/0x8)
cfg80211: Calling CRDA to update world regulatory domain
cfg80211: World regulatory domain updated:
cfg80211: (start_freq - end_freq @ bandwidth), (max_antenna_gain, max_eirp)
cfg80211: (2402000 KHz - 2472000 KHz @ 40000 KHz), (300 mBi, 2000 mBm)
cfg80211: (2457000 KHz - 2482000 KHz @ 20000 KHz), (300 mBi, 2000 mBm)
cfg80211: (2474000 KHz - 2494000 KHz @ 20000 KHz), (300 mBi, 2000 mBm)
cfg80211: (5170000 KHz - 5250000 KHz @ 40000 KHz), (300 mBi, 2000 mBm)
cfg80211: (5735000 KHz - 5835000 KHz @ 40000 KHz), (300 mBi, 2000 mBm)
Cc: stable@kernel.org
Signed-off-by: Eliad Peller <eliad@wizery.com>
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
2012-06-12 17:53:13 +08:00
|
|
|
cancel_delayed_work(®_timeout);
|
2011-04-06 01:49:04 +08:00
|
|
|
|
2010-11-18 13:46:09 +08:00
|
|
|
if (need_more_processing)
|
|
|
|
schedule_work(®_work);
|
|
|
|
}
|
|
|
|
|
2009-02-21 13:24:13 +08:00
|
|
|
/**
|
|
|
|
* __regulatory_hint - hint to the wireless core a regulatory domain
|
|
|
|
* @wiphy: if the hint comes from country information from an AP, this
|
|
|
|
* is required to be set to the wiphy that received the information
|
2009-02-21 13:24:14 +08:00
|
|
|
* @pending_request: the regulatory request currently being processed
|
2009-02-21 13:24:13 +08:00
|
|
|
*
|
|
|
|
* The Wireless subsystem can use this function to hint to the wireless core
|
2009-02-21 13:24:14 +08:00
|
|
|
* what it believes should be the current regulatory domain.
|
2009-02-21 13:24:13 +08:00
|
|
|
*
|
|
|
|
* Returns zero if all went fine, %-EALREADY if a regulatory domain had
|
|
|
|
* already been set or other standard error codes.
|
|
|
|
*
|
2009-07-31 08:38:08 +08:00
|
|
|
* Caller must hold &cfg80211_mutex and ®_mutex
|
2009-02-21 13:24:13 +08:00
|
|
|
*/
|
2009-02-21 13:24:14 +08:00
|
|
|
static int __regulatory_hint(struct wiphy *wiphy,
|
|
|
|
struct regulatory_request *pending_request)
|
2008-09-10 14:19:48 +08:00
|
|
|
{
|
2008-10-31 04:33:53 +08:00
|
|
|
bool intersect = false;
|
2008-09-10 14:19:48 +08:00
|
|
|
int r = 0;
|
|
|
|
|
2009-02-21 13:04:25 +08:00
|
|
|
assert_cfg80211_lock();
|
|
|
|
|
2009-02-21 13:24:16 +08:00
|
|
|
r = ignore_request(wiphy, pending_request);
|
2008-10-31 04:33:53 +08:00
|
|
|
|
2009-01-08 09:43:34 +08:00
|
|
|
if (r == REG_INTERSECT) {
|
2009-03-10 10:07:41 +08:00
|
|
|
if (pending_request->initiator ==
|
|
|
|
NL80211_REGDOM_SET_BY_DRIVER) {
|
2009-01-08 09:43:34 +08:00
|
|
|
r = reg_copy_regd(&wiphy->regd, cfg80211_regdomain);
|
2009-02-21 13:24:15 +08:00
|
|
|
if (r) {
|
|
|
|
kfree(pending_request);
|
2009-01-08 09:43:34 +08:00
|
|
|
return r;
|
2009-02-21 13:24:15 +08:00
|
|
|
}
|
2009-01-08 09:43:34 +08:00
|
|
|
}
|
2008-10-31 04:33:53 +08:00
|
|
|
intersect = true;
|
2009-01-08 09:43:34 +08:00
|
|
|
} else if (r) {
|
2009-02-21 13:04:31 +08:00
|
|
|
/*
|
|
|
|
* If the regulatory domain being requested by the
|
2009-01-08 09:43:34 +08:00
|
|
|
* driver has already been set just copy it to the
|
2009-02-21 13:04:31 +08:00
|
|
|
* wiphy
|
|
|
|
*/
|
2009-02-21 13:24:14 +08:00
|
|
|
if (r == -EALREADY &&
|
2009-03-10 10:07:41 +08:00
|
|
|
pending_request->initiator ==
|
|
|
|
NL80211_REGDOM_SET_BY_DRIVER) {
|
2009-01-08 09:43:34 +08:00
|
|
|
r = reg_copy_regd(&wiphy->regd, cfg80211_regdomain);
|
2009-02-21 13:24:15 +08:00
|
|
|
if (r) {
|
|
|
|
kfree(pending_request);
|
2009-01-08 09:43:34 +08:00
|
|
|
return r;
|
2009-02-21 13:24:15 +08:00
|
|
|
}
|
2009-01-08 09:43:34 +08:00
|
|
|
r = -EALREADY;
|
|
|
|
goto new_request;
|
|
|
|
}
|
2009-02-21 13:24:15 +08:00
|
|
|
kfree(pending_request);
|
2008-09-10 14:19:48 +08:00
|
|
|
return r;
|
2009-01-08 09:43:34 +08:00
|
|
|
}
|
2008-09-10 14:19:48 +08:00
|
|
|
|
2009-01-08 09:43:34 +08:00
|
|
|
new_request:
|
2011-11-29 05:47:15 +08:00
|
|
|
if (last_request != &core_request_world)
|
|
|
|
kfree(last_request);
|
2008-11-13 06:21:56 +08:00
|
|
|
|
2009-02-21 13:24:15 +08:00
|
|
|
last_request = pending_request;
|
|
|
|
last_request->intersect = intersect;
|
2008-11-13 06:21:56 +08:00
|
|
|
|
2009-02-21 13:24:15 +08:00
|
|
|
pending_request = NULL;
|
2009-01-08 09:43:34 +08:00
|
|
|
|
2010-01-30 08:58:57 +08:00
|
|
|
if (last_request->initiator == NL80211_REGDOM_SET_BY_USER) {
|
|
|
|
user_alpha2[0] = last_request->alpha2[0];
|
|
|
|
user_alpha2[1] = last_request->alpha2[1];
|
|
|
|
}
|
|
|
|
|
2009-01-08 09:43:34 +08:00
|
|
|
/* When r == REG_INTERSECT we do need to call CRDA */
|
2009-03-10 10:07:42 +08:00
|
|
|
if (r < 0) {
|
|
|
|
/*
|
|
|
|
* Since CRDA will not be called in this case as we already
|
|
|
|
* have applied the requested regulatory domain before we just
|
|
|
|
* inform userspace we have processed the request
|
|
|
|
*/
|
2010-11-18 13:46:09 +08:00
|
|
|
if (r == -EALREADY) {
|
2009-03-10 10:07:42 +08:00
|
|
|
nl80211_send_reg_change_event(last_request);
|
2010-11-18 13:46:09 +08:00
|
|
|
reg_set_request_processed();
|
|
|
|
}
|
2009-01-08 09:43:34 +08:00
|
|
|
return r;
|
2009-03-10 10:07:42 +08:00
|
|
|
}
|
2009-01-08 09:43:34 +08:00
|
|
|
|
2009-02-21 13:24:15 +08:00
|
|
|
return call_crda(last_request->alpha2);
|
2008-09-10 14:19:48 +08:00
|
|
|
}
|
|
|
|
|
2009-05-02 13:17:27 +08:00
|
|
|
/* This processes *all* regulatory hints */
|
2011-12-21 04:23:36 +08:00
|
|
|
static void reg_process_hint(struct regulatory_request *reg_request,
|
|
|
|
enum nl80211_reg_initiator reg_initiator)
|
2009-02-21 13:04:30 +08:00
|
|
|
{
|
|
|
|
int r = 0;
|
|
|
|
struct wiphy *wiphy = NULL;
|
|
|
|
|
|
|
|
BUG_ON(!reg_request->alpha2);
|
|
|
|
|
|
|
|
if (wiphy_idx_valid(reg_request->wiphy_idx))
|
|
|
|
wiphy = wiphy_idx_to_wiphy(reg_request->wiphy_idx);
|
|
|
|
|
2011-12-21 04:23:36 +08:00
|
|
|
if (reg_initiator == NL80211_REGDOM_SET_BY_DRIVER &&
|
2009-02-21 13:04:30 +08:00
|
|
|
!wiphy) {
|
2009-02-21 13:24:15 +08:00
|
|
|
kfree(reg_request);
|
2010-11-18 13:46:08 +08:00
|
|
|
return;
|
2009-02-21 13:04:30 +08:00
|
|
|
}
|
|
|
|
|
2009-02-21 13:24:14 +08:00
|
|
|
r = __regulatory_hint(wiphy, reg_request);
|
2009-02-21 13:04:30 +08:00
|
|
|
/* This is required so that the orig_* parameters are saved */
|
2009-11-19 07:56:28 +08:00
|
|
|
if (r == -EALREADY && wiphy &&
|
2011-04-06 01:49:04 +08:00
|
|
|
wiphy->flags & WIPHY_FLAG_STRICT_REGULATORY) {
|
2011-12-21 04:23:36 +08:00
|
|
|
wiphy_update_regulatory(wiphy, reg_initiator);
|
2011-04-06 01:49:04 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We only time out user hints, given that they should be the only
|
|
|
|
* source of bogus requests.
|
|
|
|
*/
|
2011-04-26 09:35:48 +08:00
|
|
|
if (r != -EALREADY &&
|
2011-12-21 04:23:36 +08:00
|
|
|
reg_initiator == NL80211_REGDOM_SET_BY_USER)
|
2011-04-06 01:49:04 +08:00
|
|
|
schedule_delayed_work(®_timeout, msecs_to_jiffies(3142));
|
2009-02-21 13:04:30 +08:00
|
|
|
}
|
|
|
|
|
2010-11-18 13:46:09 +08:00
|
|
|
/*
|
|
|
|
* Processes regulatory hints, this is all the NL80211_REGDOM_SET_BY_*
|
|
|
|
* Regulatory hints come on a first come first serve basis and we
|
|
|
|
* must process each one atomically.
|
|
|
|
*/
|
2009-02-21 13:04:30 +08:00
|
|
|
static void reg_process_pending_hints(void)
|
2010-11-18 13:46:08 +08:00
|
|
|
{
|
2009-02-21 13:04:30 +08:00
|
|
|
struct regulatory_request *reg_request;
|
|
|
|
|
2010-11-18 13:46:08 +08:00
|
|
|
mutex_lock(&cfg80211_mutex);
|
|
|
|
mutex_lock(®_mutex);
|
|
|
|
|
2010-11-18 13:46:09 +08:00
|
|
|
/* When last_request->processed becomes true this will be rescheduled */
|
|
|
|
if (last_request && !last_request->processed) {
|
|
|
|
REG_DBG_PRINT("Pending regulatory request, waiting "
|
2011-07-30 05:51:25 +08:00
|
|
|
"for it to be processed...\n");
|
2010-11-18 13:46:09 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2009-02-21 13:04:30 +08:00
|
|
|
spin_lock(®_requests_lock);
|
|
|
|
|
2010-11-18 13:46:09 +08:00
|
|
|
if (list_empty(®_requests_list)) {
|
2009-02-21 13:24:15 +08:00
|
|
|
spin_unlock(®_requests_lock);
|
2010-11-18 13:46:09 +08:00
|
|
|
goto out;
|
2009-02-21 13:04:30 +08:00
|
|
|
}
|
2010-11-18 13:46:09 +08:00
|
|
|
|
|
|
|
reg_request = list_first_entry(®_requests_list,
|
|
|
|
struct regulatory_request,
|
|
|
|
list);
|
|
|
|
list_del_init(®_request->list);
|
|
|
|
|
2009-02-21 13:04:30 +08:00
|
|
|
spin_unlock(®_requests_lock);
|
2010-11-18 13:46:08 +08:00
|
|
|
|
2011-12-21 04:23:36 +08:00
|
|
|
reg_process_hint(reg_request, reg_request->initiator);
|
2010-11-18 13:46:09 +08:00
|
|
|
|
|
|
|
out:
|
2010-11-18 13:46:08 +08:00
|
|
|
mutex_unlock(®_mutex);
|
|
|
|
mutex_unlock(&cfg80211_mutex);
|
2009-02-21 13:04:30 +08:00
|
|
|
}
|
|
|
|
|
2009-02-21 13:20:39 +08:00
|
|
|
/* Processes beacon hints -- this has nothing to do with country IEs */
|
|
|
|
static void reg_process_pending_beacon_hints(void)
|
|
|
|
{
|
2009-07-07 09:56:12 +08:00
|
|
|
struct cfg80211_registered_device *rdev;
|
2009-02-21 13:20:39 +08:00
|
|
|
struct reg_beacon *pending_beacon, *tmp;
|
|
|
|
|
2009-07-31 08:38:08 +08:00
|
|
|
/*
|
|
|
|
* No need to hold the reg_mutex here as we just touch wiphys
|
|
|
|
* and do not read or access regulatory variables.
|
|
|
|
*/
|
2009-02-21 13:20:39 +08:00
|
|
|
mutex_lock(&cfg80211_mutex);
|
|
|
|
|
|
|
|
/* This goes through the _pending_ beacon list */
|
|
|
|
spin_lock_bh(®_pending_beacons_lock);
|
|
|
|
|
|
|
|
if (list_empty(®_pending_beacons)) {
|
|
|
|
spin_unlock_bh(®_pending_beacons_lock);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
list_for_each_entry_safe(pending_beacon, tmp,
|
|
|
|
®_pending_beacons, list) {
|
|
|
|
|
|
|
|
list_del_init(&pending_beacon->list);
|
|
|
|
|
|
|
|
/* Applies the beacon hint to current wiphys */
|
2009-07-07 09:56:12 +08:00
|
|
|
list_for_each_entry(rdev, &cfg80211_rdev_list, list)
|
|
|
|
wiphy_update_new_beacon(&rdev->wiphy, pending_beacon);
|
2009-02-21 13:20:39 +08:00
|
|
|
|
|
|
|
/* Remembers the beacon hint for new wiphys or reg changes */
|
|
|
|
list_add_tail(&pending_beacon->list, ®_beacon_list);
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_bh(®_pending_beacons_lock);
|
|
|
|
out:
|
|
|
|
mutex_unlock(&cfg80211_mutex);
|
|
|
|
}
|
|
|
|
|
2009-02-21 13:04:30 +08:00
|
|
|
static void reg_todo(struct work_struct *work)
|
|
|
|
{
|
|
|
|
reg_process_pending_hints();
|
2009-02-21 13:20:39 +08:00
|
|
|
reg_process_pending_beacon_hints();
|
2009-02-21 13:04:30 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void queue_regulatory_request(struct regulatory_request *request)
|
|
|
|
{
|
2010-08-06 02:26:24 +08:00
|
|
|
if (isalpha(request->alpha2[0]))
|
|
|
|
request->alpha2[0] = toupper(request->alpha2[0]);
|
|
|
|
if (isalpha(request->alpha2[1]))
|
|
|
|
request->alpha2[1] = toupper(request->alpha2[1]);
|
|
|
|
|
2009-02-21 13:04:30 +08:00
|
|
|
spin_lock(®_requests_lock);
|
|
|
|
list_add_tail(&request->list, ®_requests_list);
|
|
|
|
spin_unlock(®_requests_lock);
|
|
|
|
|
|
|
|
schedule_work(®_work);
|
|
|
|
}
|
|
|
|
|
2010-01-30 08:58:57 +08:00
|
|
|
/*
|
|
|
|
* Core regulatory hint -- happens during cfg80211_init()
|
|
|
|
* and when we restore regulatory settings.
|
|
|
|
*/
|
2009-02-21 13:04:23 +08:00
|
|
|
static int regulatory_hint_core(const char *alpha2)
|
|
|
|
{
|
|
|
|
struct regulatory_request *request;
|
|
|
|
|
|
|
|
request = kzalloc(sizeof(struct regulatory_request),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!request)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
request->alpha2[0] = alpha2[0];
|
|
|
|
request->alpha2[1] = alpha2[1];
|
2009-03-10 10:07:41 +08:00
|
|
|
request->initiator = NL80211_REGDOM_SET_BY_CORE;
|
2009-02-21 13:04:23 +08:00
|
|
|
|
2010-11-18 13:46:06 +08:00
|
|
|
queue_regulatory_request(request);
|
2009-05-14 05:04:42 +08:00
|
|
|
|
2009-02-21 13:04:30 +08:00
|
|
|
return 0;
|
2009-02-21 13:04:23 +08:00
|
|
|
}
|
|
|
|
|
2009-02-21 13:04:30 +08:00
|
|
|
/* User hints */
|
2012-07-13 02:49:18 +08:00
|
|
|
int regulatory_hint_user(const char *alpha2,
|
|
|
|
enum nl80211_user_reg_hint_type user_reg_hint_type)
|
2008-09-10 14:19:48 +08:00
|
|
|
{
|
2009-02-21 13:04:30 +08:00
|
|
|
struct regulatory_request *request;
|
|
|
|
|
2008-10-25 02:32:21 +08:00
|
|
|
BUG_ON(!alpha2);
|
2008-09-10 14:19:48 +08:00
|
|
|
|
2009-02-21 13:04:30 +08:00
|
|
|
request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
|
|
|
|
if (!request)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
request->wiphy_idx = WIPHY_IDX_STALE;
|
|
|
|
request->alpha2[0] = alpha2[0];
|
|
|
|
request->alpha2[1] = alpha2[1];
|
2010-01-05 00:37:39 +08:00
|
|
|
request->initiator = NL80211_REGDOM_SET_BY_USER;
|
2012-07-13 02:49:18 +08:00
|
|
|
request->user_reg_hint_type = user_reg_hint_type;
|
2009-02-21 13:04:30 +08:00
|
|
|
|
|
|
|
queue_regulatory_request(request);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Driver hints */
|
|
|
|
int regulatory_hint(struct wiphy *wiphy, const char *alpha2)
|
|
|
|
{
|
|
|
|
struct regulatory_request *request;
|
|
|
|
|
|
|
|
BUG_ON(!alpha2);
|
|
|
|
BUG_ON(!wiphy);
|
|
|
|
|
|
|
|
request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
|
|
|
|
if (!request)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
request->wiphy_idx = get_wiphy_idx(wiphy);
|
|
|
|
|
|
|
|
/* Must have registered wiphy first */
|
|
|
|
BUG_ON(!wiphy_idx_valid(request->wiphy_idx));
|
|
|
|
|
|
|
|
request->alpha2[0] = alpha2[0];
|
|
|
|
request->alpha2[1] = alpha2[1];
|
2009-03-10 10:07:41 +08:00
|
|
|
request->initiator = NL80211_REGDOM_SET_BY_DRIVER;
|
2009-02-21 13:04:30 +08:00
|
|
|
|
|
|
|
queue_regulatory_request(request);
|
|
|
|
|
|
|
|
return 0;
|
2008-09-10 14:19:48 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(regulatory_hint);
|
|
|
|
|
2009-07-31 08:38:07 +08:00
|
|
|
/*
|
|
|
|
* We hold wdev_lock() here so we cannot hold cfg80211_mutex() and
|
|
|
|
* therefore cannot iterate over the rdev list here.
|
|
|
|
*/
|
2008-11-13 06:22:02 +08:00
|
|
|
void regulatory_hint_11d(struct wiphy *wiphy,
|
2010-01-15 09:08:20 +08:00
|
|
|
enum ieee80211_band band,
|
|
|
|
u8 *country_ie,
|
|
|
|
u8 country_ie_len)
|
2008-11-13 06:22:02 +08:00
|
|
|
{
|
|
|
|
char alpha2[2];
|
|
|
|
enum environment_cap env = ENVIRON_ANY;
|
2009-02-21 13:04:30 +08:00
|
|
|
struct regulatory_request *request;
|
2008-11-13 06:22:02 +08:00
|
|
|
|
2009-07-31 08:38:08 +08:00
|
|
|
mutex_lock(®_mutex);
|
2008-11-13 06:22:02 +08:00
|
|
|
|
2009-07-31 08:38:06 +08:00
|
|
|
if (unlikely(!last_request))
|
|
|
|
goto out;
|
2009-02-21 13:04:27 +08:00
|
|
|
|
2008-11-13 06:22:02 +08:00
|
|
|
/* IE len must be evenly divisible by 2 */
|
|
|
|
if (country_ie_len & 0x01)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (country_ie_len < IEEE80211_COUNTRY_IE_MIN_LEN)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
alpha2[0] = country_ie[0];
|
|
|
|
alpha2[1] = country_ie[1];
|
|
|
|
|
|
|
|
if (country_ie[2] == 'I')
|
|
|
|
env = ENVIRON_INDOOR;
|
|
|
|
else if (country_ie[2] == 'O')
|
|
|
|
env = ENVIRON_OUTDOOR;
|
|
|
|
|
2009-02-21 13:04:31 +08:00
|
|
|
/*
|
2009-07-31 08:38:09 +08:00
|
|
|
* We will run this only upon a successful connection on cfg80211.
|
2009-07-31 08:38:07 +08:00
|
|
|
* We leave conflict resolution to the workqueue, where can hold
|
|
|
|
* cfg80211_mutex.
|
2009-02-21 13:04:31 +08:00
|
|
|
*/
|
2009-03-21 11:53:05 +08:00
|
|
|
if (likely(last_request->initiator ==
|
|
|
|
NL80211_REGDOM_SET_BY_COUNTRY_IE &&
|
2009-07-31 08:38:07 +08:00
|
|
|
wiphy_idx_valid(last_request->wiphy_idx)))
|
|
|
|
goto out;
|
2008-11-13 06:22:02 +08:00
|
|
|
|
2009-02-21 13:04:30 +08:00
|
|
|
request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
|
|
|
|
if (!request)
|
2010-07-22 19:26:50 +08:00
|
|
|
goto out;
|
2009-02-21 13:04:30 +08:00
|
|
|
|
|
|
|
request->wiphy_idx = get_wiphy_idx(wiphy);
|
2010-07-16 02:57:33 +08:00
|
|
|
request->alpha2[0] = alpha2[0];
|
|
|
|
request->alpha2[1] = alpha2[1];
|
2009-03-10 10:07:41 +08:00
|
|
|
request->initiator = NL80211_REGDOM_SET_BY_COUNTRY_IE;
|
2009-02-21 13:04:30 +08:00
|
|
|
request->country_ie_env = env;
|
|
|
|
|
2009-07-31 08:38:08 +08:00
|
|
|
mutex_unlock(®_mutex);
|
2008-11-13 06:22:02 +08:00
|
|
|
|
2009-02-21 13:04:30 +08:00
|
|
|
queue_regulatory_request(request);
|
|
|
|
|
|
|
|
return;
|
2009-02-21 13:04:29 +08:00
|
|
|
|
2008-11-13 06:22:02 +08:00
|
|
|
out:
|
2009-07-31 08:38:08 +08:00
|
|
|
mutex_unlock(®_mutex);
|
2008-11-13 06:22:02 +08:00
|
|
|
}
|
2008-09-10 14:19:48 +08:00
|
|
|
|
2010-01-30 08:58:57 +08:00
|
|
|
static void restore_alpha2(char *alpha2, bool reset_user)
|
|
|
|
{
|
|
|
|
/* indicates there is no alpha2 to consider for restoration */
|
|
|
|
alpha2[0] = '9';
|
|
|
|
alpha2[1] = '7';
|
|
|
|
|
|
|
|
/* The user setting has precedence over the module parameter */
|
|
|
|
if (is_user_regdom_saved()) {
|
|
|
|
/* Unless we're asked to ignore it and reset it */
|
|
|
|
if (reset_user) {
|
2010-10-21 01:18:59 +08:00
|
|
|
REG_DBG_PRINT("Restoring regulatory settings "
|
2010-01-30 08:58:57 +08:00
|
|
|
"including user preference\n");
|
|
|
|
user_alpha2[0] = '9';
|
|
|
|
user_alpha2[1] = '7';
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we're ignoring user settings, we still need to
|
|
|
|
* check the module parameter to ensure we put things
|
|
|
|
* back as they were for a full restore.
|
|
|
|
*/
|
|
|
|
if (!is_world_regdom(ieee80211_regdom)) {
|
2010-10-21 01:18:59 +08:00
|
|
|
REG_DBG_PRINT("Keeping preference on "
|
2010-01-30 08:58:57 +08:00
|
|
|
"module parameter ieee80211_regdom: %c%c\n",
|
|
|
|
ieee80211_regdom[0],
|
|
|
|
ieee80211_regdom[1]);
|
|
|
|
alpha2[0] = ieee80211_regdom[0];
|
|
|
|
alpha2[1] = ieee80211_regdom[1];
|
|
|
|
}
|
|
|
|
} else {
|
2010-10-21 01:18:59 +08:00
|
|
|
REG_DBG_PRINT("Restoring regulatory settings "
|
2010-01-30 08:58:57 +08:00
|
|
|
"while preserving user preference for: %c%c\n",
|
|
|
|
user_alpha2[0],
|
|
|
|
user_alpha2[1]);
|
|
|
|
alpha2[0] = user_alpha2[0];
|
|
|
|
alpha2[1] = user_alpha2[1];
|
|
|
|
}
|
|
|
|
} else if (!is_world_regdom(ieee80211_regdom)) {
|
2010-10-21 01:18:59 +08:00
|
|
|
REG_DBG_PRINT("Keeping preference on "
|
2010-01-30 08:58:57 +08:00
|
|
|
"module parameter ieee80211_regdom: %c%c\n",
|
|
|
|
ieee80211_regdom[0],
|
|
|
|
ieee80211_regdom[1]);
|
|
|
|
alpha2[0] = ieee80211_regdom[0];
|
|
|
|
alpha2[1] = ieee80211_regdom[1];
|
|
|
|
} else
|
2010-10-21 01:18:59 +08:00
|
|
|
REG_DBG_PRINT("Restoring regulatory settings\n");
|
2010-01-30 08:58:57 +08:00
|
|
|
}
|
|
|
|
|
2011-12-08 00:20:08 +08:00
|
|
|
static void restore_custom_reg_settings(struct wiphy *wiphy)
|
|
|
|
{
|
|
|
|
struct ieee80211_supported_band *sband;
|
|
|
|
enum ieee80211_band band;
|
|
|
|
struct ieee80211_channel *chan;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
|
|
|
|
sband = wiphy->bands[band];
|
|
|
|
if (!sband)
|
|
|
|
continue;
|
|
|
|
for (i = 0; i < sband->n_channels; i++) {
|
|
|
|
chan = &sband->channels[i];
|
|
|
|
chan->flags = chan->orig_flags;
|
|
|
|
chan->max_antenna_gain = chan->orig_mag;
|
|
|
|
chan->max_power = chan->orig_mpwr;
|
2012-08-02 07:54:42 +08:00
|
|
|
chan->beacon_found = false;
|
2011-12-08 00:20:08 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-01-30 08:58:57 +08:00
|
|
|
/*
|
|
|
|
* Restoring regulatory settings involves ingoring any
|
|
|
|
* possibly stale country IE information and user regulatory
|
|
|
|
* settings if so desired, this includes any beacon hints
|
|
|
|
* learned as we could have traveled outside to another country
|
|
|
|
* after disconnection. To restore regulatory settings we do
|
|
|
|
* exactly what we did at bootup:
|
|
|
|
*
|
|
|
|
* - send a core regulatory hint
|
|
|
|
* - send a user regulatory hint if applicable
|
|
|
|
*
|
|
|
|
* Device drivers that send a regulatory hint for a specific country
|
|
|
|
* keep their own regulatory domain on wiphy->regd so that does does
|
|
|
|
* not need to be remembered.
|
|
|
|
*/
|
|
|
|
static void restore_regulatory_settings(bool reset_user)
|
|
|
|
{
|
|
|
|
char alpha2[2];
|
2011-12-20 04:32:21 +08:00
|
|
|
char world_alpha2[2];
|
2010-01-30 08:58:57 +08:00
|
|
|
struct reg_beacon *reg_beacon, *btmp;
|
2011-04-06 01:49:03 +08:00
|
|
|
struct regulatory_request *reg_request, *tmp;
|
|
|
|
LIST_HEAD(tmp_reg_req_list);
|
2011-12-08 00:20:08 +08:00
|
|
|
struct cfg80211_registered_device *rdev;
|
2010-01-30 08:58:57 +08:00
|
|
|
|
|
|
|
mutex_lock(&cfg80211_mutex);
|
|
|
|
mutex_lock(®_mutex);
|
|
|
|
|
2011-11-29 05:47:15 +08:00
|
|
|
reset_regdomains(true);
|
2010-01-30 08:58:57 +08:00
|
|
|
restore_alpha2(alpha2, reset_user);
|
|
|
|
|
2011-04-06 01:49:03 +08:00
|
|
|
/*
|
|
|
|
* If there's any pending requests we simply
|
|
|
|
* stash them to a temporary pending queue and
|
|
|
|
* add then after we've restored regulatory
|
|
|
|
* settings.
|
|
|
|
*/
|
|
|
|
spin_lock(®_requests_lock);
|
|
|
|
if (!list_empty(®_requests_list)) {
|
|
|
|
list_for_each_entry_safe(reg_request, tmp,
|
|
|
|
®_requests_list, list) {
|
|
|
|
if (reg_request->initiator !=
|
|
|
|
NL80211_REGDOM_SET_BY_USER)
|
|
|
|
continue;
|
2012-09-05 14:34:12 +08:00
|
|
|
list_move_tail(®_request->list, &tmp_reg_req_list);
|
2011-04-06 01:49:03 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock(®_requests_lock);
|
|
|
|
|
2010-01-30 08:58:57 +08:00
|
|
|
/* Clear beacon hints */
|
|
|
|
spin_lock_bh(®_pending_beacons_lock);
|
|
|
|
if (!list_empty(®_pending_beacons)) {
|
|
|
|
list_for_each_entry_safe(reg_beacon, btmp,
|
|
|
|
®_pending_beacons, list) {
|
|
|
|
list_del(®_beacon->list);
|
|
|
|
kfree(reg_beacon);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock_bh(®_pending_beacons_lock);
|
|
|
|
|
|
|
|
if (!list_empty(®_beacon_list)) {
|
|
|
|
list_for_each_entry_safe(reg_beacon, btmp,
|
|
|
|
®_beacon_list, list) {
|
|
|
|
list_del(®_beacon->list);
|
|
|
|
kfree(reg_beacon);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* First restore to the basic regulatory settings */
|
|
|
|
cfg80211_regdomain = cfg80211_world_regdom;
|
2011-12-20 04:32:21 +08:00
|
|
|
world_alpha2[0] = cfg80211_regdomain->alpha2[0];
|
|
|
|
world_alpha2[1] = cfg80211_regdomain->alpha2[1];
|
2010-01-30 08:58:57 +08:00
|
|
|
|
2011-12-08 00:20:08 +08:00
|
|
|
list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
|
|
|
|
if (rdev->wiphy.flags & WIPHY_FLAG_CUSTOM_REGULATORY)
|
|
|
|
restore_custom_reg_settings(&rdev->wiphy);
|
|
|
|
}
|
|
|
|
|
2010-01-30 08:58:57 +08:00
|
|
|
mutex_unlock(®_mutex);
|
|
|
|
mutex_unlock(&cfg80211_mutex);
|
|
|
|
|
2011-12-20 04:32:21 +08:00
|
|
|
regulatory_hint_core(world_alpha2);
|
2010-01-30 08:58:57 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This restores the ieee80211_regdom module parameter
|
|
|
|
* preference or the last user requested regulatory
|
|
|
|
* settings, user regulatory settings takes precedence.
|
|
|
|
*/
|
|
|
|
if (is_an_alpha2(alpha2))
|
2012-07-13 02:49:18 +08:00
|
|
|
regulatory_hint_user(user_alpha2, NL80211_USER_REG_HINT_USER);
|
2010-01-30 08:58:57 +08:00
|
|
|
|
2011-04-06 01:49:03 +08:00
|
|
|
if (list_empty(&tmp_reg_req_list))
|
|
|
|
return;
|
|
|
|
|
|
|
|
mutex_lock(&cfg80211_mutex);
|
|
|
|
mutex_lock(®_mutex);
|
|
|
|
|
|
|
|
spin_lock(®_requests_lock);
|
|
|
|
list_for_each_entry_safe(reg_request, tmp, &tmp_reg_req_list, list) {
|
|
|
|
REG_DBG_PRINT("Adding request for country %c%c back "
|
|
|
|
"into the queue\n",
|
|
|
|
reg_request->alpha2[0],
|
|
|
|
reg_request->alpha2[1]);
|
2012-09-05 14:34:12 +08:00
|
|
|
list_move_tail(®_request->list, ®_requests_list);
|
2011-04-06 01:49:03 +08:00
|
|
|
}
|
|
|
|
spin_unlock(®_requests_lock);
|
|
|
|
|
|
|
|
mutex_unlock(®_mutex);
|
|
|
|
mutex_unlock(&cfg80211_mutex);
|
|
|
|
|
|
|
|
REG_DBG_PRINT("Kicking the queue\n");
|
|
|
|
|
|
|
|
schedule_work(®_work);
|
|
|
|
}
|
2010-01-30 08:58:57 +08:00
|
|
|
|
|
|
|
void regulatory_hint_disconnect(void)
|
|
|
|
{
|
2010-10-21 01:18:59 +08:00
|
|
|
REG_DBG_PRINT("All devices are disconnected, going to "
|
2010-01-30 08:58:57 +08:00
|
|
|
"restore regulatory settings\n");
|
|
|
|
restore_regulatory_settings(false);
|
|
|
|
}
|
|
|
|
|
2009-02-21 13:20:39 +08:00
|
|
|
static bool freq_is_chan_12_13_14(u16 freq)
|
|
|
|
{
|
2011-01-17 12:37:28 +08:00
|
|
|
if (freq == ieee80211_channel_to_frequency(12, IEEE80211_BAND_2GHZ) ||
|
|
|
|
freq == ieee80211_channel_to_frequency(13, IEEE80211_BAND_2GHZ) ||
|
|
|
|
freq == ieee80211_channel_to_frequency(14, IEEE80211_BAND_2GHZ))
|
2009-02-21 13:20:39 +08:00
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
int regulatory_hint_found_beacon(struct wiphy *wiphy,
|
|
|
|
struct ieee80211_channel *beacon_chan,
|
|
|
|
gfp_t gfp)
|
|
|
|
{
|
|
|
|
struct reg_beacon *reg_beacon;
|
|
|
|
|
|
|
|
if (likely((beacon_chan->beacon_found ||
|
|
|
|
(beacon_chan->flags & IEEE80211_CHAN_RADAR) ||
|
|
|
|
(beacon_chan->band == IEEE80211_BAND_2GHZ &&
|
|
|
|
!freq_is_chan_12_13_14(beacon_chan->center_freq)))))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
reg_beacon = kzalloc(sizeof(struct reg_beacon), gfp);
|
|
|
|
if (!reg_beacon)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2010-10-21 01:18:59 +08:00
|
|
|
REG_DBG_PRINT("Found new beacon on "
|
2010-01-05 00:50:11 +08:00
|
|
|
"frequency: %d MHz (Ch %d) on %s\n",
|
|
|
|
beacon_chan->center_freq,
|
|
|
|
ieee80211_frequency_to_channel(beacon_chan->center_freq),
|
|
|
|
wiphy_name(wiphy));
|
|
|
|
|
2009-02-21 13:20:39 +08:00
|
|
|
memcpy(®_beacon->chan, beacon_chan,
|
|
|
|
sizeof(struct ieee80211_channel));
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Since we can be called from BH or and non-BH context
|
|
|
|
* we must use spin_lock_bh()
|
|
|
|
*/
|
|
|
|
spin_lock_bh(®_pending_beacons_lock);
|
|
|
|
list_add_tail(®_beacon->list, ®_pending_beacons);
|
|
|
|
spin_unlock_bh(®_pending_beacons_lock);
|
|
|
|
|
|
|
|
schedule_work(®_work);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-09-15 17:10:52 +08:00
|
|
|
static void print_rd_rules(const struct ieee80211_regdomain *rd)
|
2008-09-10 14:19:48 +08:00
|
|
|
{
|
|
|
|
unsigned int i;
|
2008-09-15 17:10:52 +08:00
|
|
|
const struct ieee80211_reg_rule *reg_rule = NULL;
|
|
|
|
const struct ieee80211_freq_range *freq_range = NULL;
|
|
|
|
const struct ieee80211_power_rule *power_rule = NULL;
|
2008-09-10 14:19:48 +08:00
|
|
|
|
cfg80211: replace reg.c Nokia commit 269ac5
Nokia hasn't gotten back to me in over 1 month for a relicense
change request. There are only a few changes that they contributed,
so just reverting their changes but replacing with another set.
This change replaces this commit:
commit 269ac5fd2d75b118d76a2291e28796527db2f3f8
Author: Kalle Valo <kalle.valo@nokia.com>
Date: Tue Dec 1 10:47:15 2009 +0200
cfg80211: indent regulatory messages with spaces
The regulatory messages in syslog look weird:
kernel: cfg80211: Regulatory domain: US
kernel: ^I(start_freq - end_freq @ bandwidth), (max_antenna_gain, max_eirp)
kernel: ^I(2402000 KHz - 2472000 KHz @ 40000 KHz), (600 mBi, 2700 mBm)
kernel: ^I(5170000 KHz - 5190000 KHz @ 40000 KHz), (600 mBi, 2300 mBm)
kernel: ^I(5190000 KHz - 5210000 KHz @ 40000 KHz), (600 mBi, 2300 mBm)
kernel: ^I(5210000 KHz - 5230000 KHz @ 40000 KHz), (600 mBi, 2300 mBm)
kernel: ^I(5230000 KHz - 5330000 KHz @ 40000 KHz), (600 mBi, 2300 mBm)
kernel: ^I(5735000 KHz - 5835000 KHz @ 40000 KHz), (600 mBi, 3000 mBm)
Indent them with four spaces instead of the tab character to get prettier
output.
Signed-off-by: Kalle Valo <kalle.valo@nokia.com>
Acked: Luis R. Rodriguez <lrodriguez@atheros.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
Cc: Petri Karhula <petri.karhula@nokia.com>
Signed-off-by: Luis R. Rodriguez <mcgrof@qca.qualcomm.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2011-12-21 04:23:37 +08:00
|
|
|
pr_info(" (start_freq - end_freq @ bandwidth), (max_antenna_gain, max_eirp)\n");
|
2008-09-10 14:19:48 +08:00
|
|
|
|
|
|
|
for (i = 0; i < rd->n_reg_rules; i++) {
|
|
|
|
reg_rule = &rd->reg_rules[i];
|
|
|
|
freq_range = ®_rule->freq_range;
|
|
|
|
power_rule = ®_rule->power_rule;
|
|
|
|
|
2009-02-21 13:04:31 +08:00
|
|
|
/*
|
|
|
|
* There may not be documentation for max antenna gain
|
|
|
|
* in certain regions
|
|
|
|
*/
|
2008-09-10 14:19:48 +08:00
|
|
|
if (power_rule->max_antenna_gain)
|
cfg80211: replace reg.c Nokia commit 269ac5
Nokia hasn't gotten back to me in over 1 month for a relicense
change request. There are only a few changes that they contributed,
so just reverting their changes but replacing with another set.
This change replaces this commit:
commit 269ac5fd2d75b118d76a2291e28796527db2f3f8
Author: Kalle Valo <kalle.valo@nokia.com>
Date: Tue Dec 1 10:47:15 2009 +0200
cfg80211: indent regulatory messages with spaces
The regulatory messages in syslog look weird:
kernel: cfg80211: Regulatory domain: US
kernel: ^I(start_freq - end_freq @ bandwidth), (max_antenna_gain, max_eirp)
kernel: ^I(2402000 KHz - 2472000 KHz @ 40000 KHz), (600 mBi, 2700 mBm)
kernel: ^I(5170000 KHz - 5190000 KHz @ 40000 KHz), (600 mBi, 2300 mBm)
kernel: ^I(5190000 KHz - 5210000 KHz @ 40000 KHz), (600 mBi, 2300 mBm)
kernel: ^I(5210000 KHz - 5230000 KHz @ 40000 KHz), (600 mBi, 2300 mBm)
kernel: ^I(5230000 KHz - 5330000 KHz @ 40000 KHz), (600 mBi, 2300 mBm)
kernel: ^I(5735000 KHz - 5835000 KHz @ 40000 KHz), (600 mBi, 3000 mBm)
Indent them with four spaces instead of the tab character to get prettier
output.
Signed-off-by: Kalle Valo <kalle.valo@nokia.com>
Acked: Luis R. Rodriguez <lrodriguez@atheros.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
Cc: Petri Karhula <petri.karhula@nokia.com>
Signed-off-by: Luis R. Rodriguez <mcgrof@qca.qualcomm.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2011-12-21 04:23:37 +08:00
|
|
|
pr_info(" (%d KHz - %d KHz @ %d KHz), (%d mBi, %d mBm)\n",
|
2008-09-10 14:19:48 +08:00
|
|
|
freq_range->start_freq_khz,
|
|
|
|
freq_range->end_freq_khz,
|
|
|
|
freq_range->max_bandwidth_khz,
|
|
|
|
power_rule->max_antenna_gain,
|
|
|
|
power_rule->max_eirp);
|
|
|
|
else
|
cfg80211: replace reg.c Nokia commit 269ac5
Nokia hasn't gotten back to me in over 1 month for a relicense
change request. There are only a few changes that they contributed,
so just reverting their changes but replacing with another set.
This change replaces this commit:
commit 269ac5fd2d75b118d76a2291e28796527db2f3f8
Author: Kalle Valo <kalle.valo@nokia.com>
Date: Tue Dec 1 10:47:15 2009 +0200
cfg80211: indent regulatory messages with spaces
The regulatory messages in syslog look weird:
kernel: cfg80211: Regulatory domain: US
kernel: ^I(start_freq - end_freq @ bandwidth), (max_antenna_gain, max_eirp)
kernel: ^I(2402000 KHz - 2472000 KHz @ 40000 KHz), (600 mBi, 2700 mBm)
kernel: ^I(5170000 KHz - 5190000 KHz @ 40000 KHz), (600 mBi, 2300 mBm)
kernel: ^I(5190000 KHz - 5210000 KHz @ 40000 KHz), (600 mBi, 2300 mBm)
kernel: ^I(5210000 KHz - 5230000 KHz @ 40000 KHz), (600 mBi, 2300 mBm)
kernel: ^I(5230000 KHz - 5330000 KHz @ 40000 KHz), (600 mBi, 2300 mBm)
kernel: ^I(5735000 KHz - 5835000 KHz @ 40000 KHz), (600 mBi, 3000 mBm)
Indent them with four spaces instead of the tab character to get prettier
output.
Signed-off-by: Kalle Valo <kalle.valo@nokia.com>
Acked: Luis R. Rodriguez <lrodriguez@atheros.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
Cc: Petri Karhula <petri.karhula@nokia.com>
Signed-off-by: Luis R. Rodriguez <mcgrof@qca.qualcomm.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2011-12-21 04:23:37 +08:00
|
|
|
pr_info(" (%d KHz - %d KHz @ %d KHz), (N/A, %d mBm)\n",
|
2008-09-10 14:19:48 +08:00
|
|
|
freq_range->start_freq_khz,
|
|
|
|
freq_range->end_freq_khz,
|
|
|
|
freq_range->max_bandwidth_khz,
|
|
|
|
power_rule->max_eirp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-12 01:59:02 +08:00
|
|
|
bool reg_supported_dfs_region(u8 dfs_region)
|
|
|
|
{
|
|
|
|
switch (dfs_region) {
|
|
|
|
case NL80211_DFS_UNSET:
|
|
|
|
case NL80211_DFS_FCC:
|
|
|
|
case NL80211_DFS_ETSI:
|
|
|
|
case NL80211_DFS_JP:
|
|
|
|
return true;
|
|
|
|
default:
|
|
|
|
REG_DBG_PRINT("Ignoring uknown DFS master region: %d\n",
|
|
|
|
dfs_region);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void print_dfs_region(u8 dfs_region)
|
|
|
|
{
|
|
|
|
if (!dfs_region)
|
|
|
|
return;
|
|
|
|
|
|
|
|
switch (dfs_region) {
|
|
|
|
case NL80211_DFS_FCC:
|
|
|
|
pr_info(" DFS Master region FCC");
|
|
|
|
break;
|
|
|
|
case NL80211_DFS_ETSI:
|
|
|
|
pr_info(" DFS Master region ETSI");
|
|
|
|
break;
|
|
|
|
case NL80211_DFS_JP:
|
|
|
|
pr_info(" DFS Master region JP");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
pr_info(" DFS Master region Uknown");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-09-15 17:10:52 +08:00
|
|
|
static void print_regdomain(const struct ieee80211_regdomain *rd)
|
2008-09-10 14:19:48 +08:00
|
|
|
{
|
|
|
|
|
2008-11-13 06:22:02 +08:00
|
|
|
if (is_intersected_alpha2(rd->alpha2)) {
|
|
|
|
|
2009-03-10 10:07:41 +08:00
|
|
|
if (last_request->initiator ==
|
|
|
|
NL80211_REGDOM_SET_BY_COUNTRY_IE) {
|
2009-07-07 09:56:12 +08:00
|
|
|
struct cfg80211_registered_device *rdev;
|
|
|
|
rdev = cfg80211_rdev_by_wiphy_idx(
|
2009-02-21 13:04:26 +08:00
|
|
|
last_request->wiphy_idx);
|
2009-07-07 09:56:12 +08:00
|
|
|
if (rdev) {
|
2010-11-17 11:56:49 +08:00
|
|
|
pr_info("Current regulatory domain updated by AP to: %c%c\n",
|
2009-07-07 09:56:12 +08:00
|
|
|
rdev->country_ie_alpha2[0],
|
|
|
|
rdev->country_ie_alpha2[1]);
|
2008-11-13 06:22:02 +08:00
|
|
|
} else
|
2010-11-17 11:56:49 +08:00
|
|
|
pr_info("Current regulatory domain intersected:\n");
|
2008-11-13 06:22:02 +08:00
|
|
|
} else
|
2010-11-17 11:56:49 +08:00
|
|
|
pr_info("Current regulatory domain intersected:\n");
|
2008-11-13 06:22:02 +08:00
|
|
|
} else if (is_world_regdom(rd->alpha2))
|
2010-11-17 11:56:49 +08:00
|
|
|
pr_info("World regulatory domain updated:\n");
|
2008-09-10 14:19:48 +08:00
|
|
|
else {
|
|
|
|
if (is_unknown_alpha2(rd->alpha2))
|
2010-11-17 11:56:49 +08:00
|
|
|
pr_info("Regulatory domain changed to driver built-in settings (unknown country)\n");
|
2012-07-13 02:49:18 +08:00
|
|
|
else {
|
|
|
|
if (reg_request_cell_base(last_request))
|
|
|
|
pr_info("Regulatory domain changed "
|
|
|
|
"to country: %c%c by Cell Station\n",
|
|
|
|
rd->alpha2[0], rd->alpha2[1]);
|
|
|
|
else
|
|
|
|
pr_info("Regulatory domain changed "
|
|
|
|
"to country: %c%c\n",
|
|
|
|
rd->alpha2[0], rd->alpha2[1]);
|
|
|
|
}
|
2008-09-10 14:19:48 +08:00
|
|
|
}
|
2011-10-12 01:59:02 +08:00
|
|
|
print_dfs_region(rd->dfs_region);
|
2008-09-10 14:19:48 +08:00
|
|
|
print_rd_rules(rd);
|
|
|
|
}
|
|
|
|
|
2008-10-28 23:49:41 +08:00
|
|
|
static void print_regdomain_info(const struct ieee80211_regdomain *rd)
|
2008-09-10 14:19:48 +08:00
|
|
|
{
|
2010-11-17 11:56:49 +08:00
|
|
|
pr_info("Regulatory domain: %c%c\n", rd->alpha2[0], rd->alpha2[1]);
|
2008-09-10 14:19:48 +08:00
|
|
|
print_rd_rules(rd);
|
|
|
|
}
|
|
|
|
|
2008-10-25 02:32:20 +08:00
|
|
|
/* Takes ownership of rd only if it doesn't fail */
|
2008-09-15 17:10:52 +08:00
|
|
|
static int __set_regdom(const struct ieee80211_regdomain *rd)
|
2008-09-10 14:19:48 +08:00
|
|
|
{
|
2008-10-31 04:33:53 +08:00
|
|
|
const struct ieee80211_regdomain *intersected_rd = NULL;
|
2009-02-21 13:04:26 +08:00
|
|
|
struct wiphy *request_wiphy;
|
2008-09-10 14:19:48 +08:00
|
|
|
/* Some basic sanity checks first */
|
|
|
|
|
|
|
|
if (is_world_regdom(rd->alpha2)) {
|
2008-10-21 17:01:33 +08:00
|
|
|
if (WARN_ON(!reg_is_valid_request(rd->alpha2)))
|
2008-09-10 14:19:48 +08:00
|
|
|
return -EINVAL;
|
|
|
|
update_world_regdomain(rd);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!is_alpha2_set(rd->alpha2) && !is_an_alpha2(rd->alpha2) &&
|
|
|
|
!is_unknown_alpha2(rd->alpha2))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-10-21 17:01:33 +08:00
|
|
|
if (!last_request)
|
2008-09-10 14:19:48 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2009-02-21 13:04:31 +08:00
|
|
|
/*
|
|
|
|
* Lets only bother proceeding on the same alpha2 if the current
|
2008-11-13 06:22:02 +08:00
|
|
|
* rd is non static (it means CRDA was present and was used last)
|
2009-02-21 13:04:31 +08:00
|
|
|
* and the pending request came in from a country IE
|
|
|
|
*/
|
2009-03-10 10:07:41 +08:00
|
|
|
if (last_request->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE) {
|
2009-02-21 13:04:31 +08:00
|
|
|
/*
|
|
|
|
* If someone else asked us to change the rd lets only bother
|
|
|
|
* checking if the alpha2 changes if CRDA was already called
|
|
|
|
*/
|
2009-12-19 06:59:02 +08:00
|
|
|
if (!regdom_changes(rd->alpha2))
|
2012-07-12 20:33:58 +08:00
|
|
|
return -EALREADY;
|
2008-11-13 06:22:02 +08:00
|
|
|
}
|
|
|
|
|
2009-02-21 13:04:31 +08:00
|
|
|
/*
|
|
|
|
* Now lets set the regulatory domain, update all driver channels
|
2008-09-10 14:19:48 +08:00
|
|
|
* and finally inform them of what we have done, in case they want
|
|
|
|
* to review or adjust their own settings based on their own
|
2009-02-21 13:04:31 +08:00
|
|
|
* internal EEPROM data
|
|
|
|
*/
|
2008-09-10 14:19:48 +08:00
|
|
|
|
2008-10-21 17:01:33 +08:00
|
|
|
if (WARN_ON(!reg_is_valid_request(rd->alpha2)))
|
2008-09-10 14:19:48 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2008-11-13 06:21:57 +08:00
|
|
|
if (!is_valid_rd(rd)) {
|
2010-11-17 11:56:49 +08:00
|
|
|
pr_err("Invalid regulatory domain detected:\n");
|
2008-11-13 06:21:57 +08:00
|
|
|
print_regdomain_info(rd);
|
|
|
|
return -EINVAL;
|
2008-09-10 14:19:48 +08:00
|
|
|
}
|
|
|
|
|
2009-02-21 13:04:26 +08:00
|
|
|
request_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);
|
2011-11-29 05:47:16 +08:00
|
|
|
if (!request_wiphy &&
|
|
|
|
(last_request->initiator == NL80211_REGDOM_SET_BY_DRIVER ||
|
|
|
|
last_request->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE)) {
|
|
|
|
schedule_delayed_work(®_timeout, 0);
|
2011-11-21 17:44:00 +08:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
2009-02-21 13:04:26 +08:00
|
|
|
|
2008-11-13 06:21:58 +08:00
|
|
|
if (!last_request->intersect) {
|
2009-01-08 09:43:34 +08:00
|
|
|
int r;
|
|
|
|
|
2009-03-10 10:07:41 +08:00
|
|
|
if (last_request->initiator != NL80211_REGDOM_SET_BY_DRIVER) {
|
2011-11-29 05:47:15 +08:00
|
|
|
reset_regdomains(false);
|
2009-01-08 09:43:34 +08:00
|
|
|
cfg80211_regdomain = rd;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-02-21 13:04:31 +08:00
|
|
|
/*
|
|
|
|
* For a driver hint, lets copy the regulatory domain the
|
|
|
|
* driver wanted to the wiphy to deal with conflicts
|
|
|
|
*/
|
2009-01-08 09:43:34 +08:00
|
|
|
|
2009-06-09 09:54:37 +08:00
|
|
|
/*
|
|
|
|
* Userspace could have sent two replies with only
|
|
|
|
* one kernel request.
|
|
|
|
*/
|
|
|
|
if (request_wiphy->regd)
|
|
|
|
return -EALREADY;
|
2009-01-08 09:43:34 +08:00
|
|
|
|
2009-02-21 13:04:26 +08:00
|
|
|
r = reg_copy_regd(&request_wiphy->regd, rd);
|
2009-01-08 09:43:34 +08:00
|
|
|
if (r)
|
|
|
|
return r;
|
|
|
|
|
2011-11-29 05:47:15 +08:00
|
|
|
reset_regdomains(false);
|
2008-11-13 06:21:58 +08:00
|
|
|
cfg80211_regdomain = rd;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Intersection requires a bit more work */
|
|
|
|
|
2009-03-10 10:07:41 +08:00
|
|
|
if (last_request->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE) {
|
2008-11-13 06:21:58 +08:00
|
|
|
|
2008-10-31 04:33:53 +08:00
|
|
|
intersected_rd = regdom_intersect(rd, cfg80211_regdomain);
|
|
|
|
if (!intersected_rd)
|
|
|
|
return -EINVAL;
|
2008-11-13 06:21:58 +08:00
|
|
|
|
2009-02-21 13:04:31 +08:00
|
|
|
/*
|
|
|
|
* We can trash what CRDA provided now.
|
2009-01-08 09:43:34 +08:00
|
|
|
* However if a driver requested this specific regulatory
|
2009-02-21 13:04:31 +08:00
|
|
|
* domain we keep it for its private use
|
|
|
|
*/
|
2009-03-10 10:07:41 +08:00
|
|
|
if (last_request->initiator == NL80211_REGDOM_SET_BY_DRIVER)
|
2009-02-21 13:04:26 +08:00
|
|
|
request_wiphy->regd = rd;
|
2009-01-08 09:43:34 +08:00
|
|
|
else
|
|
|
|
kfree(rd);
|
|
|
|
|
2008-11-13 06:21:58 +08:00
|
|
|
rd = NULL;
|
|
|
|
|
2011-11-29 05:47:15 +08:00
|
|
|
reset_regdomains(false);
|
2008-11-13 06:21:58 +08:00
|
|
|
cfg80211_regdomain = intersected_rd;
|
|
|
|
|
|
|
|
return 0;
|
2008-10-31 04:33:53 +08:00
|
|
|
}
|
|
|
|
|
2012-09-17 18:54:15 +08:00
|
|
|
return -EINVAL;
|
2008-09-10 14:19:48 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-02-21 13:04:31 +08:00
|
|
|
/*
|
|
|
|
* Use this call to set the current regulatory domain. Conflicts with
|
2008-09-10 14:19:48 +08:00
|
|
|
* multiple drivers can be ironed out later. Caller must've already
|
2009-02-21 13:04:31 +08:00
|
|
|
* kmalloc'd the rd structure. Caller must hold cfg80211_mutex
|
|
|
|
*/
|
2008-09-15 17:10:52 +08:00
|
|
|
int set_regdom(const struct ieee80211_regdomain *rd)
|
2008-09-10 14:19:48 +08:00
|
|
|
{
|
|
|
|
int r;
|
|
|
|
|
2009-02-21 13:04:25 +08:00
|
|
|
assert_cfg80211_lock();
|
|
|
|
|
2009-07-31 08:38:08 +08:00
|
|
|
mutex_lock(®_mutex);
|
|
|
|
|
2008-09-10 14:19:48 +08:00
|
|
|
/* Note that this doesn't update the wiphys, this is done below */
|
|
|
|
r = __set_regdom(rd);
|
2008-10-25 02:32:20 +08:00
|
|
|
if (r) {
|
2012-07-12 20:33:58 +08:00
|
|
|
if (r == -EALREADY)
|
|
|
|
reg_set_request_processed();
|
|
|
|
|
2008-10-25 02:32:20 +08:00
|
|
|
kfree(rd);
|
2009-07-31 08:38:08 +08:00
|
|
|
mutex_unlock(®_mutex);
|
2008-09-10 14:19:48 +08:00
|
|
|
return r;
|
2008-10-25 02:32:20 +08:00
|
|
|
}
|
2008-09-10 14:19:48 +08:00
|
|
|
|
|
|
|
/* This would make this whole thing pointless */
|
2008-11-13 06:21:59 +08:00
|
|
|
if (!last_request->intersect)
|
|
|
|
BUG_ON(rd != cfg80211_regdomain);
|
2008-09-10 14:19:48 +08:00
|
|
|
|
|
|
|
/* update all wiphys now with the new established regulatory domain */
|
2008-10-21 17:01:33 +08:00
|
|
|
update_all_wiphy_regulatory(last_request->initiator);
|
2008-09-10 14:19:48 +08:00
|
|
|
|
2008-11-13 06:21:59 +08:00
|
|
|
print_regdomain(cfg80211_regdomain);
|
2008-09-10 14:19:48 +08:00
|
|
|
|
2009-03-10 10:07:42 +08:00
|
|
|
nl80211_send_reg_change_event(last_request);
|
|
|
|
|
2010-11-18 13:46:09 +08:00
|
|
|
reg_set_request_processed();
|
|
|
|
|
2009-07-31 08:38:08 +08:00
|
|
|
mutex_unlock(®_mutex);
|
|
|
|
|
2008-09-10 14:19:48 +08:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2011-03-09 02:45:30 +08:00
|
|
|
#ifdef CONFIG_HOTPLUG
|
|
|
|
int reg_device_uevent(struct device *dev, struct kobj_uevent_env *env)
|
|
|
|
{
|
|
|
|
if (last_request && !last_request->processed) {
|
|
|
|
if (add_uevent_var(env, "COUNTRY=%c%c",
|
|
|
|
last_request->alpha2[0],
|
|
|
|
last_request->alpha2[1]))
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
int reg_device_uevent(struct device *dev, struct kobj_uevent_env *env)
|
|
|
|
{
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_HOTPLUG */
|
|
|
|
|
2012-07-13 02:49:18 +08:00
|
|
|
void wiphy_regulatory_register(struct wiphy *wiphy)
|
|
|
|
{
|
|
|
|
assert_cfg80211_lock();
|
|
|
|
|
|
|
|
mutex_lock(®_mutex);
|
|
|
|
|
|
|
|
if (!reg_dev_ignore_cell_hint(wiphy))
|
|
|
|
reg_num_devs_support_basehint++;
|
|
|
|
|
2012-07-13 02:49:21 +08:00
|
|
|
wiphy_update_regulatory(wiphy, NL80211_REGDOM_SET_BY_CORE);
|
2012-07-13 02:49:20 +08:00
|
|
|
|
2012-07-13 02:49:21 +08:00
|
|
|
mutex_unlock(®_mutex);
|
2012-07-13 02:49:18 +08:00
|
|
|
}
|
|
|
|
|
2009-02-21 13:04:21 +08:00
|
|
|
/* Caller must hold cfg80211_mutex */
|
2012-07-13 02:49:19 +08:00
|
|
|
void wiphy_regulatory_deregister(struct wiphy *wiphy)
|
2008-11-13 06:22:02 +08:00
|
|
|
{
|
2009-03-25 09:21:08 +08:00
|
|
|
struct wiphy *request_wiphy = NULL;
|
2009-02-21 13:04:26 +08:00
|
|
|
|
2009-02-21 13:04:25 +08:00
|
|
|
assert_cfg80211_lock();
|
|
|
|
|
2009-07-31 08:38:08 +08:00
|
|
|
mutex_lock(®_mutex);
|
|
|
|
|
2012-07-13 02:49:18 +08:00
|
|
|
if (!reg_dev_ignore_cell_hint(wiphy))
|
|
|
|
reg_num_devs_support_basehint--;
|
|
|
|
|
2009-04-25 05:09:31 +08:00
|
|
|
kfree(wiphy->regd);
|
|
|
|
|
2009-03-25 09:21:08 +08:00
|
|
|
if (last_request)
|
|
|
|
request_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);
|
2009-02-21 13:04:26 +08:00
|
|
|
|
2009-04-25 05:09:31 +08:00
|
|
|
if (!request_wiphy || request_wiphy != wiphy)
|
2009-07-31 08:38:08 +08:00
|
|
|
goto out;
|
2009-04-25 05:09:31 +08:00
|
|
|
|
2009-02-21 13:04:26 +08:00
|
|
|
last_request->wiphy_idx = WIPHY_IDX_STALE;
|
2008-11-13 06:22:02 +08:00
|
|
|
last_request->country_ie_env = ENVIRON_ANY;
|
2009-07-31 08:38:08 +08:00
|
|
|
out:
|
|
|
|
mutex_unlock(®_mutex);
|
2008-11-13 06:22:02 +08:00
|
|
|
}
|
|
|
|
|
2011-04-06 01:49:04 +08:00
|
|
|
static void reg_timeout_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
REG_DBG_PRINT("Timeout while waiting for CRDA to reply, "
|
2011-07-30 05:51:25 +08:00
|
|
|
"restoring regulatory settings\n");
|
2011-04-06 01:49:04 +08:00
|
|
|
restore_regulatory_settings(true);
|
|
|
|
}
|
|
|
|
|
2010-06-18 15:38:55 +08:00
|
|
|
int __init regulatory_init(void)
|
2008-09-10 14:19:48 +08:00
|
|
|
{
|
2009-02-21 13:04:24 +08:00
|
|
|
int err = 0;
|
2008-09-15 16:56:48 +08:00
|
|
|
|
2008-09-10 14:19:48 +08:00
|
|
|
reg_pdev = platform_device_register_simple("regulatory", 0, NULL, 0);
|
|
|
|
if (IS_ERR(reg_pdev))
|
|
|
|
return PTR_ERR(reg_pdev);
|
2008-09-15 16:56:48 +08:00
|
|
|
|
2011-03-09 02:45:30 +08:00
|
|
|
reg_pdev->dev.type = ®_device_type;
|
|
|
|
|
2009-02-21 13:04:30 +08:00
|
|
|
spin_lock_init(®_requests_lock);
|
2009-02-21 13:20:39 +08:00
|
|
|
spin_lock_init(®_pending_beacons_lock);
|
2009-02-21 13:04:30 +08:00
|
|
|
|
2012-03-23 22:23:31 +08:00
|
|
|
reg_regdb_size_check();
|
|
|
|
|
2008-09-15 17:10:52 +08:00
|
|
|
cfg80211_regdomain = cfg80211_world_regdom;
|
2008-09-15 16:56:48 +08:00
|
|
|
|
2010-01-30 08:58:57 +08:00
|
|
|
user_alpha2[0] = '9';
|
|
|
|
user_alpha2[1] = '7';
|
|
|
|
|
2009-07-15 08:23:15 +08:00
|
|
|
/* We always try to get an update for the static regdomain */
|
|
|
|
err = regulatory_hint_core(cfg80211_regdomain->alpha2);
|
2009-02-21 13:04:23 +08:00
|
|
|
if (err) {
|
2009-02-21 13:04:24 +08:00
|
|
|
if (err == -ENOMEM)
|
|
|
|
return err;
|
|
|
|
/*
|
|
|
|
* N.B. kobject_uevent_env() can fail mainly for when we're out
|
|
|
|
* memory which is handled and propagated appropriately above
|
|
|
|
* but it can also fail during a netlink_broadcast() or during
|
|
|
|
* early boot for call_usermodehelper(). For now treat these
|
|
|
|
* errors as non-fatal.
|
|
|
|
*/
|
2010-11-17 11:56:49 +08:00
|
|
|
pr_err("kobject_uevent_env() was unable to call CRDA during init\n");
|
2009-02-21 13:04:24 +08:00
|
|
|
#ifdef CONFIG_CFG80211_REG_DEBUG
|
|
|
|
/* We want to find out exactly why when debugging */
|
|
|
|
WARN_ON(err);
|
2008-09-15 16:56:48 +08:00
|
|
|
#endif
|
2009-02-21 13:04:24 +08:00
|
|
|
}
|
2008-09-15 16:56:48 +08:00
|
|
|
|
2009-07-15 08:23:15 +08:00
|
|
|
/*
|
|
|
|
* Finally, if the user set the module parameter treat it
|
|
|
|
* as a user hint.
|
|
|
|
*/
|
|
|
|
if (!is_world_regdom(ieee80211_regdom))
|
2012-07-13 02:49:18 +08:00
|
|
|
regulatory_hint_user(ieee80211_regdom,
|
|
|
|
NL80211_USER_REG_HINT_USER);
|
2009-07-15 08:23:15 +08:00
|
|
|
|
2008-09-10 14:19:48 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-06-18 15:38:55 +08:00
|
|
|
void /* __init_or_exit */ regulatory_exit(void)
|
2008-09-10 14:19:48 +08:00
|
|
|
{
|
2009-02-21 13:04:30 +08:00
|
|
|
struct regulatory_request *reg_request, *tmp;
|
2009-02-21 13:20:39 +08:00
|
|
|
struct reg_beacon *reg_beacon, *btmp;
|
2009-02-21 13:04:30 +08:00
|
|
|
|
|
|
|
cancel_work_sync(®_work);
|
2011-04-06 01:49:04 +08:00
|
|
|
cancel_delayed_work_sync(®_timeout);
|
2009-02-21 13:04:30 +08:00
|
|
|
|
2009-02-21 13:04:21 +08:00
|
|
|
mutex_lock(&cfg80211_mutex);
|
2009-07-31 08:38:08 +08:00
|
|
|
mutex_lock(®_mutex);
|
2008-09-15 16:56:48 +08:00
|
|
|
|
2011-11-29 05:47:15 +08:00
|
|
|
reset_regdomains(true);
|
2008-09-15 16:56:48 +08:00
|
|
|
|
2011-11-09 06:28:06 +08:00
|
|
|
dev_set_uevent_suppress(®_pdev->dev, true);
|
2008-10-21 17:01:33 +08:00
|
|
|
|
2008-09-10 14:19:48 +08:00
|
|
|
platform_device_unregister(reg_pdev);
|
2008-09-15 16:56:48 +08:00
|
|
|
|
2009-02-21 13:20:39 +08:00
|
|
|
spin_lock_bh(®_pending_beacons_lock);
|
|
|
|
if (!list_empty(®_pending_beacons)) {
|
|
|
|
list_for_each_entry_safe(reg_beacon, btmp,
|
|
|
|
®_pending_beacons, list) {
|
|
|
|
list_del(®_beacon->list);
|
|
|
|
kfree(reg_beacon);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock_bh(®_pending_beacons_lock);
|
|
|
|
|
|
|
|
if (!list_empty(®_beacon_list)) {
|
|
|
|
list_for_each_entry_safe(reg_beacon, btmp,
|
|
|
|
®_beacon_list, list) {
|
|
|
|
list_del(®_beacon->list);
|
|
|
|
kfree(reg_beacon);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-02-21 13:04:30 +08:00
|
|
|
spin_lock(®_requests_lock);
|
|
|
|
if (!list_empty(®_requests_list)) {
|
|
|
|
list_for_each_entry_safe(reg_request, tmp,
|
|
|
|
®_requests_list, list) {
|
|
|
|
list_del(®_request->list);
|
|
|
|
kfree(reg_request);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock(®_requests_lock);
|
|
|
|
|
2009-07-31 08:38:08 +08:00
|
|
|
mutex_unlock(®_mutex);
|
2009-02-21 13:04:21 +08:00
|
|
|
mutex_unlock(&cfg80211_mutex);
|
2008-01-25 02:38:38 +08:00
|
|
|
}
|