package/mac80211/src/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, channels 52..64 */
  62         RANGE_PWR(5260, 5320, 23, 6, 0),
  63         /* IEEE 802.11a, channels 149..165, outdoor */
  64         RANGE_PWR(5745, 5825, 30, 6, 0),
  65 };
  66
  67 static const struct ieee80211_channel_range ieee80211_JP_channels[] = {
  68         /* IEEE 802.11b/g, channels 1..14 */
  69         RANGE_PWR(2412, 2484, 20, 6, 0),
  70         /* IEEE 802.11a, channels 34..48 */
  71         RANGE_PWR(5170, 5240, 20, 6, IEEE80211_CHAN_PASSIVE_SCAN),
  72         /* IEEE 802.11a, channels 52..64 */
  73         RANGE_PWR(5260, 5320, 20, 6, IEEE80211_CHAN_NO_IBSS |
  74                                      IEEE80211_CHAN_RADAR),
  75 };
  76
  77 #define REGDOM(_code)                                                   \
  78         {                                                               \
  79                 .code = __stringify(_code),                             \
  80                 .ranges = ieee80211_ ##_code## _channels,               \
  81                 .n_ranges = ARRAY_SIZE(ieee80211_ ##_code## _channels), \
  82         }
  83
  84 static const struct ieee80211_regdomain ieee80211_regdoms[] = {
  85         REGDOM(US),
  86         REGDOM(JP),
  87 };
  88
  89
  90 static const struct ieee80211_regdomain *get_regdom(void)
  91 {
  92         static const struct ieee80211_channel_range
  93         ieee80211_world_channels[] = {
  94                 /* IEEE 802.11b/g, channels 1..11 */
  95                 RANGE_PWR(2412, 2462, 27, 6, 0),
  96         };
  97         static const struct ieee80211_regdomain regdom_world = REGDOM(world);
  98         int i;
  99
 100         for (i = 0; i < ARRAY_SIZE(ieee80211_regdoms); i++)
 101                 if (strcmp(ieee80211_regdom, ieee80211_regdoms[i].code) == 0)
 102                         return &ieee80211_regdoms[i];
 103
 104         return &regdom_world;
 105 }
 106
 107
 108 static void handle_channel(struct ieee80211_channel *chan,
 109                            const struct ieee80211_regdomain *rd)
 110 {
 111         int i;
 112         u32 flags = chan->orig_flags;
 113         const struct ieee80211_channel_range *rg = NULL;
 114
 115         for (i = 0; i < rd->n_ranges; i++) {
 116                 if (rd->ranges[i].start_freq <= chan->center_freq &&
 117                     chan->center_freq <= rd->ranges[i].end_freq) {
 118                         rg = &rd->ranges[i];
 119                         break;
 120                 }
 121         }
 122
 123         if (!rg) {
 124                 /* not found */
 125                 flags |= IEEE80211_CHAN_DISABLED;
 126                 chan->flags = flags;
 127                 return;
 128         }
 129
 130         chan->flags = flags;
 131         chan->max_antenna_gain = min(chan->orig_mag,
 132                                          rg->max_antenna_gain);
 133         chan->max_power = min(chan->orig_mpwr, rg->max_power);
 134 }
 135
 136 static void handle_band(struct ieee80211_supported_band *sband,
 137                         const struct ieee80211_regdomain *rd)
 138 {
 139         int i;
 140
 141         for (i = 0; i < sband->n_channels; i++)
 142                 handle_channel(&sband->channels[i], rd);
 143 }
 144
 145 void wiphy_update_regulatory(struct wiphy *wiphy)
 146 {
 147         enum ieee80211_band band;
 148         const struct ieee80211_regdomain *rd = get_regdom();
 149
 150         for (band = 0; band < IEEE80211_NUM_BANDS; band++)
 151                 if (wiphy->bands[band])
 152                         handle_band(wiphy->bands[band], rd);
 153 }