[mirror_ubuntu-artful-kernel.git] / net / wireless / reg.c

/*
 * Copyright 2002-2005, Instant802 Networks, Inc.
 * Copyright 2005-2006, Devicescape Software, Inc.
 * Copyright 2007	Johannes Berg <johannes@sipsolutions.net>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

/*
 * This regulatory domain control implementation is highly incomplete, it
 * only exists for the purpose of not regressing mac80211.
 *
 * For now, drivers can restrict the set of allowed channels by either
 * not registering those channels or setting the IEEE80211_CHAN_DISABLED
 * flag; that flag will only be *set* by this code, never *cleared.
 *
 * 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.
 *
 * Alternatively, drivers that trust the regulatory domain control here
 * will register a complete set of capabilities and the control code
 * will restrict the set by setting the IEEE80211_CHAN_* flags.
 */
#include <linux/kernel.h>
#include <net/wireless.h>
#include "core.h"

static char *ieee80211_regdom = "US";
module_param(ieee80211_regdom, charp, 0444);
MODULE_PARM_DESC(ieee80211_regdom, "IEEE 802.11 regulatory domain code");

struct ieee80211_channel_range {
	short start_freq;
	short end_freq;
	int max_power;
	int max_antenna_gain;
	u32 flags;
};

struct ieee80211_regdomain {
	const char *code;
	const struct ieee80211_channel_range *ranges;
	int n_ranges;
};

#define RANGE_PWR(_start, _end, _pwr, _ag, _flags)	\
	{ _start, _end, _pwr, _ag, _flags }


/*
 * Ideally, in the future, these definitions will be loaded from a
 * userspace table via some daemon.
 */
static const struct ieee80211_channel_range ieee80211_US_channels[] = {
	/* IEEE 802.11b/g, channels 1..11 */
	RANGE_PWR(2412, 2462, 27, 6, 0),
	/* IEEE 802.11a, channel 36*/
	RANGE_PWR(5180, 5180, 23, 6, 0),
	/* IEEE 802.11a, channel 40*/
	RANGE_PWR(5200, 5200, 23, 6, 0),
	/* IEEE 802.11a, channel 44*/
	RANGE_PWR(5220, 5220, 23, 6, 0),
	/* IEEE 802.11a, channels 48..64 */
	RANGE_PWR(5240, 5320, 23, 6, 0),
	/* IEEE 802.11a, channels 149..165, outdoor */
	RANGE_PWR(5745, 5825, 30, 6, 0),
};

static const struct ieee80211_channel_range ieee80211_JP_channels[] = {
	/* IEEE 802.11b/g, channels 1..14 */
	RANGE_PWR(2412, 2484, 20, 6, 0),
	/* IEEE 802.11a, channels 34..48 */
	RANGE_PWR(5170, 5240, 20, 6, IEEE80211_CHAN_PASSIVE_SCAN),
	/* IEEE 802.11a, channels 52..64 */
	RANGE_PWR(5260, 5320, 20, 6, IEEE80211_CHAN_NO_IBSS |
				     IEEE80211_CHAN_RADAR),
};

static const struct ieee80211_channel_range ieee80211_EU_channels[] = {
	/* IEEE 802.11b/g, channels 1..13 */
	RANGE_PWR(2412, 2472, 20, 6, 0),
	/* IEEE 802.11a, channel 36*/
	RANGE_PWR(5180, 5180, 23, 6, IEEE80211_CHAN_PASSIVE_SCAN),
	/* IEEE 802.11a, channel 40*/
	RANGE_PWR(5200, 5200, 23, 6, IEEE80211_CHAN_PASSIVE_SCAN),
	/* IEEE 802.11a, channel 44*/
	RANGE_PWR(5220, 5220, 23, 6, IEEE80211_CHAN_PASSIVE_SCAN),
	/* IEEE 802.11a, channels 48..64 */
	RANGE_PWR(5240, 5320, 23, 6, IEEE80211_CHAN_NO_IBSS |
				     IEEE80211_CHAN_RADAR),
	/* IEEE 802.11a, channels 100..140 */
	RANGE_PWR(5500, 5700, 30, 6, IEEE80211_CHAN_NO_IBSS |
				     IEEE80211_CHAN_RADAR),
};

#define REGDOM(_code)							\
	{								\
		.code = __stringify(_code),				\
		.ranges = ieee80211_ ##_code## _channels,		\
		.n_ranges = ARRAY_SIZE(ieee80211_ ##_code## _channels),	\
	}

static const struct ieee80211_regdomain ieee80211_regdoms[] = {
	REGDOM(US),
	REGDOM(JP),
	REGDOM(EU),
};


static const struct ieee80211_regdomain *get_regdom(void)
{
	static const struct ieee80211_channel_range
	ieee80211_world_channels[] = {
		/* IEEE 802.11b/g, channels 1..11 */
		RANGE_PWR(2412, 2462, 27, 6, 0),
	};
	static const struct ieee80211_regdomain regdom_world = REGDOM(world);
	int i;

	for (i = 0; i < ARRAY_SIZE(ieee80211_regdoms); i++)
		if (strcmp(ieee80211_regdom, ieee80211_regdoms[i].code) == 0)
			return &ieee80211_regdoms[i];

	return &regdom_world;
}


static void handle_channel(struct ieee80211_channel *chan,
			   const struct ieee80211_regdomain *rd)
{
	int i;
	u32 flags = chan->orig_flags;
	const struct ieee80211_channel_range *rg = NULL;

	for (i = 0; i < rd->n_ranges; i++) {
		if (rd->ranges[i].start_freq <= chan->center_freq &&
		    chan->center_freq <= rd->ranges[i].end_freq) {
			rg = &rd->ranges[i];
			break;
		}
	}

	if (!rg) {
		/* not found */
		flags |= IEEE80211_CHAN_DISABLED;
		chan->flags = flags;
		return;
	}

	chan->flags = flags;
	chan->max_antenna_gain = min(chan->orig_mag,
					 rg->max_antenna_gain);
	if (chan->orig_mpwr)
		chan->max_power = min(chan->orig_mpwr, rg->max_power);
	else
		chan->max_power = rg->max_power;
}

static void handle_band(struct ieee80211_supported_band *sband,
			const struct ieee80211_regdomain *rd)
{
	int i;

	for (i = 0; i < sband->n_channels; i++)
		handle_channel(&sband->channels[i], rd);
}

void wiphy_update_regulatory(struct wiphy *wiphy)
{
	enum ieee80211_band band;
	const struct ieee80211_regdomain *rd = get_regdom();

	for (band = 0; band < IEEE80211_NUM_BANDS; band++)
		if (wiphy->bands[band])
			handle_band(wiphy->bands[band], rd);
}
Commit	Line	Data
8318d78a JB	1	/*
	2	* Copyright 2002-2005, Instant802 Networks, Inc.
	3	* Copyright 2005-2006, Devicescape Software, Inc.
	4	* Copyright 2007 Johannes Berg <johannes@sipsolutions.net>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License version 2 as
	8	* published by the Free Software Foundation.
	9	*/
	10
	11	/*
	12	* This regulatory domain control implementation is highly incomplete, it
	13	* only exists for the purpose of not regressing mac80211.
	14	*
	15	* For now, drivers can restrict the set of allowed channels by either
	16	* not registering those channels or setting the IEEE80211_CHAN_DISABLED
	17	* flag; that flag will only be set by this code, never *cleared.
	18	*
	19	* The usual implementation is for a driver to read a device EEPROM to
	20	* determine which regulatory domain it should be operating under, then
	21	* looking up the allowable channels in a driver-local table and finally
	22	* registering those channels in the wiphy structure.
	23	*
	24	* Alternatively, drivers that trust the regulatory domain control here
	25	* will register a complete set of capabilities and the control code
	26	* will restrict the set by setting the IEEE80211_CHAN_* flags.
	27	*/
	28	#include <linux/kernel.h>
	29	#include <net/wireless.h>
	30	#include "core.h"
	31
	32	static char *ieee80211_regdom = "US";
	33	module_param(ieee80211_regdom, charp, 0444);
	34	MODULE_PARM_DESC(ieee80211_regdom, "IEEE 802.11 regulatory domain code");
	35
	36	struct ieee80211_channel_range {
	37	short start_freq;
	38	short end_freq;
	39	int max_power;
	40	int max_antenna_gain;
	41	u32 flags;
	42	};
	43
	44	struct ieee80211_regdomain {
	45	const char *code;
	46	const struct ieee80211_channel_range *ranges;
	47	int n_ranges;
	48	};
	49
	50	#define RANGE_PWR(_start, _end, _pwr, _ag, _flags) \
	51	{ _start, _end, _pwr, _ag, _flags }
	52
	53
	54	/*
	55	* Ideally, in the future, these definitions will be loaded from a
	56	* userspace table via some daemon.
	57	*/
	58	static const struct ieee80211_channel_range ieee80211_US_channels[] = {
	59	/* IEEE 802.11b/g, channels 1..11 */
	60	RANGE_PWR(2412, 2462, 27, 6, 0),
b46b4ee0 TW	61	/* IEEE 802.11a, channel 36*/
	62	RANGE_PWR(5180, 5180, 23, 6, 0),
	63	/* IEEE 802.11a, channel 40*/
	64	RANGE_PWR(5200, 5200, 23, 6, 0),
	65	/* IEEE 802.11a, channel 44*/
	66	RANGE_PWR(5220, 5220, 23, 6, 0),
	67	/* IEEE 802.11a, channels 48..64 */
	68	RANGE_PWR(5240, 5320, 23, 6, 0),
8318d78a JB	69	/* IEEE 802.11a, channels 149..165, outdoor */
	70	RANGE_PWR(5745, 5825, 30, 6, 0),
	71	};
	72
	73	static const struct ieee80211_channel_range ieee80211_JP_channels[] = {
	74	/* IEEE 802.11b/g, channels 1..14 */
	75	RANGE_PWR(2412, 2484, 20, 6, 0),
	76	/* IEEE 802.11a, channels 34..48 */
	77	RANGE_PWR(5170, 5240, 20, 6, IEEE80211_CHAN_PASSIVE_SCAN),
	78	/* IEEE 802.11a, channels 52..64 */
	79	RANGE_PWR(5260, 5320, 20, 6, IEEE80211_CHAN_NO_IBSS \|
	80	IEEE80211_CHAN_RADAR),
	81	};
	82
59d393ad TV	83	static const struct ieee80211_channel_range ieee80211_EU_channels[] = {
	84	/* IEEE 802.11b/g, channels 1..13 */
	85	RANGE_PWR(2412, 2472, 20, 6, 0),
	86	/* IEEE 802.11a, channel 36*/
	87	RANGE_PWR(5180, 5180, 23, 6, IEEE80211_CHAN_PASSIVE_SCAN),
	88	/* IEEE 802.11a, channel 40*/
	89	RANGE_PWR(5200, 5200, 23, 6, IEEE80211_CHAN_PASSIVE_SCAN),
	90	/* IEEE 802.11a, channel 44*/
	91	RANGE_PWR(5220, 5220, 23, 6, IEEE80211_CHAN_PASSIVE_SCAN),
	92	/* IEEE 802.11a, channels 48..64 */
	93	RANGE_PWR(5240, 5320, 23, 6, IEEE80211_CHAN_NO_IBSS \|
	94	IEEE80211_CHAN_RADAR),
	95	/* IEEE 802.11a, channels 100..140 */
	96	RANGE_PWR(5500, 5700, 30, 6, IEEE80211_CHAN_NO_IBSS \|
	97	IEEE80211_CHAN_RADAR),
	98	};
	99
8318d78a JB	100	#define REGDOM(_code) \
	101	{ \
	102	.code = __stringify(_code), \
	103	.ranges = ieee80211_ ##_code## _channels, \
	104	.n_ranges = ARRAY_SIZE(ieee80211_ ##_code## _channels), \
	105	}
	106
	107	static const struct ieee80211_regdomain ieee80211_regdoms[] = {
	108	REGDOM(US),
	109	REGDOM(JP),
59d393ad	110	REGDOM(EU),
8318d78a JB	111	};
	112
	113
	114	static const struct ieee80211_regdomain *get_regdom(void)
	115	{
	116	static const struct ieee80211_channel_range
	117	ieee80211_world_channels[] = {
	118	/* IEEE 802.11b/g, channels 1..11 */
	119	RANGE_PWR(2412, 2462, 27, 6, 0),
	120	};
	121	static const struct ieee80211_regdomain regdom_world = REGDOM(world);
	122	int i;
	123
	124	for (i = 0; i < ARRAY_SIZE(ieee80211_regdoms); i++)
	125	if (strcmp(ieee80211_regdom, ieee80211_regdoms[i].code) == 0)
	126	return &ieee80211_regdoms[i];
	127
	128	return &regdom_world;
	129	}
	130
	131
	132	static void handle_channel(struct ieee80211_channel *chan,
	133	const struct ieee80211_regdomain *rd)
	134	{
	135	int i;
	136	u32 flags = chan->orig_flags;
	137	const struct ieee80211_channel_range *rg = NULL;
	138
	139	for (i = 0; i < rd->n_ranges; i++) {
	140	if (rd->ranges[i].start_freq <= chan->center_freq &&
	141	chan->center_freq <= rd->ranges[i].end_freq) {
	142	rg = &rd->ranges[i];
	143	break;
	144	}
	145	}
	146
	147	if (!rg) {
	148	/* not found */
	149	flags \|= IEEE80211_CHAN_DISABLED;
	150	chan->flags = flags;
	151	return;
	152	}
	153
	154	chan->flags = flags;
	155	chan->max_antenna_gain = min(chan->orig_mag,
	156	rg->max_antenna_gain);
253898c4 JL	157	if (chan->orig_mpwr)
	158	chan->max_power = min(chan->orig_mpwr, rg->max_power);
	159	else
	160	chan->max_power = rg->max_power;
8318d78a JB	161	}
	162
	163	static void handle_band(struct ieee80211_supported_band *sband,
	164	const struct ieee80211_regdomain *rd)
	165	{
	166	int i;
	167
	168	for (i = 0; i < sband->n_channels; i++)
	169	handle_channel(&sband->channels[i], rd);
	170	}
	171
	172	void wiphy_update_regulatory(struct wiphy *wiphy)
	173	{
	174	enum ieee80211_band band;
	175	const struct ieee80211_regdomain *rd = get_regdom();
	176
	177	for (band = 0; band < IEEE80211_NUM_BANDS; band++)
	178	if (wiphy->bands[band])
	179	handle_band(wiphy->bands[band], rd);
	180	}