-
Notifications
You must be signed in to change notification settings - Fork 0
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
cfg80211: Add new wireless regulatory infrastructure
This adds the new wireless regulatory infrastructure. The main motiviation behind this was to centralize regulatory code as each driver was implementing their own regulatory solution, and to replace the initial centralized code we have where: * only 3 regulatory domains are supported: US, JP and EU * regulatory domains can only be changed through module parameter * all rules were built statically in the kernel We now have support for regulatory domains for many countries and regulatory domains are now queried through a userspace agent through udev allowing distributions to update regulatory rules without updating the kernel. Each driver can regulatory_hint() a regulatory domain based on either their EEPROM mapped regulatory domain value to a respective ISO/IEC 3166-1 country code or pass an internally built regulatory domain. We also add support to let the user set the regulatory domain through userspace in case of faulty EEPROMs to further help compliance. Support for world roaming will be added soon for cards capable of this. For more information see: http://wireless.kernel.org/en/developers/Regulatory/CRDA For now we leave an option to enable the old module parameter, ieee80211_regdom, and to build the 3 old regdomains statically (US, JP and EU). This option is CONFIG_WIRELESS_OLD_REGULATORY. These old static definitions and the module parameter is being scheduled for removal for 2.6.29. Note that if you use this you won't make use of a world regulatory domain as its pointless. If you leave this option enabled and if CRDA is present and you use US or JP we will try to ask CRDA to update us a regulatory domain for us. Signed-off-by: Luis R. Rodriguez <lrodriguez@atheros.com> Signed-off-by: John W. Linville <linville@tuxdriver.com>
- Loading branch information
Luis R. Rodriguez
authored and
John W. Linville
committed
Sep 15, 2008
1 parent
63f2c04
commit b2e1b30
Showing
13 changed files
with
1,513 additions
and
118 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,194 @@ | ||
| 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 = ®_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; | ||
| } | ||
|
|
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Oops, something went wrong.