release/src-rt-6.x/linux/linux-2.6/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
  41         /* Japan originally only had channel 14 available (see CHNL_ID 0x40 in
  42          * 802.11). However, in 2001 the range was extended to include channels
  43          * 1-13. The ZyDAS devices still use the old region code but are
  44          * designed to allow the extra channel access in Japan. */
  45         [ZD_REGDOMAIN_JAPAN_ADD] = { 1, 15},
  46 };
  47
  48 const struct channel_range *zd_channel_range(u8 regdomain)
  49 {
  50         if (regdomain >= ARRAY_SIZE(channel_ranges))
  51                 regdomain = 0;
  52         return &channel_ranges[regdomain];
  53 }
  54
  55 int zd_regdomain_supports_channel(u8 regdomain, u8 channel)
  56 {
  57         const struct channel_range *range = zd_channel_range(regdomain);
  58         return range->start <= channel && channel < range->end;
  59 }
  60
  61 int zd_regdomain_supported(u8 regdomain)
  62 {
  63         const struct channel_range *range = zd_channel_range(regdomain);
  64         return range->start != 0;
  65 }
  66
  67 /* Stores channel frequencies in MHz. */
  68 static const u16 channel_frequencies[] = {
  69         2412, 2417, 2422, 2427, 2432, 2437, 2442, 2447,
  70         2452, 2457, 2462, 2467, 2472, 2484,
  71 };
  72
  73 #define NUM_CHANNELS ARRAY_SIZE(channel_frequencies)
  74
  75 static int compute_freq(struct iw_freq *freq, u32 mhz, u32 hz)
  76 {
  77         u32 factor;
  78
  79         freq->e = 0;
  80         if (mhz >= 1000000000U) {
  81                 pr_debug("zd1211 mhz %u to large\n", mhz);
  82                 freq->m = 0;
  83                 return -EINVAL;
  84         }
  85
  86         factor = 1000;
  87         while (mhz >= factor) {
  88
  89                 freq->e += 1;
  90                 factor *= 10;
  91         }
  92
  93         factor /= 1000U;
  94         freq->m = mhz * (1000000U/factor) + hz/factor;
  95
  96         return 0;
  97 }
  98
  99 int zd_channel_to_freq(struct iw_freq *freq, u8 channel)
 100 {
 101         if (channel > NUM_CHANNELS) {
 102                 freq->m = 0;
 103                 freq->e = 0;
 104                 return -EINVAL;
 105         }
 106         if (!channel) {
 107                 freq->m = 0;
 108                 freq->e = 0;
 109                 return -EINVAL;
 110         }
 111         return compute_freq(freq, channel_frequencies[channel-1], 0);
 112 }
 113
 114 static int freq_to_mhz(const struct iw_freq *freq)
 115 {
 116         u32 factor;
 117         int e;
 118
 119         /* Such high frequencies are not supported. */
 120         if (freq->e > 6)
 121                 return -EINVAL;
 122
 123         factor = 1;
 124         for (e = freq->e; e > 0; --e) {
 125                 factor *= 10;
 126         }
 127         factor = 1000000U / factor;
 128
 129         if (freq->m % factor) {
 130                 return -EINVAL;
 131         }
 132
 133         return freq->m / factor;
 134 }
 135
 136 int zd_find_channel(u8 *channel, const struct iw_freq *freq)
 137 {
 138         int i, r;
 139         u32 mhz;
 140
 141         if (freq->m < 1000) {
 142                 if (freq->m  > NUM_CHANNELS || freq->m == 0)
 143                         return -EINVAL;
 144                 *channel = freq->m;
 145                 return 1;
 146         }
 147
 148         r = freq_to_mhz(freq);
 149         if (r < 0)
 150                 return r;
 151         mhz = r;
 152
 153         for (i = 0; i < NUM_CHANNELS; i++) {
 154                 if (mhz == channel_frequencies[i]) {
 155                         *channel = i+1;
 156                         return 1;
 157                 }
 158         }
 159
 160         return -EINVAL;
 161 }
 162
 163 int zd_geo_init(struct ieee80211_device *ieee, u8 regdomain)
 164 {
 165         struct ieee80211_geo geo;
 166         const struct channel_range *range;
 167         int i;
 168         u8 channel;
 169
 170         dev_dbg(zd_mac_dev(zd_netdev_mac(ieee->dev)),
 171                 "regdomain %#04x\n", regdomain);
 172
 173         range = zd_channel_range(regdomain);
 174         if (range->start == 0) {
 175                 dev_err(zd_mac_dev(zd_netdev_mac(ieee->dev)),
 176                         "zd1211 regdomain %#04x not supported\n",
 177                         regdomain);
 178                 return -EINVAL;
 179         }
 180
 181         memset(&geo, 0, sizeof(geo));
 182
 183         for (i = 0, channel = range->start; channel < range->end; channel++) {
 184                 struct ieee80211_channel *chan = &geo.bg[i++];
 185                 chan->freq = channel_frequencies[channel - 1];
 186                 chan->channel = channel;
 187         }
 188
 189         geo.bg_channels = i;
 190         memcpy(geo.name, "XX ", 4);
 191         ieee80211_set_geo(ieee, &geo);
 192         return 0;
 193 }