package/wlcompat/src/wlcompat.c

   1 /*
   2  * wlcompat.c
   3  *
   4  * Copyright (C) 2005 Mike Baker,
   5  *                    Felix Fietkau <openwrt@nbd.name>
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20  *
  21  * $Id$
  22  */
  23
  24
  25 #include <linux/config.h>
  26 #include <linux/module.h>
  27 #include <linux/moduleparam.h>
  28 #include <linux/init.h>
  29 #include <linux/if_arp.h>
  30 #include <asm/uaccess.h>
  31 #include <linux/wireless.h>
  32 #include <linux/timer.h>
  33
  34 #include <net/iw_handler.h>
  35 #include <wlioctl.h>
  36 #include <proto/802.11.h>
  37
  38 static struct net_device *dev;
  39 static unsigned short bss_force;
  40 static struct iw_statistics wstats;
  41 static int random = 1;
  42 char buf[WLC_IOCTL_MAXLEN];
  43
  44 /* The frequency of each channel in MHz */
  45 const long channel_frequency[] = {
  46         2412, 2417, 2422, 2427, 2432, 2437, 2442,
  47         2447, 2452, 2457, 2462, 2467, 2472, 2484
  48 };
  49 #define NUM_CHANNELS ( sizeof(channel_frequency) / sizeof(channel_frequency[0]) )
  50
  51 #define RNG_POLL_FREQ   2
  52
  53 typedef struct internal_wsec_key {
  54         uint8 index;            // 0x00
  55         uint8 unknown_1;        // 0x01
  56         uint8 type;             // 0x02
  57         uint8 unknown_2[7];     // 0x03
  58         uint8 len;              // 0x0a
  59         uint8 pad[3];
  60         char data[32];          // 0x0e
  61 } wkey;
  62
  63
  64 static int wlcompat_private_ioctl(struct net_device *dev,
  65                          struct iw_request_info *info,
  66                          union iwreq_data *wrqu,
  67                          char *extra);
  68 #ifdef DEBUG
  69 void print_buffer(int len, unsigned char *buf);
  70 #endif
  71
  72 static int wl_ioctl(struct net_device *dev, int cmd, void *buf, int len)
  73 {
  74         mm_segment_t old_fs = get_fs();
  75         struct ifreq ifr;
  76         int ret;
  77         wl_ioctl_t ioc;
  78         ioc.cmd = cmd;
  79         ioc.buf = buf;
  80         ioc.len = len;
  81         strncpy(ifr.ifr_name, dev->name, IFNAMSIZ);
  82         ifr.ifr_data = (caddr_t) &ioc;
  83         set_fs(KERNEL_DS);
  84         ret = dev->do_ioctl(dev,&ifr,SIOCDEVPRIVATE);
  85         set_fs (old_fs);
  86         return ret;
  87 }
  88
  89 static int wl_set_val(struct net_device *dev, char *var, void *val, int len)
  90 {
  91         char buf[128];
  92         int buf_len;
  93         int ret;
  94
  95         /* check for overflow */
  96         if ((buf_len = strlen(var)) + 1 + len > sizeof(buf))
  97                 return -1;
  98
  99         strcpy(buf, var);
 100         buf_len += 1;
 101
 102         /* append int value onto the end of the name string */
 103         memcpy(&(buf[buf_len]), val, len);
 104         buf_len += len;
 105
 106         ret = wl_ioctl(dev, WLC_SET_VAR, buf, buf_len);
 107         return ret;
 108 }
 109
 110 static int wl_get_val(struct net_device *dev, char *var, void *val, int len)
 111 {
 112         char buf[128];
 113         int buf_len;
 114         int ret;
 115
 116         /* check for overflow */
 117         if ((buf_len = strlen(var)) + 1 > sizeof(buf) || len > sizeof(buf))
 118                 return -1;
 119
 120         strcpy(buf, var);
 121         if (ret = wl_ioctl(dev, WLC_GET_VAR, buf, buf_len + len))
 122                 return ret;
 123
 124         memcpy(val, buf, len);
 125         return 0;
 126 }
 127
 128 int get_primary_key(struct net_device *dev)
 129 {
 130         int key, val;
 131
 132         for (key = val = 0; (key < 4) && (val == 0); key++) {
 133                 val = key;
 134                 if (wl_ioctl(dev, WLC_GET_KEY_PRIMARY, &val, sizeof(val)) < 0)
 135                         return -EINVAL;
 136         }
 137         return key;
 138 }
 139
 140
 141 static int wlcompat_ioctl_getiwrange(struct net_device *dev,
 142                                     char *extra)
 143 {
 144         int i, k;
 145         struct iw_range *range;
 146
 147         range = (struct iw_range *) extra;
 148         bzero(extra, sizeof(struct iw_range));
 149
 150         range->we_version_compiled = WIRELESS_EXT;
 151         range->we_version_source = WIRELESS_EXT;
 152
 153         range->min_nwid = range->max_nwid = 0;
 154
 155         range->num_channels = NUM_CHANNELS;
 156         k = 0;
 157         for (i = 0; i < NUM_CHANNELS; i++) {
 158                 range->freq[k].i = i + 1;
 159                 range->freq[k].m = channel_frequency[i] * 100000;
 160                 range->freq[k].e = 1;
 161                 k++;
 162                 if (k >= IW_MAX_FREQUENCIES)
 163                         break;
 164         }
 165         range->num_frequency = k;
 166         range->sensitivity = 3;
 167
 168         /* nbd: don't know what this means, but other drivers set it this way */
 169         range->pmp_flags = IW_POWER_PERIOD;
 170         range->pmt_flags = IW_POWER_TIMEOUT;
 171         range->pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT | IW_POWER_UNICAST_R;
 172
 173         range->min_pmp = 0;
 174         range->max_pmp = 65535000;
 175         range->min_pmt = 0;
 176         range->max_pmt = 65535 * 1000;
 177
 178         range->max_qual.qual = 0;
 179         range->max_qual.level = 0;
 180         range->max_qual.noise = 0;
 181
 182         range->min_rts = 0;
 183         if (wl_ioctl(dev, WLC_GET_RTS, &range->max_rts, sizeof(int)) < 0)
 184                 range->max_rts = 2347;
 185
 186         range->min_frag = 256;
 187
 188         if (wl_ioctl(dev, WLC_GET_FRAG, &range->max_frag, sizeof(int)) < 0)
 189                 range->max_frag = 2346;
 190
 191         range->txpower_capa = IW_TXPOW_DBM;
 192
 193         return 0;
 194 }
 195
 196
 197 static int wlcompat_set_scan(struct net_device *dev,
 198                          struct iw_request_info *info,
 199                          union iwreq_data *wrqu,
 200                          char *extra)
 201 {
 202         int ap = 0, oldap = 0;
 203         wl_scan_params_t params;
 204
 205         memset(&params, 0, sizeof(params));
 206
 207         /* use defaults (same parameters as wl scan) */
 208         memset(&params.bssid, 0xff, sizeof(params.bssid));
 209         params.bss_type = DOT11_BSSTYPE_ANY;
 210         params.scan_type = -1;
 211         params.nprobes = -1;
 212         params.active_time = -1;
 213         params.passive_time = -1;
 214         params.home_time = -1;
 215
 216         /* can only scan in STA mode */
 217         wl_ioctl(dev, WLC_GET_AP, &oldap, sizeof(oldap));
 218         if (oldap > 0)
 219                 wl_ioctl(dev, WLC_SET_AP, &ap, sizeof(ap));
 220
 221         if (wl_ioctl(dev, WLC_SCAN, &params, 64) < 0)
 222                 return -EINVAL;
 223
 224         if (oldap > 0)
 225                 wl_ioctl(dev, WLC_SET_AP, &oldap, sizeof(oldap));
 226
 227         return 0;
 228 }
 229
 230
 231 struct iw_statistics *wlcompat_get_wireless_stats(struct net_device *dev)
 232 {
 233         wl_bss_info_t *bss_info = (wl_bss_info_t *) buf;
 234         get_pktcnt_t pkt;
 235         unsigned int rssi, noise, ap;
 236
 237         memset(&wstats, 0, sizeof(wstats));
 238         memset(&pkt, 0, sizeof(pkt));
 239         memset(buf, 0, sizeof(buf));
 240         bss_info->version = 0x2000;
 241         wl_ioctl(dev, WLC_GET_BSS_INFO, bss_info, WLC_IOCTL_MAXLEN);
 242         wl_ioctl(dev, WLC_GET_PKTCNTS, &pkt, sizeof(pkt));
 243
 244         rssi = 0;
 245         if ((wl_ioctl(dev, WLC_GET_AP, &ap, sizeof(ap)) < 0) || ap) {
 246                 if (wl_ioctl(dev, WLC_GET_PHY_NOISE, &noise, sizeof(noise)) < 0)
 247                         noise = 0;
 248         } else {
 249                 // somehow the structure doesn't fit here
 250                 rssi = buf[82];
 251                 noise = buf[84];
 252         }
 253         rssi = (rssi == 0 ? 1 : rssi);
 254         wstats.qual.updated = 0x10;
 255         if (rssi <= 1)
 256                 wstats.qual.updated |= 0x20;
 257         if (noise <= 1)
 258                 wstats.qual.updated |= 0x40;
 259
 260         if ((wstats.qual.updated & 0x60) == 0x60)
 261                 return NULL;
 262
 263         wstats.qual.level = rssi;
 264         wstats.qual.noise = noise;
 265         wstats.discard.misc = pkt.rx_bad_pkt;
 266         wstats.discard.retries = pkt.tx_bad_pkt;
 267
 268         return &wstats;
 269 }
 270
 271 static int wlcompat_get_scan(struct net_device *dev,
 272                          struct iw_request_info *info,
 273                          union iwreq_data *wrqu,
 274                          char *extra)
 275 {
 276         wl_scan_results_t *results = (wl_scan_results_t *) buf;
 277         wl_bss_info_t *bss_info;
 278         char *info_ptr;
 279         char *current_ev = extra;
 280         char *current_val;
 281         char *end_buf = extra + IW_SCAN_MAX_DATA;
 282         struct iw_event iwe;
 283         int i, j;
 284         int rssi, noise;
 285
 286         results->buflen = WLC_IOCTL_MAXLEN - sizeof(wl_scan_results_t);
 287
 288         if (wl_ioctl(dev, WLC_SCAN_RESULTS, buf, WLC_IOCTL_MAXLEN) < 0)
 289                 return -EAGAIN;
 290
 291         bss_info = &(results->bss_info[0]);
 292         info_ptr = (char *) bss_info;
 293         for (i = 0; i < results->count; i++) {
 294
 295                 /* send the cell address (must be sent first) */
 296                 iwe.cmd = SIOCGIWAP;
 297                 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
 298                 memcpy(&iwe.u.ap_addr.sa_data, &bss_info->BSSID, sizeof(bss_info->BSSID));
 299                 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_ADDR_LEN);
 300
 301                 /* send the ESSID */
 302                 iwe.cmd = SIOCGIWESSID;
 303                 iwe.u.data.length = bss_info->SSID_len;
 304                 if (iwe.u.data.length > IW_ESSID_MAX_SIZE)
 305                         iwe.u.data.length = IW_ESSID_MAX_SIZE;
 306                 iwe.u.data.flags = 1;
 307                 current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, bss_info->SSID);
 308
 309                 /* send mode */
 310                 if  (bss_info->capability & (DOT11_CAP_ESS | DOT11_CAP_IBSS)) {
 311                         iwe.cmd = SIOCGIWMODE;
 312                         if (bss_info->capability & DOT11_CAP_ESS)
 313                                 iwe.u.mode = IW_MODE_MASTER;
 314                         else if (bss_info->capability & DOT11_CAP_IBSS)
 315                                 iwe.u.mode = IW_MODE_ADHOC;
 316                         current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_UINT_LEN);
 317                 }
 318
 319                 /* send frequency/channel info */
 320                 iwe.cmd = SIOCGIWFREQ;
 321                 iwe.u.freq.e = 0;
 322                 iwe.u.freq.m = bss_info->channel;
 323                 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_FREQ_LEN);
 324
 325                 /* add quality statistics */
 326                 iwe.cmd = IWEVQUAL;
 327                 iwe.u.qual.qual = 0;
 328                 iwe.u.qual.level = bss_info->RSSI;
 329                 iwe.u.qual.noise = bss_info->phy_noise;
 330                 current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_QUAL_LEN);
 331
 332                 /* send encryption capability */
 333                 iwe.cmd = SIOCGIWENCODE;
 334                 iwe.u.data.pointer = NULL;
 335                 iwe.u.data.length = 0;
 336                 if (bss_info->capability & DOT11_CAP_PRIVACY)
 337                         iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
 338                 else
 339                         iwe.u.data.flags = IW_ENCODE_DISABLED;
 340                 current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, NULL);
 341
 342                 /* send rate information */
 343                 iwe.cmd = SIOCGIWRATE;
 344                 current_val = current_ev + IW_EV_LCP_LEN;
 345                 iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
 346
 347                 for(j = 0 ; j < bss_info->rateset.count ; j++) {
 348                         iwe.u.bitrate.value = ((bss_info->rateset.rates[j] & 0x7f) * 500000);
 349                         current_val = iwe_stream_add_value(current_ev, current_val, end_buf, &iwe, IW_EV_PARAM_LEN);
 350                 }
 351                 if((current_val - current_ev) > IW_EV_LCP_LEN)
 352                         current_ev = current_val;
 353
 354                 info_ptr += sizeof(wl_bss_info_t);
 355                 if (bss_info->ie_length % 4)
 356                         info_ptr += bss_info->ie_length + 4 - (bss_info->ie_length % 4);
 357                 else
 358                         info_ptr += bss_info->ie_length;
 359                 bss_info = (wl_bss_info_t *) info_ptr;
 360         }
 361
 362         wrqu->data.length = (current_ev - extra);
 363         wrqu->data.flags = 0;
 364
 365         return 0;
 366 }
 367
 368 static int wlcompat_ioctl(struct net_device *dev,
 369                          struct iw_request_info *info,
 370                          union iwreq_data *wrqu,
 371                          char *extra)
 372 {
 373         switch (info->cmd) {
 374                 case SIOCGIWNAME:
 375                         strcpy(wrqu->name, "IEEE 802.11-DS");
 376                         break;
 377                 case SIOCGIWFREQ:
 378                 {
 379                         channel_info_t ci;
 380
 381                         if (wl_ioctl(dev,WLC_GET_CHANNEL, &ci, sizeof(ci)) < 0)
 382                                 return -EINVAL;
 383
 384                         wrqu->freq.m = ci.target_channel;
 385                         wrqu->freq.e = 0;
 386                         break;
 387                 }
 388                 case SIOCSIWFREQ:
 389                 {
 390                         if (wrqu->freq.m == -1) {
 391                                 wrqu->freq.m = 0;
 392                                 if (wl_ioctl(dev, WLC_SET_CHANNEL, &wrqu->freq.m, sizeof(int)) < 0)
 393                                         return -EINVAL;
 394                         } else {
 395                                 if (wrqu->freq.e == 1) {
 396                                         int channel = 0;
 397                                         int f = wrqu->freq.m / 100000;
 398                                         while ((channel < NUM_CHANNELS + 1) && (f != channel_frequency[channel]))
 399                                                 channel++;
 400
 401                                         if (channel == NUM_CHANNELS) // channel not found
 402                                                 return -EINVAL;
 403
 404                                         wrqu->freq.e = 0;
 405                                         wrqu->freq.m = channel + 1;
 406                                 }
 407                                 if ((wrqu->freq.e == 0) && (wrqu->freq.m < 1000)) {
 408                                         if (wl_ioctl(dev, WLC_SET_CHANNEL, &wrqu->freq.m, sizeof(int)) < 0)
 409                                                 return -EINVAL;
 410                                 } else {
 411                                         return -EINVAL;
 412                                 }
 413                         }
 414                         break;
 415                 }
 416                 case SIOCSIWAP:
 417                 {
 418                         int ap = 0;
 419                         int infra = 0;
 420                         rw_reg_t reg;
 421
 422                         memset(&reg, 0, sizeof(reg));
 423
 424                         if (wrqu->ap_addr.sa_family != ARPHRD_ETHER)
 425                                 return -EINVAL;
 426
 427                         if (wl_ioctl(dev, WLC_GET_AP, &ap, sizeof(ap)) < 0)
 428                                 return -EINVAL;
 429
 430                         if (wl_ioctl(dev, WLC_GET_INFRA, &infra, sizeof(infra)) < 0)
 431                                 return -EINVAL;
 432
 433                         if (!infra) {
 434                                 wl_ioctl(dev, WLC_SET_BSSID, wrqu->ap_addr.sa_data, 6);
 435
 436                                 reg.size = 4;
 437                                 reg.byteoff = 0x184;
 438                                 reg.val = bss_force << 16 | bss_force;
 439                                 wl_ioctl(dev, WLC_W_REG, &reg, sizeof(reg));
 440
 441                                 reg.byteoff = 0x180;
 442                                 wl_ioctl(dev, WLC_R_REG, &reg, sizeof(reg));
 443                                 reg.val = bss_force << 16;
 444                                 wl_ioctl(dev, WLC_W_REG, &reg, sizeof(reg));
 445                         }
 446
 447                         if (wl_ioctl(dev, ((ap || !infra) ? WLC_SET_BSSID : WLC_REASSOC), wrqu->ap_addr.sa_data, 6) < 0)
 448                                 return -EINVAL;
 449
 450                         break;
 451                 }
 452                 case SIOCGIWAP:
 453                 {
 454 #ifdef DEBUG
 455                         rw_reg_t reg;
 456                         memset(&reg, 0, sizeof(reg));
 457
 458                         reg.size = 4;
 459                         reg.byteoff = 0x184;
 460                         wl_ioctl(dev, WLC_R_REG, &reg, sizeof(reg));
 461                         printk("bss time = 0x%08x", reg.val);
 462
 463                         reg.byteoff = 0x180;
 464                         wl_ioctl(dev, WLC_R_REG, &reg, sizeof(reg));
 465                         printk("%08x\n", reg.val);
 466 #endif
 467
 468                         wrqu->ap_addr.sa_family = ARPHRD_ETHER;
 469                         if (wl_ioctl(dev,WLC_GET_BSSID,wrqu->ap_addr.sa_data,6) < 0)
 470                                 return -EINVAL;
 471                         break;
 472                 }
 473                 case SIOCGIWESSID:
 474                 {
 475                         wlc_ssid_t ssid;
 476
 477                         if (wl_ioctl(dev,WLC_GET_SSID, &ssid, sizeof(wlc_ssid_t)) < 0)
 478                                 return -EINVAL;
 479
 480                         wrqu->essid.flags = wrqu->data.flags = 1;
 481                         wrqu->essid.length = wrqu->data.length = ssid.SSID_len + 1;
 482                         memcpy(extra,ssid.SSID,ssid.SSID_len + 1);
 483                         break;
 484                 }
 485                 case SIOCSIWESSID:
 486                 {
 487                         wlc_ssid_t ssid;
 488                         memset(&ssid, 0, sizeof(ssid));
 489                         ssid.SSID_len = strlen(extra);
 490                         if (ssid.SSID_len > WLC_ESSID_MAX_SIZE)
 491                                 ssid.SSID_len = WLC_ESSID_MAX_SIZE;
 492                         memcpy(ssid.SSID, extra, ssid.SSID_len);
 493                         if (wl_ioctl(dev, WLC_SET_SSID, &ssid, sizeof(ssid)) < 0)
 494                                 return -EINVAL;
 495                         break;
 496                 }
 497                 case SIOCGIWRTS:
 498                 {
 499                         if (wl_ioctl(dev,WLC_GET_RTS,&(wrqu->rts.value),sizeof(int)) < 0)
 500                                 return -EINVAL;
 501                         break;
 502                 }
 503                 case SIOCSIWRTS:
 504                 {
 505                         if (wl_ioctl(dev,WLC_SET_RTS,&(wrqu->rts.value),sizeof(int)) < 0)
 506                                 return -EINVAL;
 507                         break;
 508                 }
 509                 case SIOCGIWFRAG:
 510                 {
 511                         if (wl_ioctl(dev,WLC_GET_FRAG,&(wrqu->frag.value),sizeof(int)) < 0)
 512                                 return -EINVAL;
 513                         break;
 514                 }
 515                 case SIOCSIWFRAG:
 516                 {
 517                         if (wl_ioctl(dev,WLC_SET_FRAG,&(wrqu->frag.value),sizeof(int)) < 0)
 518                                 return -EINVAL;
 519                         break;
 520                 }
 521                 case SIOCGIWTXPOW:
 522                 {
 523                         int radio, override;
 524
 525                         wl_ioctl(dev, WLC_GET_RADIO, &radio, sizeof(int));
 526
 527                         if (wl_get_val(dev, "qtxpower", &(wrqu->txpower.value), sizeof(int)) < 0)
 528                                 return -EINVAL;
 529
 530                         override = (wrqu->txpower.value & WL_TXPWR_OVERRIDE) == WL_TXPWR_OVERRIDE;
 531                         wrqu->txpower.value &= ~WL_TXPWR_OVERRIDE;
 532                         if (!override && (wrqu->txpower.value > 76))
 533                                 wrqu->txpower.value = 76;
 534                         wrqu->txpower.value /= 4;
 535
 536                         wrqu->txpower.fixed = 0;
 537                         wrqu->txpower.disabled = radio;
 538                         wrqu->txpower.flags = IW_TXPOW_DBM;
 539                         break;
 540                 }
 541                 case SIOCSIWTXPOW:
 542                 {
 543                         /* This is weird: WLC_SET_RADIO with 1 as argument disables the radio */
 544                         int radio = wrqu->txpower.disabled;
 545
 546                         wl_ioctl(dev, WLC_SET_RADIO, &radio, sizeof(int));
 547
 548                         if (!wrqu->txpower.disabled && (wrqu->txpower.value > 0)) {
 549                                 int value;
 550
 551                                 if (wl_get_val(dev, "qtxpower", &value, sizeof(int)) < 0)
 552                                         return -EINVAL;
 553
 554                                 value &= WL_TXPWR_OVERRIDE;
 555                                 wrqu->txpower.value *= 4;
 556                                 wrqu->txpower.value |= value;
 557
 558                                 if (wrqu->txpower.flags != IW_TXPOW_DBM)
 559                                         return -EINVAL;
 560
 561                                 if (wrqu->txpower.value > 0)
 562                                         if (wl_set_val(dev, "qtxpower", &(wrqu->txpower.value), sizeof(int)) < 0)
 563                                                 return -EINVAL;
 564                         }
 565                         break;
 566                 }
 567                 case SIOCSIWENCODE:
 568                 {
 569                         int val = 0, wep = 1, wrestrict = 1;
 570                         int index = (wrqu->data.flags & IW_ENCODE_INDEX) - 1;
 571
 572                         if (index < 0)
 573                                 index = get_primary_key(dev);
 574
 575                         if (wrqu->data.flags & IW_ENCODE_DISABLED) {
 576                                 wep = 0;
 577                                 if (wl_ioctl(dev, WLC_SET_WSEC, &wep, sizeof(val)) < 0)
 578                                         return -EINVAL;
 579                                 return 0;
 580                         }
 581
 582                         if (wl_ioctl(dev, WLC_SET_WSEC, &wep, sizeof(val)) < 0)
 583                                 return -EINVAL;
 584
 585                         if (wrqu->data.flags & IW_ENCODE_OPEN)
 586                                 wrestrict = 0;
 587
 588                         if (wrqu->data.pointer && (wrqu->data.length > 0) && (wrqu->data.length <= 16)) {
 589                                 wl_wsec_key_t key;
 590                                 memset(&key, 0, sizeof(key));
 591
 592                                 key.flags = WL_PRIMARY_KEY;
 593                                 key.len = wrqu->data.length;
 594                                 key.index = index;
 595                                 memcpy(key.data, wrqu->data.pointer, wrqu->data.length);
 596
 597                                 if (wl_ioctl(dev, WLC_SET_KEY, &key, sizeof(key)) < 0)
 598                                         return -EINVAL;
 599                         }
 600
 601                         if (index >= 0)
 602                                 wl_ioctl(dev, WLC_SET_KEY_PRIMARY, &index, sizeof(index));
 603
 604                         if (wrestrict >= 0)
 605                                 wl_ioctl(dev, WLC_SET_WEP_RESTRICT, &wrestrict, sizeof(wrestrict));
 606
 607                         break;
 608                 }
 609                 case SIOCGIWENCODE:
 610                 {
 611                         int val;
 612
 613                         if (wl_ioctl(dev, WLC_GET_WEP, &val, sizeof(val)) < 0)
 614                                 return -EINVAL;
 615
 616
 617                         if (val > 0) {
 618                                 int key = get_primary_key(dev);
 619
 620                                 wrqu->data.flags = IW_ENCODE_ENABLED;
 621                                 if (key-- > 0) {
 622                                         int *info_addr;
 623                                         wkey *wep_key;
 624
 625                                         info_addr = (int *) dev->priv;
 626                                         wep_key = (wkey *) ((*info_addr) + 0x2752 + (key * 0x110));
 627
 628                                         wrqu->data.flags |= key + 1;
 629                                         wrqu->data.length = wep_key->len;
 630
 631                                         memset(extra, 0, 16);
 632                                         memcpy(extra, wep_key->data, 16);
 633                                 } else {
 634                                         wrqu->data.flags |= IW_ENCODE_NOKEY;
 635                                 }
 636                         } else {
 637                                 wrqu->data.flags = IW_ENCODE_DISABLED;
 638                         }
 639
 640                         break;
 641                 }
 642                 case SIOCGIWRANGE:
 643                 {
 644                         return wlcompat_ioctl_getiwrange(dev, extra);
 645                         break;
 646                 }
 647                 case SIOCSIWMODE:
 648                 {
 649                         int ap = -1, infra = -1, passive = 0, wet = 0;
 650
 651                         switch (wrqu->mode) {
 652                                 case IW_MODE_MONITOR:
 653                                         passive = 1;
 654                                         break;
 655                                 case IW_MODE_ADHOC:
 656                                         infra = 0;
 657                                         ap = 0;
 658                                         break;
 659                                 case IW_MODE_MASTER:
 660                                         infra = 1;
 661                                         ap = 1;
 662                                         break;
 663                                 case IW_MODE_INFRA:
 664                                         infra = 1;
 665                                         ap = 0;
 666                                         break;
 667                                 case IW_MODE_REPEAT:
 668                                         infra = 1;
 669                                         ap = 0;
 670                                         wet = 1;
 671                                         break;
 672
 673                                 default:
 674                                         return -EINVAL;
 675                         }
 676
 677                         wl_ioctl(dev, WLC_SET_PASSIVE, &passive, sizeof(passive));
 678                         wl_ioctl(dev, WLC_SET_MONITOR, &passive, sizeof(passive));
 679                         wl_ioctl(dev, WLC_SET_WET, &wet, sizeof(wet));
 680                         if (ap >= 0)
 681                                 wl_ioctl(dev, WLC_SET_AP, &ap, sizeof(ap));
 682                         if (infra >= 0)
 683                                 wl_ioctl(dev, WLC_SET_INFRA, &infra, sizeof(infra));
 684
 685                         break;
 686
 687                 }
 688                 case SIOCGIWMODE:
 689                 {
 690                         int ap, infra, wet, passive;
 691
 692                         if (wl_ioctl(dev, WLC_GET_AP, &ap, sizeof(ap)) < 0)
 693                                 return -EINVAL;
 694                         if (wl_ioctl(dev, WLC_GET_INFRA, &infra, sizeof(infra)) < 0)
 695                                 return -EINVAL;
 696                         if (wl_ioctl(dev, WLC_GET_PASSIVE, &passive, sizeof(passive)) < 0)
 697                                 return -EINVAL;
 698                         if (wl_ioctl(dev, WLC_GET_WET, &wet, sizeof(wet)) < 0)
 699                                 return -EINVAL;
 700
 701                         if (passive) {
 702                                 wrqu->mode = IW_MODE_MONITOR;
 703                         } else if (!infra) {
 704                                 wrqu->mode = IW_MODE_ADHOC;
 705                         } else {
 706                                 if (ap) {
 707                                         wrqu->mode = IW_MODE_MASTER;
 708                                 } else {
 709                                         if (wet) {
 710                                                 wrqu->mode = IW_MODE_REPEAT;
 711                                         } else {
 712                                                 wrqu->mode = IW_MODE_INFRA;
 713                                         }
 714                                 }
 715                         }
 716                         break;
 717                 }
 718                 default:
 719                 {
 720                         if (info->cmd >= SIOCIWFIRSTPRIV)
 721                                 return wlcompat_private_ioctl(dev, info, wrqu, extra);
 722
 723                         return -EINVAL;
 724                 }
 725         }
 726
 727         return 0;
 728 }
 729
 730 static const iw_handler  wlcompat_handler[] = {
 731         NULL,                   /* SIOCSIWCOMMIT */
 732         wlcompat_ioctl,         /* SIOCGIWNAME */
 733         NULL,                   /* SIOCSIWNWID */
 734         NULL,                   /* SIOCGIWNWID */
 735         wlcompat_ioctl,         /* SIOCSIWFREQ */
 736         wlcompat_ioctl,         /* SIOCGIWFREQ */
 737         wlcompat_ioctl,         /* SIOCSIWMODE */
 738         wlcompat_ioctl,         /* SIOCGIWMODE */
 739         NULL,                   /* SIOCSIWSENS */
 740         NULL,                   /* SIOCGIWSENS */
 741         NULL,                   /* SIOCSIWRANGE, unused */
 742         wlcompat_ioctl,         /* SIOCGIWRANGE */
 743         NULL,                   /* SIOCSIWPRIV */
 744         NULL,                   /* SIOCGIWPRIV */
 745         NULL,                   /* SIOCSIWSTATS */
 746         NULL,                   /* SIOCGIWSTATS */
 747         iw_handler_set_spy,     /* SIOCSIWSPY */
 748         iw_handler_get_spy,     /* SIOCGIWSPY */
 749         iw_handler_set_thrspy,  /* SIOCSIWTHRSPY */
 750         iw_handler_get_thrspy,  /* SIOCGIWTHRSPY */
 751         wlcompat_ioctl,         /* SIOCSIWAP */
 752         wlcompat_ioctl,         /* SIOCGIWAP */
 753         NULL,                   /* -- hole -- */
 754         NULL,                   /* SIOCGIWAPLIST */
 755         wlcompat_set_scan,      /* SIOCSIWSCAN */
 756         wlcompat_get_scan,      /* SIOCGIWSCAN */
 757         wlcompat_ioctl,         /* SIOCSIWESSID */
 758         wlcompat_ioctl,         /* SIOCGIWESSID */
 759         NULL,                   /* SIOCSIWNICKN */
 760         NULL,                   /* SIOCGIWNICKN */
 761         NULL,                   /* -- hole -- */
 762         NULL,                   /* -- hole -- */
 763         NULL,                   /* SIOCSIWRATE */
 764         NULL,                   /* SIOCGIWRATE */
 765         wlcompat_ioctl,         /* SIOCSIWRTS */
 766         wlcompat_ioctl,         /* SIOCGIWRTS */
 767         wlcompat_ioctl,         /* SIOCSIWFRAG */
 768         wlcompat_ioctl,         /* SIOCGIWFRAG */
 769         wlcompat_ioctl,         /* SIOCSIWTXPOW */
 770         wlcompat_ioctl,         /* SIOCGIWTXPOW */
 771         NULL,                   /* SIOCSIWRETRY */
 772         NULL,                   /* SIOCGIWRETRY */
 773         wlcompat_ioctl,         /* SIOCSIWENCODE */
 774         wlcompat_ioctl,         /* SIOCGIWENCODE */
 775 };
 776
 777
 778 #define WLCOMPAT_SET_MONITOR            SIOCIWFIRSTPRIV + 0
 779 #define WLCOMPAT_GET_MONITOR            SIOCIWFIRSTPRIV + 1
 780 #define WLCOMPAT_SET_TXPWR_LIMIT        SIOCIWFIRSTPRIV + 2
 781 #define WLCOMPAT_GET_TXPWR_LIMIT        SIOCIWFIRSTPRIV + 3
 782 #define WLCOMPAT_SET_ANTDIV                     SIOCIWFIRSTPRIV + 4
 783 #define WLCOMPAT_GET_ANTDIV                     SIOCIWFIRSTPRIV + 5
 784 #define WLCOMPAT_SET_TXANT                      SIOCIWFIRSTPRIV + 6
 785 #define WLCOMPAT_GET_TXANT                      SIOCIWFIRSTPRIV + 7
 786 #define WLCOMPAT_SET_BSS_FORCE          SIOCIWFIRSTPRIV + 8
 787 #define WLCOMPAT_GET_BSS_FORCE          SIOCIWFIRSTPRIV + 9
 788
 789
 790 static int wlcompat_private_ioctl(struct net_device *dev,
 791                          struct iw_request_info *info,
 792                          union iwreq_data *wrqu,
 793                          char *extra)
 794 {
 795         int *value = (int *) wrqu->name;
 796
 797         switch (info->cmd) {
 798                 case WLCOMPAT_SET_MONITOR:
 799                 {
 800                         if (wl_ioctl(dev, WLC_SET_MONITOR, value, sizeof(int)) < 0)
 801                                 return -EINVAL;
 802
 803                         break;
 804                 }
 805                 case WLCOMPAT_GET_MONITOR:
 806                 {
 807                         if (wl_ioctl(dev, WLC_GET_MONITOR, extra, sizeof(int)) < 0)
 808                                 return -EINVAL;
 809
 810                         break;
 811                 }
 812                 case WLCOMPAT_SET_TXPWR_LIMIT:
 813                 {
 814                         int val;
 815
 816
 817                         if (wl_get_val(dev, "qtxpower", &val, sizeof(int)) < 0)
 818                                 return -EINVAL;
 819
 820                         if (*extra > 0)
 821                                 val |= WL_TXPWR_OVERRIDE;
 822                         else
 823                                 val &= ~WL_TXPWR_OVERRIDE;
 824
 825                         if (wl_set_val(dev, "qtxpower", &val, sizeof(int)) < 0)
 826                                 return -EINVAL;
 827
 828                         break;
 829                 }
 830                 case WLCOMPAT_GET_TXPWR_LIMIT:
 831                 {
 832                         if (wl_get_val(dev, "qtxpower", value, sizeof(int)) < 0)
 833                                 return -EINVAL;
 834
 835                         *value = ((*value & WL_TXPWR_OVERRIDE) == WL_TXPWR_OVERRIDE ? 1 : 0);
 836
 837                         break;
 838                 }
 839                 case WLCOMPAT_SET_ANTDIV:
 840                 {
 841                         if (wl_ioctl(dev, WLC_SET_ANTDIV, value, sizeof(int)) < 0)
 842                                 return -EINVAL;
 843
 844                         break;
 845                 }
 846                 case WLCOMPAT_GET_ANTDIV:
 847                 {
 848                         if (wl_ioctl(dev, WLC_GET_ANTDIV, extra, sizeof(int)) < 0)
 849                                 return -EINVAL;
 850
 851                         break;
 852                 }
 853                 case WLCOMPAT_SET_TXANT:
 854                 {
 855                         if (wl_ioctl(dev, WLC_SET_TXANT, value, sizeof(int)) < 0)
 856                                 return -EINVAL;
 857
 858                         break;
 859                 }
 860                 case WLCOMPAT_GET_TXANT:
 861                 {
 862                         if (wl_ioctl(dev, WLC_GET_TXANT, extra, sizeof(int)) < 0)
 863                                 return -EINVAL;
 864
 865                         break;
 866                 }
 867                 case WLCOMPAT_SET_BSS_FORCE:
 868                 {
 869                         bss_force = (unsigned short) *value;
 870                         break;
 871                 }
 872                 case WLCOMPAT_GET_BSS_FORCE:
 873                 {
 874                         *extra = (int) bss_force;
 875                         break;
 876                 }
 877                 default:
 878                 {
 879                         return -EINVAL;
 880                 }
 881
 882         }
 883         return 0;
 884 }
 885
 886 static const struct iw_priv_args wlcompat_private_args[] =
 887 {
 888         {       WLCOMPAT_SET_MONITOR,
 889                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
 890                 0,
 891                 "set_monitor"
 892         },
 893         {       WLCOMPAT_GET_MONITOR,
 894                 0,
 895                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
 896                 "get_monitor"
 897         },
 898         {       WLCOMPAT_SET_TXPWR_LIMIT,
 899                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
 900                 0,
 901                 "set_txpwr_force"
 902         },
 903         {       WLCOMPAT_GET_TXPWR_LIMIT,
 904                 0,
 905                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
 906                 "get_txpwr_force"
 907         },
 908         {       WLCOMPAT_SET_ANTDIV,
 909                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
 910                 0,
 911                 "set_antdiv"
 912         },
 913         {       WLCOMPAT_GET_ANTDIV,
 914                 0,
 915                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
 916                 "get_antdiv"
 917         },
 918         {       WLCOMPAT_SET_TXANT,
 919                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
 920                 0,
 921                 "set_txant"
 922         },
 923         {       WLCOMPAT_GET_TXANT,
 924                 0,
 925                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
 926                 "get_txant"
 927         },
 928         {       WLCOMPAT_SET_BSS_FORCE,
 929                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
 930                 0,
 931                 "set_bss_force"
 932         },
 933         {       WLCOMPAT_GET_BSS_FORCE,
 934                 0,
 935                 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
 936                 "get_bss_force"
 937         },
 938 };
 939
 940 static const iw_handler wlcompat_private[] =
 941 {
 942         wlcompat_private_ioctl,
 943         NULL
 944 };
 945
 946
 947 static const struct iw_handler_def wlcompat_handler_def =
 948 {
 949         .standard       = (iw_handler *) wlcompat_handler,
 950         .num_standard   = sizeof(wlcompat_handler)/sizeof(iw_handler),
 951         .private        = wlcompat_private,
 952         .num_private    = 1,
 953         .private_args   = wlcompat_private_args,
 954         .num_private_args = sizeof(wlcompat_private_args) / sizeof(wlcompat_private_args[0])
 955 };
 956
 957
 958 #ifdef DEBUG
 959 void print_buffer(int len, unsigned char *buf) {
 960         int x;
 961         if (buf != NULL) {
 962                 for (x=0;x<len && x<180 ;x++) {
 963                         if ((x % 4) == 0)
 964                                 printk(" ");
 965                         printk("%02X",buf[x]);
 966                 }
 967         } else {
 968                 printk(" NULL");
 969         }
 970         printk("\n");
 971
 972 }
 973 #endif
 974 static int (*old_ioctl)(struct net_device *dev, struct ifreq *ifr, int cmd);
 975 static int new_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) {
 976         int ret = 0;
 977         struct iwreq *iwr = (struct iwreq *) ifr;
 978         struct iw_request_info info;
 979
 980 #ifdef DEBUG
 981         printk("dev: %s ioctl: 0x%04x\n",dev->name,cmd);
 982 #endif
 983
 984         if (cmd >= SIOCIWFIRSTPRIV) {
 985                 info.cmd = cmd;
 986                 info.flags = 0;
 987                 ret = wlcompat_private_ioctl(dev, &info, &(iwr->u), (char *) &(iwr->u));
 988 #ifdef DEBUG
 989         } else if (cmd==SIOCDEVPRIVATE) {
 990                 wl_ioctl_t *ioc = (wl_ioctl_t *)ifr->ifr_data;
 991                 unsigned char *buf = ioc->buf;
 992                 printk("   cmd: %d buf: 0x%08x len: %d\n",ioc->cmd,&(ioc->buf),ioc->len);
 993                 printk("   send: ->");
 994                 print_buffer(ioc->len, buf);
 995                 ret = old_ioctl(dev,ifr,cmd);
 996                 printk("   recv: ->");
 997                 print_buffer(ioc->len, buf);
 998                 printk("   ret: %d\n", ret);
 999 #endif
1000         } else {
1001                 ret = old_ioctl(dev,ifr,cmd);
1002         }
1003         return ret;
1004 }
1005
1006 #ifndef DEBUG
1007 static struct timer_list rng_timer;
1008
1009 static void rng_timer_tick(unsigned long n)
1010 {
1011         struct net_device *dev = (struct net_device *) n;
1012         u16 data[4];
1013         int i, ret;
1014
1015         ret = 0;
1016         for (i = 0; i < 3; i++) {
1017                 ret |= wl_get_val(dev, "rand", &data[i], sizeof(u16));
1018         }
1019         if (!ret)
1020                 batch_entropy_store(*((u32 *) &data[0]), *((u32 *) &data[2]), (jiffies % 255));
1021
1022         mod_timer(&rng_timer, jiffies + (HZ/RNG_POLL_FREQ));
1023 }
1024 #endif
1025
1026 static int __init wlcompat_init()
1027 {
1028         int found = 0, i;
1029         char devname[4] = "wl0";
1030         bss_force = 0;
1031
1032         while (!found && (dev = dev_get_by_name(devname))) {
1033                 if ((dev->wireless_handlers == NULL) && ((wl_ioctl(dev, WLC_GET_MAGIC, &i, sizeof(i)) == 0) && i == WLC_IOCTL_MAGIC))
1034                         found = 1;
1035                 devname[2]++;
1036         }
1037
1038         if (!found) {
1039                 printk("No Broadcom devices found.\n");
1040                 return -ENODEV;
1041         }
1042
1043
1044         old_ioctl = dev->do_ioctl;
1045         dev->do_ioctl = new_ioctl;
1046         dev->wireless_handlers = (struct iw_handler_def *)&wlcompat_handler_def;
1047         dev->get_wireless_stats = wlcompat_get_wireless_stats;
1048
1049 #ifndef DEBUG
1050         if (random) {
1051                 init_timer(&rng_timer);
1052                 rng_timer.function = rng_timer_tick;
1053                 rng_timer.data = (unsigned long) dev;
1054                 rng_timer_tick((unsigned long) dev);
1055         }
1056 #endif
1057
1058 #ifdef DEBUG
1059         printk("broadcom driver private data: 0x%08x\n", dev->priv);
1060 #endif
1061         return 0;
1062 }
1063
1064 static void __exit wlcompat_exit()
1065 {
1066 #ifndef DEBUG
1067         if (random)
1068                 del_timer(&rng_timer);
1069 #endif
1070         dev->get_wireless_stats = NULL;
1071         dev->wireless_handlers = NULL;
1072         dev->do_ioctl = old_ioctl;
1073         return;
1074 }
1075
1076 EXPORT_NO_SYMBOLS;
1077 MODULE_AUTHOR("openwrt.org");
1078 MODULE_LICENSE("GPL");
1079
1080 #ifndef DEBUG
1081 module_param(random, int, 0);
1082 #endif
1083 module_init(wlcompat_init);
1084 module_exit(wlcompat_exit);