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
64 struct regulatory_request
{
66 enum reg_set_by initiator
;
71 /* Receipt of information from last regulatory request */
72 static struct regulatory_request
*last_request
;
74 /* To trigger userspace events */
75 static struct platform_device
*reg_pdev
;
77 /* Keep the ordering from large to small */
78 static u32 supported_bandwidths
[] = {
83 /* Central wireless core regulatory domains, we only need two,
84 * the current one and a world regulatory domain in case we have no
85 * information to give us an alpha2 */
86 static const struct ieee80211_regdomain
*cfg80211_regdomain
;
88 /* We keep a static world regulatory domain in case of the absence of CRDA */
89 static const struct ieee80211_regdomain world_regdom
= {
93 REG_RULE(2412-10, 2462+10, 40, 6, 20,
94 NL80211_RRF_PASSIVE_SCAN
|
99 static const struct ieee80211_regdomain
*cfg80211_world_regdom
=
102 #ifdef CONFIG_WIRELESS_OLD_REGULATORY
103 static char *ieee80211_regdom
= "US";
104 module_param(ieee80211_regdom
, charp
, 0444);
105 MODULE_PARM_DESC(ieee80211_regdom
, "IEEE 802.11 regulatory domain code");
107 /* We assume 40 MHz bandwidth for the old regulatory work.
108 * We make emphasis we are using the exact same frequencies
111 static const struct ieee80211_regdomain us_regdom
= {
115 /* IEEE 802.11b/g, channels 1..11 */
116 REG_RULE(2412-10, 2462+10, 40, 6, 27, 0),
117 /* IEEE 802.11a, channel 36 */
118 REG_RULE(5180-10, 5180+10, 40, 6, 23, 0),
119 /* IEEE 802.11a, channel 40 */
120 REG_RULE(5200-10, 5200+10, 40, 6, 23, 0),
121 /* IEEE 802.11a, channel 44 */
122 REG_RULE(5220-10, 5220+10, 40, 6, 23, 0),
123 /* IEEE 802.11a, channels 48..64 */
124 REG_RULE(5240-10, 5320+10, 40, 6, 23, 0),
125 /* IEEE 802.11a, channels 149..165, outdoor */
126 REG_RULE(5745-10, 5825+10, 40, 6, 30, 0),
130 static const struct ieee80211_regdomain jp_regdom
= {
134 /* IEEE 802.11b/g, channels 1..14 */
135 REG_RULE(2412-10, 2484+10, 40, 6, 20, 0),
136 /* IEEE 802.11a, channels 34..48 */
137 REG_RULE(5170-10, 5240+10, 40, 6, 20,
138 NL80211_RRF_PASSIVE_SCAN
),
139 /* IEEE 802.11a, channels 52..64 */
140 REG_RULE(5260-10, 5320+10, 40, 6, 20,
141 NL80211_RRF_NO_IBSS
|
146 static const struct ieee80211_regdomain eu_regdom
= {
148 /* This alpha2 is bogus, we leave it here just for stupid
149 * backward compatibility */
152 /* IEEE 802.11b/g, channels 1..13 */
153 REG_RULE(2412-10, 2472+10, 40, 6, 20, 0),
154 /* IEEE 802.11a, channel 36 */
155 REG_RULE(5180-10, 5180+10, 40, 6, 23,
156 NL80211_RRF_PASSIVE_SCAN
),
157 /* IEEE 802.11a, channel 40 */
158 REG_RULE(5200-10, 5200+10, 40, 6, 23,
159 NL80211_RRF_PASSIVE_SCAN
),
160 /* IEEE 802.11a, channel 44 */
161 REG_RULE(5220-10, 5220+10, 40, 6, 23,
162 NL80211_RRF_PASSIVE_SCAN
),
163 /* IEEE 802.11a, channels 48..64 */
164 REG_RULE(5240-10, 5320+10, 40, 6, 20,
165 NL80211_RRF_NO_IBSS
|
167 /* IEEE 802.11a, channels 100..140 */
168 REG_RULE(5500-10, 5700+10, 40, 6, 30,
169 NL80211_RRF_NO_IBSS
|
174 static const struct ieee80211_regdomain
*static_regdom(char *alpha2
)
176 if (alpha2
[0] == 'U' && alpha2
[1] == 'S')
178 if (alpha2
[0] == 'J' && alpha2
[1] == 'P')
180 if (alpha2
[0] == 'E' && alpha2
[1] == 'U')
182 /* Default, as per the old rules */
186 static bool is_old_static_regdom(const struct ieee80211_regdomain
*rd
)
188 if (rd
== &us_regdom
|| rd
== &jp_regdom
|| rd
== &eu_regdom
)
193 static inline bool is_old_static_regdom(const struct ieee80211_regdomain
*rd
)
199 static void reset_regdomains(void)
201 /* avoid freeing static information or freeing something twice */
202 if (cfg80211_regdomain
== cfg80211_world_regdom
)
203 cfg80211_regdomain
= NULL
;
204 if (cfg80211_world_regdom
== &world_regdom
)
205 cfg80211_world_regdom
= NULL
;
206 if (cfg80211_regdomain
== &world_regdom
)
207 cfg80211_regdomain
= NULL
;
208 if (is_old_static_regdom(cfg80211_regdomain
))
209 cfg80211_regdomain
= NULL
;
211 kfree(cfg80211_regdomain
);
212 kfree(cfg80211_world_regdom
);
214 cfg80211_world_regdom
= &world_regdom
;
215 cfg80211_regdomain
= NULL
;
218 /* Dynamic world regulatory domain requested by the wireless
219 * core upon initialization */
220 static void update_world_regdomain(const struct ieee80211_regdomain
*rd
)
222 BUG_ON(!last_request
);
226 cfg80211_world_regdom
= rd
;
227 cfg80211_regdomain
= rd
;
230 bool is_world_regdom(const char *alpha2
)
234 if (alpha2
[0] == '0' && alpha2
[1] == '0')
239 static bool is_alpha2_set(const char *alpha2
)
243 if (alpha2
[0] != 0 && alpha2
[1] != 0)
248 static bool is_alpha_upper(char letter
)
251 if (letter
>= 65 && letter
<= 90)
256 static bool is_unknown_alpha2(const char *alpha2
)
260 /* Special case where regulatory domain was built by driver
261 * but a specific alpha2 cannot be determined */
262 if (alpha2
[0] == '9' && alpha2
[1] == '9')
267 static bool is_an_alpha2(const char *alpha2
)
271 if (is_alpha_upper(alpha2
[0]) && is_alpha_upper(alpha2
[1]))
276 static bool alpha2_equal(const char *alpha2_x
, const char *alpha2_y
)
278 if (!alpha2_x
|| !alpha2_y
)
280 if (alpha2_x
[0] == alpha2_y
[0] &&
281 alpha2_x
[1] == alpha2_y
[1])
286 static bool regdom_changed(const char *alpha2
)
288 if (!cfg80211_regdomain
)
290 if (alpha2_equal(cfg80211_regdomain
->alpha2
, alpha2
))
295 /* This lets us keep regulatory code which is updated on a regulatory
296 * basis in userspace. */
297 static int call_crda(const char *alpha2
)
299 char country_env
[9 + 2] = "COUNTRY=";
305 if (!is_world_regdom((char *) alpha2
))
306 printk(KERN_INFO
"cfg80211: Calling CRDA for country: %c%c\n",
307 alpha2
[0], alpha2
[1]);
309 printk(KERN_INFO
"cfg80211: Calling CRDA to update world "
310 "regulatory domain\n");
312 country_env
[8] = alpha2
[0];
313 country_env
[9] = alpha2
[1];
315 return kobject_uevent_env(®_pdev
->dev
.kobj
, KOBJ_CHANGE
, envp
);
318 /* Used by nl80211 before kmalloc'ing our regulatory domain */
319 bool reg_is_valid_request(const char *alpha2
)
324 return alpha2_equal(last_request
->alpha2
, alpha2
);
327 /* Sanity check on a regulatory rule */
328 static bool is_valid_reg_rule(const struct ieee80211_reg_rule
*rule
)
330 const struct ieee80211_freq_range
*freq_range
= &rule
->freq_range
;
333 if (freq_range
->start_freq_khz
<= 0 || freq_range
->end_freq_khz
<= 0)
336 if (freq_range
->start_freq_khz
> freq_range
->end_freq_khz
)
339 freq_diff
= freq_range
->end_freq_khz
- freq_range
->start_freq_khz
;
341 if (freq_diff
<= 0 || freq_range
->max_bandwidth_khz
> freq_diff
)
347 static bool is_valid_rd(const struct ieee80211_regdomain
*rd
)
349 const struct ieee80211_reg_rule
*reg_rule
= NULL
;
352 if (!rd
->n_reg_rules
)
355 for (i
= 0; i
< rd
->n_reg_rules
; i
++) {
356 reg_rule
= &rd
->reg_rules
[i
];
357 if (!is_valid_reg_rule(reg_rule
))
364 /* Returns value in KHz */
365 static u32
freq_max_bandwidth(const struct ieee80211_freq_range
*freq_range
,
369 for (i
= 0; i
< ARRAY_SIZE(supported_bandwidths
); i
++) {
370 u32 start_freq_khz
= freq
- supported_bandwidths
[i
]/2;
371 u32 end_freq_khz
= freq
+ supported_bandwidths
[i
]/2;
372 if (start_freq_khz
>= freq_range
->start_freq_khz
&&
373 end_freq_khz
<= freq_range
->end_freq_khz
)
374 return supported_bandwidths
[i
];
379 /* Helper for regdom_intersect(), this does the real
380 * mathematical intersection fun */
381 static int reg_rules_intersect(
382 const struct ieee80211_reg_rule
*rule1
,
383 const struct ieee80211_reg_rule
*rule2
,
384 struct ieee80211_reg_rule
*intersected_rule
)
386 const struct ieee80211_freq_range
*freq_range1
, *freq_range2
;
387 struct ieee80211_freq_range
*freq_range
;
388 const struct ieee80211_power_rule
*power_rule1
, *power_rule2
;
389 struct ieee80211_power_rule
*power_rule
;
392 freq_range1
= &rule1
->freq_range
;
393 freq_range2
= &rule2
->freq_range
;
394 freq_range
= &intersected_rule
->freq_range
;
396 power_rule1
= &rule1
->power_rule
;
397 power_rule2
= &rule2
->power_rule
;
398 power_rule
= &intersected_rule
->power_rule
;
400 freq_range
->start_freq_khz
= max(freq_range1
->start_freq_khz
,
401 freq_range2
->start_freq_khz
);
402 freq_range
->end_freq_khz
= min(freq_range1
->end_freq_khz
,
403 freq_range2
->end_freq_khz
);
404 freq_range
->max_bandwidth_khz
= min(freq_range1
->max_bandwidth_khz
,
405 freq_range2
->max_bandwidth_khz
);
407 freq_diff
= freq_range
->end_freq_khz
- freq_range
->start_freq_khz
;
408 if (freq_range
->max_bandwidth_khz
> freq_diff
)
409 freq_range
->max_bandwidth_khz
= freq_diff
;
411 power_rule
->max_eirp
= min(power_rule1
->max_eirp
,
412 power_rule2
->max_eirp
);
413 power_rule
->max_antenna_gain
= min(power_rule1
->max_antenna_gain
,
414 power_rule2
->max_antenna_gain
);
416 intersected_rule
->flags
= (rule1
->flags
| rule2
->flags
);
418 if (!is_valid_reg_rule(intersected_rule
))
425 * regdom_intersect - do the intersection between two regulatory domains
426 * @rd1: first regulatory domain
427 * @rd2: second regulatory domain
429 * Use this function to get the intersection between two regulatory domains.
430 * Once completed we will mark the alpha2 for the rd as intersected, "98",
431 * as no one single alpha2 can represent this regulatory domain.
433 * Returns a pointer to the regulatory domain structure which will hold the
434 * resulting intersection of rules between rd1 and rd2. We will
435 * kzalloc() this structure for you.
437 static struct ieee80211_regdomain
*regdom_intersect(
438 const struct ieee80211_regdomain
*rd1
,
439 const struct ieee80211_regdomain
*rd2
)
443 unsigned int num_rules
= 0, rule_idx
= 0;
444 const struct ieee80211_reg_rule
*rule1
, *rule2
;
445 struct ieee80211_reg_rule
*intersected_rule
;
446 struct ieee80211_regdomain
*rd
;
447 /* This is just a dummy holder to help us count */
448 struct ieee80211_reg_rule irule
;
450 /* Uses the stack temporarily for counter arithmetic */
451 intersected_rule
= &irule
;
453 memset(intersected_rule
, 0, sizeof(struct ieee80211_reg_rule
));
458 /* First we get a count of the rules we'll need, then we actually
459 * build them. This is to so we can malloc() and free() a
460 * regdomain once. The reason we use reg_rules_intersect() here
461 * is it will return -EINVAL if the rule computed makes no sense.
462 * All rules that do check out OK are valid. */
464 for (x
= 0; x
< rd1
->n_reg_rules
; x
++) {
465 rule1
= &rd1
->reg_rules
[x
];
466 for (y
= 0; y
< rd2
->n_reg_rules
; y
++) {
467 rule2
= &rd2
->reg_rules
[y
];
468 if (!reg_rules_intersect(rule1
, rule2
,
471 memset(intersected_rule
, 0,
472 sizeof(struct ieee80211_reg_rule
));
479 size_of_regd
= sizeof(struct ieee80211_regdomain
) +
480 ((num_rules
+ 1) * sizeof(struct ieee80211_reg_rule
));
482 rd
= kzalloc(size_of_regd
, GFP_KERNEL
);
486 for (x
= 0; x
< rd1
->n_reg_rules
; x
++) {
487 rule1
= &rd1
->reg_rules
[x
];
488 for (y
= 0; y
< rd2
->n_reg_rules
; y
++) {
489 rule2
= &rd2
->reg_rules
[y
];
490 /* This time around instead of using the stack lets
491 * write to the target rule directly saving ourselves
493 intersected_rule
= &rd
->reg_rules
[rule_idx
];
494 r
= reg_rules_intersect(rule1
, rule2
,
496 /* No need to memset here the intersected rule here as
497 * we're not using the stack anymore */
504 if (rule_idx
!= num_rules
) {
509 rd
->n_reg_rules
= num_rules
;
516 /* XXX: add support for the rest of enum nl80211_reg_rule_flags, we may
517 * want to just have the channel structure use these */
518 static u32
map_regdom_flags(u32 rd_flags
)
520 u32 channel_flags
= 0;
521 if (rd_flags
& NL80211_RRF_PASSIVE_SCAN
)
522 channel_flags
|= IEEE80211_CHAN_PASSIVE_SCAN
;
523 if (rd_flags
& NL80211_RRF_NO_IBSS
)
524 channel_flags
|= IEEE80211_CHAN_NO_IBSS
;
525 if (rd_flags
& NL80211_RRF_DFS
)
526 channel_flags
|= IEEE80211_CHAN_RADAR
;
527 return channel_flags
;
531 * freq_reg_info - get regulatory information for the given frequency
532 * @center_freq: Frequency in KHz for which we want regulatory information for
533 * @bandwidth: the bandwidth requirement you have in KHz, if you do not have one
534 * you can set this to 0. If this frequency is allowed we then set
535 * this value to the maximum allowed bandwidth.
536 * @reg_rule: the regulatory rule which we have for this frequency
538 * Use this function to get the regulatory rule for a specific frequency.
540 static int freq_reg_info(u32 center_freq
, u32
*bandwidth
,
541 const struct ieee80211_reg_rule
**reg_rule
)
544 u32 max_bandwidth
= 0;
546 if (!cfg80211_regdomain
)
549 for (i
= 0; i
< cfg80211_regdomain
->n_reg_rules
; i
++) {
550 const struct ieee80211_reg_rule
*rr
;
551 const struct ieee80211_freq_range
*fr
= NULL
;
552 const struct ieee80211_power_rule
*pr
= NULL
;
554 rr
= &cfg80211_regdomain
->reg_rules
[i
];
555 fr
= &rr
->freq_range
;
556 pr
= &rr
->power_rule
;
557 max_bandwidth
= freq_max_bandwidth(fr
, center_freq
);
558 if (max_bandwidth
&& *bandwidth
<= max_bandwidth
) {
560 *bandwidth
= max_bandwidth
;
565 return !max_bandwidth
;
568 static void handle_channel(struct ieee80211_channel
*chan
)
571 u32 flags
= chan
->orig_flags
;
572 u32 max_bandwidth
= 0;
573 const struct ieee80211_reg_rule
*reg_rule
= NULL
;
574 const struct ieee80211_power_rule
*power_rule
= NULL
;
576 r
= freq_reg_info(MHZ_TO_KHZ(chan
->center_freq
),
577 &max_bandwidth
, ®_rule
);
580 flags
|= IEEE80211_CHAN_DISABLED
;
585 power_rule
= ®_rule
->power_rule
;
587 chan
->flags
= flags
| map_regdom_flags(reg_rule
->flags
);
588 chan
->max_antenna_gain
= min(chan
->orig_mag
,
589 (int) MBI_TO_DBI(power_rule
->max_antenna_gain
));
590 chan
->max_bandwidth
= KHZ_TO_MHZ(max_bandwidth
);
592 chan
->max_power
= min(chan
->orig_mpwr
,
593 (int) MBM_TO_DBM(power_rule
->max_eirp
));
595 chan
->max_power
= (int) MBM_TO_DBM(power_rule
->max_eirp
);
598 static void handle_band(struct ieee80211_supported_band
*sband
)
602 for (i
= 0; i
< sband
->n_channels
; i
++)
603 handle_channel(&sband
->channels
[i
]);
606 static void update_all_wiphy_regulatory(enum reg_set_by setby
)
608 struct cfg80211_registered_device
*drv
;
610 list_for_each_entry(drv
, &cfg80211_drv_list
, list
)
611 wiphy_update_regulatory(&drv
->wiphy
, setby
);
614 void wiphy_update_regulatory(struct wiphy
*wiphy
, enum reg_set_by setby
)
616 enum ieee80211_band band
;
617 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
618 if (wiphy
->bands
[band
])
619 handle_band(wiphy
->bands
[band
]);
620 if (wiphy
->reg_notifier
)
621 wiphy
->reg_notifier(wiphy
, setby
);
625 /* Return value which can be used by ignore_request() to indicate
626 * it has been determined we should intersect two regulatory domains */
627 #define REG_INTERSECT 1
629 /* This has the logic which determines when a new request
630 * should be ignored. */
631 static int ignore_request(struct wiphy
*wiphy
, enum reg_set_by set_by
,
634 /* All initial requests are respected */
639 case REGDOM_SET_BY_INIT
:
641 case REGDOM_SET_BY_CORE
:
643 * Always respect new wireless core hints, should only happen
644 * when updating the world regulatory domain at init.
647 case REGDOM_SET_BY_COUNTRY_IE
:
648 if (unlikely(!is_an_alpha2(alpha2
)))
650 if (last_request
->initiator
== REGDOM_SET_BY_COUNTRY_IE
) {
651 if (last_request
->wiphy
!= wiphy
) {
653 * Two cards with two APs claiming different
654 * different Country IE alpha2s. We could
655 * intersect them, but that seems unlikely
656 * to be correct. Reject second one for now.
658 if (!alpha2_equal(alpha2
,
659 cfg80211_regdomain
->alpha2
))
663 /* Two consecutive Country IE hints on the same wiphy */
664 if (!alpha2_equal(cfg80211_regdomain
->alpha2
, alpha2
))
669 * Ignore Country IE hints for now, need to think about
670 * what we need to do to support multi-domain operation.
673 case REGDOM_SET_BY_DRIVER
:
674 if (last_request
->initiator
== REGDOM_SET_BY_DRIVER
)
677 case REGDOM_SET_BY_USER
:
678 if (last_request
->initiator
== REGDOM_SET_BY_COUNTRY_IE
)
679 return REG_INTERSECT
;
686 /* Caller must hold &cfg80211_drv_mutex */
687 int __regulatory_hint(struct wiphy
*wiphy
, enum reg_set_by set_by
,
690 struct regulatory_request
*request
;
691 bool intersect
= false;
694 r
= ignore_request(wiphy
, set_by
, alpha2
);
696 if (r
== REG_INTERSECT
)
701 request
= kzalloc(sizeof(struct regulatory_request
),
706 request
->alpha2
[0] = alpha2
[0];
707 request
->alpha2
[1] = alpha2
[1];
708 request
->initiator
= set_by
;
709 request
->wiphy
= wiphy
;
710 request
->intersect
= intersect
;
713 last_request
= request
;
714 return call_crda(alpha2
);
717 void regulatory_hint(struct wiphy
*wiphy
, const char *alpha2
)
721 mutex_lock(&cfg80211_drv_mutex
);
722 __regulatory_hint(wiphy
, REGDOM_SET_BY_DRIVER
, alpha2
);
723 mutex_unlock(&cfg80211_drv_mutex
);
725 EXPORT_SYMBOL(regulatory_hint
);
728 static void print_rd_rules(const struct ieee80211_regdomain
*rd
)
731 const struct ieee80211_reg_rule
*reg_rule
= NULL
;
732 const struct ieee80211_freq_range
*freq_range
= NULL
;
733 const struct ieee80211_power_rule
*power_rule
= NULL
;
735 printk(KERN_INFO
"\t(start_freq - end_freq @ bandwidth), "
736 "(max_antenna_gain, max_eirp)\n");
738 for (i
= 0; i
< rd
->n_reg_rules
; i
++) {
739 reg_rule
= &rd
->reg_rules
[i
];
740 freq_range
= ®_rule
->freq_range
;
741 power_rule
= ®_rule
->power_rule
;
743 /* There may not be documentation for max antenna gain
744 * in certain regions */
745 if (power_rule
->max_antenna_gain
)
746 printk(KERN_INFO
"\t(%d KHz - %d KHz @ %d KHz), "
747 "(%d mBi, %d mBm)\n",
748 freq_range
->start_freq_khz
,
749 freq_range
->end_freq_khz
,
750 freq_range
->max_bandwidth_khz
,
751 power_rule
->max_antenna_gain
,
752 power_rule
->max_eirp
);
754 printk(KERN_INFO
"\t(%d KHz - %d KHz @ %d KHz), "
756 freq_range
->start_freq_khz
,
757 freq_range
->end_freq_khz
,
758 freq_range
->max_bandwidth_khz
,
759 power_rule
->max_eirp
);
763 static void print_regdomain(const struct ieee80211_regdomain
*rd
)
766 if (is_world_regdom(rd
->alpha2
))
767 printk(KERN_INFO
"cfg80211: World regulatory "
768 "domain updated:\n");
770 if (is_unknown_alpha2(rd
->alpha2
))
771 printk(KERN_INFO
"cfg80211: Regulatory domain "
772 "changed to driver built-in settings "
773 "(unknown country)\n");
775 printk(KERN_INFO
"cfg80211: Regulatory domain "
776 "changed to country: %c%c\n",
777 rd
->alpha2
[0], rd
->alpha2
[1]);
782 static void print_regdomain_info(const struct ieee80211_regdomain
*rd
)
784 printk(KERN_INFO
"cfg80211: Regulatory domain: %c%c\n",
785 rd
->alpha2
[0], rd
->alpha2
[1]);
789 /* Takes ownership of rd only if it doesn't fail */
790 static int __set_regdom(const struct ieee80211_regdomain
*rd
)
792 const struct ieee80211_regdomain
*intersected_rd
= NULL
;
793 /* Some basic sanity checks first */
795 if (is_world_regdom(rd
->alpha2
)) {
796 if (WARN_ON(!reg_is_valid_request(rd
->alpha2
)))
798 update_world_regdomain(rd
);
802 if (!is_alpha2_set(rd
->alpha2
) && !is_an_alpha2(rd
->alpha2
) &&
803 !is_unknown_alpha2(rd
->alpha2
))
809 /* allow overriding the static definitions if CRDA is present */
810 if (!is_old_static_regdom(cfg80211_regdomain
) &&
811 !regdom_changed(rd
->alpha2
))
814 /* Now lets set the regulatory domain, update all driver channels
815 * and finally inform them of what we have done, in case they want
816 * to review or adjust their own settings based on their own
817 * internal EEPROM data */
819 if (WARN_ON(!reg_is_valid_request(rd
->alpha2
)))
822 if (!is_valid_rd(rd
)) {
823 printk(KERN_ERR
"cfg80211: Invalid "
824 "regulatory domain detected:\n");
825 print_regdomain_info(rd
);
829 if (!last_request
->intersect
) {
831 cfg80211_regdomain
= rd
;
835 /* Intersection requires a bit more work */
837 if (last_request
->initiator
!= REGDOM_SET_BY_COUNTRY_IE
) {
839 intersected_rd
= regdom_intersect(rd
, cfg80211_regdomain
);
843 /* We can trash what CRDA provided now */
848 cfg80211_regdomain
= intersected_rd
;
853 /* Country IE parsing coming soon */
861 /* Use this call to set the current regulatory domain. Conflicts with
862 * multiple drivers can be ironed out later. Caller must've already
863 * kmalloc'd the rd structure. Caller must hold cfg80211_drv_mutex */
864 int set_regdom(const struct ieee80211_regdomain
*rd
)
868 /* Note that this doesn't update the wiphys, this is done below */
869 r
= __set_regdom(rd
);
875 /* This would make this whole thing pointless */
876 if (!last_request
->intersect
)
877 BUG_ON(rd
!= cfg80211_regdomain
);
879 /* update all wiphys now with the new established regulatory domain */
880 update_all_wiphy_regulatory(last_request
->initiator
);
882 print_regdomain(cfg80211_regdomain
);
887 int regulatory_init(void)
891 reg_pdev
= platform_device_register_simple("regulatory", 0, NULL
, 0);
892 if (IS_ERR(reg_pdev
))
893 return PTR_ERR(reg_pdev
);
895 #ifdef CONFIG_WIRELESS_OLD_REGULATORY
896 cfg80211_regdomain
= static_regdom(ieee80211_regdom
);
898 printk(KERN_INFO
"cfg80211: Using static regulatory domain info\n");
899 print_regdomain_info(cfg80211_regdomain
);
900 /* The old code still requests for a new regdomain and if
901 * you have CRDA you get it updated, otherwise you get
902 * stuck with the static values. We ignore "EU" code as
903 * that is not a valid ISO / IEC 3166 alpha2 */
904 if (ieee80211_regdom
[0] != 'E' || ieee80211_regdom
[1] != 'U')
905 err
= __regulatory_hint(NULL
, REGDOM_SET_BY_CORE
,
908 cfg80211_regdomain
= cfg80211_world_regdom
;
910 err
= __regulatory_hint(NULL
, REGDOM_SET_BY_CORE
, "00");
912 printk(KERN_ERR
"cfg80211: calling CRDA failed - "
913 "unable to update world regulatory domain, "
914 "using static definition\n");
920 void regulatory_exit(void)
922 mutex_lock(&cfg80211_drv_mutex
);
928 platform_device_unregister(reg_pdev
);
930 mutex_unlock(&cfg80211_drv_mutex
);