Commit | Line | Data |
---|---|---|
8318d78a JB |
1 | /* |
2 | * Copyright 2002-2005, Instant802 Networks, Inc. | |
3 | * Copyright 2005-2006, Devicescape Software, Inc. | |
4 | * Copyright 2007 Johannes Berg <johannes@sipsolutions.net> | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or modify | |
7 | * it under the terms of the GNU General Public License version 2 as | |
8 | * published by the Free Software Foundation. | |
9 | */ | |
10 | ||
11 | /* | |
12 | * This regulatory domain control implementation is highly incomplete, it | |
13 | * only exists for the purpose of not regressing mac80211. | |
14 | * | |
15 | * For now, drivers can restrict the set of allowed channels by either | |
16 | * not registering those channels or setting the IEEE80211_CHAN_DISABLED | |
17 | * flag; that flag will only be *set* by this code, never *cleared. | |
18 | * | |
19 | * The usual implementation is for a driver to read a device EEPROM to | |
20 | * determine which regulatory domain it should be operating under, then | |
21 | * looking up the allowable channels in a driver-local table and finally | |
22 | * registering those channels in the wiphy structure. | |
23 | * | |
24 | * Alternatively, drivers that trust the regulatory domain control here | |
25 | * will register a complete set of capabilities and the control code | |
26 | * will restrict the set by setting the IEEE80211_CHAN_* flags. | |
27 | */ | |
28 | #include <linux/kernel.h> | |
29 | #include <net/wireless.h> | |
30 | #include "core.h" | |
31 | ||
32 | static char *ieee80211_regdom = "US"; | |
33 | module_param(ieee80211_regdom, charp, 0444); | |
34 | MODULE_PARM_DESC(ieee80211_regdom, "IEEE 802.11 regulatory domain code"); | |
35 | ||
36 | struct ieee80211_channel_range { | |
37 | short start_freq; | |
38 | short end_freq; | |
39 | int max_power; | |
40 | int max_antenna_gain; | |
41 | u32 flags; | |
42 | }; | |
43 | ||
44 | struct ieee80211_regdomain { | |
45 | const char *code; | |
46 | const struct ieee80211_channel_range *ranges; | |
47 | int n_ranges; | |
48 | }; | |
49 | ||
50 | #define RANGE_PWR(_start, _end, _pwr, _ag, _flags) \ | |
51 | { _start, _end, _pwr, _ag, _flags } | |
52 | ||
53 | ||
54 | /* | |
55 | * Ideally, in the future, these definitions will be loaded from a | |
56 | * userspace table via some daemon. | |
57 | */ | |
58 | static const struct ieee80211_channel_range ieee80211_US_channels[] = { | |
59 | /* IEEE 802.11b/g, channels 1..11 */ | |
60 | RANGE_PWR(2412, 2462, 27, 6, 0), | |
b46b4ee0 TW |
61 | /* IEEE 802.11a, channel 36*/ |
62 | RANGE_PWR(5180, 5180, 23, 6, 0), | |
63 | /* IEEE 802.11a, channel 40*/ | |
64 | RANGE_PWR(5200, 5200, 23, 6, 0), | |
65 | /* IEEE 802.11a, channel 44*/ | |
66 | RANGE_PWR(5220, 5220, 23, 6, 0), | |
67 | /* IEEE 802.11a, channels 48..64 */ | |
68 | RANGE_PWR(5240, 5320, 23, 6, 0), | |
8318d78a JB |
69 | /* IEEE 802.11a, channels 149..165, outdoor */ |
70 | RANGE_PWR(5745, 5825, 30, 6, 0), | |
71 | }; | |
72 | ||
73 | static const struct ieee80211_channel_range ieee80211_JP_channels[] = { | |
74 | /* IEEE 802.11b/g, channels 1..14 */ | |
75 | RANGE_PWR(2412, 2484, 20, 6, 0), | |
76 | /* IEEE 802.11a, channels 34..48 */ | |
77 | RANGE_PWR(5170, 5240, 20, 6, IEEE80211_CHAN_PASSIVE_SCAN), | |
78 | /* IEEE 802.11a, channels 52..64 */ | |
79 | RANGE_PWR(5260, 5320, 20, 6, IEEE80211_CHAN_NO_IBSS | | |
80 | IEEE80211_CHAN_RADAR), | |
81 | }; | |
82 | ||
59d393ad TV |
83 | static const struct ieee80211_channel_range ieee80211_EU_channels[] = { |
84 | /* IEEE 802.11b/g, channels 1..13 */ | |
85 | RANGE_PWR(2412, 2472, 20, 6, 0), | |
86 | /* IEEE 802.11a, channel 36*/ | |
87 | RANGE_PWR(5180, 5180, 23, 6, IEEE80211_CHAN_PASSIVE_SCAN), | |
88 | /* IEEE 802.11a, channel 40*/ | |
89 | RANGE_PWR(5200, 5200, 23, 6, IEEE80211_CHAN_PASSIVE_SCAN), | |
90 | /* IEEE 802.11a, channel 44*/ | |
91 | RANGE_PWR(5220, 5220, 23, 6, IEEE80211_CHAN_PASSIVE_SCAN), | |
92 | /* IEEE 802.11a, channels 48..64 */ | |
93 | RANGE_PWR(5240, 5320, 23, 6, IEEE80211_CHAN_NO_IBSS | | |
94 | IEEE80211_CHAN_RADAR), | |
95 | /* IEEE 802.11a, channels 100..140 */ | |
96 | RANGE_PWR(5500, 5700, 30, 6, IEEE80211_CHAN_NO_IBSS | | |
97 | IEEE80211_CHAN_RADAR), | |
98 | }; | |
99 | ||
8318d78a JB |
100 | #define REGDOM(_code) \ |
101 | { \ | |
102 | .code = __stringify(_code), \ | |
103 | .ranges = ieee80211_ ##_code## _channels, \ | |
104 | .n_ranges = ARRAY_SIZE(ieee80211_ ##_code## _channels), \ | |
105 | } | |
106 | ||
107 | static const struct ieee80211_regdomain ieee80211_regdoms[] = { | |
108 | REGDOM(US), | |
109 | REGDOM(JP), | |
59d393ad | 110 | REGDOM(EU), |
8318d78a JB |
111 | }; |
112 | ||
113 | ||
114 | static const struct ieee80211_regdomain *get_regdom(void) | |
115 | { | |
116 | static const struct ieee80211_channel_range | |
117 | ieee80211_world_channels[] = { | |
118 | /* IEEE 802.11b/g, channels 1..11 */ | |
119 | RANGE_PWR(2412, 2462, 27, 6, 0), | |
120 | }; | |
121 | static const struct ieee80211_regdomain regdom_world = REGDOM(world); | |
122 | int i; | |
123 | ||
124 | for (i = 0; i < ARRAY_SIZE(ieee80211_regdoms); i++) | |
125 | if (strcmp(ieee80211_regdom, ieee80211_regdoms[i].code) == 0) | |
126 | return &ieee80211_regdoms[i]; | |
127 | ||
128 | return ®dom_world; | |
129 | } | |
130 | ||
131 | ||
132 | static void handle_channel(struct ieee80211_channel *chan, | |
133 | const struct ieee80211_regdomain *rd) | |
134 | { | |
135 | int i; | |
136 | u32 flags = chan->orig_flags; | |
137 | const struct ieee80211_channel_range *rg = NULL; | |
138 | ||
139 | for (i = 0; i < rd->n_ranges; i++) { | |
140 | if (rd->ranges[i].start_freq <= chan->center_freq && | |
141 | chan->center_freq <= rd->ranges[i].end_freq) { | |
142 | rg = &rd->ranges[i]; | |
143 | break; | |
144 | } | |
145 | } | |
146 | ||
147 | if (!rg) { | |
148 | /* not found */ | |
149 | flags |= IEEE80211_CHAN_DISABLED; | |
150 | chan->flags = flags; | |
151 | return; | |
152 | } | |
153 | ||
154 | chan->flags = flags; | |
155 | chan->max_antenna_gain = min(chan->orig_mag, | |
156 | rg->max_antenna_gain); | |
253898c4 JL |
157 | if (chan->orig_mpwr) |
158 | chan->max_power = min(chan->orig_mpwr, rg->max_power); | |
159 | else | |
160 | chan->max_power = rg->max_power; | |
8318d78a JB |
161 | } |
162 | ||
163 | static void handle_band(struct ieee80211_supported_band *sband, | |
164 | const struct ieee80211_regdomain *rd) | |
165 | { | |
166 | int i; | |
167 | ||
168 | for (i = 0; i < sband->n_channels; i++) | |
169 | handle_channel(&sband->channels[i], rd); | |
170 | } | |
171 | ||
172 | void wiphy_update_regulatory(struct wiphy *wiphy) | |
173 | { | |
174 | enum ieee80211_band band; | |
175 | const struct ieee80211_regdomain *rd = get_regdom(); | |
176 | ||
177 | for (band = 0; band < IEEE80211_NUM_BANDS; band++) | |
178 | if (wiphy->bands[band]) | |
179 | handle_band(wiphy->bands[band], rd); | |
180 | } |