2 * Copyright 2002-2005, Instant802 Networks, Inc.
3 * Copyright 2005-2006, Devicescape Software, Inc.
4 * Copyright 2007 Johannes Berg <johannes@sipsolutions.net>
5 * Copyright 2008 Luis R. Rodriguez <lrodriguz@atheros.com>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
13 * DOC: Wireless regulatory infrastructure
15 * The usual implementation is for a driver to read a device EEPROM to
16 * determine which regulatory domain it should be operating under, then
17 * looking up the allowable channels in a driver-local table and finally
18 * registering those channels in the wiphy structure.
20 * Another set of compliance enforcement is for drivers to use their
21 * own compliance limits which can be stored on the EEPROM. The host
22 * driver or firmware may ensure these are used.
24 * In addition to all this we provide an extra layer of regulatory
25 * conformance. For drivers which do not have any regulatory
26 * information CRDA provides the complete regulatory solution.
27 * For others it provides a community effort on further restrictions
28 * to enhance compliance.
30 * Note: When number of rules --> infinity we will not be able to
31 * index on alpha2 any more, instead we'll probably have to
32 * rely on some SHA1 checksum of the regdomain for example.
35 #include <linux/kernel.h>
36 #include <linux/list.h>
37 #include <linux/random.h>
38 #include <linux/nl80211.h>
39 #include <linux/platform_device.h>
40 #include <net/wireless.h>
41 #include <net/cfg80211.h>
45 /* Receipt of information from last regulatory request */
46 static struct regulatory_request *last_request;
48 /* To trigger userspace events */
49 static struct platform_device *reg_pdev;
51 /* Keep the ordering from large to small */
52 static u32 supported_bandwidths[] = {
57 /* Central wireless core regulatory domains, we only need two,
58 * the current one and a world regulatory domain in case we have no
59 * information to give us an alpha2 */
60 const struct ieee80211_regdomain *cfg80211_regdomain;
62 /* We use this as a place for the rd structure built from the
63 * last parsed country IE to rest until CRDA gets back to us with
64 * what it thinks should apply for the same country */
65 static const struct ieee80211_regdomain *country_ie_regdomain;
67 static LIST_HEAD(reg_requests_list);
68 static spinlock_t reg_requests_lock;
70 /* We keep a static world regulatory domain in case of the absence of CRDA */
71 static const struct ieee80211_regdomain world_regdom = {
75 REG_RULE(2412-10, 2462+10, 40, 6, 20,
76 NL80211_RRF_PASSIVE_SCAN |
81 static const struct ieee80211_regdomain *cfg80211_world_regdom =
84 #ifdef CONFIG_WIRELESS_OLD_REGULATORY
85 static char *ieee80211_regdom = "US";
86 module_param(ieee80211_regdom, charp, 0444);
87 MODULE_PARM_DESC(ieee80211_regdom, "IEEE 802.11 regulatory domain code");
89 /* We assume 40 MHz bandwidth for the old regulatory work.
90 * We make emphasis we are using the exact same frequencies
93 static const struct ieee80211_regdomain us_regdom = {
97 /* IEEE 802.11b/g, channels 1..11 */
98 REG_RULE(2412-10, 2462+10, 40, 6, 27, 0),
99 /* IEEE 802.11a, channel 36 */
100 REG_RULE(5180-10, 5180+10, 40, 6, 23, 0),
101 /* IEEE 802.11a, channel 40 */
102 REG_RULE(5200-10, 5200+10, 40, 6, 23, 0),
103 /* IEEE 802.11a, channel 44 */
104 REG_RULE(5220-10, 5220+10, 40, 6, 23, 0),
105 /* IEEE 802.11a, channels 48..64 */
106 REG_RULE(5240-10, 5320+10, 40, 6, 23, 0),
107 /* IEEE 802.11a, channels 149..165, outdoor */
108 REG_RULE(5745-10, 5825+10, 40, 6, 30, 0),
112 static const struct ieee80211_regdomain jp_regdom = {
116 /* IEEE 802.11b/g, channels 1..14 */
117 REG_RULE(2412-10, 2484+10, 40, 6, 20, 0),
118 /* IEEE 802.11a, channels 34..48 */
119 REG_RULE(5170-10, 5240+10, 40, 6, 20,
120 NL80211_RRF_PASSIVE_SCAN),
121 /* IEEE 802.11a, channels 52..64 */
122 REG_RULE(5260-10, 5320+10, 40, 6, 20,
123 NL80211_RRF_NO_IBSS |
128 static const struct ieee80211_regdomain eu_regdom = {
130 /* This alpha2 is bogus, we leave it here just for stupid
131 * backward compatibility */
134 /* IEEE 802.11b/g, channels 1..13 */
135 REG_RULE(2412-10, 2472+10, 40, 6, 20, 0),
136 /* IEEE 802.11a, channel 36 */
137 REG_RULE(5180-10, 5180+10, 40, 6, 23,
138 NL80211_RRF_PASSIVE_SCAN),
139 /* IEEE 802.11a, channel 40 */
140 REG_RULE(5200-10, 5200+10, 40, 6, 23,
141 NL80211_RRF_PASSIVE_SCAN),
142 /* IEEE 802.11a, channel 44 */
143 REG_RULE(5220-10, 5220+10, 40, 6, 23,
144 NL80211_RRF_PASSIVE_SCAN),
145 /* IEEE 802.11a, channels 48..64 */
146 REG_RULE(5240-10, 5320+10, 40, 6, 20,
147 NL80211_RRF_NO_IBSS |
149 /* IEEE 802.11a, channels 100..140 */
150 REG_RULE(5500-10, 5700+10, 40, 6, 30,
151 NL80211_RRF_NO_IBSS |
156 static const struct ieee80211_regdomain *static_regdom(char *alpha2)
158 if (alpha2[0] == 'U' && alpha2[1] == 'S')
160 if (alpha2[0] == 'J' && alpha2[1] == 'P')
162 if (alpha2[0] == 'E' && alpha2[1] == 'U')
164 /* Default, as per the old rules */
168 static bool is_old_static_regdom(const struct ieee80211_regdomain *rd)
170 if (rd == &us_regdom || rd == &jp_regdom || rd == &eu_regdom)
175 static inline bool is_old_static_regdom(const struct ieee80211_regdomain *rd)
181 static void reset_regdomains(void)
183 /* avoid freeing static information or freeing something twice */
184 if (cfg80211_regdomain == cfg80211_world_regdom)
185 cfg80211_regdomain = NULL;
186 if (cfg80211_world_regdom == &world_regdom)
187 cfg80211_world_regdom = NULL;
188 if (cfg80211_regdomain == &world_regdom)
189 cfg80211_regdomain = NULL;
190 if (is_old_static_regdom(cfg80211_regdomain))
191 cfg80211_regdomain = NULL;
193 kfree(cfg80211_regdomain);
194 kfree(cfg80211_world_regdom);
196 cfg80211_world_regdom = &world_regdom;
197 cfg80211_regdomain = NULL;
200 /* Dynamic world regulatory domain requested by the wireless
201 * core upon initialization */
202 static void update_world_regdomain(const struct ieee80211_regdomain *rd)
204 BUG_ON(!last_request);
208 cfg80211_world_regdom = rd;
209 cfg80211_regdomain = rd;
212 bool is_world_regdom(const char *alpha2)
216 if (alpha2[0] == '0' && alpha2[1] == '0')
221 static bool is_alpha2_set(const char *alpha2)
225 if (alpha2[0] != 0 && alpha2[1] != 0)
230 static bool is_alpha_upper(char letter)
233 if (letter >= 65 && letter <= 90)
238 static bool is_unknown_alpha2(const char *alpha2)
242 /* Special case where regulatory domain was built by driver
243 * but a specific alpha2 cannot be determined */
244 if (alpha2[0] == '9' && alpha2[1] == '9')
249 static bool is_intersected_alpha2(const char *alpha2)
253 /* Special case where regulatory domain is the
254 * result of an intersection between two regulatory domain
256 if (alpha2[0] == '9' && alpha2[1] == '8')
261 static bool is_an_alpha2(const char *alpha2)
265 if (is_alpha_upper(alpha2[0]) && is_alpha_upper(alpha2[1]))
270 static bool alpha2_equal(const char *alpha2_x, const char *alpha2_y)
272 if (!alpha2_x || !alpha2_y)
274 if (alpha2_x[0] == alpha2_y[0] &&
275 alpha2_x[1] == alpha2_y[1])
280 static bool regdom_changed(const char *alpha2)
282 assert_cfg80211_lock();
284 if (!cfg80211_regdomain)
286 if (alpha2_equal(cfg80211_regdomain->alpha2, alpha2))
292 * country_ie_integrity_changes - tells us if the country IE has changed
293 * @checksum: checksum of country IE of fields we are interested in
295 * If the country IE has not changed you can ignore it safely. This is
296 * useful to determine if two devices are seeing two different country IEs
297 * even on the same alpha2. Note that this will return false if no IE has
298 * been set on the wireless core yet.
300 static bool country_ie_integrity_changes(u32 checksum)
302 /* If no IE has been set then the checksum doesn't change */
303 if (unlikely(!last_request->country_ie_checksum))
305 if (unlikely(last_request->country_ie_checksum != checksum))
310 /* This lets us keep regulatory code which is updated on a regulatory
311 * basis in userspace. */
312 static int call_crda(const char *alpha2)
314 char country_env[9 + 2] = "COUNTRY=";
320 if (!is_world_regdom((char *) alpha2))
321 printk(KERN_INFO "cfg80211: Calling CRDA for country: %c%c\n",
322 alpha2[0], alpha2[1]);
324 printk(KERN_INFO "cfg80211: Calling CRDA to update world "
325 "regulatory domain\n");
327 country_env[8] = alpha2[0];
328 country_env[9] = alpha2[1];
330 return kobject_uevent_env(®_pdev->dev.kobj, KOBJ_CHANGE, envp);
333 /* Used by nl80211 before kmalloc'ing our regulatory domain */
334 bool reg_is_valid_request(const char *alpha2)
339 return alpha2_equal(last_request->alpha2, alpha2);
342 /* Sanity check on a regulatory rule */
343 static bool is_valid_reg_rule(const struct ieee80211_reg_rule *rule)
345 const struct ieee80211_freq_range *freq_range = &rule->freq_range;
348 if (freq_range->start_freq_khz <= 0 || freq_range->end_freq_khz <= 0)
351 if (freq_range->start_freq_khz > freq_range->end_freq_khz)
354 freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
356 if (freq_diff <= 0 || freq_range->max_bandwidth_khz > freq_diff)
362 static bool is_valid_rd(const struct ieee80211_regdomain *rd)
364 const struct ieee80211_reg_rule *reg_rule = NULL;
367 if (!rd->n_reg_rules)
370 if (WARN_ON(rd->n_reg_rules > NL80211_MAX_SUPP_REG_RULES))
373 for (i = 0; i < rd->n_reg_rules; i++) {
374 reg_rule = &rd->reg_rules[i];
375 if (!is_valid_reg_rule(reg_rule))
382 /* Returns value in KHz */
383 static u32 freq_max_bandwidth(const struct ieee80211_freq_range *freq_range,
387 for (i = 0; i < ARRAY_SIZE(supported_bandwidths); i++) {
388 u32 start_freq_khz = freq - supported_bandwidths[i]/2;
389 u32 end_freq_khz = freq + supported_bandwidths[i]/2;
390 if (start_freq_khz >= freq_range->start_freq_khz &&
391 end_freq_khz <= freq_range->end_freq_khz)
392 return supported_bandwidths[i];
398 * freq_in_rule_band - tells us if a frequency is in a frequency band
399 * @freq_range: frequency rule we want to query
400 * @freq_khz: frequency we are inquiring about
402 * This lets us know if a specific frequency rule is or is not relevant to
403 * a specific frequency's band. Bands are device specific and artificial
404 * definitions (the "2.4 GHz band" and the "5 GHz band"), however it is
405 * safe for now to assume that a frequency rule should not be part of a
406 * frequency's band if the start freq or end freq are off by more than 2 GHz.
407 * This resolution can be lowered and should be considered as we add
408 * regulatory rule support for other "bands".
410 static bool freq_in_rule_band(const struct ieee80211_freq_range *freq_range,
413 #define ONE_GHZ_IN_KHZ 1000000
414 if (abs(freq_khz - freq_range->start_freq_khz) <= (2 * ONE_GHZ_IN_KHZ))
416 if (abs(freq_khz - freq_range->end_freq_khz) <= (2 * ONE_GHZ_IN_KHZ))
419 #undef ONE_GHZ_IN_KHZ
422 /* Converts a country IE to a regulatory domain. A regulatory domain
423 * structure has a lot of information which the IE doesn't yet have,
424 * so for the other values we use upper max values as we will intersect
425 * with our userspace regulatory agent to get lower bounds. */
426 static struct ieee80211_regdomain *country_ie_2_rd(
431 struct ieee80211_regdomain *rd = NULL;
435 u32 num_rules = 0, size_of_regd = 0;
436 u8 *triplets_start = NULL;
437 u8 len_at_triplet = 0;
438 /* the last channel we have registered in a subband (triplet) */
439 int last_sub_max_channel = 0;
441 *checksum = 0xDEADBEEF;
443 /* Country IE requirements */
444 BUG_ON(country_ie_len < IEEE80211_COUNTRY_IE_MIN_LEN ||
445 country_ie_len & 0x01);
447 alpha2[0] = country_ie[0];
448 alpha2[1] = country_ie[1];
451 * Third octet can be:
455 * anything else we assume is no restrictions
457 if (country_ie[2] == 'I')
458 flags = NL80211_RRF_NO_OUTDOOR;
459 else if (country_ie[2] == 'O')
460 flags = NL80211_RRF_NO_INDOOR;
465 triplets_start = country_ie;
466 len_at_triplet = country_ie_len;
468 *checksum ^= ((flags ^ alpha2[0] ^ alpha2[1]) << 8);
470 /* We need to build a reg rule for each triplet, but first we must
471 * calculate the number of reg rules we will need. We will need one
472 * for each channel subband */
473 while (country_ie_len >= 3) {
475 struct ieee80211_country_ie_triplet *triplet =
476 (struct ieee80211_country_ie_triplet *) country_ie;
477 int cur_sub_max_channel = 0, cur_channel = 0;
479 if (triplet->ext.reg_extension_id >=
480 IEEE80211_COUNTRY_EXTENSION_ID) {
487 if (triplet->chans.first_channel <= 14)
488 end_channel = triplet->chans.first_channel +
489 triplet->chans.num_channels;
492 * 5 GHz -- For example in country IEs if the first
493 * channel given is 36 and the number of channels is 4
494 * then the individual channel numbers defined for the
495 * 5 GHz PHY by these parameters are: 36, 40, 44, and 48
496 * and not 36, 37, 38, 39.
498 * See: http://tinyurl.com/11d-clarification
500 end_channel = triplet->chans.first_channel +
501 (4 * (triplet->chans.num_channels - 1));
503 cur_channel = triplet->chans.first_channel;
504 cur_sub_max_channel = end_channel;
506 /* Basic sanity check */
507 if (cur_sub_max_channel < cur_channel)
510 /* Do not allow overlapping channels. Also channels
511 * passed in each subband must be monotonically
513 if (last_sub_max_channel) {
514 if (cur_channel <= last_sub_max_channel)
516 if (cur_sub_max_channel <= last_sub_max_channel)
520 /* When dot11RegulatoryClassesRequired is supported
521 * we can throw ext triplets as part of this soup,
522 * for now we don't care when those change as we
523 * don't support them */
524 *checksum ^= ((cur_channel ^ cur_sub_max_channel) << 8) |
525 ((cur_sub_max_channel ^ cur_sub_max_channel) << 16) |
526 ((triplet->chans.max_power ^ cur_sub_max_channel) << 24);
528 last_sub_max_channel = cur_sub_max_channel;
534 /* Note: this is not a IEEE requirement but
535 * simply a memory requirement */
536 if (num_rules > NL80211_MAX_SUPP_REG_RULES)
540 country_ie = triplets_start;
541 country_ie_len = len_at_triplet;
543 size_of_regd = sizeof(struct ieee80211_regdomain) +
544 (num_rules * sizeof(struct ieee80211_reg_rule));
546 rd = kzalloc(size_of_regd, GFP_KERNEL);
550 rd->n_reg_rules = num_rules;
551 rd->alpha2[0] = alpha2[0];
552 rd->alpha2[1] = alpha2[1];
554 /* This time around we fill in the rd */
555 while (country_ie_len >= 3) {
557 struct ieee80211_country_ie_triplet *triplet =
558 (struct ieee80211_country_ie_triplet *) country_ie;
559 struct ieee80211_reg_rule *reg_rule = NULL;
560 struct ieee80211_freq_range *freq_range = NULL;
561 struct ieee80211_power_rule *power_rule = NULL;
563 /* Must parse if dot11RegulatoryClassesRequired is true,
564 * we don't support this yet */
565 if (triplet->ext.reg_extension_id >=
566 IEEE80211_COUNTRY_EXTENSION_ID) {
572 reg_rule = &rd->reg_rules[i];
573 freq_range = ®_rule->freq_range;
574 power_rule = ®_rule->power_rule;
576 reg_rule->flags = flags;
579 if (triplet->chans.first_channel <= 14)
580 end_channel = triplet->chans.first_channel +
581 triplet->chans.num_channels;
583 end_channel = triplet->chans.first_channel +
584 (4 * (triplet->chans.num_channels - 1));
586 /* The +10 is since the regulatory domain expects
587 * the actual band edge, not the center of freq for
588 * its start and end freqs, assuming 20 MHz bandwidth on
589 * the channels passed */
590 freq_range->start_freq_khz =
591 MHZ_TO_KHZ(ieee80211_channel_to_frequency(
592 triplet->chans.first_channel) - 10);
593 freq_range->end_freq_khz =
594 MHZ_TO_KHZ(ieee80211_channel_to_frequency(
597 /* Large arbitrary values, we intersect later */
598 /* Increment this if we ever support >= 40 MHz channels
600 freq_range->max_bandwidth_khz = MHZ_TO_KHZ(40);
601 power_rule->max_antenna_gain = DBI_TO_MBI(100);
602 power_rule->max_eirp = DBM_TO_MBM(100);
608 BUG_ON(i > NL80211_MAX_SUPP_REG_RULES);
615 /* Helper for regdom_intersect(), this does the real
616 * mathematical intersection fun */
617 static int reg_rules_intersect(
618 const struct ieee80211_reg_rule *rule1,
619 const struct ieee80211_reg_rule *rule2,
620 struct ieee80211_reg_rule *intersected_rule)
622 const struct ieee80211_freq_range *freq_range1, *freq_range2;
623 struct ieee80211_freq_range *freq_range;
624 const struct ieee80211_power_rule *power_rule1, *power_rule2;
625 struct ieee80211_power_rule *power_rule;
628 freq_range1 = &rule1->freq_range;
629 freq_range2 = &rule2->freq_range;
630 freq_range = &intersected_rule->freq_range;
632 power_rule1 = &rule1->power_rule;
633 power_rule2 = &rule2->power_rule;
634 power_rule = &intersected_rule->power_rule;
636 freq_range->start_freq_khz = max(freq_range1->start_freq_khz,
637 freq_range2->start_freq_khz);
638 freq_range->end_freq_khz = min(freq_range1->end_freq_khz,
639 freq_range2->end_freq_khz);
640 freq_range->max_bandwidth_khz = min(freq_range1->max_bandwidth_khz,
641 freq_range2->max_bandwidth_khz);
643 freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
644 if (freq_range->max_bandwidth_khz > freq_diff)
645 freq_range->max_bandwidth_khz = freq_diff;
647 power_rule->max_eirp = min(power_rule1->max_eirp,
648 power_rule2->max_eirp);
649 power_rule->max_antenna_gain = min(power_rule1->max_antenna_gain,
650 power_rule2->max_antenna_gain);
652 intersected_rule->flags = (rule1->flags | rule2->flags);
654 if (!is_valid_reg_rule(intersected_rule))
661 * regdom_intersect - do the intersection between two regulatory domains
662 * @rd1: first regulatory domain
663 * @rd2: second regulatory domain
665 * Use this function to get the intersection between two regulatory domains.
666 * Once completed we will mark the alpha2 for the rd as intersected, "98",
667 * as no one single alpha2 can represent this regulatory domain.
669 * Returns a pointer to the regulatory domain structure which will hold the
670 * resulting intersection of rules between rd1 and rd2. We will
671 * kzalloc() this structure for you.
673 static struct ieee80211_regdomain *regdom_intersect(
674 const struct ieee80211_regdomain *rd1,
675 const struct ieee80211_regdomain *rd2)
679 unsigned int num_rules = 0, rule_idx = 0;
680 const struct ieee80211_reg_rule *rule1, *rule2;
681 struct ieee80211_reg_rule *intersected_rule;
682 struct ieee80211_regdomain *rd;
683 /* This is just a dummy holder to help us count */
684 struct ieee80211_reg_rule irule;
686 /* Uses the stack temporarily for counter arithmetic */
687 intersected_rule = &irule;
689 memset(intersected_rule, 0, sizeof(struct ieee80211_reg_rule));
694 /* First we get a count of the rules we'll need, then we actually
695 * build them. This is to so we can malloc() and free() a
696 * regdomain once. The reason we use reg_rules_intersect() here
697 * is it will return -EINVAL if the rule computed makes no sense.
698 * All rules that do check out OK are valid. */
700 for (x = 0; x < rd1->n_reg_rules; x++) {
701 rule1 = &rd1->reg_rules[x];
702 for (y = 0; y < rd2->n_reg_rules; y++) {
703 rule2 = &rd2->reg_rules[y];
704 if (!reg_rules_intersect(rule1, rule2,
707 memset(intersected_rule, 0,
708 sizeof(struct ieee80211_reg_rule));
715 size_of_regd = sizeof(struct ieee80211_regdomain) +
716 ((num_rules + 1) * sizeof(struct ieee80211_reg_rule));
718 rd = kzalloc(size_of_regd, GFP_KERNEL);
722 for (x = 0; x < rd1->n_reg_rules; x++) {
723 rule1 = &rd1->reg_rules[x];
724 for (y = 0; y < rd2->n_reg_rules; y++) {
725 rule2 = &rd2->reg_rules[y];
726 /* This time around instead of using the stack lets
727 * write to the target rule directly saving ourselves
729 intersected_rule = &rd->reg_rules[rule_idx];
730 r = reg_rules_intersect(rule1, rule2,
732 /* No need to memset here the intersected rule here as
733 * we're not using the stack anymore */
740 if (rule_idx != num_rules) {
745 rd->n_reg_rules = num_rules;
752 /* XXX: add support for the rest of enum nl80211_reg_rule_flags, we may
753 * want to just have the channel structure use these */
754 static u32 map_regdom_flags(u32 rd_flags)
756 u32 channel_flags = 0;
757 if (rd_flags & NL80211_RRF_PASSIVE_SCAN)
758 channel_flags |= IEEE80211_CHAN_PASSIVE_SCAN;
759 if (rd_flags & NL80211_RRF_NO_IBSS)
760 channel_flags |= IEEE80211_CHAN_NO_IBSS;
761 if (rd_flags & NL80211_RRF_DFS)
762 channel_flags |= IEEE80211_CHAN_RADAR;
763 return channel_flags;
766 static int freq_reg_info_regd(struct wiphy *wiphy,
769 const struct ieee80211_reg_rule **reg_rule,
770 const struct ieee80211_regdomain *custom_regd)
773 bool band_rule_found = false;
774 const struct ieee80211_regdomain *regd;
775 u32 max_bandwidth = 0;
777 regd = custom_regd ? custom_regd : cfg80211_regdomain;
779 /* Follow the driver's regulatory domain, if present, unless a country
780 * IE has been processed or a user wants to help complaince further */
781 if (last_request->initiator != REGDOM_SET_BY_COUNTRY_IE &&
782 last_request->initiator != REGDOM_SET_BY_USER &&
789 for (i = 0; i < regd->n_reg_rules; i++) {
790 const struct ieee80211_reg_rule *rr;
791 const struct ieee80211_freq_range *fr = NULL;
792 const struct ieee80211_power_rule *pr = NULL;
794 rr = ®d->reg_rules[i];
795 fr = &rr->freq_range;
796 pr = &rr->power_rule;
798 /* We only need to know if one frequency rule was
799 * was in center_freq's band, that's enough, so lets
800 * not overwrite it once found */
801 if (!band_rule_found)
802 band_rule_found = freq_in_rule_band(fr, center_freq);
804 max_bandwidth = freq_max_bandwidth(fr, center_freq);
806 if (max_bandwidth && *bandwidth <= max_bandwidth) {
808 *bandwidth = max_bandwidth;
813 if (!band_rule_found)
816 return !max_bandwidth;
818 EXPORT_SYMBOL(freq_reg_info);
820 int freq_reg_info(struct wiphy *wiphy, u32 center_freq, u32 *bandwidth,
821 const struct ieee80211_reg_rule **reg_rule)
823 return freq_reg_info_regd(wiphy, center_freq,
824 bandwidth, reg_rule, NULL);
827 static void handle_channel(struct wiphy *wiphy, enum ieee80211_band band,
828 unsigned int chan_idx)
832 u32 max_bandwidth = 0;
833 const struct ieee80211_reg_rule *reg_rule = NULL;
834 const struct ieee80211_power_rule *power_rule = NULL;
835 struct ieee80211_supported_band *sband;
836 struct ieee80211_channel *chan;
837 struct wiphy *request_wiphy = NULL;
839 assert_cfg80211_lock();
841 request_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);
843 sband = wiphy->bands[band];
844 BUG_ON(chan_idx >= sband->n_channels);
845 chan = &sband->channels[chan_idx];
847 flags = chan->orig_flags;
849 r = freq_reg_info(wiphy, MHZ_TO_KHZ(chan->center_freq),
850 &max_bandwidth, ®_rule);
853 /* This means no regulatory rule was found in the country IE
854 * with a frequency range on the center_freq's band, since
855 * IEEE-802.11 allows for a country IE to have a subset of the
856 * regulatory information provided in a country we ignore
857 * disabling the channel unless at least one reg rule was
858 * found on the center_freq's band. For details see this
861 * http://tinyurl.com/11d-clarification
864 last_request->initiator == REGDOM_SET_BY_COUNTRY_IE) {
865 #ifdef CONFIG_CFG80211_REG_DEBUG
866 printk(KERN_DEBUG "cfg80211: Leaving channel %d MHz "
867 "intact on %s - no rule found in band on "
869 chan->center_freq, wiphy_name(wiphy));
872 /* In this case we know the country IE has at least one reg rule
873 * for the band so we respect its band definitions */
874 #ifdef CONFIG_CFG80211_REG_DEBUG
875 if (last_request->initiator == REGDOM_SET_BY_COUNTRY_IE)
876 printk(KERN_DEBUG "cfg80211: Disabling "
877 "channel %d MHz on %s due to "
879 chan->center_freq, wiphy_name(wiphy));
881 flags |= IEEE80211_CHAN_DISABLED;
887 power_rule = ®_rule->power_rule;
889 if (last_request->initiator == REGDOM_SET_BY_DRIVER &&
890 request_wiphy && request_wiphy == wiphy &&
891 request_wiphy->strict_regulatory) {
892 /* This gaurantees the driver's requested regulatory domain
893 * will always be used as a base for further regulatory
895 chan->flags = chan->orig_flags =
896 map_regdom_flags(reg_rule->flags);
897 chan->max_antenna_gain = chan->orig_mag =
898 (int) MBI_TO_DBI(power_rule->max_antenna_gain);
899 chan->max_bandwidth = KHZ_TO_MHZ(max_bandwidth);
900 chan->max_power = chan->orig_mpwr =
901 (int) MBM_TO_DBM(power_rule->max_eirp);
905 chan->flags = flags | map_regdom_flags(reg_rule->flags);
906 chan->max_antenna_gain = min(chan->orig_mag,
907 (int) MBI_TO_DBI(power_rule->max_antenna_gain));
908 chan->max_bandwidth = KHZ_TO_MHZ(max_bandwidth);
910 chan->max_power = min(chan->orig_mpwr,
911 (int) MBM_TO_DBM(power_rule->max_eirp));
913 chan->max_power = (int) MBM_TO_DBM(power_rule->max_eirp);
916 static void handle_band(struct wiphy *wiphy, enum ieee80211_band band)
919 struct ieee80211_supported_band *sband;
921 BUG_ON(!wiphy->bands[band]);
922 sband = wiphy->bands[band];
924 for (i = 0; i < sband->n_channels; i++)
925 handle_channel(wiphy, band, i);
928 static bool ignore_reg_update(struct wiphy *wiphy, enum reg_set_by setby)
932 if (setby == REGDOM_SET_BY_CORE &&
933 wiphy->custom_regulatory)
935 /* wiphy->regd will be set once the device has its own
936 * desired regulatory domain set */
937 if (wiphy->strict_regulatory && !wiphy->regd &&
938 !is_world_regdom(last_request->alpha2))
943 static void update_all_wiphy_regulatory(enum reg_set_by setby)
945 struct cfg80211_registered_device *drv;
947 list_for_each_entry(drv, &cfg80211_drv_list, list)
948 wiphy_update_regulatory(&drv->wiphy, setby);
951 void wiphy_update_regulatory(struct wiphy *wiphy, enum reg_set_by setby)
953 enum ieee80211_band band;
955 if (ignore_reg_update(wiphy, setby))
957 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
958 if (wiphy->bands[band])
959 handle_band(wiphy, band);
961 if (wiphy->reg_notifier)
962 wiphy->reg_notifier(wiphy, last_request);
965 static void handle_channel_custom(struct wiphy *wiphy,
966 enum ieee80211_band band,
967 unsigned int chan_idx,
968 const struct ieee80211_regdomain *regd)
971 u32 max_bandwidth = 0;
972 const struct ieee80211_reg_rule *reg_rule = NULL;
973 const struct ieee80211_power_rule *power_rule = NULL;
974 struct ieee80211_supported_band *sband;
975 struct ieee80211_channel *chan;
977 sband = wiphy->bands[band];
978 BUG_ON(chan_idx >= sband->n_channels);
979 chan = &sband->channels[chan_idx];
981 r = freq_reg_info_regd(wiphy, MHZ_TO_KHZ(chan->center_freq),
982 &max_bandwidth, ®_rule, regd);
985 chan->flags = IEEE80211_CHAN_DISABLED;
989 power_rule = ®_rule->power_rule;
991 chan->flags |= map_regdom_flags(reg_rule->flags);
992 chan->max_antenna_gain = (int) MBI_TO_DBI(power_rule->max_antenna_gain);
993 chan->max_bandwidth = KHZ_TO_MHZ(max_bandwidth);
994 chan->max_power = (int) MBM_TO_DBM(power_rule->max_eirp);
997 static void handle_band_custom(struct wiphy *wiphy, enum ieee80211_band band,
998 const struct ieee80211_regdomain *regd)
1001 struct ieee80211_supported_band *sband;
1003 BUG_ON(!wiphy->bands[band]);
1004 sband = wiphy->bands[band];
1006 for (i = 0; i < sband->n_channels; i++)
1007 handle_channel_custom(wiphy, band, i, regd);
1010 /* Used by drivers prior to wiphy registration */
1011 void wiphy_apply_custom_regulatory(struct wiphy *wiphy,
1012 const struct ieee80211_regdomain *regd)
1014 enum ieee80211_band band;
1015 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1016 if (wiphy->bands[band])
1017 handle_band_custom(wiphy, band, regd);
1020 EXPORT_SYMBOL(wiphy_apply_custom_regulatory);
1022 static int reg_copy_regd(const struct ieee80211_regdomain **dst_regd,
1023 const struct ieee80211_regdomain *src_regd)
1025 struct ieee80211_regdomain *regd;
1026 int size_of_regd = 0;
1029 size_of_regd = sizeof(struct ieee80211_regdomain) +
1030 ((src_regd->n_reg_rules + 1) * sizeof(struct ieee80211_reg_rule));
1032 regd = kzalloc(size_of_regd, GFP_KERNEL);
1036 memcpy(regd, src_regd, sizeof(struct ieee80211_regdomain));
1038 for (i = 0; i < src_regd->n_reg_rules; i++)
1039 memcpy(®d->reg_rules[i], &src_regd->reg_rules[i],
1040 sizeof(struct ieee80211_reg_rule));
1046 /* Return value which can be used by ignore_request() to indicate
1047 * it has been determined we should intersect two regulatory domains */
1048 #define REG_INTERSECT 1
1050 /* This has the logic which determines when a new request
1051 * should be ignored. */
1052 static int ignore_request(struct wiphy *wiphy, enum reg_set_by set_by,
1055 struct wiphy *last_wiphy = NULL;
1057 assert_cfg80211_lock();
1059 /* All initial requests are respected */
1064 case REGDOM_SET_BY_INIT:
1066 case REGDOM_SET_BY_CORE:
1068 case REGDOM_SET_BY_COUNTRY_IE:
1070 last_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);
1072 if (unlikely(!is_an_alpha2(alpha2)))
1074 if (last_request->initiator == REGDOM_SET_BY_COUNTRY_IE) {
1075 if (last_wiphy != wiphy) {
1077 * Two cards with two APs claiming different
1078 * different Country IE alpha2s. We could
1079 * intersect them, but that seems unlikely
1080 * to be correct. Reject second one for now.
1082 if (!alpha2_equal(alpha2,
1083 cfg80211_regdomain->alpha2))
1087 /* Two consecutive Country IE hints on the same wiphy.
1088 * This should be picked up early by the driver/stack */
1089 if (WARN_ON(!alpha2_equal(cfg80211_regdomain->alpha2,
1094 return REG_INTERSECT;
1095 case REGDOM_SET_BY_DRIVER:
1096 if (last_request->initiator == REGDOM_SET_BY_CORE) {
1097 if (is_old_static_regdom(cfg80211_regdomain))
1099 if (!alpha2_equal(cfg80211_regdomain->alpha2, alpha2))
1103 return REG_INTERSECT;
1104 case REGDOM_SET_BY_USER:
1105 if (last_request->initiator == REGDOM_SET_BY_COUNTRY_IE)
1106 return REG_INTERSECT;
1107 /* If the user knows better the user should set the regdom
1108 * to their country before the IE is picked up */
1109 if (last_request->initiator == REGDOM_SET_BY_USER &&
1110 last_request->intersect)
1112 /* Process user requests only after previous user/driver/core
1113 * requests have been processed */
1114 if (last_request->initiator == REGDOM_SET_BY_CORE ||
1115 last_request->initiator == REGDOM_SET_BY_DRIVER ||
1116 last_request->initiator == REGDOM_SET_BY_USER) {
1117 if (!alpha2_equal(last_request->alpha2,
1118 cfg80211_regdomain->alpha2))
1122 if (!is_old_static_regdom(cfg80211_regdomain) &&
1123 alpha2_equal(cfg80211_regdomain->alpha2, alpha2))
1132 /* Caller must hold &cfg80211_mutex */
1133 int __regulatory_hint(struct wiphy *wiphy, enum reg_set_by set_by,
1135 u32 country_ie_checksum,
1136 enum environment_cap env)
1138 struct regulatory_request *request;
1139 bool intersect = false;
1142 assert_cfg80211_lock();
1144 r = ignore_request(wiphy, set_by, alpha2);
1146 if (r == REG_INTERSECT) {
1147 if (set_by == REGDOM_SET_BY_DRIVER) {
1148 r = reg_copy_regd(&wiphy->regd, cfg80211_regdomain);
1154 /* If the regulatory domain being requested by the
1155 * driver has already been set just copy it to the
1157 if (r == -EALREADY && set_by == REGDOM_SET_BY_DRIVER) {
1158 r = reg_copy_regd(&wiphy->regd, cfg80211_regdomain);
1168 request = kzalloc(sizeof(struct regulatory_request),
1173 request->alpha2[0] = alpha2[0];
1174 request->alpha2[1] = alpha2[1];
1175 request->initiator = set_by;
1176 request->wiphy_idx = get_wiphy_idx(wiphy);
1177 request->intersect = intersect;
1178 request->country_ie_checksum = country_ie_checksum;
1179 request->country_ie_env = env;
1181 kfree(last_request);
1182 last_request = request;
1184 /* When r == REG_INTERSECT we do need to call CRDA */
1189 * Note: When CONFIG_WIRELESS_OLD_REGULATORY is enabled
1190 * AND if CRDA is NOT present nothing will happen, if someone
1191 * wants to bother with 11d with OLD_REG you can add a timer.
1192 * If after x amount of time nothing happens you can call:
1194 * return set_regdom(country_ie_regdomain);
1196 * to intersect with the static rd
1198 return call_crda(alpha2);
1201 /* This currently only processes user and driver regulatory hints */
1202 static int reg_process_hint(struct regulatory_request *reg_request)
1205 struct wiphy *wiphy = NULL;
1207 BUG_ON(!reg_request->alpha2);
1209 mutex_lock(&cfg80211_mutex);
1211 if (wiphy_idx_valid(reg_request->wiphy_idx))
1212 wiphy = wiphy_idx_to_wiphy(reg_request->wiphy_idx);
1214 if (reg_request->initiator == REGDOM_SET_BY_DRIVER &&
1220 r = __regulatory_hint(wiphy,
1221 reg_request->initiator,
1222 reg_request->alpha2,
1223 reg_request->country_ie_checksum,
1224 reg_request->country_ie_env);
1225 /* This is required so that the orig_* parameters are saved */
1226 if (r == -EALREADY && wiphy && wiphy->strict_regulatory)
1227 wiphy_update_regulatory(wiphy, reg_request->initiator);
1229 mutex_unlock(&cfg80211_mutex);
1237 static void reg_process_pending_hints(void)
1239 struct regulatory_request *reg_request;
1242 spin_lock(®_requests_lock);
1243 while (!list_empty(®_requests_list)) {
1244 reg_request = list_first_entry(®_requests_list,
1245 struct regulatory_request,
1247 list_del_init(®_request->list);
1248 spin_unlock(®_requests_lock);
1250 r = reg_process_hint(reg_request);
1251 #ifdef CONFIG_CFG80211_REG_DEBUG
1252 if (r && (reg_request->initiator == REGDOM_SET_BY_DRIVER ||
1253 reg_request->initiator == REGDOM_SET_BY_COUNTRY_IE))
1254 printk(KERN_ERR "cfg80211: wiphy_idx %d sent a "
1255 "regulatory hint for %c%c but now has "
1256 "gone fishing, ignoring request\n",
1257 reg_request->wiphy_idx,
1258 reg_request->alpha2[0],
1259 reg_request->alpha2[1]);
1262 spin_lock(®_requests_lock);
1264 spin_unlock(®_requests_lock);
1267 static void reg_todo(struct work_struct *work)
1269 reg_process_pending_hints();
1272 static DECLARE_WORK(reg_work, reg_todo);
1274 static void queue_regulatory_request(struct regulatory_request *request)
1276 spin_lock(®_requests_lock);
1277 list_add_tail(&request->list, ®_requests_list);
1278 spin_unlock(®_requests_lock);
1280 schedule_work(®_work);
1283 /* Core regulatory hint -- happens once during cfg80211_init() */
1284 static int regulatory_hint_core(const char *alpha2)
1286 struct regulatory_request *request;
1288 BUG_ON(last_request);
1290 request = kzalloc(sizeof(struct regulatory_request),
1295 request->alpha2[0] = alpha2[0];
1296 request->alpha2[1] = alpha2[1];
1297 request->initiator = REGDOM_SET_BY_CORE;
1299 queue_regulatory_request(request);
1305 int regulatory_hint_user(const char *alpha2)
1307 struct regulatory_request *request;
1311 request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
1315 request->wiphy_idx = WIPHY_IDX_STALE;
1316 request->alpha2[0] = alpha2[0];
1317 request->alpha2[1] = alpha2[1];
1318 request->initiator = REGDOM_SET_BY_USER,
1320 queue_regulatory_request(request);
1326 int regulatory_hint(struct wiphy *wiphy, const char *alpha2)
1328 struct regulatory_request *request;
1333 request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
1337 request->wiphy_idx = get_wiphy_idx(wiphy);
1339 /* Must have registered wiphy first */
1340 BUG_ON(!wiphy_idx_valid(request->wiphy_idx));
1342 request->alpha2[0] = alpha2[0];
1343 request->alpha2[1] = alpha2[1];
1344 request->initiator = REGDOM_SET_BY_DRIVER;
1346 queue_regulatory_request(request);
1350 EXPORT_SYMBOL(regulatory_hint);
1352 static bool reg_same_country_ie_hint(struct wiphy *wiphy,
1353 u32 country_ie_checksum)
1355 struct wiphy *request_wiphy;
1357 assert_cfg80211_lock();
1359 request_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);
1364 if (likely(request_wiphy != wiphy))
1365 return !country_ie_integrity_changes(country_ie_checksum);
1366 /* We should not have let these through at this point, they
1367 * should have been picked up earlier by the first alpha2 check
1369 if (WARN_ON(!country_ie_integrity_changes(country_ie_checksum)))
1374 void regulatory_hint_11d(struct wiphy *wiphy,
1378 struct ieee80211_regdomain *rd = NULL;
1381 enum environment_cap env = ENVIRON_ANY;
1382 struct regulatory_request *request;
1384 mutex_lock(&cfg80211_mutex);
1386 if (unlikely(!last_request)) {
1387 mutex_unlock(&cfg80211_mutex);
1391 /* IE len must be evenly divisible by 2 */
1392 if (country_ie_len & 0x01)
1395 if (country_ie_len < IEEE80211_COUNTRY_IE_MIN_LEN)
1398 /* Pending country IE processing, this can happen after we
1399 * call CRDA and wait for a response if a beacon was received before
1400 * we were able to process the last regulatory_hint_11d() call */
1401 if (country_ie_regdomain)
1404 alpha2[0] = country_ie[0];
1405 alpha2[1] = country_ie[1];
1407 if (country_ie[2] == 'I')
1408 env = ENVIRON_INDOOR;
1409 else if (country_ie[2] == 'O')
1410 env = ENVIRON_OUTDOOR;
1412 /* We will run this for *every* beacon processed for the BSSID, so
1413 * we optimize an early check to exit out early if we don't have to
1415 if (likely(wiphy_idx_valid(last_request->wiphy_idx))) {
1416 struct cfg80211_registered_device *drv_last_ie;
1419 cfg80211_drv_by_wiphy_idx(last_request->wiphy_idx);
1421 /* Lets keep this simple -- we trust the first AP
1422 * after we intersect with CRDA */
1423 if (likely(&drv_last_ie->wiphy == wiphy)) {
1424 /* Ignore IEs coming in on this wiphy with
1425 * the same alpha2 and environment cap */
1426 if (likely(alpha2_equal(drv_last_ie->country_ie_alpha2,
1428 env == drv_last_ie->env)) {
1431 /* the wiphy moved on to another BSSID or the AP
1432 * was reconfigured. XXX: We need to deal with the
1433 * case where the user suspends and goes to goes
1434 * to another country, and then gets IEs from an
1435 * AP with different settings */
1438 /* Ignore IEs coming in on two separate wiphys with
1439 * the same alpha2 and environment cap */
1440 if (likely(alpha2_equal(drv_last_ie->country_ie_alpha2,
1442 env == drv_last_ie->env)) {
1445 /* We could potentially intersect though */
1450 rd = country_ie_2_rd(country_ie, country_ie_len, &checksum);
1455 * This will not happen right now but we leave it here for the
1456 * the future when we want to add suspend/resume support and having
1457 * the user move to another country after doing so, or having the user
1458 * move to another AP. Right now we just trust the first AP.
1460 * If we hit this before we add this support we want to be informed of
1461 * it as it would indicate a mistake in the current design
1463 if (WARN_ON(reg_same_country_ie_hint(wiphy, checksum)))
1466 request = kzalloc(sizeof(struct regulatory_request), GFP_KERNEL);
1470 /* We keep this around for when CRDA comes back with a response so
1471 * we can intersect with that */
1472 country_ie_regdomain = rd;
1474 request->wiphy_idx = get_wiphy_idx(wiphy);
1475 request->alpha2[0] = rd->alpha2[0];
1476 request->alpha2[1] = rd->alpha2[1];
1477 request->initiator = REGDOM_SET_BY_COUNTRY_IE;
1478 request->country_ie_checksum = checksum;
1479 request->country_ie_env = env;
1481 mutex_unlock(&cfg80211_mutex);
1483 queue_regulatory_request(request);
1490 mutex_unlock(&cfg80211_mutex);
1492 EXPORT_SYMBOL(regulatory_hint_11d);
1494 static void print_rd_rules(const struct ieee80211_regdomain *rd)
1497 const struct ieee80211_reg_rule *reg_rule = NULL;
1498 const struct ieee80211_freq_range *freq_range = NULL;
1499 const struct ieee80211_power_rule *power_rule = NULL;
1501 printk(KERN_INFO "\t(start_freq - end_freq @ bandwidth), "
1502 "(max_antenna_gain, max_eirp)\n");
1504 for (i = 0; i < rd->n_reg_rules; i++) {
1505 reg_rule = &rd->reg_rules[i];
1506 freq_range = ®_rule->freq_range;
1507 power_rule = ®_rule->power_rule;
1509 /* There may not be documentation for max antenna gain
1510 * in certain regions */
1511 if (power_rule->max_antenna_gain)
1512 printk(KERN_INFO "\t(%d KHz - %d KHz @ %d KHz), "
1513 "(%d mBi, %d mBm)\n",
1514 freq_range->start_freq_khz,
1515 freq_range->end_freq_khz,
1516 freq_range->max_bandwidth_khz,
1517 power_rule->max_antenna_gain,
1518 power_rule->max_eirp);
1520 printk(KERN_INFO "\t(%d KHz - %d KHz @ %d KHz), "
1522 freq_range->start_freq_khz,
1523 freq_range->end_freq_khz,
1524 freq_range->max_bandwidth_khz,
1525 power_rule->max_eirp);
1529 static void print_regdomain(const struct ieee80211_regdomain *rd)
1532 if (is_intersected_alpha2(rd->alpha2)) {
1534 if (last_request->initiator == REGDOM_SET_BY_COUNTRY_IE) {
1535 struct cfg80211_registered_device *drv;
1536 drv = cfg80211_drv_by_wiphy_idx(
1537 last_request->wiphy_idx);
1539 printk(KERN_INFO "cfg80211: Current regulatory "
1540 "domain updated by AP to: %c%c\n",
1541 drv->country_ie_alpha2[0],
1542 drv->country_ie_alpha2[1]);
1544 printk(KERN_INFO "cfg80211: Current regulatory "
1545 "domain intersected: \n");
1547 printk(KERN_INFO "cfg80211: Current regulatory "
1548 "domain intersected: \n");
1549 } else if (is_world_regdom(rd->alpha2))
1550 printk(KERN_INFO "cfg80211: World regulatory "
1551 "domain updated:\n");
1553 if (is_unknown_alpha2(rd->alpha2))
1554 printk(KERN_INFO "cfg80211: Regulatory domain "
1555 "changed to driver built-in settings "
1556 "(unknown country)\n");
1558 printk(KERN_INFO "cfg80211: Regulatory domain "
1559 "changed to country: %c%c\n",
1560 rd->alpha2[0], rd->alpha2[1]);
1565 static void print_regdomain_info(const struct ieee80211_regdomain *rd)
1567 printk(KERN_INFO "cfg80211: Regulatory domain: %c%c\n",
1568 rd->alpha2[0], rd->alpha2[1]);
1572 #ifdef CONFIG_CFG80211_REG_DEBUG
1573 static void reg_country_ie_process_debug(
1574 const struct ieee80211_regdomain *rd,
1575 const struct ieee80211_regdomain *country_ie_regdomain,
1576 const struct ieee80211_regdomain *intersected_rd)
1578 printk(KERN_DEBUG "cfg80211: Received country IE:\n");
1579 print_regdomain_info(country_ie_regdomain);
1580 printk(KERN_DEBUG "cfg80211: CRDA thinks this should applied:\n");
1581 print_regdomain_info(rd);
1582 if (intersected_rd) {
1583 printk(KERN_DEBUG "cfg80211: We intersect both of these "
1585 print_regdomain_info(intersected_rd);
1588 printk(KERN_DEBUG "cfg80211: Intersection between both failed\n");
1591 static inline void reg_country_ie_process_debug(
1592 const struct ieee80211_regdomain *rd,
1593 const struct ieee80211_regdomain *country_ie_regdomain,
1594 const struct ieee80211_regdomain *intersected_rd)
1599 /* Takes ownership of rd only if it doesn't fail */
1600 static int __set_regdom(const struct ieee80211_regdomain *rd)
1602 const struct ieee80211_regdomain *intersected_rd = NULL;
1603 struct cfg80211_registered_device *drv = NULL;
1604 struct wiphy *request_wiphy;
1605 /* Some basic sanity checks first */
1607 if (is_world_regdom(rd->alpha2)) {
1608 if (WARN_ON(!reg_is_valid_request(rd->alpha2)))
1610 update_world_regdomain(rd);
1614 if (!is_alpha2_set(rd->alpha2) && !is_an_alpha2(rd->alpha2) &&
1615 !is_unknown_alpha2(rd->alpha2))
1621 /* Lets only bother proceeding on the same alpha2 if the current
1622 * rd is non static (it means CRDA was present and was used last)
1623 * and the pending request came in from a country IE */
1624 if (last_request->initiator != REGDOM_SET_BY_COUNTRY_IE) {
1625 /* If someone else asked us to change the rd lets only bother
1626 * checking if the alpha2 changes if CRDA was already called */
1627 if (!is_old_static_regdom(cfg80211_regdomain) &&
1628 !regdom_changed(rd->alpha2))
1632 /* Now lets set the regulatory domain, update all driver channels
1633 * and finally inform them of what we have done, in case they want
1634 * to review or adjust their own settings based on their own
1635 * internal EEPROM data */
1637 if (WARN_ON(!reg_is_valid_request(rd->alpha2)))
1640 if (!is_valid_rd(rd)) {
1641 printk(KERN_ERR "cfg80211: Invalid "
1642 "regulatory domain detected:\n");
1643 print_regdomain_info(rd);
1647 request_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);
1649 if (!last_request->intersect) {
1652 if (last_request->initiator != REGDOM_SET_BY_DRIVER) {
1654 cfg80211_regdomain = rd;
1658 /* For a driver hint, lets copy the regulatory domain the
1659 * driver wanted to the wiphy to deal with conflicts */
1661 BUG_ON(request_wiphy->regd);
1663 r = reg_copy_regd(&request_wiphy->regd, rd);
1668 cfg80211_regdomain = rd;
1672 /* Intersection requires a bit more work */
1674 if (last_request->initiator != REGDOM_SET_BY_COUNTRY_IE) {
1676 intersected_rd = regdom_intersect(rd, cfg80211_regdomain);
1677 if (!intersected_rd)
1680 /* We can trash what CRDA provided now.
1681 * However if a driver requested this specific regulatory
1682 * domain we keep it for its private use */
1683 if (last_request->initiator == REGDOM_SET_BY_DRIVER)
1684 request_wiphy->regd = rd;
1691 cfg80211_regdomain = intersected_rd;
1697 * Country IE requests are handled a bit differently, we intersect
1698 * the country IE rd with what CRDA believes that country should have
1701 BUG_ON(!country_ie_regdomain);
1703 if (rd != country_ie_regdomain) {
1704 /* Intersect what CRDA returned and our what we
1705 * had built from the Country IE received */
1707 intersected_rd = regdom_intersect(rd, country_ie_regdomain);
1709 reg_country_ie_process_debug(rd, country_ie_regdomain,
1712 kfree(country_ie_regdomain);
1713 country_ie_regdomain = NULL;
1715 /* This would happen when CRDA was not present and
1716 * OLD_REGULATORY was enabled. We intersect our Country
1717 * IE rd and what was set on cfg80211 originally */
1718 intersected_rd = regdom_intersect(rd, cfg80211_regdomain);
1721 if (!intersected_rd)
1724 drv = wiphy_to_dev(request_wiphy);
1726 drv->country_ie_alpha2[0] = rd->alpha2[0];
1727 drv->country_ie_alpha2[1] = rd->alpha2[1];
1728 drv->env = last_request->country_ie_env;
1730 BUG_ON(intersected_rd == rd);
1736 cfg80211_regdomain = intersected_rd;
1742 /* Use this call to set the current regulatory domain. Conflicts with
1743 * multiple drivers can be ironed out later. Caller must've already
1744 * kmalloc'd the rd structure. Caller must hold cfg80211_mutex */
1745 int set_regdom(const struct ieee80211_regdomain *rd)
1749 assert_cfg80211_lock();
1751 /* Note that this doesn't update the wiphys, this is done below */
1752 r = __set_regdom(rd);
1758 /* This would make this whole thing pointless */
1759 if (!last_request->intersect)
1760 BUG_ON(rd != cfg80211_regdomain);
1762 /* update all wiphys now with the new established regulatory domain */
1763 update_all_wiphy_regulatory(last_request->initiator);
1765 print_regdomain(cfg80211_regdomain);
1770 /* Caller must hold cfg80211_mutex */
1771 void reg_device_remove(struct wiphy *wiphy)
1773 struct wiphy *request_wiphy;
1775 assert_cfg80211_lock();
1777 request_wiphy = wiphy_idx_to_wiphy(last_request->wiphy_idx);
1780 if (!last_request || !request_wiphy)
1782 if (request_wiphy != wiphy)
1784 last_request->wiphy_idx = WIPHY_IDX_STALE;
1785 last_request->country_ie_env = ENVIRON_ANY;
1788 int regulatory_init(void)
1792 reg_pdev = platform_device_register_simple("regulatory", 0, NULL, 0);
1793 if (IS_ERR(reg_pdev))
1794 return PTR_ERR(reg_pdev);
1796 spin_lock_init(®_requests_lock);
1798 #ifdef CONFIG_WIRELESS_OLD_REGULATORY
1799 cfg80211_regdomain = static_regdom(ieee80211_regdom);
1801 printk(KERN_INFO "cfg80211: Using static regulatory domain info\n");
1802 print_regdomain_info(cfg80211_regdomain);
1803 /* The old code still requests for a new regdomain and if
1804 * you have CRDA you get it updated, otherwise you get
1805 * stuck with the static values. We ignore "EU" code as
1806 * that is not a valid ISO / IEC 3166 alpha2 */
1807 if (ieee80211_regdom[0] != 'E' || ieee80211_regdom[1] != 'U')
1808 err = regulatory_hint_core(ieee80211_regdom);
1810 cfg80211_regdomain = cfg80211_world_regdom;
1812 err = regulatory_hint_core("00");
1818 * N.B. kobject_uevent_env() can fail mainly for when we're out
1819 * memory which is handled and propagated appropriately above
1820 * but it can also fail during a netlink_broadcast() or during
1821 * early boot for call_usermodehelper(). For now treat these
1822 * errors as non-fatal.
1824 printk(KERN_ERR "cfg80211: kobject_uevent_env() was unable "
1825 "to call CRDA during init");
1826 #ifdef CONFIG_CFG80211_REG_DEBUG
1827 /* We want to find out exactly why when debugging */
1835 void regulatory_exit(void)
1837 struct regulatory_request *reg_request, *tmp;
1839 cancel_work_sync(®_work);
1841 mutex_lock(&cfg80211_mutex);
1845 kfree(country_ie_regdomain);
1846 country_ie_regdomain = NULL;
1848 kfree(last_request);
1850 platform_device_unregister(reg_pdev);
1852 spin_lock(®_requests_lock);
1853 if (!list_empty(®_requests_list)) {
1854 list_for_each_entry_safe(reg_request, tmp,
1855 ®_requests_list, list) {
1856 list_del(®_request->list);
1860 spin_unlock(®_requests_lock);
1862 mutex_unlock(&cfg80211_mutex);