]> err.no Git - linux-2.6/blob - net/wireless/reg.c
Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6
[linux-2.6] / net / wireless / reg.c
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),
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),
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
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
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),
110         REGDOM(EU),
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 &regdom_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);
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;
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 }