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 * wiphy is set if this request's initiator is
47 * REGDOM_SET_BY_COUNTRY_IE or _DRIVER
49 struct regulatory_request
{
51 enum reg_set_by initiator
;
55 static struct regulatory_request
*last_request
;
57 /* To trigger userspace events */
58 static struct platform_device
*reg_pdev
;
60 /* Keep the ordering from large to small */
61 static u32 supported_bandwidths
[] = {
66 /* Central wireless core regulatory domains, we only need two,
67 * the current one and a world regulatory domain in case we have no
68 * information to give us an alpha2 */
69 static const struct ieee80211_regdomain
*cfg80211_regdomain
;
71 /* We keep a static world regulatory domain in case of the absence of CRDA */
72 static const struct ieee80211_regdomain world_regdom
= {
76 REG_RULE(2412-10, 2462+10, 40, 6, 20,
77 NL80211_RRF_PASSIVE_SCAN
|
82 static const struct ieee80211_regdomain
*cfg80211_world_regdom
=
85 #ifdef CONFIG_WIRELESS_OLD_REGULATORY
86 static char *ieee80211_regdom
= "US";
87 module_param(ieee80211_regdom
, charp
, 0444);
88 MODULE_PARM_DESC(ieee80211_regdom
, "IEEE 802.11 regulatory domain code");
90 /* We assume 40 MHz bandwidth for the old regulatory work.
91 * We make emphasis we are using the exact same frequencies
94 static const struct ieee80211_regdomain us_regdom
= {
98 /* IEEE 802.11b/g, channels 1..11 */
99 REG_RULE(2412-10, 2462+10, 40, 6, 27, 0),
100 /* IEEE 802.11a, channel 36 */
101 REG_RULE(5180-10, 5180+10, 40, 6, 23, 0),
102 /* IEEE 802.11a, channel 40 */
103 REG_RULE(5200-10, 5200+10, 40, 6, 23, 0),
104 /* IEEE 802.11a, channel 44 */
105 REG_RULE(5220-10, 5220+10, 40, 6, 23, 0),
106 /* IEEE 802.11a, channels 48..64 */
107 REG_RULE(5240-10, 5320+10, 40, 6, 23, 0),
108 /* IEEE 802.11a, channels 149..165, outdoor */
109 REG_RULE(5745-10, 5825+10, 40, 6, 30, 0),
113 static const struct ieee80211_regdomain jp_regdom
= {
117 /* IEEE 802.11b/g, channels 1..14 */
118 REG_RULE(2412-10, 2484+10, 40, 6, 20, 0),
119 /* IEEE 802.11a, channels 34..48 */
120 REG_RULE(5170-10, 5240+10, 40, 6, 20,
121 NL80211_RRF_PASSIVE_SCAN
),
122 /* IEEE 802.11a, channels 52..64 */
123 REG_RULE(5260-10, 5320+10, 40, 6, 20,
124 NL80211_RRF_NO_IBSS
|
129 static const struct ieee80211_regdomain eu_regdom
= {
131 /* This alpha2 is bogus, we leave it here just for stupid
132 * backward compatibility */
135 /* IEEE 802.11b/g, channels 1..13 */
136 REG_RULE(2412-10, 2472+10, 40, 6, 20, 0),
137 /* IEEE 802.11a, channel 36 */
138 REG_RULE(5180-10, 5180+10, 40, 6, 23,
139 NL80211_RRF_PASSIVE_SCAN
),
140 /* IEEE 802.11a, channel 40 */
141 REG_RULE(5200-10, 5200+10, 40, 6, 23,
142 NL80211_RRF_PASSIVE_SCAN
),
143 /* IEEE 802.11a, channel 44 */
144 REG_RULE(5220-10, 5220+10, 40, 6, 23,
145 NL80211_RRF_PASSIVE_SCAN
),
146 /* IEEE 802.11a, channels 48..64 */
147 REG_RULE(5240-10, 5320+10, 40, 6, 20,
148 NL80211_RRF_NO_IBSS
|
150 /* IEEE 802.11a, channels 100..140 */
151 REG_RULE(5500-10, 5700+10, 40, 6, 30,
152 NL80211_RRF_NO_IBSS
|
157 static const struct ieee80211_regdomain
*static_regdom(char *alpha2
)
159 if (alpha2
[0] == 'U' && alpha2
[1] == 'S')
161 if (alpha2
[0] == 'J' && alpha2
[1] == 'P')
163 if (alpha2
[0] == 'E' && alpha2
[1] == 'U')
165 /* Default, as per the old rules */
169 static bool is_old_static_regdom(const struct ieee80211_regdomain
*rd
)
171 if (rd
== &us_regdom
|| rd
== &jp_regdom
|| rd
== &eu_regdom
)
176 static inline bool is_old_static_regdom(const struct ieee80211_regdomain
*rd
)
182 static void reset_regdomains(void)
184 /* avoid freeing static information or freeing something twice */
185 if (cfg80211_regdomain
== cfg80211_world_regdom
)
186 cfg80211_regdomain
= NULL
;
187 if (cfg80211_world_regdom
== &world_regdom
)
188 cfg80211_world_regdom
= NULL
;
189 if (cfg80211_regdomain
== &world_regdom
)
190 cfg80211_regdomain
= NULL
;
191 if (is_old_static_regdom(cfg80211_regdomain
))
192 cfg80211_regdomain
= NULL
;
194 kfree(cfg80211_regdomain
);
195 kfree(cfg80211_world_regdom
);
197 cfg80211_world_regdom
= &world_regdom
;
198 cfg80211_regdomain
= NULL
;
201 /* Dynamic world regulatory domain requested by the wireless
202 * core upon initialization */
203 static void update_world_regdomain(const struct ieee80211_regdomain
*rd
)
205 BUG_ON(!last_request
);
209 cfg80211_world_regdom
= rd
;
210 cfg80211_regdomain
= rd
;
213 bool is_world_regdom(const char *alpha2
)
217 if (alpha2
[0] == '0' && alpha2
[1] == '0')
222 static bool is_alpha2_set(const char *alpha2
)
226 if (alpha2
[0] != 0 && alpha2
[1] != 0)
231 static bool is_alpha_upper(char letter
)
234 if (letter
>= 65 && letter
<= 90)
239 static bool is_unknown_alpha2(const char *alpha2
)
243 /* Special case where regulatory domain was built by driver
244 * but a specific alpha2 cannot be determined */
245 if (alpha2
[0] == '9' && alpha2
[1] == '9')
250 static bool is_an_alpha2(const char *alpha2
)
254 if (is_alpha_upper(alpha2
[0]) && is_alpha_upper(alpha2
[1]))
259 static bool alpha2_equal(const char *alpha2_x
, const char *alpha2_y
)
261 if (!alpha2_x
|| !alpha2_y
)
263 if (alpha2_x
[0] == alpha2_y
[0] &&
264 alpha2_x
[1] == alpha2_y
[1])
269 static bool regdom_changed(const char *alpha2
)
271 if (!cfg80211_regdomain
)
273 if (alpha2_equal(cfg80211_regdomain
->alpha2
, alpha2
))
278 /* This lets us keep regulatory code which is updated on a regulatory
279 * basis in userspace. */
280 static int call_crda(const char *alpha2
)
282 char country_env
[9 + 2] = "COUNTRY=";
288 if (!is_world_regdom((char *) alpha2
))
289 printk(KERN_INFO
"cfg80211: Calling CRDA for country: %c%c\n",
290 alpha2
[0], alpha2
[1]);
292 printk(KERN_INFO
"cfg80211: Calling CRDA to update world "
293 "regulatory domain\n");
295 country_env
[8] = alpha2
[0];
296 country_env
[9] = alpha2
[1];
298 return kobject_uevent_env(®_pdev
->dev
.kobj
, KOBJ_CHANGE
, envp
);
301 /* Used by nl80211 before kmalloc'ing our regulatory domain */
302 bool reg_is_valid_request(const char *alpha2
)
307 return alpha2_equal(last_request
->alpha2
, alpha2
);
310 /* Sanity check on a regulatory rule */
311 static bool is_valid_reg_rule(const struct ieee80211_reg_rule
*rule
)
313 const struct ieee80211_freq_range
*freq_range
= &rule
->freq_range
;
316 if (freq_range
->start_freq_khz
== 0 || freq_range
->end_freq_khz
== 0)
319 if (freq_range
->start_freq_khz
> freq_range
->end_freq_khz
)
322 freq_diff
= freq_range
->end_freq_khz
- freq_range
->start_freq_khz
;
324 if (freq_range
->max_bandwidth_khz
> freq_diff
)
330 static bool is_valid_rd(const struct ieee80211_regdomain
*rd
)
332 const struct ieee80211_reg_rule
*reg_rule
= NULL
;
335 if (!rd
->n_reg_rules
)
338 for (i
= 0; i
< rd
->n_reg_rules
; i
++) {
339 reg_rule
= &rd
->reg_rules
[i
];
340 if (!is_valid_reg_rule(reg_rule
))
347 /* Returns value in KHz */
348 static u32
freq_max_bandwidth(const struct ieee80211_freq_range
*freq_range
,
352 for (i
= 0; i
< ARRAY_SIZE(supported_bandwidths
); i
++) {
353 u32 start_freq_khz
= freq
- supported_bandwidths
[i
]/2;
354 u32 end_freq_khz
= freq
+ supported_bandwidths
[i
]/2;
355 if (start_freq_khz
>= freq_range
->start_freq_khz
&&
356 end_freq_khz
<= freq_range
->end_freq_khz
)
357 return supported_bandwidths
[i
];
362 /* XXX: add support for the rest of enum nl80211_reg_rule_flags, we may
363 * want to just have the channel structure use these */
364 static u32
map_regdom_flags(u32 rd_flags
)
366 u32 channel_flags
= 0;
367 if (rd_flags
& NL80211_RRF_PASSIVE_SCAN
)
368 channel_flags
|= IEEE80211_CHAN_PASSIVE_SCAN
;
369 if (rd_flags
& NL80211_RRF_NO_IBSS
)
370 channel_flags
|= IEEE80211_CHAN_NO_IBSS
;
371 if (rd_flags
& NL80211_RRF_DFS
)
372 channel_flags
|= IEEE80211_CHAN_RADAR
;
373 return channel_flags
;
377 * freq_reg_info - get regulatory information for the given frequency
378 * @center_freq: Frequency in KHz for which we want regulatory information for
379 * @bandwidth: the bandwidth requirement you have in KHz, if you do not have one
380 * you can set this to 0. If this frequency is allowed we then set
381 * this value to the maximum allowed bandwidth.
382 * @reg_rule: the regulatory rule which we have for this frequency
384 * Use this function to get the regulatory rule for a specific frequency.
386 static int freq_reg_info(u32 center_freq
, u32
*bandwidth
,
387 const struct ieee80211_reg_rule
**reg_rule
)
390 u32 max_bandwidth
= 0;
392 if (!cfg80211_regdomain
)
395 for (i
= 0; i
< cfg80211_regdomain
->n_reg_rules
; i
++) {
396 const struct ieee80211_reg_rule
*rr
;
397 const struct ieee80211_freq_range
*fr
= NULL
;
398 const struct ieee80211_power_rule
*pr
= NULL
;
400 rr
= &cfg80211_regdomain
->reg_rules
[i
];
401 fr
= &rr
->freq_range
;
402 pr
= &rr
->power_rule
;
403 max_bandwidth
= freq_max_bandwidth(fr
, center_freq
);
404 if (max_bandwidth
&& *bandwidth
<= max_bandwidth
) {
406 *bandwidth
= max_bandwidth
;
411 return !max_bandwidth
;
414 static void handle_channel(struct ieee80211_channel
*chan
)
417 u32 flags
= chan
->orig_flags
;
418 u32 max_bandwidth
= 0;
419 const struct ieee80211_reg_rule
*reg_rule
= NULL
;
420 const struct ieee80211_power_rule
*power_rule
= NULL
;
422 r
= freq_reg_info(MHZ_TO_KHZ(chan
->center_freq
),
423 &max_bandwidth
, ®_rule
);
426 flags
|= IEEE80211_CHAN_DISABLED
;
431 power_rule
= ®_rule
->power_rule
;
433 chan
->flags
= flags
| map_regdom_flags(reg_rule
->flags
);
434 chan
->max_antenna_gain
= min(chan
->orig_mag
,
435 (int) MBI_TO_DBI(power_rule
->max_antenna_gain
));
436 chan
->max_bandwidth
= KHZ_TO_MHZ(max_bandwidth
);
438 chan
->max_power
= min(chan
->orig_mpwr
,
439 (int) MBM_TO_DBM(power_rule
->max_eirp
));
441 chan
->max_power
= (int) MBM_TO_DBM(power_rule
->max_eirp
);
444 static void handle_band(struct ieee80211_supported_band
*sband
)
448 for (i
= 0; i
< sband
->n_channels
; i
++)
449 handle_channel(&sband
->channels
[i
]);
452 static void update_all_wiphy_regulatory(enum reg_set_by setby
)
454 struct cfg80211_registered_device
*drv
;
456 list_for_each_entry(drv
, &cfg80211_drv_list
, list
)
457 wiphy_update_regulatory(&drv
->wiphy
, setby
);
460 void wiphy_update_regulatory(struct wiphy
*wiphy
, enum reg_set_by setby
)
462 enum ieee80211_band band
;
463 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
464 if (wiphy
->bands
[band
])
465 handle_band(wiphy
->bands
[band
]);
466 if (wiphy
->reg_notifier
)
467 wiphy
->reg_notifier(wiphy
, setby
);
471 /* This has the logic which determines when a new request
472 * should be ignored. */
473 static int ignore_request(struct wiphy
*wiphy
, enum reg_set_by set_by
,
476 /* All initial requests are respected */
481 case REGDOM_SET_BY_INIT
:
483 case REGDOM_SET_BY_CORE
:
485 * Always respect new wireless core hints, should only happen
486 * when updating the world regulatory domain at init.
489 case REGDOM_SET_BY_COUNTRY_IE
:
490 if (unlikely(!is_an_alpha2(alpha2
)))
492 if (last_request
->initiator
== REGDOM_SET_BY_COUNTRY_IE
) {
493 if (last_request
->wiphy
!= wiphy
) {
495 * Two cards with two APs claiming different
496 * different Country IE alpha2s. We could
497 * intersect them, but that seems unlikely
498 * to be correct. Reject second one for now.
500 if (!alpha2_equal(alpha2
,
501 cfg80211_regdomain
->alpha2
))
505 /* Two consecutive Country IE hints on the same wiphy */
506 if (!alpha2_equal(cfg80211_regdomain
->alpha2
, alpha2
))
511 * Ignore Country IE hints for now, need to think about
512 * what we need to do to support multi-domain operation.
515 case REGDOM_SET_BY_DRIVER
:
516 if (last_request
->initiator
== REGDOM_SET_BY_DRIVER
)
519 case REGDOM_SET_BY_USER
:
521 * If the user wants to override the AP's hint, we may
522 * need to follow both and use the intersection. For now,
523 * reject any such attempt (but we don't support country
524 * IEs right now anyway.)
526 if (last_request
->initiator
== REGDOM_SET_BY_COUNTRY_IE
)
534 /* Caller must hold &cfg80211_drv_mutex */
535 int __regulatory_hint(struct wiphy
*wiphy
, enum reg_set_by set_by
,
538 struct regulatory_request
*request
;
541 r
= ignore_request(wiphy
, set_by
, alpha2
);
546 case REGDOM_SET_BY_CORE
:
547 case REGDOM_SET_BY_COUNTRY_IE
:
548 case REGDOM_SET_BY_DRIVER
:
549 case REGDOM_SET_BY_USER
:
550 request
= kzalloc(sizeof(struct regulatory_request
),
555 request
->alpha2
[0] = alpha2
[0];
556 request
->alpha2
[1] = alpha2
[1];
557 request
->initiator
= set_by
;
558 request
->wiphy
= wiphy
;
561 last_request
= request
;
562 r
= call_crda(alpha2
);
563 #ifndef CONFIG_WIRELESS_OLD_REGULATORY
565 printk(KERN_ERR
"cfg80211: Failed calling CRDA\n");
576 void regulatory_hint(struct wiphy
*wiphy
, const char *alpha2
)
580 mutex_lock(&cfg80211_drv_mutex
);
581 __regulatory_hint(wiphy
, REGDOM_SET_BY_DRIVER
, alpha2
);
582 mutex_unlock(&cfg80211_drv_mutex
);
584 EXPORT_SYMBOL(regulatory_hint
);
587 static void print_rd_rules(const struct ieee80211_regdomain
*rd
)
590 const struct ieee80211_reg_rule
*reg_rule
= NULL
;
591 const struct ieee80211_freq_range
*freq_range
= NULL
;
592 const struct ieee80211_power_rule
*power_rule
= NULL
;
594 printk(KERN_INFO
"\t(start_freq - end_freq @ bandwidth), "
595 "(max_antenna_gain, max_eirp)\n");
597 for (i
= 0; i
< rd
->n_reg_rules
; i
++) {
598 reg_rule
= &rd
->reg_rules
[i
];
599 freq_range
= ®_rule
->freq_range
;
600 power_rule
= ®_rule
->power_rule
;
602 /* There may not be documentation for max antenna gain
603 * in certain regions */
604 if (power_rule
->max_antenna_gain
)
605 printk(KERN_INFO
"\t(%d KHz - %d KHz @ %d KHz), "
606 "(%d mBi, %d mBm)\n",
607 freq_range
->start_freq_khz
,
608 freq_range
->end_freq_khz
,
609 freq_range
->max_bandwidth_khz
,
610 power_rule
->max_antenna_gain
,
611 power_rule
->max_eirp
);
613 printk(KERN_INFO
"\t(%d KHz - %d KHz @ %d KHz), "
615 freq_range
->start_freq_khz
,
616 freq_range
->end_freq_khz
,
617 freq_range
->max_bandwidth_khz
,
618 power_rule
->max_eirp
);
622 static void print_regdomain(const struct ieee80211_regdomain
*rd
)
625 if (is_world_regdom(rd
->alpha2
))
626 printk(KERN_INFO
"cfg80211: World regulatory "
627 "domain updated:\n");
629 if (is_unknown_alpha2(rd
->alpha2
))
630 printk(KERN_INFO
"cfg80211: Regulatory domain "
631 "changed to driver built-in settings "
632 "(unknown country)\n");
634 printk(KERN_INFO
"cfg80211: Regulatory domain "
635 "changed to country: %c%c\n",
636 rd
->alpha2
[0], rd
->alpha2
[1]);
641 void print_regdomain_info(const struct ieee80211_regdomain
*rd
)
643 printk(KERN_INFO
"cfg80211: Regulatory domain: %c%c\n",
644 rd
->alpha2
[0], rd
->alpha2
[1]);
648 /* Takes ownership of rd only if it doesn't fail */
649 static int __set_regdom(const struct ieee80211_regdomain
*rd
)
651 /* Some basic sanity checks first */
653 if (is_world_regdom(rd
->alpha2
)) {
654 if (WARN_ON(!reg_is_valid_request(rd
->alpha2
)))
656 update_world_regdomain(rd
);
660 if (!is_alpha2_set(rd
->alpha2
) && !is_an_alpha2(rd
->alpha2
) &&
661 !is_unknown_alpha2(rd
->alpha2
))
667 /* allow overriding the static definitions if CRDA is present */
668 if (!is_old_static_regdom(cfg80211_regdomain
) &&
669 !regdom_changed(rd
->alpha2
))
672 /* Now lets set the regulatory domain, update all driver channels
673 * and finally inform them of what we have done, in case they want
674 * to review or adjust their own settings based on their own
675 * internal EEPROM data */
677 if (WARN_ON(!reg_is_valid_request(rd
->alpha2
)))
682 /* Country IE parsing coming soon */
683 switch (last_request
->initiator
) {
684 case REGDOM_SET_BY_CORE
:
685 case REGDOM_SET_BY_DRIVER
:
686 case REGDOM_SET_BY_USER
:
687 if (!is_valid_rd(rd
)) {
688 printk(KERN_ERR
"cfg80211: Invalid "
689 "regulatory domain detected:\n");
690 print_regdomain_info(rd
);
694 case REGDOM_SET_BY_COUNTRY_IE
: /* Not yet */
701 cfg80211_regdomain
= rd
;
707 /* Use this call to set the current regulatory domain. Conflicts with
708 * multiple drivers can be ironed out later. Caller must've already
709 * kmalloc'd the rd structure. Caller must hold cfg80211_drv_mutex */
710 int set_regdom(const struct ieee80211_regdomain
*rd
)
714 /* Note that this doesn't update the wiphys, this is done below */
715 r
= __set_regdom(rd
);
721 /* This would make this whole thing pointless */
722 BUG_ON(rd
!= cfg80211_regdomain
);
724 /* update all wiphys now with the new established regulatory domain */
725 update_all_wiphy_regulatory(last_request
->initiator
);
732 int regulatory_init(void)
736 reg_pdev
= platform_device_register_simple("regulatory", 0, NULL
, 0);
737 if (IS_ERR(reg_pdev
))
738 return PTR_ERR(reg_pdev
);
740 #ifdef CONFIG_WIRELESS_OLD_REGULATORY
741 cfg80211_regdomain
= static_regdom(ieee80211_regdom
);
743 printk(KERN_INFO
"cfg80211: Using static regulatory domain info\n");
744 print_regdomain_info(cfg80211_regdomain
);
745 /* The old code still requests for a new regdomain and if
746 * you have CRDA you get it updated, otherwise you get
747 * stuck with the static values. We ignore "EU" code as
748 * that is not a valid ISO / IEC 3166 alpha2 */
749 if (ieee80211_regdom
[0] != 'E' || ieee80211_regdom
[1] != 'U')
750 err
= __regulatory_hint(NULL
, REGDOM_SET_BY_CORE
,
753 cfg80211_regdomain
= cfg80211_world_regdom
;
755 err
= __regulatory_hint(NULL
, REGDOM_SET_BY_CORE
, "00");
757 printk(KERN_ERR
"cfg80211: calling CRDA failed - "
758 "unable to update world regulatory domain, "
759 "using static definition\n");
765 void regulatory_exit(void)
767 mutex_lock(&cfg80211_drv_mutex
);
773 platform_device_unregister(reg_pdev
);
775 mutex_unlock(&cfg80211_drv_mutex
);