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 /* wiphy is set if this request's initiator is REGDOM_SET_BY_DRIVER */
46 struct regulatory_request
{
49 enum reg_set_by initiator
;
53 static struct regulatory_request
*last_request
;
55 /* To trigger userspace events */
56 static struct platform_device
*reg_pdev
;
58 /* Keep the ordering from large to small */
59 static u32 supported_bandwidths
[] = {
64 /* Central wireless core regulatory domains, we only need two,
65 * the current one and a world regulatory domain in case we have no
66 * information to give us an alpha2 */
67 static const struct ieee80211_regdomain
*cfg80211_regdomain
;
69 /* We keep a static world regulatory domain in case of the absence of CRDA */
70 static const struct ieee80211_regdomain world_regdom
= {
74 REG_RULE(2412-10, 2462+10, 40, 6, 20,
75 NL80211_RRF_PASSIVE_SCAN
|
80 static const struct ieee80211_regdomain
*cfg80211_world_regdom
=
83 #ifdef CONFIG_WIRELESS_OLD_REGULATORY
84 static char *ieee80211_regdom
= "US";
85 module_param(ieee80211_regdom
, charp
, 0444);
86 MODULE_PARM_DESC(ieee80211_regdom
, "IEEE 802.11 regulatory domain code");
88 /* We assume 40 MHz bandwidth for the old regulatory work.
89 * We make emphasis we are using the exact same frequencies
92 static const struct ieee80211_regdomain us_regdom
= {
96 /* IEEE 802.11b/g, channels 1..11 */
97 REG_RULE(2412-10, 2462+10, 40, 6, 27, 0),
98 /* IEEE 802.11a, channel 36 */
99 REG_RULE(5180-10, 5180+10, 40, 6, 23, 0),
100 /* IEEE 802.11a, channel 40 */
101 REG_RULE(5200-10, 5200+10, 40, 6, 23, 0),
102 /* IEEE 802.11a, channel 44 */
103 REG_RULE(5220-10, 5220+10, 40, 6, 23, 0),
104 /* IEEE 802.11a, channels 48..64 */
105 REG_RULE(5240-10, 5320+10, 40, 6, 23, 0),
106 /* IEEE 802.11a, channels 149..165, outdoor */
107 REG_RULE(5745-10, 5825+10, 40, 6, 30, 0),
111 static const struct ieee80211_regdomain jp_regdom
= {
115 /* IEEE 802.11b/g, channels 1..14 */
116 REG_RULE(2412-10, 2484+10, 40, 6, 20, 0),
117 /* IEEE 802.11a, channels 34..48 */
118 REG_RULE(5170-10, 5240+10, 40, 6, 20,
119 NL80211_RRF_PASSIVE_SCAN
),
120 /* IEEE 802.11a, channels 52..64 */
121 REG_RULE(5260-10, 5320+10, 40, 6, 20,
122 NL80211_RRF_NO_IBSS
|
127 static const struct ieee80211_regdomain eu_regdom
= {
129 /* This alpha2 is bogus, we leave it here just for stupid
130 * backward compatibility */
133 /* IEEE 802.11b/g, channels 1..13 */
134 REG_RULE(2412-10, 2472+10, 40, 6, 20, 0),
135 /* IEEE 802.11a, channel 36 */
136 REG_RULE(5180-10, 5180+10, 40, 6, 23,
137 NL80211_RRF_PASSIVE_SCAN
),
138 /* IEEE 802.11a, channel 40 */
139 REG_RULE(5200-10, 5200+10, 40, 6, 23,
140 NL80211_RRF_PASSIVE_SCAN
),
141 /* IEEE 802.11a, channel 44 */
142 REG_RULE(5220-10, 5220+10, 40, 6, 23,
143 NL80211_RRF_PASSIVE_SCAN
),
144 /* IEEE 802.11a, channels 48..64 */
145 REG_RULE(5240-10, 5320+10, 40, 6, 20,
146 NL80211_RRF_NO_IBSS
|
148 /* IEEE 802.11a, channels 100..140 */
149 REG_RULE(5500-10, 5700+10, 40, 6, 30,
150 NL80211_RRF_NO_IBSS
|
155 static const struct ieee80211_regdomain
*static_regdom(char *alpha2
)
157 if (alpha2
[0] == 'U' && alpha2
[1] == 'S')
159 if (alpha2
[0] == 'J' && alpha2
[1] == 'P')
161 if (alpha2
[0] == 'E' && alpha2
[1] == 'U')
163 /* Default, as per the old rules */
167 static bool is_old_static_regdom(const struct ieee80211_regdomain
*rd
)
169 if (rd
== &us_regdom
|| rd
== &jp_regdom
|| rd
== &eu_regdom
)
174 static inline bool is_old_static_regdom(const struct ieee80211_regdomain
*rd
)
180 static void reset_regdomains(void)
182 /* avoid freeing static information or freeing something twice */
183 if (cfg80211_regdomain
== cfg80211_world_regdom
)
184 cfg80211_regdomain
= NULL
;
185 if (cfg80211_world_regdom
== &world_regdom
)
186 cfg80211_world_regdom
= NULL
;
187 if (cfg80211_regdomain
== &world_regdom
)
188 cfg80211_regdomain
= NULL
;
189 if (is_old_static_regdom(cfg80211_regdomain
))
190 cfg80211_regdomain
= NULL
;
192 kfree(cfg80211_regdomain
);
193 kfree(cfg80211_world_regdom
);
195 cfg80211_world_regdom
= &world_regdom
;
196 cfg80211_regdomain
= NULL
;
199 /* Dynamic world regulatory domain requested by the wireless
200 * core upon initialization */
201 static void update_world_regdomain(const struct ieee80211_regdomain
*rd
)
203 BUG_ON(!last_request
);
207 cfg80211_world_regdom
= rd
;
208 cfg80211_regdomain
= rd
;
211 bool is_world_regdom(const char *alpha2
)
215 if (alpha2
[0] == '0' && alpha2
[1] == '0')
220 static bool is_alpha2_set(const char *alpha2
)
224 if (alpha2
[0] != 0 && alpha2
[1] != 0)
229 static bool is_alpha_upper(char letter
)
232 if (letter
>= 65 && letter
<= 90)
237 static bool is_unknown_alpha2(const char *alpha2
)
241 /* Special case where regulatory domain was built by driver
242 * but a specific alpha2 cannot be determined */
243 if (alpha2
[0] == '9' && alpha2
[1] == '9')
248 static bool is_an_alpha2(const char *alpha2
)
252 if (is_alpha_upper(alpha2
[0]) && is_alpha_upper(alpha2
[1]))
257 static bool alpha2_equal(const char *alpha2_x
, const char *alpha2_y
)
259 if (!alpha2_x
|| !alpha2_y
)
261 if (alpha2_x
[0] == alpha2_y
[0] &&
262 alpha2_x
[1] == alpha2_y
[1])
267 static bool regdom_changed(const char *alpha2
)
269 if (!cfg80211_regdomain
)
271 if (alpha2_equal(cfg80211_regdomain
->alpha2
, alpha2
))
276 /* This lets us keep regulatory code which is updated on a regulatory
277 * basis in userspace. */
278 static int call_crda(const char *alpha2
)
280 char country_env
[9 + 2] = "COUNTRY=";
286 if (!is_world_regdom((char *) alpha2
))
287 printk(KERN_INFO
"cfg80211: Calling CRDA for country: %c%c\n",
288 alpha2
[0], alpha2
[1]);
290 printk(KERN_INFO
"cfg80211: Calling CRDA to update world "
291 "regulatory domain\n");
293 country_env
[8] = alpha2
[0];
294 country_env
[9] = alpha2
[1];
296 return kobject_uevent_env(®_pdev
->dev
.kobj
, KOBJ_CHANGE
, envp
);
299 /* This has the logic which determines when a new request
300 * should be ignored. */
301 static int ignore_request(struct wiphy
*wiphy
, enum reg_set_by set_by
,
302 char *alpha2
, struct ieee80211_regdomain
*rd
)
304 /* All initial requests are respected */
309 case REGDOM_SET_BY_INIT
:
311 case REGDOM_SET_BY_CORE
:
312 /* Always respect new wireless core hints, should only
313 * come in for updating the world regulatory domain at init
316 case REGDOM_SET_BY_COUNTRY_IE
:
317 if (last_request
->initiator
== REGDOM_SET_BY_COUNTRY_IE
) {
318 if (last_request
->wiphy
!= wiphy
) {
319 /* Two cards with two APs claiming different
320 * different Country IE alpha2s!
321 * You're special!! */
322 if (!alpha2_equal(last_request
->alpha2
,
323 cfg80211_regdomain
->alpha2
)) {
324 /* XXX: Deal with conflict, consider
325 * building a new one out of the
332 /* Two consecutive Country IE hints on the same wiphy */
333 if (!alpha2_equal(cfg80211_regdomain
->alpha2
, alpha2
))
337 if (WARN_ON(!is_alpha2_set(alpha2
) || !is_an_alpha2(alpha2
)),
338 "Invalid Country IE regulatory hint passed "
339 "to the wireless core\n")
341 /* We ignore Country IE hints for now, as we haven't yet
342 * added the dot11MultiDomainCapabilityEnabled flag
345 case REGDOM_SET_BY_DRIVER
:
347 if (last_request
->initiator
== REGDOM_SET_BY_DRIVER
) {
348 /* Two separate drivers hinting different things,
349 * this is possible if you have two devices present
350 * on a system with different EEPROM regulatory
351 * readings. XXX: Do intersection, we support only
352 * the first regulatory hint for now */
353 if (last_request
->wiphy
!= wiphy
)
357 /* Driver should not be trying to hint different
358 * regulatory domains! */
359 BUG_ON(!alpha2_equal(alpha2
,
360 cfg80211_regdomain
->alpha2
));
363 if (last_request
->initiator
== REGDOM_SET_BY_CORE
)
365 /* XXX: Handle intersection, and add the
366 * dot11MultiDomainCapabilityEnabled flag to wiphy. For now
367 * we assume the driver has this set to false, following the
368 * 802.11d dot11MultiDomainCapabilityEnabled documentation */
369 if (last_request
->initiator
== REGDOM_SET_BY_COUNTRY_IE
)
372 case REGDOM_SET_BY_USER
:
373 if (last_request
->initiator
== REGDOM_SET_BY_USER
||
374 last_request
->initiator
== REGDOM_SET_BY_CORE
)
376 /* Drivers can use their wiphy's reg_notifier()
377 * to override any information */
378 if (last_request
->initiator
== REGDOM_SET_BY_DRIVER
)
380 /* XXX: Handle intersection */
381 if (last_request
->initiator
== REGDOM_SET_BY_COUNTRY_IE
)
389 /* Used by nl80211 before kmalloc'ing our regulatory domain */
390 bool reg_is_valid_request(const char *alpha2
)
395 return alpha2_equal(last_request
->alpha2
, alpha2
);
398 /* Sanity check on a regulatory rule */
399 static bool is_valid_reg_rule(const struct ieee80211_reg_rule
*rule
)
401 const struct ieee80211_freq_range
*freq_range
= &rule
->freq_range
;
404 if (freq_range
->start_freq_khz
== 0 || freq_range
->end_freq_khz
== 0)
407 if (freq_range
->start_freq_khz
> freq_range
->end_freq_khz
)
410 freq_diff
= freq_range
->end_freq_khz
- freq_range
->start_freq_khz
;
412 if (freq_range
->max_bandwidth_khz
> freq_diff
)
418 static bool is_valid_rd(const struct ieee80211_regdomain
*rd
)
420 const struct ieee80211_reg_rule
*reg_rule
= NULL
;
423 if (!rd
->n_reg_rules
)
426 for (i
= 0; i
< rd
->n_reg_rules
; i
++) {
427 reg_rule
= &rd
->reg_rules
[i
];
428 if (!is_valid_reg_rule(reg_rule
))
435 /* Returns value in KHz */
436 static u32
freq_max_bandwidth(const struct ieee80211_freq_range
*freq_range
,
440 for (i
= 0; i
< ARRAY_SIZE(supported_bandwidths
); i
++) {
441 u32 start_freq_khz
= freq
- supported_bandwidths
[i
]/2;
442 u32 end_freq_khz
= freq
+ supported_bandwidths
[i
]/2;
443 if (start_freq_khz
>= freq_range
->start_freq_khz
&&
444 end_freq_khz
<= freq_range
->end_freq_khz
)
445 return supported_bandwidths
[i
];
450 /* XXX: add support for the rest of enum nl80211_reg_rule_flags, we may
451 * want to just have the channel structure use these */
452 static u32
map_regdom_flags(u32 rd_flags
)
454 u32 channel_flags
= 0;
455 if (rd_flags
& NL80211_RRF_PASSIVE_SCAN
)
456 channel_flags
|= IEEE80211_CHAN_PASSIVE_SCAN
;
457 if (rd_flags
& NL80211_RRF_NO_IBSS
)
458 channel_flags
|= IEEE80211_CHAN_NO_IBSS
;
459 if (rd_flags
& NL80211_RRF_DFS
)
460 channel_flags
|= IEEE80211_CHAN_RADAR
;
461 return channel_flags
;
465 * freq_reg_info - get regulatory information for the given frequency
466 * @center_freq: Frequency in KHz for which we want regulatory information for
467 * @bandwidth: the bandwidth requirement you have in KHz, if you do not have one
468 * you can set this to 0. If this frequency is allowed we then set
469 * this value to the maximum allowed bandwidth.
470 * @reg_rule: the regulatory rule which we have for this frequency
472 * Use this function to get the regulatory rule for a specific frequency.
474 static int freq_reg_info(u32 center_freq
, u32
*bandwidth
,
475 const struct ieee80211_reg_rule
**reg_rule
)
478 u32 max_bandwidth
= 0;
480 if (!cfg80211_regdomain
)
483 for (i
= 0; i
< cfg80211_regdomain
->n_reg_rules
; i
++) {
484 const struct ieee80211_reg_rule
*rr
;
485 const struct ieee80211_freq_range
*fr
= NULL
;
486 const struct ieee80211_power_rule
*pr
= NULL
;
488 rr
= &cfg80211_regdomain
->reg_rules
[i
];
489 fr
= &rr
->freq_range
;
490 pr
= &rr
->power_rule
;
491 max_bandwidth
= freq_max_bandwidth(fr
, center_freq
);
492 if (max_bandwidth
&& *bandwidth
<= max_bandwidth
) {
494 *bandwidth
= max_bandwidth
;
499 return !max_bandwidth
;
502 static void handle_channel(struct ieee80211_channel
*chan
)
505 u32 flags
= chan
->orig_flags
;
506 u32 max_bandwidth
= 0;
507 const struct ieee80211_reg_rule
*reg_rule
= NULL
;
508 const struct ieee80211_power_rule
*power_rule
= NULL
;
510 r
= freq_reg_info(MHZ_TO_KHZ(chan
->center_freq
),
511 &max_bandwidth
, ®_rule
);
514 flags
|= IEEE80211_CHAN_DISABLED
;
519 power_rule
= ®_rule
->power_rule
;
521 chan
->flags
= flags
| map_regdom_flags(reg_rule
->flags
);
522 chan
->max_antenna_gain
= min(chan
->orig_mag
,
523 (int) MBI_TO_DBI(power_rule
->max_antenna_gain
));
524 chan
->max_bandwidth
= KHZ_TO_MHZ(max_bandwidth
);
526 chan
->max_power
= min(chan
->orig_mpwr
,
527 (int) MBM_TO_DBM(power_rule
->max_eirp
));
529 chan
->max_power
= (int) MBM_TO_DBM(power_rule
->max_eirp
);
532 static void handle_band(struct ieee80211_supported_band
*sband
)
536 for (i
= 0; i
< sband
->n_channels
; i
++)
537 handle_channel(&sband
->channels
[i
]);
540 static void update_all_wiphy_regulatory(enum reg_set_by setby
)
542 struct cfg80211_registered_device
*drv
;
544 list_for_each_entry(drv
, &cfg80211_drv_list
, list
)
545 wiphy_update_regulatory(&drv
->wiphy
, setby
);
548 void wiphy_update_regulatory(struct wiphy
*wiphy
, enum reg_set_by setby
)
550 enum ieee80211_band band
;
551 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
552 if (wiphy
->bands
[band
])
553 handle_band(wiphy
->bands
[band
]);
554 if (wiphy
->reg_notifier
)
555 wiphy
->reg_notifier(wiphy
, setby
);
559 /* Caller must hold &cfg80211_drv_mutex */
560 int __regulatory_hint(struct wiphy
*wiphy
, enum reg_set_by set_by
,
561 const char *alpha2
, struct ieee80211_regdomain
*rd
)
563 struct regulatory_request
*request
;
567 r
= ignore_request(wiphy
, set_by
, (char *) alpha2
, rd
);
572 rd_alpha2
= rd
->alpha2
;
574 rd_alpha2
= (char *) alpha2
;
577 case REGDOM_SET_BY_CORE
:
578 case REGDOM_SET_BY_COUNTRY_IE
:
579 case REGDOM_SET_BY_DRIVER
:
580 case REGDOM_SET_BY_USER
:
581 request
= kzalloc(sizeof(struct regulatory_request
),
586 request
->alpha2
[0] = rd_alpha2
[0];
587 request
->alpha2
[1] = rd_alpha2
[1];
588 request
->initiator
= set_by
;
589 request
->wiphy
= wiphy
;
592 last_request
= request
;
595 r
= call_crda(alpha2
);
596 #ifndef CONFIG_WIRELESS_OLD_REGULATORY
598 printk(KERN_ERR
"cfg80211: Failed calling CRDA\n");
609 /* If rd is not NULL and if this call fails the caller must free it */
610 int regulatory_hint(struct wiphy
*wiphy
, const char *alpha2
,
611 struct ieee80211_regdomain
*rd
)
614 BUG_ON(!rd
&& !alpha2
);
616 mutex_lock(&cfg80211_drv_mutex
);
618 r
= __regulatory_hint(wiphy
, REGDOM_SET_BY_DRIVER
, alpha2
, rd
);
620 goto unlock_and_exit
;
622 /* If the driver passed a regulatory domain we skipped asking
623 * userspace for one so we can now go ahead and set it */
627 mutex_unlock(&cfg80211_drv_mutex
);
630 EXPORT_SYMBOL(regulatory_hint
);
633 static void print_rd_rules(const struct ieee80211_regdomain
*rd
)
636 const struct ieee80211_reg_rule
*reg_rule
= NULL
;
637 const struct ieee80211_freq_range
*freq_range
= NULL
;
638 const struct ieee80211_power_rule
*power_rule
= NULL
;
640 printk(KERN_INFO
"\t(start_freq - end_freq @ bandwidth), "
641 "(max_antenna_gain, max_eirp)\n");
643 for (i
= 0; i
< rd
->n_reg_rules
; i
++) {
644 reg_rule
= &rd
->reg_rules
[i
];
645 freq_range
= ®_rule
->freq_range
;
646 power_rule
= ®_rule
->power_rule
;
648 /* There may not be documentation for max antenna gain
649 * in certain regions */
650 if (power_rule
->max_antenna_gain
)
651 printk(KERN_INFO
"\t(%d KHz - %d KHz @ %d KHz), "
652 "(%d mBi, %d mBm)\n",
653 freq_range
->start_freq_khz
,
654 freq_range
->end_freq_khz
,
655 freq_range
->max_bandwidth_khz
,
656 power_rule
->max_antenna_gain
,
657 power_rule
->max_eirp
);
659 printk(KERN_INFO
"\t(%d KHz - %d KHz @ %d KHz), "
661 freq_range
->start_freq_khz
,
662 freq_range
->end_freq_khz
,
663 freq_range
->max_bandwidth_khz
,
664 power_rule
->max_eirp
);
668 static void print_regdomain(const struct ieee80211_regdomain
*rd
)
671 if (is_world_regdom(rd
->alpha2
))
672 printk(KERN_INFO
"cfg80211: World regulatory "
673 "domain updated:\n");
675 if (is_unknown_alpha2(rd
->alpha2
))
676 printk(KERN_INFO
"cfg80211: Regulatory domain "
677 "changed to driver built-in settings "
678 "(unknown country)\n");
680 printk(KERN_INFO
"cfg80211: Regulatory domain "
681 "changed to country: %c%c\n",
682 rd
->alpha2
[0], rd
->alpha2
[1]);
687 void print_regdomain_info(const struct ieee80211_regdomain
*rd
)
689 printk(KERN_INFO
"cfg80211: Regulatory domain: %c%c\n",
690 rd
->alpha2
[0], rd
->alpha2
[1]);
694 static int __set_regdom(const struct ieee80211_regdomain
*rd
)
696 /* Some basic sanity checks first */
698 if (is_world_regdom(rd
->alpha2
)) {
699 if (WARN_ON(!reg_is_valid_request(rd
->alpha2
)))
701 update_world_regdomain(rd
);
705 if (!is_alpha2_set(rd
->alpha2
) && !is_an_alpha2(rd
->alpha2
) &&
706 !is_unknown_alpha2(rd
->alpha2
))
712 /* allow overriding the static definitions if CRDA is present */
713 if (!is_old_static_regdom(cfg80211_regdomain
) &&
714 !regdom_changed(rd
->alpha2
))
717 /* Now lets set the regulatory domain, update all driver channels
718 * and finally inform them of what we have done, in case they want
719 * to review or adjust their own settings based on their own
720 * internal EEPROM data */
722 if (WARN_ON(!reg_is_valid_request(rd
->alpha2
)))
727 /* Country IE parsing coming soon */
728 switch (last_request
->initiator
) {
729 case REGDOM_SET_BY_CORE
:
730 case REGDOM_SET_BY_DRIVER
:
731 case REGDOM_SET_BY_USER
:
732 if (!is_valid_rd(rd
)) {
733 printk(KERN_ERR
"cfg80211: Invalid "
734 "regulatory domain detected:\n");
735 print_regdomain_info(rd
);
739 case REGDOM_SET_BY_COUNTRY_IE
: /* Not yet */
746 cfg80211_regdomain
= rd
;
747 last_request
->granted
= 1;
753 /* Use this call to set the current regulatory domain. Conflicts with
754 * multiple drivers can be ironed out later. Caller must've already
755 * kmalloc'd the rd structure. If this calls fails you should kfree()
756 * the passed rd. Caller must hold cfg80211_drv_mutex */
757 int set_regdom(const struct ieee80211_regdomain
*rd
)
761 /* Note that this doesn't update the wiphys, this is done below */
762 r
= __set_regdom(rd
);
766 /* This would make this whole thing pointless */
767 BUG_ON(rd
!= cfg80211_regdomain
);
769 /* update all wiphys now with the new established regulatory domain */
770 update_all_wiphy_regulatory(last_request
->initiator
);
777 int regulatory_init(void)
781 reg_pdev
= platform_device_register_simple("regulatory", 0, NULL
, 0);
782 if (IS_ERR(reg_pdev
))
783 return PTR_ERR(reg_pdev
);
785 #ifdef CONFIG_WIRELESS_OLD_REGULATORY
786 cfg80211_regdomain
= static_regdom(ieee80211_regdom
);
788 printk(KERN_INFO
"cfg80211: Using static regulatory domain info\n");
789 print_regdomain_info(cfg80211_regdomain
);
790 /* The old code still requests for a new regdomain and if
791 * you have CRDA you get it updated, otherwise you get
792 * stuck with the static values. We ignore "EU" code as
793 * that is not a valid ISO / IEC 3166 alpha2 */
794 if (ieee80211_regdom
[0] != 'E' || ieee80211_regdom
[1] != 'U')
795 err
= __regulatory_hint(NULL
, REGDOM_SET_BY_CORE
,
796 ieee80211_regdom
, NULL
);
798 cfg80211_regdomain
= cfg80211_world_regdom
;
800 err
= __regulatory_hint(NULL
, REGDOM_SET_BY_CORE
, "00", NULL
);
802 printk(KERN_ERR
"cfg80211: calling CRDA failed - "
803 "unable to update world regulatory domain, "
804 "using static definition\n");
810 void regulatory_exit(void)
812 mutex_lock(&cfg80211_drv_mutex
);
818 platform_device_unregister(reg_pdev
);
820 mutex_unlock(&cfg80211_drv_mutex
);