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>
46 * struct regulatory_request - receipt of last regulatory request
48 * @wiphy: this is set if this request's initiator is
49 * %REGDOM_SET_BY_COUNTRY_IE or %REGDOM_SET_BY_DRIVER. This
50 * can be used by the wireless core to deal with conflicts
51 * and potentially inform users of which devices specifically
52 * cased the conflicts.
53 * @initiator: indicates who sent this request, could be any of
54 * of those set in reg_set_by, %REGDOM_SET_BY_*
55 * @alpha2: the ISO / IEC 3166 alpha2 country code of the requested
56 * regulatory domain. We have a few special codes:
57 * 00 - World regulatory domain
58 * 99 - built by driver but a specific alpha2 cannot be determined
59 * 98 - result of an intersection between two regulatory domains
60 * @intersect: indicates whether the wireless core should intersect
61 * the requested regulatory domain with the presently set regulatory
63 * @country_ie_checksum: checksum of the last processed and accepted
65 * @country_ie_env: lets us know if the AP is telling us we are outdoor,
66 * indoor, or if it doesn't matter
68 struct regulatory_request
{
70 enum reg_set_by initiator
;
73 u32 country_ie_checksum
;
74 enum environment_cap country_ie_env
;
77 /* Receipt of information from last regulatory request */
78 static struct regulatory_request
*last_request
;
80 /* To trigger userspace events */
81 static struct platform_device
*reg_pdev
;
83 /* Keep the ordering from large to small */
84 static u32 supported_bandwidths
[] = {
89 /* Central wireless core regulatory domains, we only need two,
90 * the current one and a world regulatory domain in case we have no
91 * information to give us an alpha2 */
92 static const struct ieee80211_regdomain
*cfg80211_regdomain
;
94 /* We use this as a place for the rd structure built from the
95 * last parsed country IE to rest until CRDA gets back to us with
96 * what it thinks should apply for the same country */
97 static const struct ieee80211_regdomain
*country_ie_regdomain
;
99 /* We keep a static world regulatory domain in case of the absence of CRDA */
100 static const struct ieee80211_regdomain world_regdom
= {
104 REG_RULE(2412-10, 2462+10, 40, 6, 20,
105 NL80211_RRF_PASSIVE_SCAN
|
106 NL80211_RRF_NO_IBSS
),
110 static const struct ieee80211_regdomain
*cfg80211_world_regdom
=
113 #ifdef CONFIG_WIRELESS_OLD_REGULATORY
114 static char *ieee80211_regdom
= "US";
115 module_param(ieee80211_regdom
, charp
, 0444);
116 MODULE_PARM_DESC(ieee80211_regdom
, "IEEE 802.11 regulatory domain code");
118 /* We assume 40 MHz bandwidth for the old regulatory work.
119 * We make emphasis we are using the exact same frequencies
122 static const struct ieee80211_regdomain us_regdom
= {
126 /* IEEE 802.11b/g, channels 1..11 */
127 REG_RULE(2412-10, 2462+10, 40, 6, 27, 0),
128 /* IEEE 802.11a, channel 36 */
129 REG_RULE(5180-10, 5180+10, 40, 6, 23, 0),
130 /* IEEE 802.11a, channel 40 */
131 REG_RULE(5200-10, 5200+10, 40, 6, 23, 0),
132 /* IEEE 802.11a, channel 44 */
133 REG_RULE(5220-10, 5220+10, 40, 6, 23, 0),
134 /* IEEE 802.11a, channels 48..64 */
135 REG_RULE(5240-10, 5320+10, 40, 6, 23, 0),
136 /* IEEE 802.11a, channels 149..165, outdoor */
137 REG_RULE(5745-10, 5825+10, 40, 6, 30, 0),
141 static const struct ieee80211_regdomain jp_regdom
= {
145 /* IEEE 802.11b/g, channels 1..14 */
146 REG_RULE(2412-10, 2484+10, 40, 6, 20, 0),
147 /* IEEE 802.11a, channels 34..48 */
148 REG_RULE(5170-10, 5240+10, 40, 6, 20,
149 NL80211_RRF_PASSIVE_SCAN
),
150 /* IEEE 802.11a, channels 52..64 */
151 REG_RULE(5260-10, 5320+10, 40, 6, 20,
152 NL80211_RRF_NO_IBSS
|
157 static const struct ieee80211_regdomain eu_regdom
= {
159 /* This alpha2 is bogus, we leave it here just for stupid
160 * backward compatibility */
163 /* IEEE 802.11b/g, channels 1..13 */
164 REG_RULE(2412-10, 2472+10, 40, 6, 20, 0),
165 /* IEEE 802.11a, channel 36 */
166 REG_RULE(5180-10, 5180+10, 40, 6, 23,
167 NL80211_RRF_PASSIVE_SCAN
),
168 /* IEEE 802.11a, channel 40 */
169 REG_RULE(5200-10, 5200+10, 40, 6, 23,
170 NL80211_RRF_PASSIVE_SCAN
),
171 /* IEEE 802.11a, channel 44 */
172 REG_RULE(5220-10, 5220+10, 40, 6, 23,
173 NL80211_RRF_PASSIVE_SCAN
),
174 /* IEEE 802.11a, channels 48..64 */
175 REG_RULE(5240-10, 5320+10, 40, 6, 20,
176 NL80211_RRF_NO_IBSS
|
178 /* IEEE 802.11a, channels 100..140 */
179 REG_RULE(5500-10, 5700+10, 40, 6, 30,
180 NL80211_RRF_NO_IBSS
|
185 static const struct ieee80211_regdomain
*static_regdom(char *alpha2
)
187 if (alpha2
[0] == 'U' && alpha2
[1] == 'S')
189 if (alpha2
[0] == 'J' && alpha2
[1] == 'P')
191 if (alpha2
[0] == 'E' && alpha2
[1] == 'U')
193 /* Default, as per the old rules */
197 static bool is_old_static_regdom(const struct ieee80211_regdomain
*rd
)
199 if (rd
== &us_regdom
|| rd
== &jp_regdom
|| rd
== &eu_regdom
)
204 static inline bool is_old_static_regdom(const struct ieee80211_regdomain
*rd
)
210 static void reset_regdomains(void)
212 /* avoid freeing static information or freeing something twice */
213 if (cfg80211_regdomain
== cfg80211_world_regdom
)
214 cfg80211_regdomain
= NULL
;
215 if (cfg80211_world_regdom
== &world_regdom
)
216 cfg80211_world_regdom
= NULL
;
217 if (cfg80211_regdomain
== &world_regdom
)
218 cfg80211_regdomain
= NULL
;
219 if (is_old_static_regdom(cfg80211_regdomain
))
220 cfg80211_regdomain
= NULL
;
222 kfree(cfg80211_regdomain
);
223 kfree(cfg80211_world_regdom
);
225 cfg80211_world_regdom
= &world_regdom
;
226 cfg80211_regdomain
= NULL
;
229 /* Dynamic world regulatory domain requested by the wireless
230 * core upon initialization */
231 static void update_world_regdomain(const struct ieee80211_regdomain
*rd
)
233 BUG_ON(!last_request
);
237 cfg80211_world_regdom
= rd
;
238 cfg80211_regdomain
= rd
;
241 bool is_world_regdom(const char *alpha2
)
245 if (alpha2
[0] == '0' && alpha2
[1] == '0')
250 static bool is_alpha2_set(const char *alpha2
)
254 if (alpha2
[0] != 0 && alpha2
[1] != 0)
259 static bool is_alpha_upper(char letter
)
262 if (letter
>= 65 && letter
<= 90)
267 static bool is_unknown_alpha2(const char *alpha2
)
271 /* Special case where regulatory domain was built by driver
272 * but a specific alpha2 cannot be determined */
273 if (alpha2
[0] == '9' && alpha2
[1] == '9')
278 static bool is_intersected_alpha2(const char *alpha2
)
282 /* Special case where regulatory domain is the
283 * result of an intersection between two regulatory domain
285 if (alpha2
[0] == '9' && alpha2
[1] == '8')
290 static bool is_an_alpha2(const char *alpha2
)
294 if (is_alpha_upper(alpha2
[0]) && is_alpha_upper(alpha2
[1]))
299 static bool alpha2_equal(const char *alpha2_x
, const char *alpha2_y
)
301 if (!alpha2_x
|| !alpha2_y
)
303 if (alpha2_x
[0] == alpha2_y
[0] &&
304 alpha2_x
[1] == alpha2_y
[1])
309 static bool regdom_changed(const char *alpha2
)
311 if (!cfg80211_regdomain
)
313 if (alpha2_equal(cfg80211_regdomain
->alpha2
, alpha2
))
319 * country_ie_integrity_changes - tells us if the country IE has changed
320 * @checksum: checksum of country IE of fields we are interested in
322 * If the country IE has not changed you can ignore it safely. This is
323 * useful to determine if two devices are seeing two different country IEs
324 * even on the same alpha2. Note that this will return false if no IE has
325 * been set on the wireless core yet.
327 static bool country_ie_integrity_changes(u32 checksum
)
329 /* If no IE has been set then the checksum doesn't change */
330 if (unlikely(!last_request
->country_ie_checksum
))
332 if (unlikely(last_request
->country_ie_checksum
!= checksum
))
337 /* This lets us keep regulatory code which is updated on a regulatory
338 * basis in userspace. */
339 static int call_crda(const char *alpha2
)
341 char country_env
[9 + 2] = "COUNTRY=";
347 if (!is_world_regdom((char *) alpha2
))
348 printk(KERN_INFO
"cfg80211: Calling CRDA for country: %c%c\n",
349 alpha2
[0], alpha2
[1]);
351 printk(KERN_INFO
"cfg80211: Calling CRDA to update world "
352 "regulatory domain\n");
354 country_env
[8] = alpha2
[0];
355 country_env
[9] = alpha2
[1];
357 return kobject_uevent_env(®_pdev
->dev
.kobj
, KOBJ_CHANGE
, envp
);
360 /* Used by nl80211 before kmalloc'ing our regulatory domain */
361 bool reg_is_valid_request(const char *alpha2
)
366 return alpha2_equal(last_request
->alpha2
, alpha2
);
369 /* Sanity check on a regulatory rule */
370 static bool is_valid_reg_rule(const struct ieee80211_reg_rule
*rule
)
372 const struct ieee80211_freq_range
*freq_range
= &rule
->freq_range
;
375 if (freq_range
->start_freq_khz
<= 0 || freq_range
->end_freq_khz
<= 0)
378 if (freq_range
->start_freq_khz
> freq_range
->end_freq_khz
)
381 freq_diff
= freq_range
->end_freq_khz
- freq_range
->start_freq_khz
;
383 if (freq_range
->end_freq_khz
<= freq_range
->start_freq_khz
||
384 freq_range
->max_bandwidth_khz
> freq_diff
)
390 static bool is_valid_rd(const struct ieee80211_regdomain
*rd
)
392 const struct ieee80211_reg_rule
*reg_rule
= NULL
;
395 if (!rd
->n_reg_rules
)
398 if (WARN_ON(rd
->n_reg_rules
> NL80211_MAX_SUPP_REG_RULES
))
401 for (i
= 0; i
< rd
->n_reg_rules
; i
++) {
402 reg_rule
= &rd
->reg_rules
[i
];
403 if (!is_valid_reg_rule(reg_rule
))
410 /* Returns value in KHz */
411 static u32
freq_max_bandwidth(const struct ieee80211_freq_range
*freq_range
,
415 for (i
= 0; i
< ARRAY_SIZE(supported_bandwidths
); i
++) {
416 u32 start_freq_khz
= freq
- supported_bandwidths
[i
]/2;
417 u32 end_freq_khz
= freq
+ supported_bandwidths
[i
]/2;
418 if (start_freq_khz
>= freq_range
->start_freq_khz
&&
419 end_freq_khz
<= freq_range
->end_freq_khz
)
420 return supported_bandwidths
[i
];
426 * freq_in_rule_band - tells us if a frequency is in a frequency band
427 * @freq_range: frequency rule we want to query
428 * @freq_khz: frequency we are inquiring about
430 * This lets us know if a specific frequency rule is or is not relevant to
431 * a specific frequency's band. Bands are device specific and artificial
432 * definitions (the "2.4 GHz band" and the "5 GHz band"), however it is
433 * safe for now to assume that a frequency rule should not be part of a
434 * frequency's band if the start freq or end freq are off by more than 2 GHz.
435 * This resolution can be lowered and should be considered as we add
436 * regulatory rule support for other "bands".
438 static bool freq_in_rule_band(const struct ieee80211_freq_range
*freq_range
,
441 #define ONE_GHZ_IN_KHZ 1000000
442 if (abs(freq_khz
- freq_range
->start_freq_khz
) <= (2 * ONE_GHZ_IN_KHZ
))
444 if (abs(freq_khz
- freq_range
->end_freq_khz
) <= (2 * ONE_GHZ_IN_KHZ
))
447 #undef ONE_GHZ_IN_KHZ
450 /* Converts a country IE to a regulatory domain. A regulatory domain
451 * structure has a lot of information which the IE doesn't yet have,
452 * so for the other values we use upper max values as we will intersect
453 * with our userspace regulatory agent to get lower bounds. */
454 static struct ieee80211_regdomain
*country_ie_2_rd(
459 struct ieee80211_regdomain
*rd
= NULL
;
463 u32 num_rules
= 0, size_of_regd
= 0;
464 u8
*triplets_start
= NULL
;
465 u8 len_at_triplet
= 0;
466 /* the last channel we have registered in a subband (triplet) */
467 int last_sub_max_channel
= 0;
469 *checksum
= 0xDEADBEEF;
471 /* Country IE requirements */
472 BUG_ON(country_ie_len
< IEEE80211_COUNTRY_IE_MIN_LEN
||
473 country_ie_len
& 0x01);
475 alpha2
[0] = country_ie
[0];
476 alpha2
[1] = country_ie
[1];
479 * Third octet can be:
483 * anything else we assume is no restrictions
485 if (country_ie
[2] == 'I')
486 flags
= NL80211_RRF_NO_OUTDOOR
;
487 else if (country_ie
[2] == 'O')
488 flags
= NL80211_RRF_NO_INDOOR
;
493 triplets_start
= country_ie
;
494 len_at_triplet
= country_ie_len
;
496 *checksum
^= ((flags
^ alpha2
[0] ^ alpha2
[1]) << 8);
498 /* We need to build a reg rule for each triplet, but first we must
499 * calculate the number of reg rules we will need. We will need one
500 * for each channel subband */
501 while (country_ie_len
>= 3) {
503 struct ieee80211_country_ie_triplet
*triplet
=
504 (struct ieee80211_country_ie_triplet
*) country_ie
;
505 int cur_sub_max_channel
= 0, cur_channel
= 0;
507 if (triplet
->ext
.reg_extension_id
>=
508 IEEE80211_COUNTRY_EXTENSION_ID
) {
515 if (triplet
->chans
.first_channel
<= 14)
516 end_channel
= triplet
->chans
.first_channel
+
517 triplet
->chans
.num_channels
;
520 * 5 GHz -- For example in country IEs if the first
521 * channel given is 36 and the number of channels is 4
522 * then the individual channel numbers defined for the
523 * 5 GHz PHY by these parameters are: 36, 40, 44, and 48
524 * and not 36, 37, 38, 39.
526 * See: http://tinyurl.com/11d-clarification
528 end_channel
= triplet
->chans
.first_channel
+
529 (4 * (triplet
->chans
.num_channels
- 1));
531 cur_channel
= triplet
->chans
.first_channel
;
532 cur_sub_max_channel
= end_channel
;
534 /* Basic sanity check */
535 if (cur_sub_max_channel
< cur_channel
)
538 /* Do not allow overlapping channels. Also channels
539 * passed in each subband must be monotonically
541 if (last_sub_max_channel
) {
542 if (cur_channel
<= last_sub_max_channel
)
544 if (cur_sub_max_channel
<= last_sub_max_channel
)
548 /* When dot11RegulatoryClassesRequired is supported
549 * we can throw ext triplets as part of this soup,
550 * for now we don't care when those change as we
551 * don't support them */
552 *checksum
^= ((cur_channel
^ cur_sub_max_channel
) << 8) |
553 ((cur_sub_max_channel
^ cur_sub_max_channel
) << 16) |
554 ((triplet
->chans
.max_power
^ cur_sub_max_channel
) << 24);
556 last_sub_max_channel
= cur_sub_max_channel
;
562 /* Note: this is not a IEEE requirement but
563 * simply a memory requirement */
564 if (num_rules
> NL80211_MAX_SUPP_REG_RULES
)
568 country_ie
= triplets_start
;
569 country_ie_len
= len_at_triplet
;
571 size_of_regd
= sizeof(struct ieee80211_regdomain
) +
572 (num_rules
* sizeof(struct ieee80211_reg_rule
));
574 rd
= kzalloc(size_of_regd
, GFP_KERNEL
);
578 rd
->n_reg_rules
= num_rules
;
579 rd
->alpha2
[0] = alpha2
[0];
580 rd
->alpha2
[1] = alpha2
[1];
582 /* This time around we fill in the rd */
583 while (country_ie_len
>= 3) {
585 struct ieee80211_country_ie_triplet
*triplet
=
586 (struct ieee80211_country_ie_triplet
*) country_ie
;
587 struct ieee80211_reg_rule
*reg_rule
= NULL
;
588 struct ieee80211_freq_range
*freq_range
= NULL
;
589 struct ieee80211_power_rule
*power_rule
= NULL
;
591 /* Must parse if dot11RegulatoryClassesRequired is true,
592 * we don't support this yet */
593 if (triplet
->ext
.reg_extension_id
>=
594 IEEE80211_COUNTRY_EXTENSION_ID
) {
600 reg_rule
= &rd
->reg_rules
[i
];
601 freq_range
= ®_rule
->freq_range
;
602 power_rule
= ®_rule
->power_rule
;
604 reg_rule
->flags
= flags
;
607 if (triplet
->chans
.first_channel
<= 14)
608 end_channel
= triplet
->chans
.first_channel
+
609 triplet
->chans
.num_channels
;
611 end_channel
= triplet
->chans
.first_channel
+
612 (4 * (triplet
->chans
.num_channels
- 1));
614 /* The +10 is since the regulatory domain expects
615 * the actual band edge, not the center of freq for
616 * its start and end freqs, assuming 20 MHz bandwidth on
617 * the channels passed */
618 freq_range
->start_freq_khz
=
619 MHZ_TO_KHZ(ieee80211_channel_to_frequency(
620 triplet
->chans
.first_channel
) - 10);
621 freq_range
->end_freq_khz
=
622 MHZ_TO_KHZ(ieee80211_channel_to_frequency(
625 /* Large arbitrary values, we intersect later */
626 /* Increment this if we ever support >= 40 MHz channels
628 freq_range
->max_bandwidth_khz
= MHZ_TO_KHZ(40);
629 power_rule
->max_antenna_gain
= DBI_TO_MBI(100);
630 power_rule
->max_eirp
= DBM_TO_MBM(100);
636 BUG_ON(i
> NL80211_MAX_SUPP_REG_RULES
);
643 /* Helper for regdom_intersect(), this does the real
644 * mathematical intersection fun */
645 static int reg_rules_intersect(
646 const struct ieee80211_reg_rule
*rule1
,
647 const struct ieee80211_reg_rule
*rule2
,
648 struct ieee80211_reg_rule
*intersected_rule
)
650 const struct ieee80211_freq_range
*freq_range1
, *freq_range2
;
651 struct ieee80211_freq_range
*freq_range
;
652 const struct ieee80211_power_rule
*power_rule1
, *power_rule2
;
653 struct ieee80211_power_rule
*power_rule
;
656 freq_range1
= &rule1
->freq_range
;
657 freq_range2
= &rule2
->freq_range
;
658 freq_range
= &intersected_rule
->freq_range
;
660 power_rule1
= &rule1
->power_rule
;
661 power_rule2
= &rule2
->power_rule
;
662 power_rule
= &intersected_rule
->power_rule
;
664 freq_range
->start_freq_khz
= max(freq_range1
->start_freq_khz
,
665 freq_range2
->start_freq_khz
);
666 freq_range
->end_freq_khz
= min(freq_range1
->end_freq_khz
,
667 freq_range2
->end_freq_khz
);
668 freq_range
->max_bandwidth_khz
= min(freq_range1
->max_bandwidth_khz
,
669 freq_range2
->max_bandwidth_khz
);
671 freq_diff
= freq_range
->end_freq_khz
- freq_range
->start_freq_khz
;
672 if (freq_range
->max_bandwidth_khz
> freq_diff
)
673 freq_range
->max_bandwidth_khz
= freq_diff
;
675 power_rule
->max_eirp
= min(power_rule1
->max_eirp
,
676 power_rule2
->max_eirp
);
677 power_rule
->max_antenna_gain
= min(power_rule1
->max_antenna_gain
,
678 power_rule2
->max_antenna_gain
);
680 intersected_rule
->flags
= (rule1
->flags
| rule2
->flags
);
682 if (!is_valid_reg_rule(intersected_rule
))
689 * regdom_intersect - do the intersection between two regulatory domains
690 * @rd1: first regulatory domain
691 * @rd2: second regulatory domain
693 * Use this function to get the intersection between two regulatory domains.
694 * Once completed we will mark the alpha2 for the rd as intersected, "98",
695 * as no one single alpha2 can represent this regulatory domain.
697 * Returns a pointer to the regulatory domain structure which will hold the
698 * resulting intersection of rules between rd1 and rd2. We will
699 * kzalloc() this structure for you.
701 static struct ieee80211_regdomain
*regdom_intersect(
702 const struct ieee80211_regdomain
*rd1
,
703 const struct ieee80211_regdomain
*rd2
)
707 unsigned int num_rules
= 0, rule_idx
= 0;
708 const struct ieee80211_reg_rule
*rule1
, *rule2
;
709 struct ieee80211_reg_rule
*intersected_rule
;
710 struct ieee80211_regdomain
*rd
;
711 /* This is just a dummy holder to help us count */
712 struct ieee80211_reg_rule irule
;
714 /* Uses the stack temporarily for counter arithmetic */
715 intersected_rule
= &irule
;
717 memset(intersected_rule
, 0, sizeof(struct ieee80211_reg_rule
));
722 /* First we get a count of the rules we'll need, then we actually
723 * build them. This is to so we can malloc() and free() a
724 * regdomain once. The reason we use reg_rules_intersect() here
725 * is it will return -EINVAL if the rule computed makes no sense.
726 * All rules that do check out OK are valid. */
728 for (x
= 0; x
< rd1
->n_reg_rules
; x
++) {
729 rule1
= &rd1
->reg_rules
[x
];
730 for (y
= 0; y
< rd2
->n_reg_rules
; y
++) {
731 rule2
= &rd2
->reg_rules
[y
];
732 if (!reg_rules_intersect(rule1
, rule2
,
735 memset(intersected_rule
, 0,
736 sizeof(struct ieee80211_reg_rule
));
743 size_of_regd
= sizeof(struct ieee80211_regdomain
) +
744 ((num_rules
+ 1) * sizeof(struct ieee80211_reg_rule
));
746 rd
= kzalloc(size_of_regd
, GFP_KERNEL
);
750 for (x
= 0; x
< rd1
->n_reg_rules
; x
++) {
751 rule1
= &rd1
->reg_rules
[x
];
752 for (y
= 0; y
< rd2
->n_reg_rules
; y
++) {
753 rule2
= &rd2
->reg_rules
[y
];
754 /* This time around instead of using the stack lets
755 * write to the target rule directly saving ourselves
757 intersected_rule
= &rd
->reg_rules
[rule_idx
];
758 r
= reg_rules_intersect(rule1
, rule2
,
760 /* No need to memset here the intersected rule here as
761 * we're not using the stack anymore */
768 if (rule_idx
!= num_rules
) {
773 rd
->n_reg_rules
= num_rules
;
780 /* XXX: add support for the rest of enum nl80211_reg_rule_flags, we may
781 * want to just have the channel structure use these */
782 static u32
map_regdom_flags(u32 rd_flags
)
784 u32 channel_flags
= 0;
785 if (rd_flags
& NL80211_RRF_PASSIVE_SCAN
)
786 channel_flags
|= IEEE80211_CHAN_PASSIVE_SCAN
;
787 if (rd_flags
& NL80211_RRF_NO_IBSS
)
788 channel_flags
|= IEEE80211_CHAN_NO_IBSS
;
789 if (rd_flags
& NL80211_RRF_DFS
)
790 channel_flags
|= IEEE80211_CHAN_RADAR
;
791 return channel_flags
;
795 * freq_reg_info - get regulatory information for the given frequency
796 * @center_freq: Frequency in KHz for which we want regulatory information for
797 * @bandwidth: the bandwidth requirement you have in KHz, if you do not have one
798 * you can set this to 0. If this frequency is allowed we then set
799 * this value to the maximum allowed bandwidth.
800 * @reg_rule: the regulatory rule which we have for this frequency
802 * Use this function to get the regulatory rule for a specific frequency on
803 * a given wireless device. If the device has a specific regulatory domain
804 * it wants to follow we respect that unless a country IE has been received
805 * and processed already.
807 * Returns 0 if it was able to find a valid regulatory rule which does
808 * apply to the given center_freq otherwise it returns non-zero. It will
809 * also return -ERANGE if we determine the given center_freq does not even have
810 * a regulatory rule for a frequency range in the center_freq's band. See
811 * freq_in_rule_band() for our current definition of a band -- this is purely
812 * subjective and right now its 802.11 specific.
814 static int freq_reg_info(u32 center_freq
, u32
*bandwidth
,
815 const struct ieee80211_reg_rule
**reg_rule
)
818 bool band_rule_found
= false;
819 u32 max_bandwidth
= 0;
821 if (!cfg80211_regdomain
)
824 for (i
= 0; i
< cfg80211_regdomain
->n_reg_rules
; i
++) {
825 const struct ieee80211_reg_rule
*rr
;
826 const struct ieee80211_freq_range
*fr
= NULL
;
827 const struct ieee80211_power_rule
*pr
= NULL
;
829 rr
= &cfg80211_regdomain
->reg_rules
[i
];
830 fr
= &rr
->freq_range
;
831 pr
= &rr
->power_rule
;
833 /* We only need to know if one frequency rule was
834 * was in center_freq's band, that's enough, so lets
835 * not overwrite it once found */
836 if (!band_rule_found
)
837 band_rule_found
= freq_in_rule_band(fr
, center_freq
);
839 max_bandwidth
= freq_max_bandwidth(fr
, center_freq
);
841 if (max_bandwidth
&& *bandwidth
<= max_bandwidth
) {
843 *bandwidth
= max_bandwidth
;
848 if (!band_rule_found
)
851 return !max_bandwidth
;
854 static void handle_channel(struct wiphy
*wiphy
, enum ieee80211_band band
,
855 unsigned int chan_idx
)
859 u32 max_bandwidth
= 0;
860 const struct ieee80211_reg_rule
*reg_rule
= NULL
;
861 const struct ieee80211_power_rule
*power_rule
= NULL
;
862 struct ieee80211_supported_band
*sband
;
863 struct ieee80211_channel
*chan
;
865 sband
= wiphy
->bands
[band
];
866 BUG_ON(chan_idx
>= sband
->n_channels
);
867 chan
= &sband
->channels
[chan_idx
];
869 flags
= chan
->orig_flags
;
871 r
= freq_reg_info(MHZ_TO_KHZ(chan
->center_freq
),
872 &max_bandwidth
, ®_rule
);
875 /* This means no regulatory rule was found in the country IE
876 * with a frequency range on the center_freq's band, since
877 * IEEE-802.11 allows for a country IE to have a subset of the
878 * regulatory information provided in a country we ignore
879 * disabling the channel unless at least one reg rule was
880 * found on the center_freq's band. For details see this
883 * http://tinyurl.com/11d-clarification
886 last_request
->initiator
== REGDOM_SET_BY_COUNTRY_IE
) {
887 #ifdef CONFIG_CFG80211_REG_DEBUG
888 printk(KERN_DEBUG
"cfg80211: Leaving channel %d MHz "
889 "intact on %s - no rule found in band on "
891 chan
->center_freq
, wiphy_name(wiphy
));
894 /* In this case we know the country IE has at least one reg rule
895 * for the band so we respect its band definitions */
896 #ifdef CONFIG_CFG80211_REG_DEBUG
897 if (last_request
->initiator
== REGDOM_SET_BY_COUNTRY_IE
)
898 printk(KERN_DEBUG
"cfg80211: Disabling "
899 "channel %d MHz on %s due to "
901 chan
->center_freq
, wiphy_name(wiphy
));
903 flags
|= IEEE80211_CHAN_DISABLED
;
909 power_rule
= ®_rule
->power_rule
;
911 chan
->flags
= flags
| map_regdom_flags(reg_rule
->flags
);
912 chan
->max_antenna_gain
= min(chan
->orig_mag
,
913 (int) MBI_TO_DBI(power_rule
->max_antenna_gain
));
914 chan
->max_bandwidth
= KHZ_TO_MHZ(max_bandwidth
);
916 chan
->max_power
= min(chan
->orig_mpwr
,
917 (int) MBM_TO_DBM(power_rule
->max_eirp
));
919 chan
->max_power
= (int) MBM_TO_DBM(power_rule
->max_eirp
);
922 static void handle_band(struct wiphy
*wiphy
, enum ieee80211_band band
)
925 struct ieee80211_supported_band
*sband
;
927 BUG_ON(!wiphy
->bands
[band
]);
928 sband
= wiphy
->bands
[band
];
930 for (i
= 0; i
< sband
->n_channels
; i
++)
931 handle_channel(wiphy
, band
, i
);
934 static bool ignore_reg_update(struct wiphy
*wiphy
, enum reg_set_by setby
)
938 if (setby
== REGDOM_SET_BY_CORE
&&
939 wiphy
->fw_handles_regulatory
)
944 static void update_all_wiphy_regulatory(enum reg_set_by setby
)
946 struct cfg80211_registered_device
*drv
;
948 list_for_each_entry(drv
, &cfg80211_drv_list
, list
)
949 if (!ignore_reg_update(&drv
->wiphy
, setby
))
950 wiphy_update_regulatory(&drv
->wiphy
, setby
);
953 void wiphy_update_regulatory(struct wiphy
*wiphy
, enum reg_set_by setby
)
955 enum ieee80211_band band
;
956 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
957 if (wiphy
->bands
[band
])
958 handle_band(wiphy
, band
);
959 if (wiphy
->reg_notifier
)
960 wiphy
->reg_notifier(wiphy
, setby
);
964 /* Return value which can be used by ignore_request() to indicate
965 * it has been determined we should intersect two regulatory domains */
966 #define REG_INTERSECT 1
968 /* This has the logic which determines when a new request
969 * should be ignored. */
970 static int ignore_request(struct wiphy
*wiphy
, enum reg_set_by set_by
,
973 /* All initial requests are respected */
978 case REGDOM_SET_BY_INIT
:
980 case REGDOM_SET_BY_CORE
:
982 * Always respect new wireless core hints, should only happen
983 * when updating the world regulatory domain at init.
986 case REGDOM_SET_BY_COUNTRY_IE
:
987 if (unlikely(!is_an_alpha2(alpha2
)))
989 if (last_request
->initiator
== REGDOM_SET_BY_COUNTRY_IE
) {
990 if (last_request
->wiphy
!= wiphy
) {
992 * Two cards with two APs claiming different
993 * different Country IE alpha2s. We could
994 * intersect them, but that seems unlikely
995 * to be correct. Reject second one for now.
997 if (!alpha2_equal(alpha2
,
998 cfg80211_regdomain
->alpha2
))
1002 /* Two consecutive Country IE hints on the same wiphy.
1003 * This should be picked up early by the driver/stack */
1004 if (WARN_ON(!alpha2_equal(cfg80211_regdomain
->alpha2
,
1009 return REG_INTERSECT
;
1010 case REGDOM_SET_BY_DRIVER
:
1011 if (last_request
->initiator
== REGDOM_SET_BY_DRIVER
)
1014 case REGDOM_SET_BY_USER
:
1015 if (last_request
->initiator
== REGDOM_SET_BY_COUNTRY_IE
)
1016 return REG_INTERSECT
;
1017 /* If the user knows better the user should set the regdom
1018 * to their country before the IE is picked up */
1019 if (last_request
->initiator
== REGDOM_SET_BY_USER
&&
1020 last_request
->intersect
)
1028 /* Caller must hold &cfg80211_drv_mutex */
1029 int __regulatory_hint(struct wiphy
*wiphy
, enum reg_set_by set_by
,
1031 u32 country_ie_checksum
,
1032 enum environment_cap env
)
1034 struct regulatory_request
*request
;
1035 bool intersect
= false;
1038 r
= ignore_request(wiphy
, set_by
, alpha2
);
1040 if (r
== REG_INTERSECT
)
1045 request
= kzalloc(sizeof(struct regulatory_request
),
1050 request
->alpha2
[0] = alpha2
[0];
1051 request
->alpha2
[1] = alpha2
[1];
1052 request
->initiator
= set_by
;
1053 request
->wiphy
= wiphy
;
1054 request
->intersect
= intersect
;
1055 request
->country_ie_checksum
= country_ie_checksum
;
1056 request
->country_ie_env
= env
;
1058 kfree(last_request
);
1059 last_request
= request
;
1061 * Note: When CONFIG_WIRELESS_OLD_REGULATORY is enabled
1062 * AND if CRDA is NOT present nothing will happen, if someone
1063 * wants to bother with 11d with OLD_REG you can add a timer.
1064 * If after x amount of time nothing happens you can call:
1066 * return set_regdom(country_ie_regdomain);
1068 * to intersect with the static rd
1070 return call_crda(alpha2
);
1073 void regulatory_hint(struct wiphy
*wiphy
, const char *alpha2
)
1077 mutex_lock(&cfg80211_drv_mutex
);
1078 __regulatory_hint(wiphy
, REGDOM_SET_BY_DRIVER
, alpha2
, 0, ENVIRON_ANY
);
1079 mutex_unlock(&cfg80211_drv_mutex
);
1081 EXPORT_SYMBOL(regulatory_hint
);
1083 static bool reg_same_country_ie_hint(struct wiphy
*wiphy
,
1084 u32 country_ie_checksum
)
1086 if (unlikely(last_request
->initiator
!= REGDOM_SET_BY_COUNTRY_IE
))
1088 if (!last_request
->wiphy
)
1090 if (likely(last_request
->wiphy
!= wiphy
))
1091 return !country_ie_integrity_changes(country_ie_checksum
);
1092 /* We should not have let these through at this point, they
1093 * should have been picked up earlier by the first alpha2 check
1095 if (WARN_ON(!country_ie_integrity_changes(country_ie_checksum
)))
1100 void regulatory_hint_11d(struct wiphy
*wiphy
,
1104 struct ieee80211_regdomain
*rd
= NULL
;
1107 enum environment_cap env
= ENVIRON_ANY
;
1112 mutex_lock(&cfg80211_drv_mutex
);
1114 /* IE len must be evenly divisible by 2 */
1115 if (country_ie_len
& 0x01)
1118 if (country_ie_len
< IEEE80211_COUNTRY_IE_MIN_LEN
)
1121 /* Pending country IE processing, this can happen after we
1122 * call CRDA and wait for a response if a beacon was received before
1123 * we were able to process the last regulatory_hint_11d() call */
1124 if (country_ie_regdomain
)
1127 alpha2
[0] = country_ie
[0];
1128 alpha2
[1] = country_ie
[1];
1130 if (country_ie
[2] == 'I')
1131 env
= ENVIRON_INDOOR
;
1132 else if (country_ie
[2] == 'O')
1133 env
= ENVIRON_OUTDOOR
;
1135 /* We will run this for *every* beacon processed for the BSSID, so
1136 * we optimize an early check to exit out early if we don't have to
1138 if (likely(last_request
->initiator
==
1139 REGDOM_SET_BY_COUNTRY_IE
&&
1140 likely(last_request
->wiphy
))) {
1141 struct cfg80211_registered_device
*drv_last_ie
;
1143 drv_last_ie
= wiphy_to_dev(last_request
->wiphy
);
1145 /* Lets keep this simple -- we trust the first AP
1146 * after we intersect with CRDA */
1147 if (likely(last_request
->wiphy
== wiphy
)) {
1148 /* Ignore IEs coming in on this wiphy with
1149 * the same alpha2 and environment cap */
1150 if (likely(alpha2_equal(drv_last_ie
->country_ie_alpha2
,
1152 env
== drv_last_ie
->env
)) {
1155 /* the wiphy moved on to another BSSID or the AP
1156 * was reconfigured. XXX: We need to deal with the
1157 * case where the user suspends and goes to goes
1158 * to another country, and then gets IEs from an
1159 * AP with different settings */
1162 /* Ignore IEs coming in on two separate wiphys with
1163 * the same alpha2 and environment cap */
1164 if (likely(alpha2_equal(drv_last_ie
->country_ie_alpha2
,
1166 env
== drv_last_ie
->env
)) {
1169 /* We could potentially intersect though */
1174 rd
= country_ie_2_rd(country_ie
, country_ie_len
, &checksum
);
1178 /* This will not happen right now but we leave it here for the
1179 * the future when we want to add suspend/resume support and having
1180 * the user move to another country after doing so, or having the user
1181 * move to another AP. Right now we just trust the first AP. This is why
1182 * this is marked as likley(). If we hit this before we add this support
1183 * we want to be informed of it as it would indicate a mistake in the
1185 if (likely(WARN_ON(reg_same_country_ie_hint(wiphy
, checksum
))))
1188 /* We keep this around for when CRDA comes back with a response so
1189 * we can intersect with that */
1190 country_ie_regdomain
= rd
;
1192 __regulatory_hint(wiphy
, REGDOM_SET_BY_COUNTRY_IE
,
1193 country_ie_regdomain
->alpha2
, checksum
, env
);
1196 mutex_unlock(&cfg80211_drv_mutex
);
1198 EXPORT_SYMBOL(regulatory_hint_11d
);
1200 static void print_rd_rules(const struct ieee80211_regdomain
*rd
)
1203 const struct ieee80211_reg_rule
*reg_rule
= NULL
;
1204 const struct ieee80211_freq_range
*freq_range
= NULL
;
1205 const struct ieee80211_power_rule
*power_rule
= NULL
;
1207 printk(KERN_INFO
"\t(start_freq - end_freq @ bandwidth), "
1208 "(max_antenna_gain, max_eirp)\n");
1210 for (i
= 0; i
< rd
->n_reg_rules
; i
++) {
1211 reg_rule
= &rd
->reg_rules
[i
];
1212 freq_range
= ®_rule
->freq_range
;
1213 power_rule
= ®_rule
->power_rule
;
1215 /* There may not be documentation for max antenna gain
1216 * in certain regions */
1217 if (power_rule
->max_antenna_gain
)
1218 printk(KERN_INFO
"\t(%d KHz - %d KHz @ %d KHz), "
1219 "(%d mBi, %d mBm)\n",
1220 freq_range
->start_freq_khz
,
1221 freq_range
->end_freq_khz
,
1222 freq_range
->max_bandwidth_khz
,
1223 power_rule
->max_antenna_gain
,
1224 power_rule
->max_eirp
);
1226 printk(KERN_INFO
"\t(%d KHz - %d KHz @ %d KHz), "
1228 freq_range
->start_freq_khz
,
1229 freq_range
->end_freq_khz
,
1230 freq_range
->max_bandwidth_khz
,
1231 power_rule
->max_eirp
);
1235 static void print_regdomain(const struct ieee80211_regdomain
*rd
)
1238 if (is_intersected_alpha2(rd
->alpha2
)) {
1239 struct wiphy
*wiphy
= NULL
;
1240 struct cfg80211_registered_device
*drv
;
1242 if (last_request
->initiator
== REGDOM_SET_BY_COUNTRY_IE
) {
1243 if (last_request
->wiphy
) {
1244 wiphy
= last_request
->wiphy
;
1245 drv
= wiphy_to_dev(wiphy
);
1246 printk(KERN_INFO
"cfg80211: Current regulatory "
1247 "domain updated by AP to: %c%c\n",
1248 drv
->country_ie_alpha2
[0],
1249 drv
->country_ie_alpha2
[1]);
1251 printk(KERN_INFO
"cfg80211: Current regulatory "
1252 "domain intersected: \n");
1254 printk(KERN_INFO
"cfg80211: Current regulatory "
1256 } else if (is_world_regdom(rd
->alpha2
))
1257 printk(KERN_INFO
"cfg80211: World regulatory "
1258 "domain updated:\n");
1260 if (is_unknown_alpha2(rd
->alpha2
))
1261 printk(KERN_INFO
"cfg80211: Regulatory domain "
1262 "changed to driver built-in settings "
1263 "(unknown country)\n");
1265 printk(KERN_INFO
"cfg80211: Regulatory domain "
1266 "changed to country: %c%c\n",
1267 rd
->alpha2
[0], rd
->alpha2
[1]);
1272 static void print_regdomain_info(const struct ieee80211_regdomain
*rd
)
1274 printk(KERN_INFO
"cfg80211: Regulatory domain: %c%c\n",
1275 rd
->alpha2
[0], rd
->alpha2
[1]);
1279 #ifdef CONFIG_CFG80211_REG_DEBUG
1280 static void reg_country_ie_process_debug(
1281 const struct ieee80211_regdomain
*rd
,
1282 const struct ieee80211_regdomain
*country_ie_regdomain
,
1283 const struct ieee80211_regdomain
*intersected_rd
)
1285 printk(KERN_DEBUG
"cfg80211: Received country IE:\n");
1286 print_regdomain_info(country_ie_regdomain
);
1287 printk(KERN_DEBUG
"cfg80211: CRDA thinks this should applied:\n");
1288 print_regdomain_info(rd
);
1289 if (intersected_rd
) {
1290 printk(KERN_DEBUG
"cfg80211: We intersect both of these "
1292 print_regdomain_info(intersected_rd
);
1295 printk(KERN_DEBUG
"cfg80211: Intersection between both failed\n");
1298 static inline void reg_country_ie_process_debug(
1299 const struct ieee80211_regdomain
*rd
,
1300 const struct ieee80211_regdomain
*country_ie_regdomain
,
1301 const struct ieee80211_regdomain
*intersected_rd
)
1306 /* Takes ownership of rd only if it doesn't fail */
1307 static int __set_regdom(const struct ieee80211_regdomain
*rd
)
1309 const struct ieee80211_regdomain
*intersected_rd
= NULL
;
1310 struct cfg80211_registered_device
*drv
= NULL
;
1311 struct wiphy
*wiphy
= NULL
;
1312 /* Some basic sanity checks first */
1314 if (is_world_regdom(rd
->alpha2
)) {
1315 if (WARN_ON(!reg_is_valid_request(rd
->alpha2
)))
1317 update_world_regdomain(rd
);
1321 if (!is_alpha2_set(rd
->alpha2
) && !is_an_alpha2(rd
->alpha2
) &&
1322 !is_unknown_alpha2(rd
->alpha2
))
1328 /* Lets only bother proceeding on the same alpha2 if the current
1329 * rd is non static (it means CRDA was present and was used last)
1330 * and the pending request came in from a country IE */
1331 if (last_request
->initiator
!= REGDOM_SET_BY_COUNTRY_IE
) {
1332 /* If someone else asked us to change the rd lets only bother
1333 * checking if the alpha2 changes if CRDA was already called */
1334 if (!is_old_static_regdom(cfg80211_regdomain
) &&
1335 !regdom_changed(rd
->alpha2
))
1339 wiphy
= last_request
->wiphy
;
1341 /* Now lets set the regulatory domain, update all driver channels
1342 * and finally inform them of what we have done, in case they want
1343 * to review or adjust their own settings based on their own
1344 * internal EEPROM data */
1346 if (WARN_ON(!reg_is_valid_request(rd
->alpha2
)))
1349 if (!is_valid_rd(rd
)) {
1350 printk(KERN_ERR
"cfg80211: Invalid "
1351 "regulatory domain detected:\n");
1352 print_regdomain_info(rd
);
1356 if (!last_request
->intersect
) {
1358 cfg80211_regdomain
= rd
;
1362 /* Intersection requires a bit more work */
1364 if (last_request
->initiator
!= REGDOM_SET_BY_COUNTRY_IE
) {
1366 intersected_rd
= regdom_intersect(rd
, cfg80211_regdomain
);
1367 if (!intersected_rd
)
1370 /* We can trash what CRDA provided now */
1375 cfg80211_regdomain
= intersected_rd
;
1381 * Country IE requests are handled a bit differently, we intersect
1382 * the country IE rd with what CRDA believes that country should have
1385 BUG_ON(!country_ie_regdomain
);
1387 if (rd
!= country_ie_regdomain
) {
1388 /* Intersect what CRDA returned and our what we
1389 * had built from the Country IE received */
1391 intersected_rd
= regdom_intersect(rd
, country_ie_regdomain
);
1393 reg_country_ie_process_debug(rd
, country_ie_regdomain
,
1396 kfree(country_ie_regdomain
);
1397 country_ie_regdomain
= NULL
;
1399 /* This would happen when CRDA was not present and
1400 * OLD_REGULATORY was enabled. We intersect our Country
1401 * IE rd and what was set on cfg80211 originally */
1402 intersected_rd
= regdom_intersect(rd
, cfg80211_regdomain
);
1405 if (!intersected_rd
)
1408 drv
= wiphy_to_dev(wiphy
);
1410 drv
->country_ie_alpha2
[0] = rd
->alpha2
[0];
1411 drv
->country_ie_alpha2
[1] = rd
->alpha2
[1];
1412 drv
->env
= last_request
->country_ie_env
;
1414 BUG_ON(intersected_rd
== rd
);
1420 cfg80211_regdomain
= intersected_rd
;
1426 /* Use this call to set the current regulatory domain. Conflicts with
1427 * multiple drivers can be ironed out later. Caller must've already
1428 * kmalloc'd the rd structure. Caller must hold cfg80211_drv_mutex */
1429 int set_regdom(const struct ieee80211_regdomain
*rd
)
1433 /* Note that this doesn't update the wiphys, this is done below */
1434 r
= __set_regdom(rd
);
1440 /* This would make this whole thing pointless */
1441 if (!last_request
->intersect
)
1442 BUG_ON(rd
!= cfg80211_regdomain
);
1444 /* update all wiphys now with the new established regulatory domain */
1445 update_all_wiphy_regulatory(last_request
->initiator
);
1447 print_regdomain(cfg80211_regdomain
);
1452 /* Caller must hold cfg80211_drv_mutex */
1453 void reg_device_remove(struct wiphy
*wiphy
)
1455 if (!last_request
|| !last_request
->wiphy
)
1457 if (last_request
->wiphy
!= wiphy
)
1459 last_request
->wiphy
= NULL
;
1460 last_request
->country_ie_env
= ENVIRON_ANY
;
1463 int regulatory_init(void)
1467 reg_pdev
= platform_device_register_simple("regulatory", 0, NULL
, 0);
1468 if (IS_ERR(reg_pdev
))
1469 return PTR_ERR(reg_pdev
);
1471 #ifdef CONFIG_WIRELESS_OLD_REGULATORY
1472 cfg80211_regdomain
= static_regdom(ieee80211_regdom
);
1474 printk(KERN_INFO
"cfg80211: Using static regulatory domain info\n");
1475 print_regdomain_info(cfg80211_regdomain
);
1477 * The old code still requests for a new regdomain and if
1478 * you have CRDA you get it updated, otherwise you get
1479 * stuck with the static values. We ignore "EU" code as
1480 * that is not a valid ISO / IEC 3166 alpha2
1481 * stuck with the static values. Since "EU" is not a valid
1482 * ISO / IEC 3166 alpha2 code we can't expect userpace to
1483 * give us a regulatory domain for it. We need last_request
1484 * iniitalized though so lets just send a request which we
1485 * know will be ignored... this crap will be removed once
1488 err
= __regulatory_hint(NULL
, REGDOM_SET_BY_CORE
,
1489 ieee80211_regdom
, 0, ENVIRON_ANY
);
1491 cfg80211_regdomain
= cfg80211_world_regdom
;
1493 err
= __regulatory_hint(NULL
, REGDOM_SET_BY_CORE
, "00", 0, ENVIRON_ANY
);
1495 printk(KERN_ERR
"cfg80211: calling CRDA failed - "
1496 "unable to update world regulatory domain, "
1497 "using static definition\n");
1501 * This ensures last_request is populated once modules
1502 * come swinging in and calling regulatory hints and
1503 * wiphy_apply_custom_regulatory().
1505 flush_scheduled_work();
1510 void regulatory_exit(void)
1512 mutex_lock(&cfg80211_drv_mutex
);
1516 kfree(country_ie_regdomain
);
1517 country_ie_regdomain
= NULL
;
1519 kfree(last_request
);
1521 platform_device_unregister(reg_pdev
);
1523 mutex_unlock(&cfg80211_drv_mutex
);