2 * Copyright (c) 2008-2009 Atheros Communications Inc.
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
19 #include <linux/kernel.h>
20 #include <linux/export.h>
21 #include <net/cfg80211.h>
22 #include <net/mac80211.h>
24 #include "regd_common.h"
26 static int __ath_regd_init(struct ath_regulatory *reg);
29 * This is a set of common rules used by our world regulatory domains.
30 * We have 12 world regulatory domains. To save space we consolidate
31 * the regulatory domains in 5 structures by frequency and change
32 * the flags on our reg_notifier() on a case by case basis.
35 /* Only these channels all allow active scan on all world regulatory domains */
36 #define ATH9K_2GHZ_CH01_11 REG_RULE(2412-10, 2462+10, 40, 0, 20, 0)
38 /* We enable active scan on these a case by case basis by regulatory domain */
39 #define ATH9K_2GHZ_CH12_13 REG_RULE(2467-10, 2472+10, 40, 0, 20,\
41 #define ATH9K_2GHZ_CH14 REG_RULE(2484-10, 2484+10, 40, 0, 20,\
45 /* We allow IBSS on these on a case by case basis by regulatory domain */
46 #define ATH9K_5GHZ_5150_5350 REG_RULE(5150-10, 5350+10, 80, 0, 30,\
48 #define ATH9K_5GHZ_5470_5850 REG_RULE(5470-10, 5850+10, 80, 0, 30,\
50 #define ATH9K_5GHZ_5725_5850 REG_RULE(5725-10, 5850+10, 80, 0, 30,\
53 #define ATH9K_2GHZ_ALL ATH9K_2GHZ_CH01_11, \
57 #define ATH9K_5GHZ_ALL ATH9K_5GHZ_5150_5350, \
60 /* This one skips what we call "mid band" */
61 #define ATH9K_5GHZ_NO_MIDBAND ATH9K_5GHZ_5150_5350, \
66 static const struct ieee80211_regdomain ath_world_regdom_60_61_62 = {
75 /* Can be used by 0x63 and 0x65 */
76 static const struct ieee80211_regdomain ath_world_regdom_63_65 = {
82 ATH9K_5GHZ_NO_MIDBAND,
86 /* Can be used by 0x64 only */
87 static const struct ieee80211_regdomain ath_world_regdom_64 = {
92 ATH9K_5GHZ_NO_MIDBAND,
96 /* Can be used by 0x66 and 0x69 */
97 static const struct ieee80211_regdomain ath_world_regdom_66_69 = {
106 /* Can be used by 0x67, 0x68, 0x6A and 0x6C */
107 static const struct ieee80211_regdomain ath_world_regdom_67_68_6A_6C = {
117 static inline bool is_wwr_sku(u16 regd)
119 return ((regd & COUNTRY_ERD_FLAG) != COUNTRY_ERD_FLAG) &&
120 (((regd & WORLD_SKU_MASK) == WORLD_SKU_PREFIX) ||
124 static u16 ath_regd_get_eepromRD(struct ath_regulatory *reg)
126 return reg->current_rd & ~WORLDWIDE_ROAMING_FLAG;
129 bool ath_is_world_regd(struct ath_regulatory *reg)
131 return is_wwr_sku(ath_regd_get_eepromRD(reg));
133 EXPORT_SYMBOL(ath_is_world_regd);
135 static const struct ieee80211_regdomain *ath_default_world_regdomain(void)
137 /* this is the most restrictive */
138 return &ath_world_regdom_64;
142 ieee80211_regdomain *ath_world_regdomain(struct ath_regulatory *reg)
144 switch (reg->regpair->regDmnEnum) {
148 return &ath_world_regdom_60_61_62;
151 return &ath_world_regdom_63_65;
153 return &ath_world_regdom_64;
156 return &ath_world_regdom_66_69;
161 return &ath_world_regdom_67_68_6A_6C;
164 return ath_default_world_regdomain();
168 bool ath_is_49ghz_allowed(u16 regdomain)
171 return regdomain == MKK9_MKKC;
173 EXPORT_SYMBOL(ath_is_49ghz_allowed);
175 /* Frequency is one where radar detection is required */
176 static bool ath_is_radar_freq(u16 center_freq)
178 return (center_freq >= 5260 && center_freq <= 5700);
182 * N.B: These exception rules do not apply radar freqs.
184 * - We enable adhoc (or beaconing) if allowed by 11d
185 * - We enable active scan if the channel is allowed by 11d
186 * - If no country IE has been processed and a we determine we have
187 * received a beacon on a channel we can enable active scan and
188 * adhoc (or beaconing).
191 ath_reg_apply_beaconing_flags(struct wiphy *wiphy,
192 enum nl80211_reg_initiator initiator)
194 enum ieee80211_band band;
195 struct ieee80211_supported_band *sband;
196 const struct ieee80211_reg_rule *reg_rule;
197 struct ieee80211_channel *ch;
200 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
202 if (!wiphy->bands[band])
205 sband = wiphy->bands[band];
207 for (i = 0; i < sband->n_channels; i++) {
209 ch = &sband->channels[i];
211 if (ath_is_radar_freq(ch->center_freq) ||
212 (ch->flags & IEEE80211_CHAN_RADAR))
215 if (initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE) {
216 reg_rule = freq_reg_info(wiphy, ch->center_freq);
217 if (IS_ERR(reg_rule))
220 * If 11d had a rule for this channel ensure
221 * we enable adhoc/beaconing if it allows us to
222 * use it. Note that we would have disabled it
223 * by applying our static world regdomain by
224 * default during init, prior to calling our
227 if (!(reg_rule->flags & NL80211_RRF_NO_IR))
228 ch->flags &= ~IEEE80211_CHAN_NO_IR;
230 if (ch->beacon_found)
231 ch->flags &= ~IEEE80211_CHAN_NO_IR;
238 /* Allows active scan scan on Ch 12 and 13 */
240 ath_reg_apply_active_scan_flags(struct wiphy *wiphy,
241 enum nl80211_reg_initiator initiator)
243 struct ieee80211_supported_band *sband;
244 struct ieee80211_channel *ch;
245 const struct ieee80211_reg_rule *reg_rule;
247 sband = wiphy->bands[IEEE80211_BAND_2GHZ];
252 * If no country IE has been received always enable passive scan
253 * and no-ibss on these channels. This is only done for specific
256 if (initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE) {
257 ch = &sband->channels[11]; /* CH 12 */
258 ch->flags |= IEEE80211_CHAN_NO_IR;
260 ch = &sband->channels[12]; /* CH 13 */
261 ch->flags |= IEEE80211_CHAN_NO_IR;
266 * If a country IE has been received check its rule for this
267 * channel first before enabling active scan. The passive scan
268 * would have been enforced by the initial processing of our
269 * custom regulatory domain.
272 ch = &sband->channels[11]; /* CH 12 */
273 reg_rule = freq_reg_info(wiphy, ch->center_freq);
274 if (!IS_ERR(reg_rule)) {
275 if (!(reg_rule->flags & NL80211_RRF_NO_IR))
276 if (ch->flags & IEEE80211_CHAN_NO_IR)
277 ch->flags &= ~IEEE80211_CHAN_NO_IR;
280 ch = &sband->channels[12]; /* CH 13 */
281 reg_rule = freq_reg_info(wiphy, ch->center_freq);
282 if (!IS_ERR(reg_rule)) {
283 if (!(reg_rule->flags & NL80211_RRF_NO_IR))
284 if (ch->flags & IEEE80211_CHAN_NO_IR)
285 ch->flags &= ~IEEE80211_CHAN_NO_IR;
289 /* Always apply Radar/DFS rules on freq range 5260 MHz - 5700 MHz */
290 static void ath_reg_apply_radar_flags(struct wiphy *wiphy)
292 struct ieee80211_supported_band *sband;
293 struct ieee80211_channel *ch;
296 if (!wiphy->bands[IEEE80211_BAND_5GHZ])
299 sband = wiphy->bands[IEEE80211_BAND_5GHZ];
301 for (i = 0; i < sband->n_channels; i++) {
302 ch = &sband->channels[i];
303 if (!ath_is_radar_freq(ch->center_freq))
305 /* We always enable radar detection/DFS on this
306 * frequency range. Additionally we also apply on
307 * this frequency range:
308 * - If STA mode does not yet have DFS supports disable
310 * - If adhoc mode does not support DFS yet then
311 * disable adhoc in the frequency.
312 * - If AP mode does not yet support radar detection/DFS
313 * do not allow AP mode
315 if (!(ch->flags & IEEE80211_CHAN_DISABLED))
316 ch->flags |= IEEE80211_CHAN_RADAR |
317 IEEE80211_CHAN_NO_IR;
321 static void ath_reg_apply_world_flags(struct wiphy *wiphy,
322 enum nl80211_reg_initiator initiator,
323 struct ath_regulatory *reg)
325 switch (reg->regpair->regDmnEnum) {
331 ath_reg_apply_beaconing_flags(wiphy, initiator);
334 ath_reg_apply_beaconing_flags(wiphy, initiator);
335 ath_reg_apply_active_scan_flags(wiphy, initiator);
340 static u16 ath_regd_find_country_by_name(char *alpha2)
344 for (i = 0; i < ARRAY_SIZE(allCountries); i++) {
345 if (!memcmp(allCountries[i].isoName, alpha2, 2))
346 return allCountries[i].countryCode;
352 static int __ath_reg_dyn_country(struct wiphy *wiphy,
353 struct ath_regulatory *reg,
354 struct regulatory_request *request)
358 if (request->initiator == NL80211_REGDOM_SET_BY_COUNTRY_IE &&
359 !ath_is_world_regd(reg))
362 country_code = ath_regd_find_country_by_name(request->alpha2);
363 if (country_code == (u16) -1)
366 reg->current_rd = COUNTRY_ERD_FLAG;
367 reg->current_rd |= country_code;
369 __ath_regd_init(reg);
371 ath_reg_apply_world_flags(wiphy, request->initiator, reg);
376 static void ath_reg_dyn_country(struct wiphy *wiphy,
377 struct ath_regulatory *reg,
378 struct regulatory_request *request)
380 if (__ath_reg_dyn_country(wiphy, reg, request))
383 printk(KERN_DEBUG "ath: regdomain 0x%0x "
384 "dynamically updated by %s\n",
386 reg_initiator_name(request->initiator));
389 static bool dynamic_country_user_possible(struct ath_regulatory *reg)
391 if (config_enabled(CONFIG_ATH_REG_DYNAMIC_USER_CERT_TESTING))
394 switch (reg->country_code) {
395 case CTRY_UNITED_STATES:
461 static void ath_reg_dyn_country_user(struct wiphy *wiphy,
462 struct ath_regulatory *reg,
463 struct regulatory_request *request)
465 if (!config_enabled(CONFIG_ATH_REG_DYNAMIC_USER_REG_HINTS))
467 if (!dynamic_country_user_possible(reg))
469 ath_reg_dyn_country(wiphy, reg, request);
472 void ath_reg_notifier_apply(struct wiphy *wiphy,
473 struct regulatory_request *request,
474 struct ath_regulatory *reg)
476 struct ath_common *common = container_of(reg, struct ath_common,
478 /* We always apply this */
479 ath_reg_apply_radar_flags(wiphy);
482 * This would happen when we have sent a custom regulatory request
483 * a world regulatory domain and the scheduler hasn't yet processed
484 * any pending requests in the queue.
489 switch (request->initiator) {
490 case NL80211_REGDOM_SET_BY_CORE:
492 * If common->reg_world_copy is world roaming it means we *were*
493 * world roaming... so we now have to restore that data.
495 if (!ath_is_world_regd(&common->reg_world_copy))
498 memcpy(reg, &common->reg_world_copy,
499 sizeof(struct ath_regulatory));
501 case NL80211_REGDOM_SET_BY_DRIVER:
503 case NL80211_REGDOM_SET_BY_USER:
504 ath_reg_dyn_country_user(wiphy, reg, request);
506 case NL80211_REGDOM_SET_BY_COUNTRY_IE:
507 ath_reg_dyn_country(wiphy, reg, request);
511 EXPORT_SYMBOL(ath_reg_notifier_apply);
513 static bool ath_regd_is_eeprom_valid(struct ath_regulatory *reg)
515 u16 rd = ath_regd_get_eepromRD(reg);
518 if (rd & COUNTRY_ERD_FLAG) {
519 /* EEPROM value is a country code */
520 u16 cc = rd & ~COUNTRY_ERD_FLAG;
522 "ath: EEPROM indicates we should expect "
524 for (i = 0; i < ARRAY_SIZE(allCountries); i++)
525 if (allCountries[i].countryCode == cc)
528 /* EEPROM value is a regpair value */
529 if (rd != CTRY_DEFAULT)
530 printk(KERN_DEBUG "ath: EEPROM indicates we "
531 "should expect a direct regpair map\n");
532 for (i = 0; i < ARRAY_SIZE(regDomainPairs); i++)
533 if (regDomainPairs[i].regDmnEnum == rd)
537 "ath: invalid regulatory domain/country code 0x%x\n", rd);
541 /* EEPROM country code to regpair mapping */
542 static struct country_code_to_enum_rd*
543 ath_regd_find_country(u16 countryCode)
547 for (i = 0; i < ARRAY_SIZE(allCountries); i++) {
548 if (allCountries[i].countryCode == countryCode)
549 return &allCountries[i];
554 /* EEPROM rd code to regpair mapping */
555 static struct country_code_to_enum_rd*
556 ath_regd_find_country_by_rd(int regdmn)
560 for (i = 0; i < ARRAY_SIZE(allCountries); i++) {
561 if (allCountries[i].regDmnEnum == regdmn)
562 return &allCountries[i];
567 /* Returns the map of the EEPROM set RD to a country code */
568 static u16 ath_regd_get_default_country(u16 rd)
570 if (rd & COUNTRY_ERD_FLAG) {
571 struct country_code_to_enum_rd *country = NULL;
572 u16 cc = rd & ~COUNTRY_ERD_FLAG;
574 country = ath_regd_find_country(cc);
582 static struct reg_dmn_pair_mapping*
583 ath_get_regpair(int regdmn)
587 if (regdmn == NO_ENUMRD)
589 for (i = 0; i < ARRAY_SIZE(regDomainPairs); i++) {
590 if (regDomainPairs[i].regDmnEnum == regdmn)
591 return ®DomainPairs[i];
597 ath_regd_init_wiphy(struct ath_regulatory *reg,
599 void (*reg_notifier)(struct wiphy *wiphy,
600 struct regulatory_request *request))
602 const struct ieee80211_regdomain *regd;
604 wiphy->reg_notifier = reg_notifier;
605 wiphy->regulatory_flags |= REGULATORY_STRICT_REG;
607 if (ath_is_world_regd(reg)) {
609 * Anything applied here (prior to wiphy registration) gets
610 * saved on the wiphy orig_* parameters
612 regd = ath_world_regdomain(reg);
613 wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG |
614 REGULATORY_COUNTRY_IE_FOLLOW_POWER;
617 * This gets applied in the case of the absence of CRDA,
618 * it's our own custom world regulatory domain, similar to
619 * cfg80211's but we enable passive scanning.
621 regd = ath_default_world_regdomain();
623 wiphy_apply_custom_regulatory(wiphy, regd);
624 ath_reg_apply_radar_flags(wiphy);
625 ath_reg_apply_world_flags(wiphy, NL80211_REGDOM_SET_BY_DRIVER, reg);
630 * Some users have reported their EEPROM programmed with
631 * 0x8000 set, this is not a supported regulatory domain
632 * but since we have more than one user with it we need
633 * a solution for them. We default to 0x64, which is the
634 * default Atheros world regulatory domain.
636 static void ath_regd_sanitize(struct ath_regulatory *reg)
638 if (reg->current_rd != COUNTRY_ERD_FLAG)
640 printk(KERN_DEBUG "ath: EEPROM regdomain sanitized\n");
641 reg->current_rd = 0x64;
644 static int __ath_regd_init(struct ath_regulatory *reg)
646 struct country_code_to_enum_rd *country = NULL;
652 ath_regd_sanitize(reg);
654 printk(KERN_DEBUG "ath: EEPROM regdomain: 0x%0x\n", reg->current_rd);
656 if (!ath_regd_is_eeprom_valid(reg)) {
657 pr_err("Invalid EEPROM contents\n");
661 regdmn = ath_regd_get_eepromRD(reg);
662 reg->country_code = ath_regd_get_default_country(regdmn);
664 if (reg->country_code == CTRY_DEFAULT &&
665 regdmn == CTRY_DEFAULT) {
666 printk(KERN_DEBUG "ath: EEPROM indicates default "
667 "country code should be used\n");
668 reg->country_code = CTRY_UNITED_STATES;
671 if (reg->country_code == CTRY_DEFAULT) {
674 printk(KERN_DEBUG "ath: doing EEPROM country->regdmn "
676 country = ath_regd_find_country(reg->country_code);
677 if (country == NULL) {
679 "ath: no valid country maps found for "
680 "country code: 0x%0x\n",
684 regdmn = country->regDmnEnum;
685 printk(KERN_DEBUG "ath: country maps to "
686 "regdmn code: 0x%0x\n",
691 reg->regpair = ath_get_regpair(regdmn);
694 printk(KERN_DEBUG "ath: "
695 "No regulatory domain pair found, cannot continue\n");
700 country = ath_regd_find_country_by_rd(regdmn);
703 reg->alpha2[0] = country->isoName[0];
704 reg->alpha2[1] = country->isoName[1];
706 reg->alpha2[0] = '0';
707 reg->alpha2[1] = '0';
710 printk(KERN_DEBUG "ath: Country alpha2 being used: %c%c\n",
711 reg->alpha2[0], reg->alpha2[1]);
712 printk(KERN_DEBUG "ath: Regpair used: 0x%0x\n",
713 reg->regpair->regDmnEnum);
719 ath_regd_init(struct ath_regulatory *reg,
721 void (*reg_notifier)(struct wiphy *wiphy,
722 struct regulatory_request *request))
724 struct ath_common *common = container_of(reg, struct ath_common,
728 r = __ath_regd_init(reg);
732 if (ath_is_world_regd(reg))
733 memcpy(&common->reg_world_copy, reg,
734 sizeof(struct ath_regulatory));
736 ath_regd_init_wiphy(reg, wiphy, reg_notifier);
740 EXPORT_SYMBOL(ath_regd_init);
742 u32 ath_regd_get_band_ctl(struct ath_regulatory *reg,
743 enum ieee80211_band band)
746 (reg->country_code == CTRY_DEFAULT &&
747 is_wwr_sku(ath_regd_get_eepromRD(reg)))) {
752 case IEEE80211_BAND_2GHZ:
753 return reg->regpair->reg_2ghz_ctl;
754 case IEEE80211_BAND_5GHZ:
755 return reg->regpair->reg_5ghz_ctl;
760 EXPORT_SYMBOL(ath_regd_get_band_ctl);