cfg80211: Add new wireless regulatory infrastructure

---------------------------

What:	old static regulatory information and ieee80211_regdom module parameter

When:	2.6.29

Why:	The old regulatory infrastructure has been replaced with a new one

	which does not require statically defined regulatory domains. We do

	not want to keep static regulatory domains in the kernel due to the

	the dynamic nature of regulatory law and localization. We kept around

	the old static definitions for the regulatory domains of:

		* US

		* JP

		* EU

	and used by default the US when CONFIG_WIRELESS_OLD_REGULATORY was

	set. We also kept around the ieee80211_regdom module parameter in case

	some applications were relying on it. Changing regulatory domains

	can now be done instead by using nl80211, as is done with iw.

Who:	Luis R. Rodriguez <lrodriguez@atheros.com>

---------------------------

What:	dev->power.power_state

When:	July 2007

Why:	Broken design for runtime control over driver power states, confusing

Linux wireless regulatory documentation

---------------------------------------

This document gives a brief review over how the Linux wireless

regulatory infrastructure works.

More up to date information can be obtained at the project's web page:

http://wireless.kernel.org/en/developers/Regulatory

Keeping regulatory domains in userspace

---------------------------------------

Due to the dynamic nature of regulatory domains we keep them

in userspace and provide a framework for userspace to upload

to the kernel one regulatory domain to be used as the central

core regulatory domain all wireless devices should adhere to.

How to get regulatory domains to the kernel

-------------------------------------------

Userspace gets a regulatory domain in the kernel by having

a userspace agent build it and send it via nl80211. Only

expected regulatory domains will be respected by the kernel.

A currently available userspace agent which can accomplish this

is CRDA - central regulatory domain agent. Its documented here:

http://wireless.kernel.org/en/developers/Regulatory/CRDA

Essentially the kernel will send a udev event when it knows

it needs a new regulatory domain. A udev rule can be put in place

to trigger crda to send the respective regulatory domain for a

specific ISO/IEC 3166 alpha2.

Below is an example udev rule which can be used:

# Example file, should be put in /etc/udev/rules.d/regulatory.rules

KERNEL=="regulatory*", ACTION=="change", SUBSYSTEM=="platform", RUN+="/sbin/crda"

The alpha2 is passed as an environment variable under the variable COUNTRY.

Who asks for regulatory domains?

--------------------------------

* Users

Users can use iw:

http://wireless.kernel.org/en/users/Documentation/iw

An example:

  # set regulatory domain to "Costa Rica"

  iw reg set CR

This will request the kernel to set the regulatory domain to

the specificied alpha2. The kernel in turn will then ask userspace

to provide a regulatory domain for the alpha2 specified by the user

by sending a uevent.

* Wireless subsystems for Country Information elements

The kernel will send a uevent to inform userspace a new

regulatory domain is required. More on this to be added

as its integration is added.

* Drivers

If drivers determine they need a specific regulatory domain

set they can inform the wireless core using regulatory_hint().

They have two options -- they either provide an alpha2 so that

crda can provide back a regulatory domain for that country or

they can build their own regulatory domain based on internal

custom knowledge so the wireless core can respect it.

*Most* drivers will rely on the first mechanism of providing a

regulatory hint with an alpha2. For these drivers there is an additional

check that can be used to ensure compliance based on custom EEPROM

regulatory data. This additional check can be used by drivers by

registering on its struct wiphy a reg_notifier() callback. This notifier

is called when the core's regulatory domain has been changed. The driver

can use this to review the changes made and also review who made them

(driver, user, country IE) and determine what to allow based on its

internal EEPROM data. Devices drivers wishing to be capable of world

roaming should use this callback. More on world roaming will be

added to this document when its support is enabled.

Device drivers who provide their own built regulatory domain

do not need a callback as the channels registered by them are

the only ones that will be allowed and therefore *additional*

cannels cannot be enabled.

Example code - drivers hinting an alpha2:

------------------------------------------

This example comes from the zd1211rw device driver. You can start

by having a mapping of your device's EEPROM country/regulatory

domain value to to a specific alpha2 as follows:

static struct zd_reg_alpha2_map reg_alpha2_map[] = {

	{ ZD_REGDOMAIN_FCC, "US" },

	{ ZD_REGDOMAIN_IC, "CA" },

	{ ZD_REGDOMAIN_ETSI, "DE" }, /* Generic ETSI, use most restrictive */

	{ ZD_REGDOMAIN_JAPAN, "JP" },

	{ ZD_REGDOMAIN_JAPAN_ADD, "JP" },

	{ ZD_REGDOMAIN_SPAIN, "ES" },

	{ ZD_REGDOMAIN_FRANCE, "FR" },

Then you can define a routine to map your read EEPROM value to an alpha2,

as follows:

static int zd_reg2alpha2(u8 regdomain, char *alpha2)

{

	unsigned int i;

	struct zd_reg_alpha2_map *reg_map;

		for (i = 0; i < ARRAY_SIZE(reg_alpha2_map); i++) {

			reg_map = &reg_alpha2_map[i];

			if (regdomain == reg_map->reg) {

			alpha2[0] = reg_map->alpha2[0];

			alpha2[1] = reg_map->alpha2[1];

			return 0;

		}

	}

	return 1;

}

Lastly, you can then hint to the core of your discovered alpha2, if a match

was found. You need to do this after you have registered your wiphy. You

are expected to do this during initialization.

	r = zd_reg2alpha2(mac->regdomain, alpha2);

	if (!r)

		regulatory_hint(hw->wiphy, alpha2, NULL);

Example code - drivers providing a built in regulatory domain:

--------------------------------------------------------------

If you have regulatory information you can obtain from your

driver and you *need* to use this we let you build a regulatory domain

structure and pass it to the wireless core. To do this you should

kmalloc() a structure big enough to hold your regulatory domain

structure and you should then fill it with your data. Finally you simply

call regulatory_hint() with the regulatory domain structure in it.

Bellow is a simple example, with a regulatory domain cached using the stack.

Your implementation may vary (read EEPROM cache instead, for example).

Example cache of some regulatory domain

struct ieee80211_regdomain mydriver_jp_regdom = {

	.n_reg_rules = 3,

	.alpha2 =  "JP",

	//.alpha2 =  "99", /* If I have no alpha2 to map it to */

	.reg_rules = {

		/* IEEE 802.11b/g, channels 1..14 */

		REG_RULE(2412-20, 2484+20, 40, 6, 20, 0),

		/* IEEE 802.11a, channels 34..48 */

		REG_RULE(5170-20, 5240+20, 40, 6, 20,

			NL80211_RRF_PASSIVE_SCAN),

		/* IEEE 802.11a, channels 52..64 */

		REG_RULE(5260-20, 5320+20, 40, 6, 20,

			NL80211_RRF_NO_IBSS |

			NL80211_RRF_DFS),

	}

};

Then in some part of your code after your wiphy has been registered:

	int r;

	struct ieee80211_regdomain *rd;

	int size_of_regd;

	int num_rules = mydriver_jp_regdom.n_reg_rules;

	unsigned int i;

	size_of_regd = sizeof(struct ieee80211_regdomain) +

		(num_rules * sizeof(struct ieee80211_reg_rule));

	rd = kzalloc(size_of_regd, GFP_KERNEL);

	if (!rd)

	return -ENOMEM;

	memcpy(rd, &mydriver_jp_regdom, sizeof(struct ieee80211_regdomain));

	for (i=0; i < num_rules; i++) {

		memcpy(&rd->reg_rules[i], &mydriver_jp_regdom.reg_rules[i],

			sizeof(struct ieee80211_reg_rule));

	}

	r = regulatory_hint(hw->wiphy, NULL, rd);

	if (r) {

		kfree(rd);

		return r;

	}

 * @NL80211_CMD_SET_BSS: Set BSS attributes for BSS identified by

 *	%NL80211_ATTR_IFINDEX.

 *

 * @NL80211_CMD_SET_REG: Set current regulatory domain. CRDA sends this command

 *	after being queried by the kernel. CRDA replies by sending a regulatory

 *	domain structure which consists of %NL80211_ATTR_REG_ALPHA set to our

 *	current alpha2 if it found a match. It also provides

 * 	NL80211_ATTR_REG_RULE_FLAGS, and a set of regulatory rules. Each

 * 	regulatory rule is a nested set of attributes  given by

 * 	%NL80211_ATTR_REG_RULE_FREQ_[START|END] and

 * 	%NL80211_ATTR_FREQ_RANGE_MAX_BW with an attached power rule given by

 * 	%NL80211_ATTR_REG_RULE_POWER_MAX_ANT_GAIN and

 * 	%NL80211_ATTR_REG_RULE_POWER_MAX_EIRP.

 * @NL80211_CMD_REQ_SET_REG: ask the wireless core to set the regulatory domain

 * 	to the the specified ISO/IEC 3166-1 alpha2 country code. The core will

 * 	store this as a valid request and then query userspace for it.

 *

 * @NL80211_CMD_MAX: highest used command number

 * @__NL80211_CMD_AFTER_LAST: internal use

 */

	NL80211_CMD_SET_BSS,

	/* add commands here */

	NL80211_CMD_SET_REG,

	NL80211_CMD_REQ_SET_REG,

	/* add new commands above here */

	/* used to define NL80211_CMD_MAX below */

	__NL80211_CMD_AFTER_LAST,

 * 	info given for %NL80211_CMD_GET_MPATH, nested attribute described at

 *	&enum nl80211_mpath_info.

 *

 *

 * @NL80211_ATTR_MNTR_FLAGS: flags, nested element with NLA_FLAG attributes of

 *      &enum nl80211_mntr_flags.

 *

 * @NL80211_ATTR_REG_ALPHA2: an ISO-3166-alpha2 country code for which the

 * 	current regulatory domain should be set to or is already set to.

 * 	For example, 'CR', for Costa Rica. This attribute is used by the kernel

 * 	to query the CRDA to retrieve one regulatory domain. This attribute can

 * 	also be used by userspace to query the kernel for the currently set

 * 	regulatory domain. We chose an alpha2 as that is also used by the

 * 	IEEE-802.11d country information element to identify a country.

 * 	Users can also simply ask the wireless core to set regulatory domain

 * 	to a specific alpha2.

 * @NL80211_ATTR_REG_RULES: a nested array of regulatory domain regulatory

 *	rules.

 *

 * @NL80211_ATTR_BSS_CTS_PROT: whether CTS protection is enabled (u8, 0 or 1)

 * @NL80211_ATTR_BSS_SHORT_PREAMBLE: whether short preamble is enabled

 *	(u8, 0 or 1)

	NL80211_ATTR_SUPPORTED_IFTYPES,

	NL80211_ATTR_REG_ALPHA2,

	NL80211_ATTR_REG_RULES,

	/* add attributes here, update the policy in nl80211.c */

	__NL80211_ATTR_AFTER_LAST,

#define NL80211_ATTR_HT_CAPABILITY NL80211_ATTR_HT_CAPABILITY

#define NL80211_MAX_SUPP_RATES			32

#define NL80211_MAX_SUPP_REG_RULES		32

#define NL80211_TKIP_DATA_OFFSET_ENCR_KEY	0

#define NL80211_TKIP_DATA_OFFSET_TX_MIC_KEY	16

#define NL80211_TKIP_DATA_OFFSET_RX_MIC_KEY	24

	NL80211_BITRATE_ATTR_MAX = __NL80211_BITRATE_ATTR_AFTER_LAST - 1

};

/**

 * enum nl80211_reg_rule_attr - regulatory rule attributes

 * @NL80211_ATTR_REG_RULE_FLAGS: a set of flags which specify additional

 * 	considerations for a given frequency range. These are the

 * 	&enum nl80211_reg_rule_flags.

 * @NL80211_ATTR_FREQ_RANGE_START: starting frequencry for the regulatory

 * 	rule in KHz. This is not a center of frequency but an actual regulatory

 * 	band edge.

 * @NL80211_ATTR_FREQ_RANGE_END: ending frequency for the regulatory rule

 * 	in KHz. This is not a center a frequency but an actual regulatory

 * 	band edge.

 * @NL80211_ATTR_FREQ_RANGE_MAX_BW: maximum allowed bandwidth for this

 * 	frequency range, in KHz.

 * @NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN: the maximum allowed antenna gain

 * 	for a given frequency range. The value is in mBi (100 * dBi).

 * 	If you don't have one then don't send this.

 * @NL80211_ATTR_POWER_RULE_MAX_EIRP: the maximum allowed EIRP for

 * 	a given frequency range. The value is in mBm (100 * dBm).

 */

enum nl80211_reg_rule_attr {

	__NL80211_REG_RULE_ATTR_INVALID,

	NL80211_ATTR_REG_RULE_FLAGS,

	NL80211_ATTR_FREQ_RANGE_START,

	NL80211_ATTR_FREQ_RANGE_END,

	NL80211_ATTR_FREQ_RANGE_MAX_BW,

	NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN,

	NL80211_ATTR_POWER_RULE_MAX_EIRP,

	/* keep last */

	__NL80211_REG_RULE_ATTR_AFTER_LAST,

	NL80211_REG_RULE_ATTR_MAX = __NL80211_REG_RULE_ATTR_AFTER_LAST - 1

};

/**

 * enum nl80211_reg_rule_flags - regulatory rule flags

 *

 * @NL80211_RRF_NO_OFDM: OFDM modulation not allowed

 * @NL80211_RRF_NO_CCK: CCK modulation not allowed

 * @NL80211_RRF_NO_INDOOR: indoor operation not allowed

 * @NL80211_RRF_NO_OUTDOOR: outdoor operation not allowed

 * @NL80211_RRF_DFS: DFS support is required to be used

 * @NL80211_RRF_PTP_ONLY: this is only for Point To Point links

 * @NL80211_RRF_PTMP_ONLY: this is only for Point To Multi Point links

 * @NL80211_RRF_PASSIVE_SCAN: passive scan is required

 * @NL80211_RRF_NO_IBSS: no IBSS is allowed

 */

enum nl80211_reg_rule_flags {

	NL80211_RRF_NO_OFDM		= 1<<0,

	NL80211_RRF_NO_CCK		= 1<<1,

	NL80211_RRF_NO_INDOOR		= 1<<2,

	NL80211_RRF_NO_OUTDOOR		= 1<<3,

	NL80211_RRF_DFS			= 1<<4,

	NL80211_RRF_PTP_ONLY		= 1<<5,

	NL80211_RRF_PTMP_ONLY		= 1<<6,

	NL80211_RRF_PASSIVE_SCAN	= 1<<7,

	NL80211_RRF_NO_IBSS		= 1<<8,

};

/**

 * enum nl80211_mntr_flags - monitor configuration flags

 *

	int use_short_slot_time;

};

/**

 * enum reg_set_by - Indicates who is trying to set the regulatory domain

 * @REGDOM_SET_BY_INIT: regulatory domain was set by initialization. We will be

 * 	using a static world regulatory domain by default.

 * @REGDOM_SET_BY_CORE: Core queried CRDA for a dynamic world regulatory domain.

 * @REGDOM_SET_BY_USER: User asked the wireless core to set the

 * 	regulatory domain.

 * @REGDOM_SET_BY_DRIVER: a wireless drivers has hinted to the wireless core

 *	it thinks its knows the regulatory domain we should be in.

 * @REGDOM_SET_BY_COUNTRY_IE: the wireless core has received an 802.11 country

 *	information element with regulatory information it thinks we

 *	should consider.

 */

enum reg_set_by {

	REGDOM_SET_BY_INIT,

	REGDOM_SET_BY_CORE,

	REGDOM_SET_BY_USER,

	REGDOM_SET_BY_DRIVER,

	REGDOM_SET_BY_COUNTRY_IE,

};

struct ieee80211_freq_range {

	u32 start_freq_khz;

	u32 end_freq_khz;

	u32 max_bandwidth_khz;

};

struct ieee80211_power_rule {

	u32 max_antenna_gain;

	u32 max_eirp;

};

struct ieee80211_reg_rule {

	struct ieee80211_freq_range freq_range;

	struct ieee80211_power_rule power_rule;

	u32 flags;

};

struct ieee80211_regdomain {

	u32 n_reg_rules;

	char alpha2[2];

	struct ieee80211_reg_rule reg_rules[];

};

#define MHZ_TO_KHZ(freq) (freq * 1000)

#define KHZ_TO_MHZ(freq) (freq / 1000)

#define DBI_TO_MBI(gain) (gain * 100)

#define MBI_TO_DBI(gain) (gain / 100)

#define DBM_TO_MBM(gain) (gain * 100)

#define MBM_TO_DBM(gain) (gain / 100)

#define REG_RULE(start, end, bw, gain, eirp, reg_flags) { \

	.freq_range.start_freq_khz = (start) * 1000, \

	.freq_range.end_freq_khz = (end) * 1000, \

	.freq_range.max_bandwidth_khz = (bw) * 1000, \

	.power_rule.max_antenna_gain = (gain) * 100, \

	.power_rule.max_eirp = (eirp) * 100, \

	.flags = reg_flags, \

	}

/* from net/wireless.h */

struct wiphy;

	s8 max_signal;

};

struct ieee80211_hw *wiphy_to_hw(struct wiphy *wiphy);

/**

 * SET_IEEE80211_DEV - set device for 802.11 hardware

 *