drivers/net/wireless/zd1211rw/zd_ieee80211.c

   1 /* zd_ieee80211.c
   2  *
   3  * This program is free software; you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation; either version 2 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software
  15  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  16  */
  17
  18 /*
  19  * A lot of this code is generic and should be moved into the upper layers
  20  * at some point.
  21  */
  22
  23 #include <linux/errno.h>
  24 #include <linux/wireless.h>
  25 #include <linux/kernel.h>
  26 #include <net/ieee80211.h>
  27
  28 #include "zd_def.h"
  29 #include "zd_ieee80211.h"
  30 #include "zd_mac.h"
  31
  32 static const struct channel_range channel_ranges[] = {
  33         [0]                      = { 0,  0},
  34         [ZD_REGDOMAIN_FCC]       = { 1, 12},
  35         [ZD_REGDOMAIN_IC]        = { 1, 12},
  36         [ZD_REGDOMAIN_ETSI]      = { 1, 14},
  37         [ZD_REGDOMAIN_JAPAN]     = { 1, 14},
  38         [ZD_REGDOMAIN_SPAIN]     = { 1, 14},
  39         [ZD_REGDOMAIN_FRANCE]    = { 1, 14},
  40         [ZD_REGDOMAIN_JAPAN_ADD] = {14, 15},
  41 };
  42
  43 const struct channel_range *zd_channel_range(u8 regdomain)
  44 {
  45         if (regdomain >= ARRAY_SIZE(channel_ranges))
  46                 regdomain = 0;
  47         return &channel_ranges[regdomain];
  48 }
  49
  50 int zd_regdomain_supports_channel(u8 regdomain, u8 channel)
  51 {
  52         const struct channel_range *range = zd_channel_range(regdomain);
  53         return range->start <= channel && channel < range->end;
  54 }
  55
  56 int zd_regdomain_supported(u8 regdomain)
  57 {
  58         const struct channel_range *range = zd_channel_range(regdomain);
  59         return range->start != 0;
  60 }
  61
  62 /* Stores channel frequencies in MHz. */
  63 static const u16 channel_frequencies[] = {
  64         2412, 2417, 2422, 2427, 2432, 2437, 2442, 2447,
  65         2452, 2457, 2462, 2467, 2472, 2484,
  66 };
  67
  68 #define NUM_CHANNELS ARRAY_SIZE(channel_frequencies)
  69
  70 static int compute_freq(struct iw_freq *freq, u32 mhz, u32 hz)
  71 {
  72         u32 factor;
  73
  74         freq->e = 0;
  75         if (mhz >= 1000000000U) {
  76                 pr_debug("zd1211 mhz %u to large\n", mhz);
  77                 freq->m = 0;
  78                 return -EINVAL;
  79         }
  80
  81         factor = 1000;
  82         while (mhz >= factor) {
  83
  84                 freq->e += 1;
  85                 factor *= 10;
  86         }
  87
  88         factor /= 1000U;
  89         freq->m = mhz * (1000000U/factor) + hz/factor;
  90
  91         return 0;
  92 }
  93
  94 int zd_channel_to_freq(struct iw_freq *freq, u8 channel)
  95 {
  96         if (channel > NUM_CHANNELS) {
  97                 freq->m = 0;
  98                 freq->e = 0;
  99                 return -EINVAL;
 100         }
 101         if (!channel) {
 102                 freq->m = 0;
 103                 freq->e = 0;
 104                 return -EINVAL;
 105         }
 106         return compute_freq(freq, channel_frequencies[channel-1], 0);
 107 }
 108
 109 static int freq_to_mhz(const struct iw_freq *freq)
 110 {
 111         u32 factor;
 112         int e;
 113
 114         /* Such high frequencies are not supported. */
 115         if (freq->e > 6)
 116                 return -EINVAL;
 117
 118         factor = 1;
 119         for (e = freq->e; e > 0; --e) {
 120                 factor *= 10;
 121         }
 122         factor = 1000000U / factor;
 123
 124         if (freq->m % factor) {
 125                 return -EINVAL;
 126         }
 127
 128         return freq->m / factor;
 129 }
 130
 131 int zd_find_channel(u8 *channel, const struct iw_freq *freq)
 132 {
 133         int i, r;
 134         u32 mhz;
 135
 136         if (freq->m < 1000) {
 137                 if (freq->m  > NUM_CHANNELS || freq->m == 0)
 138                         return -EINVAL;
 139                 *channel = freq->m;
 140                 return 1;
 141         }
 142
 143         r = freq_to_mhz(freq);
 144         if (r < 0)
 145                 return r;
 146         mhz = r;
 147
 148         for (i = 0; i < NUM_CHANNELS; i++) {
 149                 if (mhz == channel_frequencies[i]) {
 150                         *channel = i+1;
 151                         return 1;
 152                 }
 153         }
 154
 155         return -EINVAL;
 156 }
 157
 158 int zd_geo_init(struct ieee80211_device *ieee, u8 regdomain)
 159 {
 160         struct ieee80211_geo geo;
 161         const struct channel_range *range;
 162         int i;
 163         u8 channel;
 164
 165         dev_dbg(zd_mac_dev(zd_netdev_mac(ieee->dev)),
 166                 "regdomain %#04x\n", regdomain);
 167
 168         range = zd_channel_range(regdomain);
 169         if (range->start == 0) {
 170                 dev_err(zd_mac_dev(zd_netdev_mac(ieee->dev)),
 171                         "zd1211 regdomain %#04x not supported\n",
 172                         regdomain);
 173                 return -EINVAL;
 174         }
 175
 176         memset(&geo, 0, sizeof(geo));
 177
 178         for (i = 0, channel = range->start; channel < range->end; channel++) {
 179                 struct ieee80211_channel *chan = &geo.bg[i++];
 180                 chan->freq = channel_frequencies[channel - 1];
 181                 chan->channel = channel;
 182         }
 183
 184         geo.bg_channels = i;
 185         memcpy(geo.name, "XX ", 4);
 186         ieee80211_set_geo(ieee, &geo);
 187         return 0;
 188 }