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 #define REGDOM(_code)                                                   \
  84         {                                                               \
  85                 .code = __stringify(_code),                             \
  86                 .ranges = ieee80211_ ##_code## _channels,               \
  87                 .n_ranges = ARRAY_SIZE(ieee80211_ ##_code## _channels), \
  88         }
  89
  90 static const struct ieee80211_regdomain ieee80211_regdoms[] = {
  91         REGDOM(US),
  92         REGDOM(JP),
  93 };
  94
  95
  96 static const struct ieee80211_regdomain *get_regdom(void)
  97 {
  98         static const struct ieee80211_channel_range
  99         ieee80211_world_channels[] = {
 100                 /* IEEE 802.11b/g, channels 1..11 */
 101                 RANGE_PWR(2412, 2462, 27, 6, 0),
 102         };
 103         static const struct ieee80211_regdomain regdom_world = REGDOM(world);
 104         int i;
 105
 106         for (i = 0; i < ARRAY_SIZE(ieee80211_regdoms); i++)
 107                 if (strcmp(ieee80211_regdom, ieee80211_regdoms[i].code) == 0)
 108                         return &ieee80211_regdoms[i];
 109
 110         return &regdom_world;
 111 }
 112
 113
 114 static void handle_channel(struct ieee80211_channel *chan,
 115                            const struct ieee80211_regdomain *rd)
 116 {
 117         int i;
 118         u32 flags = chan->orig_flags;
 119         const struct ieee80211_channel_range *rg = NULL;
 120
 121         for (i = 0; i < rd->n_ranges; i++) {
 122                 if (rd->ranges[i].start_freq <= chan->center_freq &&
 123                     chan->center_freq <= rd->ranges[i].end_freq) {
 124                         rg = &rd->ranges[i];
 125                         break;
 126                 }
 127         }
 128
 129         if (!rg) {
 130                 /* not found */
 131                 flags |= IEEE80211_CHAN_DISABLED;
 132                 chan->flags = flags;
 133                 return;
 134         }
 135
 136         chan->flags = flags;
 137         chan->max_antenna_gain = min(chan->orig_mag,
 138                                          rg->max_antenna_gain);
 139         if (chan->orig_mpwr)
 140                 chan->max_power = min(chan->orig_mpwr, rg->max_power);
 141         else
 142                 chan->max_power = rg->max_power;
 143 }
 144
 145 static void handle_band(struct ieee80211_supported_band *sband,
 146                         const struct ieee80211_regdomain *rd)
 147 {
 148         int i;
 149
 150         for (i = 0; i < sband->n_channels; i++)
 151                 handle_channel(&sband->channels[i], rd);
 152 }
 153
 154 void wiphy_update_regulatory(struct wiphy *wiphy)
 155 {
 156         enum ieee80211_band band;
 157         const struct ieee80211_regdomain *rd = get_regdom();
 158
 159         for (band = 0; band < IEEE80211_NUM_BANDS; band++)
 160                 if (wiphy->bands[band])
 161                         handle_band(wiphy->bands[band], rd);
 162 }