Pileus Git - ~andy/linux/blob - drivers/staging/brcm80211/brcmfmac/wl_iw.c

   1 /*
   2  * Copyright (c) 2010 Broadcom Corporation
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  11  * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  13  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  14  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #include <wlioctl.h>
  18
  19 #include <typedefs.h>
  20 #include <linuxver.h>
  21 #include <linux/kthread.h>
  22 #include <osl.h>
  23
  24 #include <bcmutils.h>
  25 #include <bcmendian.h>
  26 #include <proto/ethernet.h>
  27
  28 #include <linux/if_arp.h>
  29 #include <asm/uaccess.h>
  30
  31 #include <dngl_stats.h>
  32 #include <dhd.h>
  33 #include <dhdioctl.h>
  34
  35 typedef void wlc_info_t;
  36 typedef void wl_info_t;
  37 typedef const struct si_pub si_t;
  38 #include <wlioctl.h>
  39
  40 #include <proto/ethernet.h>
  41 #include <dngl_stats.h>
  42 #include <dhd.h>
  43 #define WL_ERROR(x) printf x
  44 #define WL_TRACE(x)
  45 #define WL_ASSOC(x)
  46 #define WL_INFORM(x)
  47 #define WL_WSEC(x)
  48 #define WL_SCAN(x)
  49
  50 #include <wl_iw.h>
  51
  52 #define IW_WSEC_ENABLED(wsec)   ((wsec) & (WEP_ENABLED |        \
  53                                          TKIP_ENABLED | AES_ENABLED))
  54
  55 #include <linux/rtnetlink.h>
  56
  57 #define WL_IW_USE_ISCAN  1
  58 #define ENABLE_ACTIVE_PASSIVE_SCAN_SUPPRESS  1
  59
  60 bool g_set_essid_before_scan = TRUE;
  61
  62 #define WL_IW_IOCTL_CALL(func_call) \
  63         do {                            \
  64                 func_call;              \
  65         } while (0)
  66
  67 static int g_onoff = G_WLAN_SET_ON;
  68 wl_iw_extra_params_t g_wl_iw_params;
  69
  70 extern bool wl_iw_conn_status_str(u32 event_type, u32 status,
  71                                   u32 reason, char *stringBuf, uint buflen);
  72
  73 uint wl_msg_level = WL_ERROR_VAL;
  74
  75 #define MAX_WLIW_IOCTL_LEN 1024
  76
  77 #if defined(IL_BIGENDIAN)
  78 #include <bcmendian.h>
  79 #define htod32(i) (bcmswap32(i))
  80 #define htod16(i) (bcmswap16(i))
  81 #define dtoh32(i) (bcmswap32(i))
  82 #define dtoh16(i) (bcmswap16(i))
  83 #define htodchanspec(i) htod16(i)
  84 #define dtohchanspec(i) dtoh16(i)
  85 #else
  86 #define htod32(i) i
  87 #define htod16(i) i
  88 #define dtoh32(i) i
  89 #define dtoh16(i) i
  90 #define htodchanspec(i) i
  91 #define dtohchanspec(i) i
  92 #endif
  93
  94 #ifdef CONFIG_WIRELESS_EXT
  95
  96 extern struct iw_statistics *dhd_get_wireless_stats(struct net_device *dev);
  97 extern int dhd_wait_pend8021x(struct net_device *dev);
  98 #endif
  99
 100 #if WIRELESS_EXT < 19
 101 #define IW_IOCTL_IDX(cmd)       ((cmd) - SIOCIWFIRST)
 102 #define IW_EVENT_IDX(cmd)       ((cmd) - IWEVFIRST)
 103 #endif
 104
 105 static void *g_scan;
 106 static volatile uint g_scan_specified_ssid;
 107 static wlc_ssid_t g_specific_ssid;
 108
 109 static wlc_ssid_t g_ssid;
 110
 111 #if defined(WL_IW_USE_ISCAN)
 112 #define ISCAN_STATE_IDLE   0
 113 #define ISCAN_STATE_SCANING 1
 114
 115 #define WLC_IW_ISCAN_MAXLEN   2048
 116 typedef struct iscan_buf {
 117         struct iscan_buf *next;
 118         char iscan_buf[WLC_IW_ISCAN_MAXLEN];
 119 } iscan_buf_t;
 120
 121 typedef struct iscan_info {
 122         struct net_device *dev;
 123         struct timer_list timer;
 124         u32 timer_ms;
 125         u32 timer_on;
 126         int iscan_state;
 127         iscan_buf_t *list_hdr;
 128         iscan_buf_t *list_cur;
 129
 130         struct task_struct *sysioc_tsk;
 131         struct semaphore sysioc_sem;
 132
 133 #if defined CSCAN
 134         char ioctlbuf[WLC_IOCTL_MEDLEN];
 135 #else
 136         char ioctlbuf[WLC_IOCTL_SMLEN];
 137 #endif
 138         wl_iscan_params_t *iscan_ex_params_p;
 139         int iscan_ex_param_size;
 140 } iscan_info_t;
 141 iscan_info_t *g_iscan;
 142 static void wl_iw_timerfunc(unsigned long data);
 143 static void wl_iw_set_event_mask(struct net_device *dev);
 144 static int wl_iw_iscan(iscan_info_t *iscan, wlc_ssid_t *ssid, u16 action);
 145 #endif                          /* defined(WL_IW_USE_ISCAN) */
 146
 147 static int
 148 wl_iw_set_scan(struct net_device *dev,
 149                struct iw_request_info *info,
 150                union iwreq_data *wrqu, char *extra);
 151
 152 static int
 153 wl_iw_get_scan(struct net_device *dev,
 154                struct iw_request_info *info,
 155                struct iw_point *dwrq, char *extra);
 156
 157 static uint
 158 wl_iw_get_scan_prep(wl_scan_results_t *list,
 159                     struct iw_request_info *info, char *extra, short max_size);
 160
 161 static void swap_key_from_BE(wl_wsec_key_t *key)
 162 {
 163         key->index = htod32(key->index);
 164         key->len = htod32(key->len);
 165         key->algo = htod32(key->algo);
 166         key->flags = htod32(key->flags);
 167         key->rxiv.hi = htod32(key->rxiv.hi);
 168         key->rxiv.lo = htod16(key->rxiv.lo);
 169         key->iv_initialized = htod32(key->iv_initialized);
 170 }
 171
 172 static void swap_key_to_BE(wl_wsec_key_t *key)
 173 {
 174         key->index = dtoh32(key->index);
 175         key->len = dtoh32(key->len);
 176         key->algo = dtoh32(key->algo);
 177         key->flags = dtoh32(key->flags);
 178         key->rxiv.hi = dtoh32(key->rxiv.hi);
 179         key->rxiv.lo = dtoh16(key->rxiv.lo);
 180         key->iv_initialized = dtoh32(key->iv_initialized);
 181 }
 182
 183 static int dev_wlc_ioctl(struct net_device *dev, int cmd, void *arg, int len)
 184 {
 185         struct ifreq ifr;
 186         wl_ioctl_t ioc;
 187         mm_segment_t fs;
 188         int ret = -EINVAL;
 189
 190         if (!dev) {
 191                 WL_ERROR(("%s: dev is null\n", __func__));
 192                 return ret;
 193         }
 194
 195         WL_INFORM(("\n%s, PID:%x: send Local IOCTL -> dhd: cmd:0x%x, buf:%p, "
 196                 "len:%d ,\n", __func__, current->pid, cmd, arg, len));
 197
 198         if (g_onoff == G_WLAN_SET_ON) {
 199                 memset(&ioc, 0, sizeof(ioc));
 200                 ioc.cmd = cmd;
 201                 ioc.buf = arg;
 202                 ioc.len = len;
 203
 204                 strcpy(ifr.ifr_name, dev->name);
 205                 ifr.ifr_data = (caddr_t)&ioc;
 206
 207                 ret = dev_open(dev);
 208                 if (ret) {
 209                         WL_ERROR(("%s: Error dev_open: %d\n", __func__, ret));
 210                         return ret;
 211                 }
 212
 213                 fs = get_fs();
 214                 set_fs(get_ds());
 215                 ret = dev->netdev_ops->ndo_do_ioctl(dev, &ifr, SIOCDEVPRIVATE);
 216                 set_fs(fs);
 217         } else {
 218                 WL_TRACE(("%s: call after driver stop : ignored\n", __func__));
 219         }
 220         return ret;
 221 }
 222
 223 static int dev_wlc_intvar_set(struct net_device *dev, char *name, int val)
 224 {
 225         char buf[WLC_IOCTL_SMLEN];
 226         uint len;
 227
 228         val = htod32(val);
 229         len = bcm_mkiovar(name, (char *)(&val), sizeof(val), buf, sizeof(buf));
 230         ASSERT(len);
 231
 232         return dev_wlc_ioctl(dev, WLC_SET_VAR, buf, len);
 233 }
 234
 235 #if defined(WL_IW_USE_ISCAN)
 236 static int
 237 dev_iw_iovar_setbuf(struct net_device *dev,
 238                     char *iovar,
 239                     void *param, int paramlen, void *bufptr, int buflen)
 240 {
 241         int iolen;
 242
 243         iolen = bcm_mkiovar(iovar, param, paramlen, bufptr, buflen);
 244         ASSERT(iolen);
 245
 246         if (iolen == 0)
 247                 return 0;
 248
 249         return dev_wlc_ioctl(dev, WLC_SET_VAR, bufptr, iolen);
 250 }
 251
 252 static int
 253 dev_iw_iovar_getbuf(struct net_device *dev,
 254                     char *iovar,
 255                     void *param, int paramlen, void *bufptr, int buflen)
 256 {
 257         int iolen;
 258
 259         iolen = bcm_mkiovar(iovar, param, paramlen, bufptr, buflen);
 260         ASSERT(iolen);
 261
 262         return dev_wlc_ioctl(dev, WLC_GET_VAR, bufptr, buflen);
 263 }
 264 #endif                          /* defined(WL_IW_USE_ISCAN) */
 265
 266 #if WIRELESS_EXT > 17
 267 static int
 268 dev_wlc_bufvar_set(struct net_device *dev, char *name, char *buf, int len)
 269 {
 270         static char ioctlbuf[MAX_WLIW_IOCTL_LEN];
 271         uint buflen;
 272
 273         buflen = bcm_mkiovar(name, buf, len, ioctlbuf, sizeof(ioctlbuf));
 274         ASSERT(buflen);
 275
 276         return dev_wlc_ioctl(dev, WLC_SET_VAR, ioctlbuf, buflen);
 277 }
 278 #endif                          /* WIRELESS_EXT > 17 */
 279
 280 static int
 281 dev_wlc_bufvar_get(struct net_device *dev, char *name, char *buf, int buflen)
 282 {
 283         static char ioctlbuf[MAX_WLIW_IOCTL_LEN];
 284         int error;
 285         uint len;
 286
 287         len = bcm_mkiovar(name, NULL, 0, ioctlbuf, sizeof(ioctlbuf));
 288         ASSERT(len);
 289         error =
 290             dev_wlc_ioctl(dev, WLC_GET_VAR, (void *)ioctlbuf,
 291                           MAX_WLIW_IOCTL_LEN);
 292         if (!error)
 293                 bcopy(ioctlbuf, buf, buflen);
 294
 295         return error;
 296 }
 297
 298 static int dev_wlc_intvar_get(struct net_device *dev, char *name, int *retval)
 299 {
 300         union {
 301                 char buf[WLC_IOCTL_SMLEN];
 302                 int val;
 303         } var;
 304         int error;
 305
 306         uint len;
 307         uint data_null;
 308
 309         len =
 310             bcm_mkiovar(name, (char *)(&data_null), 0, (char *)(&var),
 311                         sizeof(var.buf));
 312         ASSERT(len);
 313         error = dev_wlc_ioctl(dev, WLC_GET_VAR, (void *)&var, len);
 314
 315         *retval = dtoh32(var.val);
 316
 317         return error;
 318 }
 319
 320 #if WIRELESS_EXT < 13
 321 struct iw_request_info {
 322         __u16 cmd;
 323         __u16 flags;
 324 };
 325
 326 typedef int (*iw_handler) (struct net_device *dev,
 327                            struct iw_request_info *info,
 328                            void *wrqu, char *extra);
 329 #endif
 330
 331 static int
 332 wl_iw_config_commit(struct net_device *dev,
 333                     struct iw_request_info *info, void *zwrq, char *extra)
 334 {
 335         wlc_ssid_t ssid;
 336         int error;
 337         struct sockaddr bssid;
 338
 339         WL_TRACE(("%s: SIOCSIWCOMMIT\n", dev->name));
 340
 341         error = dev_wlc_ioctl(dev, WLC_GET_SSID, &ssid, sizeof(ssid));
 342         if (error)
 343                 return error;
 344
 345         ssid.SSID_len = dtoh32(ssid.SSID_len);
 346
 347         if (!ssid.SSID_len)
 348                 return 0;
 349
 350         bzero(&bssid, sizeof(struct sockaddr));
 351         error = dev_wlc_ioctl(dev, WLC_REASSOC, &bssid, ETHER_ADDR_LEN);
 352         if (error) {
 353                 WL_ERROR(("%s: WLC_REASSOC to %s failed \n", __func__,
 354                           ssid.SSID));
 355                 return error;
 356         }
 357
 358         return 0;
 359 }
 360
 361 static int
 362 wl_iw_get_name(struct net_device *dev,
 363                struct iw_request_info *info, char *cwrq, char *extra)
 364 {
 365         WL_TRACE(("%s: SIOCGIWNAME\n", dev->name));
 366
 367         strcpy(cwrq, "IEEE 802.11-DS");
 368
 369         return 0;
 370 }
 371
 372 static int
 373 wl_iw_set_freq(struct net_device *dev,
 374                struct iw_request_info *info, struct iw_freq *fwrq, char *extra)
 375 {
 376         int error, chan;
 377         uint sf = 0;
 378
 379         WL_TRACE(("\n %s %s: SIOCSIWFREQ\n", __func__, dev->name));
 380
 381         if (fwrq->e == 0 && fwrq->m < MAXCHANNEL) {
 382                 chan = fwrq->m;
 383         } else {
 384                 if (fwrq->e >= 6) {
 385                         fwrq->e -= 6;
 386                         while (fwrq->e--)
 387                                 fwrq->m *= 10;
 388                 } else if (fwrq->e < 6) {
 389                         while (fwrq->e++ < 6)
 390                                 fwrq->m /= 10;
 391                 }
 392                 if (fwrq->m > 4000 && fwrq->m < 5000)
 393                         sf = WF_CHAN_FACTOR_4_G;
 394
 395                 chan = wf_mhz2channel(fwrq->m, sf);
 396         }
 397         chan = htod32(chan);
 398
 399         error = dev_wlc_ioctl(dev, WLC_SET_CHANNEL, &chan, sizeof(chan));
 400         if (error)
 401                 return error;
 402
 403         g_wl_iw_params.target_channel = chan;
 404         return -EINPROGRESS;
 405 }
 406
 407 static int
 408 wl_iw_get_freq(struct net_device *dev,
 409                struct iw_request_info *info, struct iw_freq *fwrq, char *extra)
 410 {
 411         channel_info_t ci;
 412         int error;
 413
 414         WL_TRACE(("%s: SIOCGIWFREQ\n", dev->name));
 415
 416         error = dev_wlc_ioctl(dev, WLC_GET_CHANNEL, &ci, sizeof(ci));
 417         if (error)
 418                 return error;
 419
 420         fwrq->m = dtoh32(ci.hw_channel);
 421         fwrq->e = dtoh32(0);
 422         return 0;
 423 }
 424
 425 static int
 426 wl_iw_set_mode(struct net_device *dev,
 427                struct iw_request_info *info, __u32 *uwrq, char *extra)
 428 {
 429         int infra = 0, ap = 0, error = 0;
 430
 431         WL_TRACE(("%s: SIOCSIWMODE\n", dev->name));
 432
 433         switch (*uwrq) {
 434         case IW_MODE_MASTER:
 435                 infra = ap = 1;
 436                 break;
 437         case IW_MODE_ADHOC:
 438         case IW_MODE_AUTO:
 439                 break;
 440         case IW_MODE_INFRA:
 441                 infra = 1;
 442                 break;
 443         default:
 444                 return -EINVAL;
 445         }
 446         infra = htod32(infra);
 447         ap = htod32(ap);
 448
 449         error = dev_wlc_ioctl(dev, WLC_SET_INFRA, &infra, sizeof(infra));
 450         if (error)
 451                 return error;
 452
 453         error = dev_wlc_ioctl(dev, WLC_SET_AP, &ap, sizeof(ap));
 454         if (error)
 455                 return error;
 456
 457         return -EINPROGRESS;
 458 }
 459
 460 static int
 461 wl_iw_get_mode(struct net_device *dev,
 462                struct iw_request_info *info, __u32 *uwrq, char *extra)
 463 {
 464         int error, infra = 0, ap = 0;
 465
 466         WL_TRACE(("%s: SIOCGIWMODE\n", dev->name));
 467
 468         error = dev_wlc_ioctl(dev, WLC_GET_INFRA, &infra, sizeof(infra));
 469         if (error)
 470                 return error;
 471
 472         error = dev_wlc_ioctl(dev, WLC_GET_AP, &ap, sizeof(ap));
 473         if (error)
 474                 return error;
 475
 476         infra = dtoh32(infra);
 477         ap = dtoh32(ap);
 478         *uwrq = infra ? ap ? IW_MODE_MASTER : IW_MODE_INFRA : IW_MODE_ADHOC;
 479
 480         return 0;
 481 }
 482
 483 static int
 484 wl_iw_get_range(struct net_device *dev,
 485                 struct iw_request_info *info,
 486                 struct iw_point *dwrq, char *extra)
 487 {
 488         struct iw_range *range = (struct iw_range *)extra;
 489         wl_u32_list_t *list;
 490         wl_rateset_t rateset;
 491         s8 *channels;
 492         int error, i, k;
 493         uint sf, ch;
 494
 495         int phytype;
 496         int bw_cap = 0, sgi_tx = 0, nmode = 0;
 497         channel_info_t ci;
 498         u8 nrate_list2copy = 0;
 499         u16 nrate_list[4][8] = { {13, 26, 39, 52, 78, 104, 117, 130},
 500         {14, 29, 43, 58, 87, 116, 130, 144},
 501         {27, 54, 81, 108, 162, 216, 243, 270},
 502         {30, 60, 90, 120, 180, 240, 270, 300}
 503         };
 504
 505         WL_TRACE(("%s: SIOCGIWRANGE\n", dev->name));
 506
 507         if (!extra)
 508                 return -EINVAL;
 509
 510         channels = kmalloc((MAXCHANNEL + 1) * 4, GFP_KERNEL);
 511         if (!channels) {
 512                 WL_ERROR(("Could not alloc channels\n"));
 513                 return -ENOMEM;
 514         }
 515         list = (wl_u32_list_t *) channels;
 516
 517         dwrq->length = sizeof(struct iw_range);
 518         memset(range, 0, sizeof(range));
 519
 520         range->min_nwid = range->max_nwid = 0;
 521
 522         list->count = htod32(MAXCHANNEL);
 523         error = dev_wlc_ioctl(dev, WLC_GET_VALID_CHANNELS, channels,
 524                                 (MAXCHANNEL + 1) * 4);
 525         if (error) {
 526                 kfree(channels);
 527                 return error;
 528         }
 529         for (i = 0; i < dtoh32(list->count) && i < IW_MAX_FREQUENCIES; i++) {
 530                 range->freq[i].i = dtoh32(list->element[i]);
 531
 532                 ch = dtoh32(list->element[i]);
 533                 if (ch <= CH_MAX_2G_CHANNEL)
 534                         sf = WF_CHAN_FACTOR_2_4_G;
 535                 else
 536                         sf = WF_CHAN_FACTOR_5_G;
 537
 538                 range->freq[i].m = wf_channel2mhz(ch, sf);
 539                 range->freq[i].e = 6;
 540         }
 541         range->num_frequency = range->num_channels = i;
 542
 543         range->max_qual.qual = 5;
 544         range->max_qual.level = 0x100 - 200;
 545         range->max_qual.noise = 0x100 - 200;
 546         range->sensitivity = 65535;
 547
 548 #if WIRELESS_EXT > 11
 549         range->avg_qual.qual = 3;
 550         range->avg_qual.level = 0x100 + WL_IW_RSSI_GOOD;
 551         range->avg_qual.noise = 0x100 - 75;
 552 #endif
 553
 554         error = dev_wlc_ioctl(dev, WLC_GET_CURR_RATESET, &rateset,
 555                                 sizeof(rateset));
 556         if (error) {
 557                 kfree(channels);
 558                 return error;
 559         }
 560         rateset.count = dtoh32(rateset.count);
 561         range->num_bitrates = rateset.count;
 562         for (i = 0; i < rateset.count && i < IW_MAX_BITRATES; i++)
 563                 range->bitrate[i] = (rateset.rates[i] & 0x7f) * 500000;
 564         dev_wlc_intvar_get(dev, "nmode", &nmode);
 565         dev_wlc_ioctl(dev, WLC_GET_PHYTYPE, &phytype, sizeof(phytype));
 566
 567         if (nmode == 1 && phytype == WLC_PHY_TYPE_SSN) {
 568                 dev_wlc_intvar_get(dev, "mimo_bw_cap", &bw_cap);
 569                 dev_wlc_intvar_get(dev, "sgi_tx", &sgi_tx);
 570                 dev_wlc_ioctl(dev, WLC_GET_CHANNEL, &ci,
 571                               sizeof(channel_info_t));
 572                 ci.hw_channel = dtoh32(ci.hw_channel);
 573
 574                 if (bw_cap == 0 || (bw_cap == 2 && ci.hw_channel <= 14)) {
 575                         if (sgi_tx == 0)
 576                                 nrate_list2copy = 0;
 577                         else
 578                                 nrate_list2copy = 1;
 579                 }
 580                 if (bw_cap == 1 || (bw_cap == 2 && ci.hw_channel >= 36)) {
 581                         if (sgi_tx == 0)
 582                                 nrate_list2copy = 2;
 583                         else
 584                                 nrate_list2copy = 3;
 585                 }
 586                 range->num_bitrates += 8;
 587                 for (k = 0; i < range->num_bitrates; k++, i++) {
 588                         range->bitrate[i] =
 589                             (nrate_list[nrate_list2copy][k]) * 500000;
 590                 }
 591         }
 592
 593         error = dev_wlc_ioctl(dev, WLC_GET_PHYTYPE, &i, sizeof(i));
 594         if (error) {
 595                 kfree(channels);
 596                 return error;
 597         }
 598         i = dtoh32(i);
 599         if (i == WLC_PHY_TYPE_A)
 600                 range->throughput = 24000000;
 601         else
 602                 range->throughput = 1500000;
 603
 604         range->min_rts = 0;
 605         range->max_rts = 2347;
 606         range->min_frag = 256;
 607         range->max_frag = 2346;
 608
 609         range->max_encoding_tokens = DOT11_MAX_DEFAULT_KEYS;
 610         range->num_encoding_sizes = 4;
 611         range->encoding_size[0] = WEP1_KEY_SIZE;
 612         range->encoding_size[1] = WEP128_KEY_SIZE;
 613 #if WIRELESS_EXT > 17
 614         range->encoding_size[2] = TKIP_KEY_SIZE;
 615 #else
 616         range->encoding_size[2] = 0;
 617 #endif
 618         range->encoding_size[3] = AES_KEY_SIZE;
 619
 620         range->min_pmp = 0;
 621         range->max_pmp = 0;
 622         range->min_pmt = 0;
 623         range->max_pmt = 0;
 624         range->pmp_flags = 0;
 625         range->pm_capa = 0;
 626
 627         range->num_txpower = 2;
 628         range->txpower[0] = 1;
 629         range->txpower[1] = 255;
 630         range->txpower_capa = IW_TXPOW_MWATT;
 631
 632 #if WIRELESS_EXT > 10
 633         range->we_version_compiled = WIRELESS_EXT;
 634         range->we_version_source = 19;
 635
 636         range->retry_capa = IW_RETRY_LIMIT;
 637         range->retry_flags = IW_RETRY_LIMIT;
 638         range->r_time_flags = 0;
 639         range->min_retry = 1;
 640         range->max_retry = 255;
 641         range->min_r_time = 0;
 642         range->max_r_time = 0;
 643 #endif
 644
 645 #if WIRELESS_EXT > 17
 646         range->enc_capa = IW_ENC_CAPA_WPA;
 647         range->enc_capa |= IW_ENC_CAPA_CIPHER_TKIP;
 648         range->enc_capa |= IW_ENC_CAPA_CIPHER_CCMP;
 649         range->enc_capa |= IW_ENC_CAPA_WPA2;
 650
 651         IW_EVENT_CAPA_SET_KERNEL(range->event_capa);
 652         IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWAP);
 653         IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWSCAN);
 654         IW_EVENT_CAPA_SET(range->event_capa, IWEVTXDROP);
 655         IW_EVENT_CAPA_SET(range->event_capa, IWEVMICHAELMICFAILURE);
 656         IW_EVENT_CAPA_SET(range->event_capa, IWEVPMKIDCAND);
 657 #endif                          /* WIRELESS_EXT > 17 */
 658
 659         kfree(channels);
 660
 661         return 0;
 662 }
 663
 664 static int rssi_to_qual(int rssi)
 665 {
 666         if (rssi <= WL_IW_RSSI_NO_SIGNAL)
 667                 return 0;
 668         else if (rssi <= WL_IW_RSSI_VERY_LOW)
 669                 return 1;
 670         else if (rssi <= WL_IW_RSSI_LOW)
 671                 return 2;
 672         else if (rssi <= WL_IW_RSSI_GOOD)
 673                 return 3;
 674         else if (rssi <= WL_IW_RSSI_VERY_GOOD)
 675                 return 4;
 676         else
 677                 return 5;
 678 }
 679
 680 static int
 681 wl_iw_set_spy(struct net_device *dev,
 682               struct iw_request_info *info, struct iw_point *dwrq, char *extra)
 683 {
 684         wl_iw_t *iw = *(wl_iw_t **) netdev_priv(dev);
 685         struct sockaddr *addr = (struct sockaddr *)extra;
 686         int i;
 687
 688         WL_TRACE(("%s: SIOCSIWSPY\n", dev->name));
 689
 690         if (!extra)
 691                 return -EINVAL;
 692
 693         iw->spy_num = min(ARRAY_SIZE(iw->spy_addr), dwrq->length);
 694         for (i = 0; i < iw->spy_num; i++)
 695                 memcpy(&iw->spy_addr[i], addr[i].sa_data, ETHER_ADDR_LEN);
 696         memset(iw->spy_qual, 0, sizeof(iw->spy_qual));
 697
 698         return 0;
 699 }
 700
 701 static int
 702 wl_iw_get_spy(struct net_device *dev,
 703               struct iw_request_info *info, struct iw_point *dwrq, char *extra)
 704 {
 705         wl_iw_t *iw = *(wl_iw_t **) netdev_priv(dev);
 706         struct sockaddr *addr = (struct sockaddr *)extra;
 707         struct iw_quality *qual = (struct iw_quality *)&addr[iw->spy_num];
 708         int i;
 709
 710         WL_TRACE(("%s: SIOCGIWSPY\n", dev->name));
 711
 712         if (!extra)
 713                 return -EINVAL;
 714
 715         dwrq->length = iw->spy_num;
 716         for (i = 0; i < iw->spy_num; i++) {
 717                 memcpy(addr[i].sa_data, &iw->spy_addr[i], ETHER_ADDR_LEN);
 718                 addr[i].sa_family = AF_UNIX;
 719                 memcpy(&qual[i], &iw->spy_qual[i], sizeof(struct iw_quality));
 720                 iw->spy_qual[i].updated = 0;
 721         }
 722
 723         return 0;
 724 }
 725
 726 static int
 727 wl_iw_ch_to_chanspec(int ch, wl_join_params_t *join_params,
 728                      int *join_params_size)
 729 {
 730         chanspec_t chanspec = 0;
 731
 732         if (ch != 0) {
 733                 join_params->params.chanspec_num = 1;
 734                 join_params->params.chanspec_list[0] = ch;
 735
 736                 if (join_params->params.chanspec_list[0])
 737                         chanspec |= WL_CHANSPEC_BAND_2G;
 738                 else
 739                         chanspec |= WL_CHANSPEC_BAND_5G;
 740
 741                 chanspec |= WL_CHANSPEC_BW_20;
 742                 chanspec |= WL_CHANSPEC_CTL_SB_NONE;
 743
 744                 *join_params_size += WL_ASSOC_PARAMS_FIXED_SIZE +
 745                     join_params->params.chanspec_num * sizeof(chanspec_t);
 746
 747                 join_params->params.chanspec_list[0] &= WL_CHANSPEC_CHAN_MASK;
 748                 join_params->params.chanspec_list[0] |= chanspec;
 749                 join_params->params.chanspec_list[0] =
 750                     htodchanspec(join_params->params.chanspec_list[0]);
 751
 752                 join_params->params.chanspec_num =
 753                     htod32(join_params->params.chanspec_num);
 754
 755                 WL_TRACE(("%s  join_params->params.chanspec_list[0]= %X\n",
 756                           __func__, join_params->params.chanspec_list[0]));
 757         }
 758         return 1;
 759 }
 760
 761 static int
 762 wl_iw_set_wap(struct net_device *dev,
 763               struct iw_request_info *info, struct sockaddr *awrq, char *extra)
 764 {
 765         int error = -EINVAL;
 766         wl_join_params_t join_params;
 767         int join_params_size;
 768
 769         WL_TRACE(("%s: SIOCSIWAP\n", dev->name));
 770
 771         if (awrq->sa_family != ARPHRD_ETHER) {
 772                 WL_ERROR(("Invalid Header...sa_family\n"));
 773                 return -EINVAL;
 774         }
 775
 776         if (ETHER_ISBCAST(awrq->sa_data) || ETHER_ISNULLADDR(awrq->sa_data)) {
 777                 scb_val_t scbval;
 778                 bzero(&scbval, sizeof(scb_val_t));
 779                 (void)dev_wlc_ioctl(dev, WLC_DISASSOC, &scbval,
 780                                     sizeof(scb_val_t));
 781                 return 0;
 782         }
 783
 784         memset(&join_params, 0, sizeof(join_params));
 785         join_params_size = sizeof(join_params.ssid);
 786
 787         memcpy(join_params.ssid.SSID, g_ssid.SSID, g_ssid.SSID_len);
 788         join_params.ssid.SSID_len = htod32(g_ssid.SSID_len);
 789         memcpy(&join_params.params.bssid, awrq->sa_data, ETHER_ADDR_LEN);
 790
 791         WL_TRACE(("%s  target_channel=%d\n", __func__,
 792                   g_wl_iw_params.target_channel));
 793         wl_iw_ch_to_chanspec(g_wl_iw_params.target_channel, &join_params,
 794                              &join_params_size);
 795
 796         error = dev_wlc_ioctl(dev, WLC_SET_SSID, &join_params,
 797                                 join_params_size);
 798         if (error) {
 799                 WL_ERROR(("%s Invalid ioctl data=%d\n", __func__, error));
 800         }
 801
 802         if (g_ssid.SSID_len) {
 803                 WL_TRACE(("%s: join SSID=%s BSSID=" MACSTR " ch=%d\n",
 804                           __func__, g_ssid.SSID,
 805                           MAC2STR((u8 *) awrq->sa_data),
 806                           g_wl_iw_params.target_channel));
 807         }
 808
 809         memset(&g_ssid, 0, sizeof(g_ssid));
 810         return 0;
 811 }
 812
 813 static int
 814 wl_iw_get_wap(struct net_device *dev,
 815               struct iw_request_info *info, struct sockaddr *awrq, char *extra)
 816 {
 817         WL_TRACE(("%s: SIOCGIWAP\n", dev->name));
 818
 819         awrq->sa_family = ARPHRD_ETHER;
 820         memset(awrq->sa_data, 0, ETHER_ADDR_LEN);
 821
 822         (void)dev_wlc_ioctl(dev, WLC_GET_BSSID, awrq->sa_data, ETHER_ADDR_LEN);
 823
 824         return 0;
 825 }
 826
 827 #if WIRELESS_EXT > 17
 828 static int
 829 wl_iw_mlme(struct net_device *dev,
 830            struct iw_request_info *info, struct sockaddr *awrq, char *extra)
 831 {
 832         struct iw_mlme *mlme;
 833         scb_val_t scbval;
 834         int error = -EINVAL;
 835
 836         WL_TRACE(("%s: SIOCSIWMLME DISASSOC/DEAUTH\n", dev->name));
 837
 838         mlme = (struct iw_mlme *)extra;
 839         if (mlme == NULL) {
 840                 WL_ERROR(("Invalid ioctl data.\n"));
 841                 return error;
 842         }
 843
 844         scbval.val = mlme->reason_code;
 845         bcopy(&mlme->addr.sa_data, &scbval.ea, ETHER_ADDR_LEN);
 846
 847         if (mlme->cmd == IW_MLME_DISASSOC) {
 848                 scbval.val = htod32(scbval.val);
 849                 error =
 850                     dev_wlc_ioctl(dev, WLC_DISASSOC, &scbval,
 851                                   sizeof(scb_val_t));
 852         } else if (mlme->cmd == IW_MLME_DEAUTH) {
 853                 scbval.val = htod32(scbval.val);
 854                 error =
 855                     dev_wlc_ioctl(dev, WLC_SCB_DEAUTHENTICATE_FOR_REASON,
 856                                   &scbval, sizeof(scb_val_t));
 857         } else {
 858                 WL_ERROR(("Invalid ioctl data.\n"));
 859                 return error;
 860         }
 861
 862         return error;
 863 }
 864 #endif                          /* WIRELESS_EXT > 17 */
 865
 866 #ifndef WL_IW_USE_ISCAN
 867 static int
 868 wl_iw_get_aplist(struct net_device *dev,
 869                  struct iw_request_info *info,
 870                  struct iw_point *dwrq, char *extra)
 871 {
 872         wl_scan_results_t *list;
 873         struct sockaddr *addr = (struct sockaddr *)extra;
 874         struct iw_quality qual[IW_MAX_AP];
 875         wl_bss_info_t *bi = NULL;
 876         int error, i;
 877         uint buflen = dwrq->length;
 878
 879         WL_TRACE(("%s: SIOCGIWAPLIST\n", dev->name));
 880
 881         if (!extra)
 882                 return -EINVAL;
 883
 884         list = kmalloc(buflen, GFP_KERNEL);
 885         if (!list)
 886                 return -ENOMEM;
 887         memset(list, 0, buflen);
 888         list->buflen = htod32(buflen);
 889         error = dev_wlc_ioctl(dev, WLC_SCAN_RESULTS, list, buflen);
 890         if (error) {
 891                 WL_ERROR(("%d: Scan results error %d\n", __LINE__, error));
 892                 kfree(list);
 893                 return error;
 894         }
 895         list->buflen = dtoh32(list->buflen);
 896         list->version = dtoh32(list->version);
 897         list->count = dtoh32(list->count);
 898         if (list->version != WL_BSS_INFO_VERSION) {
 899                 WL_ERROR(("%s : list->version %d != WL_BSS_INFO_VERSION\n",
 900                           __func__, list->version));
 901                 kfree(list);
 902                 return -EINVAL;
 903         }
 904
 905         for (i = 0, dwrq->length = 0;
 906              i < list->count && dwrq->length < IW_MAX_AP; i++) {
 907                 bi = bi ? (wl_bss_info_t *) ((uintptr) bi +
 908                                              dtoh32(bi->length)) : list->
 909                     bss_info;
 910                 ASSERT(((uintptr) bi + dtoh32(bi->length)) <=
 911                        ((uintptr) list + buflen));
 912
 913                 if (!(dtoh16(bi->capability) & DOT11_CAP_ESS))
 914                         continue;
 915
 916                 memcpy(addr[dwrq->length].sa_data, &bi->BSSID, ETHER_ADDR_LEN);
 917                 addr[dwrq->length].sa_family = ARPHRD_ETHER;
 918                 qual[dwrq->length].qual = rssi_to_qual(dtoh16(bi->RSSI));
 919                 qual[dwrq->length].level = 0x100 + dtoh16(bi->RSSI);
 920                 qual[dwrq->length].noise = 0x100 + bi->phy_noise;
 921
 922 #if WIRELESS_EXT > 18
 923                 qual[dwrq->length].updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
 924 #else
 925                 qual[dwrq->length].updated = 7;
 926 #endif
 927                 dwrq->length++;
 928         }
 929
 930         kfree(list);
 931
 932         if (dwrq->length) {
 933                 memcpy(&addr[dwrq->length], qual,
 934                        sizeof(struct iw_quality) * dwrq->length);
 935                 dwrq->flags = 1;
 936         }
 937
 938         return 0;
 939 }
 940 #endif                          /* WL_IW_USE_ISCAN */
 941
 942 #ifdef WL_IW_USE_ISCAN
 943 static int
 944 wl_iw_iscan_get_aplist(struct net_device *dev,
 945                        struct iw_request_info *info,
 946                        struct iw_point *dwrq, char *extra)
 947 {
 948         wl_scan_results_t *list;
 949         iscan_buf_t *buf;
 950         iscan_info_t *iscan = g_iscan;
 951
 952         struct sockaddr *addr = (struct sockaddr *)extra;
 953         struct iw_quality qual[IW_MAX_AP];
 954         wl_bss_info_t *bi = NULL;
 955         int i;
 956
 957         WL_TRACE(("%s: SIOCGIWAPLIST\n", dev->name));
 958
 959         if (!extra)
 960                 return -EINVAL;
 961
 962         if ((!iscan) || (!iscan->sysioc_tsk)) {
 963                 WL_ERROR(("%s error\n", __func__));
 964                 return 0;
 965         }
 966
 967         buf = iscan->list_hdr;
 968         while (buf) {
 969                 list = &((wl_iscan_results_t *) buf->iscan_buf)->results;
 970                 if (list->version != WL_BSS_INFO_VERSION) {
 971                         WL_ERROR(("%s : list->version %d != "
 972                                 "WL_BSS_INFO_VERSION\n",
 973                                 __func__, list->version));
 974                         return -EINVAL;
 975                 }
 976
 977                 bi = NULL;
 978                 for (i = 0, dwrq->length = 0;
 979                      i < list->count && dwrq->length < IW_MAX_AP; i++) {
 980                         bi = bi ? (wl_bss_info_t *) ((uintptr) bi +
 981                                                      dtoh32(bi->length)) :
 982                             list->bss_info;
 983                         ASSERT(((uintptr) bi + dtoh32(bi->length)) <=
 984                                ((uintptr) list + WLC_IW_ISCAN_MAXLEN));
 985
 986                         if (!(dtoh16(bi->capability) & DOT11_CAP_ESS))
 987                                 continue;
 988
 989                         memcpy(addr[dwrq->length].sa_data, &bi->BSSID,
 990                                ETHER_ADDR_LEN);
 991                         addr[dwrq->length].sa_family = ARPHRD_ETHER;
 992                         qual[dwrq->length].qual =
 993                             rssi_to_qual(dtoh16(bi->RSSI));
 994                         qual[dwrq->length].level = 0x100 + dtoh16(bi->RSSI);
 995                         qual[dwrq->length].noise = 0x100 + bi->phy_noise;
 996
 997 #if WIRELESS_EXT > 18
 998                         qual[dwrq->length].updated =
 999                             IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
1000 #else
1001                         qual[dwrq->length].updated = 7;
1002 #endif
1003
1004                         dwrq->length++;
1005                 }
1006                 buf = buf->next;
1007         }
1008         if (dwrq->length) {
1009                 memcpy(&addr[dwrq->length], qual,
1010                        sizeof(struct iw_quality) * dwrq->length);
1011                 dwrq->flags = 1;
1012         }
1013
1014         return 0;
1015 }
1016
1017 static int wl_iw_iscan_prep(wl_scan_params_t *params, wlc_ssid_t *ssid)
1018 {
1019         int err = 0;
1020
1021         memcpy(&params->bssid, &ether_bcast, ETHER_ADDR_LEN);
1022         params->bss_type = DOT11_BSSTYPE_ANY;
1023         params->scan_type = 0;
1024         params->nprobes = -1;
1025         params->active_time = -1;
1026         params->passive_time = -1;
1027         params->home_time = -1;
1028         params->channel_num = 0;
1029
1030         params->nprobes = htod32(params->nprobes);
1031         params->active_time = htod32(params->active_time);
1032         params->passive_time = htod32(params->passive_time);
1033         params->home_time = htod32(params->home_time);
1034         if (ssid && ssid->SSID_len)
1035                 memcpy(&params->ssid, ssid, sizeof(wlc_ssid_t));
1036
1037         return err;
1038 }
1039
1040 static int wl_iw_iscan(iscan_info_t *iscan, wlc_ssid_t *ssid, u16 action)
1041 {
1042         int err = 0;
1043
1044         iscan->iscan_ex_params_p->version = htod32(ISCAN_REQ_VERSION);
1045         iscan->iscan_ex_params_p->action = htod16(action);
1046         iscan->iscan_ex_params_p->scan_duration = htod16(0);
1047
1048         WL_SCAN(("%s : nprobes=%d\n", __func__,
1049                  iscan->iscan_ex_params_p->params.nprobes));
1050         WL_SCAN(("active_time=%d\n",
1051                  iscan->iscan_ex_params_p->params.active_time));
1052         WL_SCAN(("passive_time=%d\n",
1053                  iscan->iscan_ex_params_p->params.passive_time));
1054         WL_SCAN(("home_time=%d\n", iscan->iscan_ex_params_p->params.home_time));
1055         WL_SCAN(("scan_type=%d\n", iscan->iscan_ex_params_p->params.scan_type));
1056         WL_SCAN(("bss_type=%d\n", iscan->iscan_ex_params_p->params.bss_type));
1057
1058         (void)dev_iw_iovar_setbuf(iscan->dev, "iscan", iscan->iscan_ex_params_p,
1059                                   iscan->iscan_ex_param_size, iscan->ioctlbuf,
1060                                   sizeof(iscan->ioctlbuf));
1061
1062         return err;
1063 }
1064
1065 static void wl_iw_timerfunc(unsigned long data)
1066 {
1067         iscan_info_t *iscan = (iscan_info_t *) data;
1068         if (iscan) {
1069                 iscan->timer_on = 0;
1070                 if (iscan->iscan_state != ISCAN_STATE_IDLE) {
1071                         WL_TRACE(("timer trigger\n"));
1072                         up(&iscan->sysioc_sem);
1073                 }
1074         }
1075 }
1076
1077 static void wl_iw_set_event_mask(struct net_device *dev)
1078 {
1079         char eventmask[WL_EVENTING_MASK_LEN];
1080         char iovbuf[WL_EVENTING_MASK_LEN + 12];
1081
1082         dev_iw_iovar_getbuf(dev, "event_msgs", "", 0, iovbuf, sizeof(iovbuf));
1083         bcopy(iovbuf, eventmask, WL_EVENTING_MASK_LEN);
1084         setbit(eventmask, WLC_E_SCAN_COMPLETE);
1085         dev_iw_iovar_setbuf(dev, "event_msgs", eventmask, WL_EVENTING_MASK_LEN,
1086                             iovbuf, sizeof(iovbuf));
1087 }
1088
1089 static u32 wl_iw_iscan_get(iscan_info_t *iscan)
1090 {
1091         iscan_buf_t *buf;
1092         iscan_buf_t *ptr;
1093         wl_iscan_results_t *list_buf;
1094         wl_iscan_results_t list;
1095         wl_scan_results_t *results;
1096         u32 status;
1097         int res = 0;
1098
1099         MUTEX_LOCK_WL_SCAN_SET();
1100         if (iscan->list_cur) {
1101                 buf = iscan->list_cur;
1102                 iscan->list_cur = buf->next;
1103         } else {
1104                 buf = kmalloc(sizeof(iscan_buf_t), GFP_KERNEL);
1105                 if (!buf) {
1106                         WL_ERROR(("%s can't alloc iscan_buf_t : going to abort "
1107                                 "currect iscan\n", __func__));
1108                         MUTEX_UNLOCK_WL_SCAN_SET();
1109                         return WL_SCAN_RESULTS_NO_MEM;
1110                 }
1111                 buf->next = NULL;
1112                 if (!iscan->list_hdr)
1113                         iscan->list_hdr = buf;
1114                 else {
1115                         ptr = iscan->list_hdr;
1116                         while (ptr->next) {
1117                                 ptr = ptr->next;
1118                         }
1119                         ptr->next = buf;
1120                 }
1121         }
1122         memset(buf->iscan_buf, 0, WLC_IW_ISCAN_MAXLEN);
1123         list_buf = (wl_iscan_results_t *) buf->iscan_buf;
1124         results = &list_buf->results;
1125         results->buflen = WL_ISCAN_RESULTS_FIXED_SIZE;
1126         results->version = 0;
1127         results->count = 0;
1128
1129         memset(&list, 0, sizeof(list));
1130         list.results.buflen = htod32(WLC_IW_ISCAN_MAXLEN);
1131         res = dev_iw_iovar_getbuf(iscan->dev,
1132                                   "iscanresults",
1133                                   &list,
1134                                   WL_ISCAN_RESULTS_FIXED_SIZE,
1135                                   buf->iscan_buf, WLC_IW_ISCAN_MAXLEN);
1136         if (res == 0) {
1137                 results->buflen = dtoh32(results->buflen);
1138                 results->version = dtoh32(results->version);
1139                 results->count = dtoh32(results->count);
1140                 WL_TRACE(("results->count = %d\n", results->count));
1141                 WL_TRACE(("results->buflen = %d\n", results->buflen));
1142                 status = dtoh32(list_buf->status);
1143         } else {
1144                 WL_ERROR(("%s returns error %d\n", __func__, res));
1145                 status = WL_SCAN_RESULTS_NO_MEM;
1146         }
1147         MUTEX_UNLOCK_WL_SCAN_SET();
1148         return status;
1149 }
1150
1151 static void wl_iw_force_specific_scan(iscan_info_t *iscan)
1152 {
1153         WL_TRACE(("%s force Specific SCAN for %s\n", __func__,
1154                   g_specific_ssid.SSID));
1155         rtnl_lock();
1156
1157         (void)dev_wlc_ioctl(iscan->dev, WLC_SCAN, &g_specific_ssid,
1158                             sizeof(g_specific_ssid));
1159
1160         rtnl_unlock();
1161 }
1162
1163 static void wl_iw_send_scan_complete(iscan_info_t *iscan)
1164 {
1165 #ifndef SANDGATE2G
1166         union iwreq_data wrqu;
1167
1168         memset(&wrqu, 0, sizeof(wrqu));
1169
1170         wireless_send_event(iscan->dev, SIOCGIWSCAN, &wrqu, NULL);
1171         WL_TRACE(("Send Event ISCAN complete\n"));
1172 #endif
1173 }
1174
1175 static int _iscan_sysioc_thread(void *data)
1176 {
1177         u32 status;
1178         iscan_info_t *iscan = (iscan_info_t *) data;
1179         static bool iscan_pass_abort = FALSE;
1180
1181         status = WL_SCAN_RESULTS_PARTIAL;
1182         while (down_interruptible(&iscan->sysioc_sem) == 0) {
1183                 if (kthread_should_stop())
1184                         break;
1185
1186                 if (iscan->timer_on) {
1187                         del_timer_sync(&iscan->timer);
1188                         iscan->timer_on = 0;
1189                 }
1190                 rtnl_lock();
1191                 status = wl_iw_iscan_get(iscan);
1192                 rtnl_unlock();
1193                 if (g_scan_specified_ssid && (iscan_pass_abort == TRUE)) {
1194                         WL_TRACE(("%s Get results from specific scan "
1195                                 "status = %d\n", __func__, status));
1196                         wl_iw_send_scan_complete(iscan);
1197                         iscan_pass_abort = FALSE;
1198                         status = -1;
1199                 }
1200
1201                 switch (status) {
1202                 case WL_SCAN_RESULTS_PARTIAL:
1203                         WL_TRACE(("iscanresults incomplete\n"));
1204                         rtnl_lock();
1205                         wl_iw_iscan(iscan, NULL, WL_SCAN_ACTION_CONTINUE);
1206                         rtnl_unlock();
1207                         mod_timer(&iscan->timer,
1208                                   jiffies + iscan->timer_ms * HZ / 1000);
1209                         iscan->timer_on = 1;
1210                         break;
1211                 case WL_SCAN_RESULTS_SUCCESS:
1212                         WL_TRACE(("iscanresults complete\n"));
1213                         iscan->iscan_state = ISCAN_STATE_IDLE;
1214                         wl_iw_send_scan_complete(iscan);
1215                         break;
1216                 case WL_SCAN_RESULTS_PENDING:
1217                         WL_TRACE(("iscanresults pending\n"));
1218                         mod_timer(&iscan->timer,
1219                                   jiffies + iscan->timer_ms * HZ / 1000);
1220                         iscan->timer_on = 1;
1221                         break;
1222                 case WL_SCAN_RESULTS_ABORTED:
1223                         WL_TRACE(("iscanresults aborted\n"));
1224                         iscan->iscan_state = ISCAN_STATE_IDLE;
1225                         if (g_scan_specified_ssid == 0)
1226                                 wl_iw_send_scan_complete(iscan);
1227                         else {
1228                                 iscan_pass_abort = TRUE;
1229                                 wl_iw_force_specific_scan(iscan);
1230                         }
1231                         break;
1232                 case WL_SCAN_RESULTS_NO_MEM:
1233                         WL_TRACE(("iscanresults can't alloc memory: skip\n"));
1234                         iscan->iscan_state = ISCAN_STATE_IDLE;
1235                         break;
1236                 default:
1237                         WL_TRACE(("iscanresults returned unknown status %d\n",
1238                                   status));
1239                         break;
1240                 }
1241         }
1242
1243         if (iscan->timer_on) {
1244                 del_timer_sync(&iscan->timer);
1245                 iscan->timer_on = 0;
1246         }
1247         return 0;
1248 }
1249 #endif                          /* WL_IW_USE_ISCAN */
1250
1251 static int
1252 wl_iw_set_scan(struct net_device *dev,
1253                struct iw_request_info *info,
1254                union iwreq_data *wrqu, char *extra)
1255 {
1256         int error;
1257         WL_TRACE(("\n:%s dev:%s: SIOCSIWSCAN : SCAN\n", __func__, dev->name));
1258
1259         g_set_essid_before_scan = FALSE;
1260 #if defined(CSCAN)
1261         WL_ERROR(("%s: Scan from SIOCGIWSCAN not supported\n", __func__));
1262         return -EINVAL;
1263 #endif
1264
1265         if (g_onoff == G_WLAN_SET_OFF)
1266                 return 0;
1267
1268         memset(&g_specific_ssid, 0, sizeof(g_specific_ssid));
1269 #ifndef WL_IW_USE_ISCAN
1270         g_scan_specified_ssid = 0;
1271 #endif
1272
1273 #if WIRELESS_EXT > 17
1274         if (wrqu->data.length == sizeof(struct iw_scan_req)) {
1275                 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
1276                         struct iw_scan_req *req = (struct iw_scan_req *)extra;
1277                         if (g_scan_specified_ssid) {
1278                                 WL_TRACE(("%s Specific SCAN is not done ignore "
1279                                         "scan for = %s\n",
1280                                         __func__, req->essid));
1281                                 return -EBUSY;
1282                         } else {
1283                                 g_specific_ssid.SSID_len =
1284                                     min(sizeof(g_specific_ssid.SSID),
1285                                         req->essid_len);
1286                                 memcpy(g_specific_ssid.SSID, req->essid,
1287                                        g_specific_ssid.SSID_len);
1288                                 g_specific_ssid.SSID_len =
1289                                     htod32(g_specific_ssid.SSID_len);
1290                                 g_scan_specified_ssid = 1;
1291                                 WL_TRACE(("### Specific scan ssid=%s len=%d\n",
1292                                           g_specific_ssid.SSID,
1293                                           g_specific_ssid.SSID_len));
1294                         }
1295                 }
1296         }
1297 #endif                          /* WIRELESS_EXT > 17 */
1298         error = dev_wlc_ioctl(dev, WLC_SCAN, &g_specific_ssid,
1299                                 sizeof(g_specific_ssid));
1300         if (error) {
1301                 WL_TRACE(("#### Set SCAN for %s failed with %d\n",
1302                           g_specific_ssid.SSID, error));
1303                 g_scan_specified_ssid = 0;
1304                 return -EBUSY;
1305         }
1306
1307         return 0;
1308 }
1309
1310 #ifdef WL_IW_USE_ISCAN
1311 int wl_iw_iscan_set_scan_broadcast_prep(struct net_device *dev, uint flag)
1312 {
1313         wlc_ssid_t ssid;
1314         iscan_info_t *iscan = g_iscan;
1315
1316         if (flag)
1317                 rtnl_lock();
1318
1319         wl_iw_set_event_mask(dev);
1320
1321         WL_TRACE(("+++: Set Broadcast ISCAN\n"));
1322         memset(&ssid, 0, sizeof(ssid));
1323
1324         iscan->list_cur = iscan->list_hdr;
1325         iscan->iscan_state = ISCAN_STATE_SCANING;
1326
1327         memset(&iscan->iscan_ex_params_p->params, 0,
1328                iscan->iscan_ex_param_size);
1329         wl_iw_iscan_prep(&iscan->iscan_ex_params_p->params, &ssid);
1330         wl_iw_iscan(iscan, &ssid, WL_SCAN_ACTION_START);
1331
1332         if (flag)
1333                 rtnl_unlock();
1334
1335         mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
1336
1337         iscan->timer_on = 1;
1338
1339         return 0;
1340 }
1341
1342 static int
1343 wl_iw_iscan_set_scan(struct net_device *dev,
1344                      struct iw_request_info *info,
1345                      union iwreq_data *wrqu, char *extra)
1346 {
1347         wlc_ssid_t ssid;
1348         iscan_info_t *iscan = g_iscan;
1349
1350         WL_TRACE(("%s: SIOCSIWSCAN : ISCAN\n", dev->name));
1351
1352 #if defined(CSCAN)
1353         WL_ERROR(("%s: Scan from SIOCGIWSCAN not supported\n", __func__));
1354         return -EINVAL;
1355 #endif
1356
1357         if (g_onoff == G_WLAN_SET_OFF) {
1358                 WL_TRACE(("%s: driver is not up yet after START\n", __func__));
1359                 return 0;
1360         }
1361 #ifdef PNO_SUPPORT
1362         if (dhd_dev_get_pno_status(dev)) {
1363                 WL_ERROR(("%s: Scan called when PNO is active\n", __func__));
1364         }
1365 #endif
1366
1367         if ((!iscan) || (!iscan->sysioc_tsk))
1368                 return wl_iw_set_scan(dev, info, wrqu, extra);
1369
1370         if (g_scan_specified_ssid) {
1371                 WL_TRACE(("%s Specific SCAN already running ignoring BC scan\n",
1372                           __func__));
1373                 return EBUSY;
1374         }
1375
1376         memset(&ssid, 0, sizeof(ssid));
1377
1378 #if WIRELESS_EXT > 17
1379         if (wrqu->data.length == sizeof(struct iw_scan_req)) {
1380                 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
1381                         struct iw_scan_req *req = (struct iw_scan_req *)extra;
1382                         ssid.SSID_len = min(sizeof(ssid.SSID), req->essid_len);
1383                         memcpy(ssid.SSID, req->essid, ssid.SSID_len);
1384                         ssid.SSID_len = htod32(ssid.SSID_len);
1385                 } else {
1386                         g_scan_specified_ssid = 0;
1387
1388                         if (iscan->iscan_state == ISCAN_STATE_SCANING) {
1389                                 WL_TRACE(("%s ISCAN already in progress \n",
1390                                           __func__));
1391                                 return 0;
1392                         }
1393                 }
1394         }
1395 #endif                          /* WIRELESS_EXT > 17 */
1396         wl_iw_iscan_set_scan_broadcast_prep(dev, 0);
1397
1398         return 0;
1399 }
1400 #endif                          /* WL_IW_USE_ISCAN */
1401
1402 #if WIRELESS_EXT > 17
1403 static bool ie_is_wpa_ie(u8 **wpaie, u8 **tlvs, int *tlvs_len)
1404 {
1405
1406         u8 *ie = *wpaie;
1407
1408         if ((ie[1] >= 6) &&
1409             !bcmp((const void *)&ie[2], (const void *)(WPA_OUI "\x01"), 4)) {
1410                 return TRUE;
1411         }
1412
1413         ie += ie[1] + 2;
1414         *tlvs_len -= (int)(ie - *tlvs);
1415         *tlvs = ie;
1416         return FALSE;
1417 }
1418
1419 static bool ie_is_wps_ie(u8 **wpsie, u8 **tlvs, int *tlvs_len)
1420 {
1421
1422         u8 *ie = *wpsie;
1423
1424         if ((ie[1] >= 4) &&
1425             !bcmp((const void *)&ie[2], (const void *)(WPA_OUI "\x04"), 4)) {
1426                 return TRUE;
1427         }
1428
1429         ie += ie[1] + 2;
1430         *tlvs_len -= (int)(ie - *tlvs);
1431         *tlvs = ie;
1432         return FALSE;
1433 }
1434 #endif                          /* WIRELESS_EXT > 17 */
1435
1436 static int
1437 wl_iw_handle_scanresults_ies(char **event_p, char *end,
1438                              struct iw_request_info *info, wl_bss_info_t *bi)
1439 {
1440 #if WIRELESS_EXT > 17
1441         struct iw_event iwe;
1442         char *event;
1443
1444         event = *event_p;
1445         if (bi->ie_length) {
1446                 bcm_tlv_t *ie;
1447                 u8 *ptr = ((u8 *) bi) + sizeof(wl_bss_info_t);
1448                 int ptr_len = bi->ie_length;
1449
1450                 ie = bcm_parse_tlvs(ptr, ptr_len, DOT11_MNG_RSN_ID);
1451                 if (ie) {
1452                         iwe.cmd = IWEVGENIE;
1453                         iwe.u.data.length = ie->len + 2;
1454                         event =
1455                             IWE_STREAM_ADD_POINT(info, event, end, &iwe,
1456                                                  (char *)ie);
1457                 }
1458                 ptr = ((u8 *) bi) + sizeof(wl_bss_info_t);
1459
1460                 while ((ie = bcm_parse_tlvs(ptr, ptr_len, DOT11_MNG_WPA_ID))) {
1461                         if (ie_is_wps_ie(((u8 **)&ie), &ptr, &ptr_len)) {
1462                                 iwe.cmd = IWEVGENIE;
1463                                 iwe.u.data.length = ie->len + 2;
1464                                 event =
1465                                     IWE_STREAM_ADD_POINT(info, event, end, &iwe,
1466                                                          (char *)ie);
1467                                 break;
1468                         }
1469                 }
1470
1471                 ptr = ((u8 *) bi) + sizeof(wl_bss_info_t);
1472                 ptr_len = bi->ie_length;
1473                 while ((ie = bcm_parse_tlvs(ptr, ptr_len, DOT11_MNG_WPA_ID))) {
1474                         if (ie_is_wpa_ie(((u8 **)&ie), &ptr, &ptr_len)) {
1475                                 iwe.cmd = IWEVGENIE;
1476                                 iwe.u.data.length = ie->len + 2;
1477                                 event =
1478                                     IWE_STREAM_ADD_POINT(info, event, end, &iwe,
1479                                                          (char *)ie);
1480                                 break;
1481                         }
1482                 }
1483
1484                 *event_p = event;
1485         }
1486 #endif          /* WIRELESS_EXT > 17 */
1487         return 0;
1488 }
1489
1490 static uint
1491 wl_iw_get_scan_prep(wl_scan_results_t *list,
1492                     struct iw_request_info *info, char *extra, short max_size)
1493 {
1494         int i, j;
1495         struct iw_event iwe;
1496         wl_bss_info_t *bi = NULL;
1497         char *event = extra, *end = extra + max_size - WE_ADD_EVENT_FIX, *value;
1498         int ret = 0;
1499
1500         ASSERT(list);
1501
1502         for (i = 0; i < list->count && i < IW_MAX_AP; i++) {
1503                 if (list->version != WL_BSS_INFO_VERSION) {
1504                         WL_ERROR(("%s : list->version %d != "
1505                                 "WL_BSS_INFO_VERSION\n",
1506                                 __func__, list->version));
1507                         return ret;
1508                 }
1509
1510                 bi = bi ? (wl_bss_info_t *) ((uintptr) bi +
1511                                              dtoh32(bi->length)) : list->
1512                     bss_info;
1513
1514                 WL_TRACE(("%s : %s\n", __func__, bi->SSID));
1515
1516                 iwe.cmd = SIOCGIWAP;
1517                 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
1518                 memcpy(iwe.u.ap_addr.sa_data, &bi->BSSID, ETHER_ADDR_LEN);
1519                 event =
1520                     IWE_STREAM_ADD_EVENT(info, event, end, &iwe,
1521                                          IW_EV_ADDR_LEN);
1522                 iwe.u.data.length = dtoh32(bi->SSID_len);
1523                 iwe.cmd = SIOCGIWESSID;
1524                 iwe.u.data.flags = 1;
1525                 event = IWE_STREAM_ADD_POINT(info, event, end, &iwe, bi->SSID);
1526
1527                 if (dtoh16(bi->capability) & (DOT11_CAP_ESS | DOT11_CAP_IBSS)) {
1528                         iwe.cmd = SIOCGIWMODE;
1529                         if (dtoh16(bi->capability) & DOT11_CAP_ESS)
1530                                 iwe.u.mode = IW_MODE_INFRA;
1531                         else
1532                                 iwe.u.mode = IW_MODE_ADHOC;
1533                         event =
1534                             IWE_STREAM_ADD_EVENT(info, event, end, &iwe,
1535                                                  IW_EV_UINT_LEN);
1536                 }
1537
1538                 iwe.cmd = SIOCGIWFREQ;
1539                 iwe.u.freq.m = wf_channel2mhz(CHSPEC_CHANNEL(bi->chanspec),
1540                                               CHSPEC_CHANNEL(bi->chanspec) <=
1541                                               CH_MAX_2G_CHANNEL ?
1542                                               WF_CHAN_FACTOR_2_4_G :
1543                                               WF_CHAN_FACTOR_5_G);
1544                 iwe.u.freq.e = 6;
1545                 event =
1546                     IWE_STREAM_ADD_EVENT(info, event, end, &iwe,
1547                                          IW_EV_FREQ_LEN);
1548
1549                 iwe.cmd = IWEVQUAL;
1550                 iwe.u.qual.qual = rssi_to_qual(dtoh16(bi->RSSI));
1551                 iwe.u.qual.level = 0x100 + dtoh16(bi->RSSI);
1552                 iwe.u.qual.noise = 0x100 + bi->phy_noise;
1553                 event =
1554                     IWE_STREAM_ADD_EVENT(info, event, end, &iwe,
1555                                          IW_EV_QUAL_LEN);
1556
1557                 wl_iw_handle_scanresults_ies(&event, end, info, bi);
1558
1559                 iwe.cmd = SIOCGIWENCODE;
1560                 if (dtoh16(bi->capability) & DOT11_CAP_PRIVACY)
1561                         iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
1562                 else
1563                         iwe.u.data.flags = IW_ENCODE_DISABLED;
1564                 iwe.u.data.length = 0;
1565                 event =
1566                     IWE_STREAM_ADD_POINT(info, event, end, &iwe, (char *)event);
1567
1568                 if (bi->rateset.count) {
1569                         if (((event - extra) +
1570                                 IW_EV_LCP_LEN) <= (uintptr) end) {
1571                                 value = event + IW_EV_LCP_LEN;
1572                                 iwe.cmd = SIOCGIWRATE;
1573                                 iwe.u.bitrate.fixed = iwe.u.bitrate.disabled =
1574                                     0;
1575                                 for (j = 0;
1576                                      j < bi->rateset.count
1577                                      && j < IW_MAX_BITRATES; j++) {
1578                                         iwe.u.bitrate.value =
1579                                             (bi->rateset.rates[j] & 0x7f) *
1580                                             500000;
1581                                         value =
1582                                             IWE_STREAM_ADD_VALUE(info, event,
1583                                                  value, end, &iwe,
1584                                                  IW_EV_PARAM_LEN);
1585                                 }
1586                                 event = value;
1587                         }
1588                 }
1589         }
1590
1591         ret = event - extra;
1592         if (ret < 0) {
1593                 WL_ERROR(("==> Wrong size\n"));
1594                 ret = 0;
1595         }
1596         WL_TRACE(("%s: size=%d bytes prepared\n", __func__,
1597                   (unsigned int)(event - extra)));
1598         return (uint)ret;
1599 }
1600
1601 static int
1602 wl_iw_get_scan(struct net_device *dev,
1603                struct iw_request_info *info, struct iw_point *dwrq, char *extra)
1604 {
1605         channel_info_t ci;
1606         wl_scan_results_t *list_merge;
1607         wl_scan_results_t *list = (wl_scan_results_t *) g_scan;
1608         int error;
1609         uint buflen_from_user = dwrq->length;
1610         uint len = G_SCAN_RESULTS;
1611         __u16 len_ret = 0;
1612 #if defined(WL_IW_USE_ISCAN)
1613         iscan_info_t *iscan = g_iscan;
1614         iscan_buf_t *p_buf;
1615 #endif
1616
1617         WL_TRACE(("%s: buflen_from_user %d: \n", dev->name, buflen_from_user));
1618
1619         if (!extra) {
1620                 WL_TRACE(("%s: wl_iw_get_scan return -EINVAL\n", dev->name));
1621                 return -EINVAL;
1622         }
1623
1624         error = dev_wlc_ioctl(dev, WLC_GET_CHANNEL, &ci, sizeof(ci));
1625         if (error)
1626                 return error;
1627         ci.scan_channel = dtoh32(ci.scan_channel);
1628         if (ci.scan_channel)
1629                 return -EAGAIN;
1630
1631         if (g_scan_specified_ssid) {
1632                 list = kmalloc(len, GFP_KERNEL);
1633                 if (!list) {
1634                         WL_TRACE(("%s: wl_iw_get_scan return -ENOMEM\n",
1635                                   dev->name));
1636                         g_scan_specified_ssid = 0;
1637                         return -ENOMEM;
1638                 }
1639         }
1640
1641         memset(list, 0, len);
1642         list->buflen = htod32(len);
1643         error = dev_wlc_ioctl(dev, WLC_SCAN_RESULTS, list, len);
1644         if (error) {
1645                 WL_ERROR(("%s: %s : Scan_results ERROR %d\n", dev->name,
1646                           __func__, error));
1647                 dwrq->length = len;
1648                 if (g_scan_specified_ssid) {
1649                         g_scan_specified_ssid = 0;
1650                         kfree(list);
1651                 }
1652                 return 0;
1653         }
1654         list->buflen = dtoh32(list->buflen);
1655         list->version = dtoh32(list->version);
1656         list->count = dtoh32(list->count);
1657
1658         if (list->version != WL_BSS_INFO_VERSION) {
1659                 WL_ERROR(("%s : list->version %d != WL_BSS_INFO_VERSION\n",
1660                           __func__, list->version));
1661                 if (g_scan_specified_ssid) {
1662                         g_scan_specified_ssid = 0;
1663                         kfree(list);
1664                 }
1665                 return -EINVAL;
1666         }
1667
1668         if (g_scan_specified_ssid) {
1669                 WL_TRACE(("%s: Specified scan APs in the list =%d\n",
1670                           __func__, list->count));
1671                 len_ret =
1672                     (__u16) wl_iw_get_scan_prep(list, info, extra,
1673                                                 buflen_from_user);
1674                 kfree(list);
1675
1676 #if defined(WL_IW_USE_ISCAN)
1677                 p_buf = iscan->list_hdr;
1678                 while (p_buf != iscan->list_cur) {
1679                         list_merge =
1680                             &((wl_iscan_results_t *) p_buf->iscan_buf)->results;
1681                         WL_TRACE(("%s: Bcast APs list=%d\n", __func__,
1682                                   list_merge->count));
1683                         if (list_merge->count > 0)
1684                                 len_ret +=
1685                                     (__u16) wl_iw_get_scan_prep(list_merge,
1686                                         info, extra + len_ret,
1687                                         buflen_from_user - len_ret);
1688                         p_buf = p_buf->next;
1689                 }
1690 #else
1691                 list_merge = (wl_scan_results_t *) g_scan;
1692                 WL_TRACE(("%s: Bcast APs list=%d\n", __func__,
1693                           list_merge->count));
1694                 if (list_merge->count > 0)
1695                         len_ret +=
1696                             (__u16) wl_iw_get_scan_prep(list_merge, info,
1697                                                         extra + len_ret,
1698                                                         buflen_from_user -
1699                                                         len_ret);
1700 #endif                          /* defined(WL_IW_USE_ISCAN) */
1701         } else {
1702                 list = (wl_scan_results_t *) g_scan;
1703                 len_ret =
1704                     (__u16) wl_iw_get_scan_prep(list, info, extra,
1705                                                 buflen_from_user);
1706         }
1707
1708 #if defined(WL_IW_USE_ISCAN)
1709         g_scan_specified_ssid = 0;
1710 #endif
1711         if ((len_ret + WE_ADD_EVENT_FIX) < buflen_from_user)
1712                 len = len_ret;
1713
1714         dwrq->length = len;
1715         dwrq->flags = 0;
1716
1717         WL_TRACE(("%s return to WE %d bytes APs=%d\n", __func__,
1718                   dwrq->length, list->count));
1719         return 0;
1720 }
1721
1722 #if defined(WL_IW_USE_ISCAN)
1723 static int
1724 wl_iw_iscan_get_scan(struct net_device *dev,
1725                      struct iw_request_info *info,
1726                      struct iw_point *dwrq, char *extra)
1727 {
1728         wl_scan_results_t *list;
1729         struct iw_event iwe;
1730         wl_bss_info_t *bi = NULL;
1731         int ii, j;
1732         int apcnt;
1733         char *event = extra, *end = extra + dwrq->length, *value;
1734         iscan_info_t *iscan = g_iscan;
1735         iscan_buf_t *p_buf;
1736         u32 counter = 0;
1737         u8 channel;
1738
1739         WL_TRACE(("%s %s buflen_from_user %d:\n", dev->name, __func__,
1740                   dwrq->length));
1741
1742         if (!extra) {
1743                 WL_TRACE(("%s: INVALID SIOCGIWSCAN GET bad parameter\n",
1744                           dev->name));
1745                 return -EINVAL;
1746         }
1747
1748         if ((!iscan) || (!iscan->sysioc_tsk)) {
1749                 WL_ERROR(("%ssysioc_tsk\n", __func__));
1750                 return wl_iw_get_scan(dev, info, dwrq, extra);
1751         }
1752
1753         if (iscan->iscan_state == ISCAN_STATE_SCANING) {
1754                 WL_TRACE(("%s: SIOCGIWSCAN GET still scanning\n", dev->name));
1755                 return -EAGAIN;
1756         }
1757
1758         WL_TRACE(("%s: SIOCGIWSCAN GET broadcast results\n", dev->name));
1759         apcnt = 0;
1760         p_buf = iscan->list_hdr;
1761         while (p_buf != iscan->list_cur) {
1762                 list = &((wl_iscan_results_t *) p_buf->iscan_buf)->results;
1763
1764                 counter += list->count;
1765
1766                 if (list->version != WL_BSS_INFO_VERSION) {
1767                         WL_ERROR(("%s : list->version %d != "
1768                                 "WL_BSS_INFO_VERSION\n",
1769                                 __func__, list->version));
1770                         return -EINVAL;
1771                 }
1772
1773                 bi = NULL;
1774                 for (ii = 0; ii < list->count && apcnt < IW_MAX_AP;
1775                      apcnt++, ii++) {
1776                         bi = bi ? (wl_bss_info_t *) ((uintptr) bi +
1777                                                      dtoh32(bi->length)) :
1778                             list->bss_info;
1779                         ASSERT(((uintptr) bi + dtoh32(bi->length)) <=
1780                                ((uintptr) list + WLC_IW_ISCAN_MAXLEN));
1781
1782                         if (event + ETHER_ADDR_LEN + bi->SSID_len +
1783                             IW_EV_UINT_LEN + IW_EV_FREQ_LEN + IW_EV_QUAL_LEN >=
1784                             end)
1785                                 return -E2BIG;
1786                         iwe.cmd = SIOCGIWAP;
1787                         iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
1788                         memcpy(iwe.u.ap_addr.sa_data, &bi->BSSID,
1789                                ETHER_ADDR_LEN);
1790                         event =
1791                             IWE_STREAM_ADD_EVENT(info, event, end, &iwe,
1792                                                  IW_EV_ADDR_LEN);
1793
1794                         iwe.u.data.length = dtoh32(bi->SSID_len);
1795                         iwe.cmd = SIOCGIWESSID;
1796                         iwe.u.data.flags = 1;
1797                         event =
1798                             IWE_STREAM_ADD_POINT(info, event, end, &iwe,
1799                                                  bi->SSID);
1800
1801                         if (dtoh16(bi->capability) &
1802                             (DOT11_CAP_ESS | DOT11_CAP_IBSS)) {
1803                                 iwe.cmd = SIOCGIWMODE;
1804                                 if (dtoh16(bi->capability) & DOT11_CAP_ESS)
1805                                         iwe.u.mode = IW_MODE_INFRA;
1806                                 else
1807                                         iwe.u.mode = IW_MODE_ADHOC;
1808                                 event =
1809                                     IWE_STREAM_ADD_EVENT(info, event, end, &iwe,
1810                                                          IW_EV_UINT_LEN);
1811                         }
1812
1813                         iwe.cmd = SIOCGIWFREQ;
1814                         channel =
1815                             (bi->ctl_ch ==
1816                              0) ? CHSPEC_CHANNEL(bi->chanspec) : bi->ctl_ch;
1817                         iwe.u.freq.m =
1818                             wf_channel2mhz(channel,
1819                                            channel <=
1820                                            CH_MAX_2G_CHANNEL ?
1821                                            WF_CHAN_FACTOR_2_4_G :
1822                                            WF_CHAN_FACTOR_5_G);
1823                         iwe.u.freq.e = 6;
1824                         event =
1825                             IWE_STREAM_ADD_EVENT(info, event, end, &iwe,
1826                                                  IW_EV_FREQ_LEN);
1827
1828                         iwe.cmd = IWEVQUAL;
1829                         iwe.u.qual.qual = rssi_to_qual(dtoh16(bi->RSSI));
1830                         iwe.u.qual.level = 0x100 + dtoh16(bi->RSSI);
1831                         iwe.u.qual.noise = 0x100 + bi->phy_noise;
1832                         event =
1833                             IWE_STREAM_ADD_EVENT(info, event, end, &iwe,
1834                                                  IW_EV_QUAL_LEN);
1835
1836                         wl_iw_handle_scanresults_ies(&event, end, info, bi);
1837
1838                         iwe.cmd = SIOCGIWENCODE;
1839                         if (dtoh16(bi->capability) & DOT11_CAP_PRIVACY)
1840                                 iwe.u.data.flags =
1841                                     IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
1842                         else
1843                                 iwe.u.data.flags = IW_ENCODE_DISABLED;
1844                         iwe.u.data.length = 0;
1845                         event =
1846                             IWE_STREAM_ADD_POINT(info, event, end, &iwe,
1847                                                  (char *)event);
1848
1849                         if (bi->rateset.count) {
1850                                 if (event + IW_MAX_BITRATES * IW_EV_PARAM_LEN >=
1851                                     end)
1852                                         return -E2BIG;
1853
1854                                 value = event + IW_EV_LCP_LEN;
1855                                 iwe.cmd = SIOCGIWRATE;
1856                                 iwe.u.bitrate.fixed = iwe.u.bitrate.disabled =
1857                                     0;
1858                                 for (j = 0;
1859                                      j < bi->rateset.count
1860                                      && j < IW_MAX_BITRATES; j++) {
1861                                         iwe.u.bitrate.value =
1862                                             (bi->rateset.rates[j] & 0x7f) *
1863                                             500000;
1864                                         value =
1865                                             IWE_STREAM_ADD_VALUE(info, event,
1866                                                  value, end,
1867                                                  &iwe,
1868                                                  IW_EV_PARAM_LEN);
1869                                 }
1870                                 event = value;
1871                         }
1872                 }
1873                 p_buf = p_buf->next;
1874         }
1875
1876         dwrq->length = event - extra;
1877         dwrq->flags = 0;
1878
1879         WL_TRACE(("%s return to WE %d bytes APs=%d\n", __func__,
1880                   dwrq->length, counter));
1881
1882         if (!dwrq->length)
1883                 return -EAGAIN;
1884
1885         return 0;
1886 }
1887 #endif                          /* defined(WL_IW_USE_ISCAN) */
1888
1889 static int
1890 wl_iw_set_essid(struct net_device *dev,
1891                 struct iw_request_info *info,
1892                 struct iw_point *dwrq, char *extra)
1893 {
1894         int error;
1895         wl_join_params_t join_params;
1896         int join_params_size;
1897
1898         WL_TRACE(("%s: SIOCSIWESSID\n", dev->name));
1899
1900         if (g_set_essid_before_scan)
1901                 return -EAGAIN;
1902
1903         memset(&g_ssid, 0, sizeof(g_ssid));
1904
1905         CHECK_EXTRA_FOR_NULL(extra);
1906
1907         if (dwrq->length && extra) {
1908 #if WIRELESS_EXT > 20
1909                 g_ssid.SSID_len = min(sizeof(g_ssid.SSID), dwrq->length);
1910 #else
1911                 g_ssid.SSID_len = min(sizeof(g_ssid.SSID), dwrq->length - 1);
1912 #endif
1913                 memcpy(g_ssid.SSID, extra, g_ssid.SSID_len);
1914         } else {
1915                 g_ssid.SSID_len = 0;
1916         }
1917         g_ssid.SSID_len = htod32(g_ssid.SSID_len);
1918
1919         memset(&join_params, 0, sizeof(join_params));
1920         join_params_size = sizeof(join_params.ssid);
1921
1922         memcpy(&join_params.ssid.SSID, g_ssid.SSID, g_ssid.SSID_len);
1923         join_params.ssid.SSID_len = htod32(g_ssid.SSID_len);
1924         memcpy(&join_params.params.bssid, &ether_bcast, ETHER_ADDR_LEN);
1925
1926         wl_iw_ch_to_chanspec(g_wl_iw_params.target_channel, &join_params,
1927                              &join_params_size);
1928
1929         error = dev_wlc_ioctl(dev, WLC_SET_SSID, &join_params,
1930                                 join_params_size);
1931         if (error)
1932                 WL_ERROR(("Invalid ioctl data=%d\n", error));
1933
1934         if (g_ssid.SSID_len) {
1935                 WL_TRACE(("%s: join SSID=%s ch=%d\n", __func__,
1936                           g_ssid.SSID, g_wl_iw_params.target_channel));
1937         }
1938         return 0;
1939 }
1940
1941 static int
1942 wl_iw_get_essid(struct net_device *dev,
1943                 struct iw_request_info *info,
1944                 struct iw_point *dwrq, char *extra)
1945 {
1946         wlc_ssid_t ssid;
1947         int error;
1948
1949         WL_TRACE(("%s: SIOCGIWESSID\n", dev->name));
1950
1951         if (!extra)
1952                 return -EINVAL;
1953
1954         error = dev_wlc_ioctl(dev, WLC_GET_SSID, &ssid, sizeof(ssid));
1955         if (error) {
1956                 WL_ERROR(("Error getting the SSID\n"));
1957                 return error;
1958         }
1959
1960         ssid.SSID_len = dtoh32(ssid.SSID_len);
1961
1962         memcpy(extra, ssid.SSID, ssid.SSID_len);
1963
1964         dwrq->length = ssid.SSID_len;
1965
1966         dwrq->flags = 1;
1967
1968         return 0;
1969 }
1970
1971 static int
1972 wl_iw_set_nick(struct net_device *dev,
1973                struct iw_request_info *info, struct iw_point *dwrq, char *extra)
1974 {
1975         wl_iw_t *iw = *(wl_iw_t **) netdev_priv(dev);
1976
1977         WL_TRACE(("%s: SIOCSIWNICKN\n", dev->name));
1978
1979         if (!extra)
1980                 return -EINVAL;
1981
1982         if (dwrq->length > sizeof(iw->nickname))
1983                 return -E2BIG;
1984
1985         memcpy(iw->nickname, extra, dwrq->length);
1986         iw->nickname[dwrq->length - 1] = '\0';
1987
1988         return 0;
1989 }
1990
1991 static int
1992 wl_iw_get_nick(struct net_device *dev,
1993                struct iw_request_info *info, struct iw_point *dwrq, char *extra)
1994 {
1995         wl_iw_t *iw = *(wl_iw_t **) netdev_priv(dev);
1996
1997         WL_TRACE(("%s: SIOCGIWNICKN\n", dev->name));
1998
1999         if (!extra)
2000                 return -EINVAL;
2001
2002         strcpy(extra, iw->nickname);
2003         dwrq->length = strlen(extra) + 1;
2004
2005         return 0;
2006 }
2007
2008 static int
2009 wl_iw_set_rate(struct net_device *dev,
2010                struct iw_request_info *info, struct iw_param *vwrq, char *extra)
2011 {
2012         wl_rateset_t rateset;
2013         int error, rate, i, error_bg, error_a;
2014
2015         WL_TRACE(("%s: SIOCSIWRATE\n", dev->name));
2016
2017         error = dev_wlc_ioctl(dev, WLC_GET_CURR_RATESET, &rateset,
2018                                 sizeof(rateset));
2019         if (error)
2020                 return error;
2021
2022         rateset.count = dtoh32(rateset.count);
2023
2024         if (vwrq->value < 0)
2025                 rate = rateset.rates[rateset.count - 1] & 0x7f;
2026         else if (vwrq->value < rateset.count)
2027                 rate = rateset.rates[vwrq->value] & 0x7f;
2028         else
2029                 rate = vwrq->value / 500000;
2030
2031         if (vwrq->fixed) {
2032                 error_bg = dev_wlc_intvar_set(dev, "bg_rate", rate);
2033                 error_a = dev_wlc_intvar_set(dev, "a_rate", rate);
2034
2035                 if (error_bg && error_a)
2036                         return error_bg | error_a;
2037         } else {
2038                 error_bg = dev_wlc_intvar_set(dev, "bg_rate", 0);
2039                 error_a = dev_wlc_intvar_set(dev, "a_rate", 0);
2040
2041                 if (error_bg && error_a)
2042                         return error_bg | error_a;
2043
2044                 for (i = 0; i < rateset.count; i++)
2045                         if ((rateset.rates[i] & 0x7f) > rate)
2046                                 break;
2047                 rateset.count = htod32(i);
2048
2049                 error = dev_wlc_ioctl(dev, WLC_SET_RATESET, &rateset,
2050                                         sizeof(rateset));
2051                 if (error)
2052                         return error;
2053         }
2054
2055         return 0;
2056 }
2057
2058 static int
2059 wl_iw_get_rate(struct net_device *dev,
2060                struct iw_request_info *info, struct iw_param *vwrq, char *extra)
2061 {
2062         int error, rate;
2063
2064         WL_TRACE(("%s: SIOCGIWRATE\n", dev->name));
2065
2066         error = dev_wlc_ioctl(dev, WLC_GET_RATE, &rate, sizeof(rate));
2067         if (error)
2068                 return error;
2069         rate = dtoh32(rate);
2070         vwrq->value = rate * 500000;
2071
2072         return 0;
2073 }
2074
2075 static int
2076 wl_iw_set_rts(struct net_device *dev,
2077               struct iw_request_info *info, struct iw_param *vwrq, char *extra)
2078 {
2079         int error, rts;
2080
2081         WL_TRACE(("%s: SIOCSIWRTS\n", dev->name));
2082
2083         if (vwrq->disabled)
2084                 rts = DOT11_DEFAULT_RTS_LEN;
2085         else if (vwrq->value < 0 || vwrq->value > DOT11_DEFAULT_RTS_LEN)
2086                 return -EINVAL;
2087         else
2088                 rts = vwrq->value;
2089
2090         error = dev_wlc_intvar_set(dev, "rtsthresh", rts);
2091         if (error)
2092                 return error;
2093
2094         return 0;
2095 }
2096
2097 static int
2098 wl_iw_get_rts(struct net_device *dev,
2099               struct iw_request_info *info, struct iw_param *vwrq, char *extra)
2100 {
2101         int error, rts;
2102
2103         WL_TRACE(("%s: SIOCGIWRTS\n", dev->name));
2104
2105         error = dev_wlc_intvar_get(dev, "rtsthresh", &rts);
2106         if (error)
2107                 return error;
2108
2109         vwrq->value = rts;
2110         vwrq->disabled = (rts >= DOT11_DEFAULT_RTS_LEN);
2111         vwrq->fixed = 1;
2112
2113         return 0;
2114 }
2115
2116 static int
2117 wl_iw_set_frag(struct net_device *dev,
2118                struct iw_request_info *info, struct iw_param *vwrq, char *extra)
2119 {
2120         int error, frag;
2121
2122         WL_TRACE(("%s: SIOCSIWFRAG\n", dev->name));
2123
2124         if (vwrq->disabled)
2125                 frag = DOT11_DEFAULT_FRAG_LEN;
2126         else if (vwrq->value < 0 || vwrq->value > DOT11_DEFAULT_FRAG_LEN)
2127                 return -EINVAL;
2128         else
2129                 frag = vwrq->value;
2130
2131         error = dev_wlc_intvar_set(dev, "fragthresh", frag);
2132         if (error)
2133                 return error;
2134
2135         return 0;
2136 }
2137
2138 static int
2139 wl_iw_get_frag(struct net_device *dev,
2140                struct iw_request_info *info, struct iw_param *vwrq, char *extra)
2141 {
2142         int error, fragthreshold;
2143
2144         WL_TRACE(("%s: SIOCGIWFRAG\n", dev->name));
2145
2146         error = dev_wlc_intvar_get(dev, "fragthresh", &fragthreshold);
2147         if (error)
2148                 return error;
2149
2150         vwrq->value = fragthreshold;
2151         vwrq->disabled = (fragthreshold >= DOT11_DEFAULT_FRAG_LEN);
2152         vwrq->fixed = 1;
2153
2154         return 0;
2155 }
2156
2157 static int
2158 wl_iw_set_txpow(struct net_device *dev,
2159                 struct iw_request_info *info,
2160                 struct iw_param *vwrq, char *extra)
2161 {
2162         int error, disable;
2163         u16 txpwrmw;
2164         WL_TRACE(("%s: SIOCSIWTXPOW\n", dev->name));
2165
2166         disable = vwrq->disabled ? WL_RADIO_SW_DISABLE : 0;
2167         disable += WL_RADIO_SW_DISABLE << 16;
2168
2169         disable = htod32(disable);
2170         error = dev_wlc_ioctl(dev, WLC_SET_RADIO, &disable, sizeof(disable));
2171         if (error)
2172                 return error;
2173
2174         if (disable & WL_RADIO_SW_DISABLE)
2175                 return 0;
2176
2177         if (!(vwrq->flags & IW_TXPOW_MWATT))
2178                 return -EINVAL;
2179
2180         if (vwrq->value < 0)
2181                 return 0;
2182
2183         if (vwrq->value > 0xffff)
2184                 txpwrmw = 0xffff;
2185         else
2186                 txpwrmw = (u16) vwrq->value;
2187
2188         error =
2189             dev_wlc_intvar_set(dev, "qtxpower", (int)(bcm_mw_to_qdbm(txpwrmw)));
2190         return error;
2191 }
2192
2193 static int
2194 wl_iw_get_txpow(struct net_device *dev,
2195                 struct iw_request_info *info,
2196                 struct iw_param *vwrq, char *extra)
2197 {
2198         int error, disable, txpwrdbm;
2199         u8 result;
2200
2201         WL_TRACE(("%s: SIOCGIWTXPOW\n", dev->name));
2202
2203         error = dev_wlc_ioctl(dev, WLC_GET_RADIO, &disable, sizeof(disable));
2204         if (error)
2205                 return error;
2206
2207         error = dev_wlc_intvar_get(dev, "qtxpower", &txpwrdbm);
2208         if (error)
2209                 return error;
2210
2211         disable = dtoh32(disable);
2212         result = (u8) (txpwrdbm & ~WL_TXPWR_OVERRIDE);
2213         vwrq->value = (s32) bcm_qdbm_to_mw(result);
2214         vwrq->fixed = 0;
2215         vwrq->disabled =
2216             (disable & (WL_RADIO_SW_DISABLE | WL_RADIO_HW_DISABLE)) ? 1 : 0;
2217         vwrq->flags = IW_TXPOW_MWATT;
2218
2219         return 0;
2220 }
2221
2222 #if WIRELESS_EXT > 10
2223 static int
2224 wl_iw_set_retry(struct net_device *dev,
2225                 struct iw_request_info *info,
2226                 struct iw_param *vwrq, char *extra)
2227 {
2228         int error, lrl, srl;
2229
2230         WL_TRACE(("%s: SIOCSIWRETRY\n", dev->name));
2231
2232         if (vwrq->disabled || (vwrq->flags & IW_RETRY_LIFETIME))
2233                 return -EINVAL;
2234
2235         if (vwrq->flags & IW_RETRY_LIMIT) {
2236
2237 #if WIRELESS_EXT > 20
2238                 if ((vwrq->flags & IW_RETRY_LONG)
2239                     || (vwrq->flags & IW_RETRY_MAX)
2240                     || !((vwrq->flags & IW_RETRY_SHORT)
2241                          || (vwrq->flags & IW_RETRY_MIN))) {
2242 #else
2243                 if ((vwrq->flags & IW_RETRY_MAX)
2244                     || !(vwrq->flags & IW_RETRY_MIN)) {
2245 #endif
2246                         lrl = htod32(vwrq->value);
2247                         error = dev_wlc_ioctl(dev, WLC_SET_LRL, &lrl,
2248                                                 sizeof(lrl));
2249                         if (error)
2250                                 return error;
2251                 }
2252 #if WIRELESS_EXT > 20
2253                 if ((vwrq->flags & IW_RETRY_SHORT)
2254                     || (vwrq->flags & IW_RETRY_MIN)
2255                     || !((vwrq->flags & IW_RETRY_LONG)
2256                          || (vwrq->flags & IW_RETRY_MAX))) {
2257 #else
2258                 if ((vwrq->flags & IW_RETRY_MIN)
2259                     || !(vwrq->flags & IW_RETRY_MAX)) {
2260 #endif
2261                         srl = htod32(vwrq->value);
2262                         error = dev_wlc_ioctl(dev, WLC_SET_SRL, &srl,
2263                                                 sizeof(srl));
2264                         if (error)
2265                                 return error;
2266                 }
2267         }
2268         return 0;
2269 }
2270
2271 static int
2272 wl_iw_get_retry(struct net_device *dev,
2273                 struct iw_request_info *info,
2274                 struct iw_param *vwrq, char *extra)
2275 {
2276         int error, lrl, srl;
2277
2278         WL_TRACE(("%s: SIOCGIWRETRY\n", dev->name));
2279
2280         vwrq->disabled = 0;
2281
2282         if ((vwrq->flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME)
2283                 return -EINVAL;
2284
2285         error = dev_wlc_ioctl(dev, WLC_GET_LRL, &lrl, sizeof(lrl));
2286         if (error)
2287                 return error;
2288
2289         error = dev_wlc_ioctl(dev, WLC_GET_SRL, &srl, sizeof(srl));
2290         if (error)
2291                 return error;
2292
2293         lrl = dtoh32(lrl);
2294         srl = dtoh32(srl);
2295
2296         if (vwrq->flags & IW_RETRY_MAX) {
2297                 vwrq->flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
2298                 vwrq->value = lrl;
2299         } else {
2300                 vwrq->flags = IW_RETRY_LIMIT;
2301                 vwrq->value = srl;
2302                 if (srl != lrl)
2303                         vwrq->flags |= IW_RETRY_MIN;
2304         }
2305
2306         return 0;
2307 }
2308 #endif                          /* WIRELESS_EXT > 10 */
2309
2310 static int
2311 wl_iw_set_encode(struct net_device *dev,
2312                  struct iw_request_info *info,
2313                  struct iw_point *dwrq, char *extra)
2314 {
2315         wl_wsec_key_t key;
2316         int error, val, wsec;
2317
2318         WL_TRACE(("%s: SIOCSIWENCODE\n", dev->name));
2319
2320         memset(&key, 0, sizeof(key));
2321
2322         if ((dwrq->flags & IW_ENCODE_INDEX) == 0) {
2323                 for (key.index = 0; key.index < DOT11_MAX_DEFAULT_KEYS;
2324                      key.index++) {
2325                         val = htod32(key.index);
2326                         error = dev_wlc_ioctl(dev, WLC_GET_KEY_PRIMARY, &val,
2327                                                 sizeof(val));
2328                         if (error)
2329                                 return error;
2330                         val = dtoh32(val);
2331                         if (val)
2332                                 break;
2333                 }
2334                 if (key.index == DOT11_MAX_DEFAULT_KEYS)
2335                         key.index = 0;
2336         } else {
2337                 key.index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
2338                 if (key.index >= DOT11_MAX_DEFAULT_KEYS)
2339                         return -EINVAL;
2340         }
2341
2342         if (!extra || !dwrq->length || (dwrq->flags & IW_ENCODE_NOKEY)) {
2343                 val = htod32(key.index);
2344                 error = dev_wlc_ioctl(dev, WLC_SET_KEY_PRIMARY, &val,
2345                                         sizeof(val));
2346                 if (error)
2347                         return error;
2348         } else {
2349                 key.len = dwrq->length;
2350
2351                 if (dwrq->length > sizeof(key.data))
2352                         return -EINVAL;
2353
2354                 memcpy(key.data, extra, dwrq->length);
2355
2356                 key.flags = WL_PRIMARY_KEY;
2357                 switch (key.len) {
2358                 case WEP1_KEY_SIZE:
2359                         key.algo = CRYPTO_ALGO_WEP1;
2360                         break;
2361                 case WEP128_KEY_SIZE:
2362                         key.algo = CRYPTO_ALGO_WEP128;
2363                         break;
2364                 case TKIP_KEY_SIZE:
2365                         key.algo = CRYPTO_ALGO_TKIP;
2366                         break;
2367                 case AES_KEY_SIZE:
2368                         key.algo = CRYPTO_ALGO_AES_CCM;
2369                         break;
2370                 default:
2371                         return -EINVAL;
2372                 }
2373
2374                 swap_key_from_BE(&key);
2375                 error = dev_wlc_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
2376                 if (error)
2377                         return error;
2378         }
2379
2380         val = (dwrq->flags & IW_ENCODE_DISABLED) ? 0 : WEP_ENABLED;
2381
2382         error = dev_wlc_intvar_get(dev, "wsec", &wsec);
2383         if (error)
2384                 return error;
2385
2386         wsec &= ~(WEP_ENABLED);
2387         wsec |= val;
2388
2389         error = dev_wlc_intvar_set(dev, "wsec", wsec);
2390         if (error)
2391                 return error;
2392
2393         val = (dwrq->flags & IW_ENCODE_RESTRICTED) ? 1 : 0;
2394         val = htod32(val);
2395         error = dev_wlc_ioctl(dev, WLC_SET_AUTH, &val, sizeof(val));
2396         if (error)
2397                 return error;
2398
2399         return 0;
2400 }
2401
2402 static int
2403 wl_iw_get_encode(struct net_device *dev,
2404                  struct iw_request_info *info,
2405                  struct iw_point *dwrq, char *extra)
2406 {
2407         wl_wsec_key_t key;
2408         int error, val, wsec, auth;
2409
2410         WL_TRACE(("%s: SIOCGIWENCODE\n", dev->name));
2411
2412         bzero(&key, sizeof(wl_wsec_key_t));
2413
2414         if ((dwrq->flags & IW_ENCODE_INDEX) == 0) {
2415                 for (key.index = 0; key.index < DOT11_MAX_DEFAULT_KEYS;
2416                      key.index++) {
2417                         val = key.index;
2418                         error = dev_wlc_ioctl(dev, WLC_GET_KEY_PRIMARY, &val,
2419                                                 sizeof(val));
2420                         if (error)
2421                                 return error;
2422                         val = dtoh32(val);
2423                         if (val)
2424                                 break;
2425                 }
2426         } else
2427                 key.index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
2428
2429         if (key.index >= DOT11_MAX_DEFAULT_KEYS)
2430                 key.index = 0;
2431
2432         error = dev_wlc_ioctl(dev, WLC_GET_WSEC, &wsec, sizeof(wsec));
2433         if (error)
2434                 return error;
2435
2436         error = dev_wlc_ioctl(dev, WLC_GET_AUTH, &auth, sizeof(auth));
2437         if (error)
2438                 return error;
2439
2440         swap_key_to_BE(&key);
2441
2442         wsec = dtoh32(wsec);
2443         auth = dtoh32(auth);
2444         dwrq->length = min(DOT11_MAX_KEY_SIZE, key.len);
2445
2446         dwrq->flags = key.index + 1;
2447         if (!(wsec & (WEP_ENABLED | TKIP_ENABLED | AES_ENABLED)))
2448                 dwrq->flags |= IW_ENCODE_DISABLED;
2449
2450         if (auth)
2451                 dwrq->flags |= IW_ENCODE_RESTRICTED;
2452
2453         if (dwrq->length && extra)
2454                 memcpy(extra, key.data, dwrq->length);
2455
2456         return 0;
2457 }
2458
2459 static int
2460 wl_iw_set_power(struct net_device *dev,
2461                 struct iw_request_info *info,
2462                 struct iw_param *vwrq, char *extra)
2463 {
2464         int error, pm;
2465
2466         WL_TRACE(("%s: SIOCSIWPOWER\n", dev->name));
2467
2468         pm = vwrq->disabled ? PM_OFF : PM_MAX;
2469
2470         pm = htod32(pm);
2471         error = dev_wlc_ioctl(dev, WLC_SET_PM, &pm, sizeof(pm));
2472         if (error)
2473                 return error;
2474
2475         return 0;
2476 }
2477
2478 static int
2479 wl_iw_get_power(struct net_device *dev,
2480                 struct iw_request_info *info,
2481                 struct iw_param *vwrq, char *extra)
2482 {
2483         int error, pm;
2484
2485         WL_TRACE(("%s: SIOCGIWPOWER\n", dev->name));
2486
2487         error = dev_wlc_ioctl(dev, WLC_GET_PM, &pm, sizeof(pm));
2488         if (error)
2489                 return error;
2490
2491         pm = dtoh32(pm);
2492         vwrq->disabled = pm ? 0 : 1;
2493         vwrq->flags = IW_POWER_ALL_R;
2494
2495         return 0;
2496 }
2497
2498 #if WIRELESS_EXT > 17
2499 static int
2500 wl_iw_set_wpaie(struct net_device *dev,
2501                 struct iw_request_info *info, struct iw_point *iwp, char *extra)
2502 {
2503
2504         WL_TRACE(("%s: SIOCSIWGENIE\n", dev->name));
2505
2506         CHECK_EXTRA_FOR_NULL(extra);
2507
2508         dev_wlc_bufvar_set(dev, "wpaie", extra, iwp->length);
2509
2510         return 0;
2511 }
2512
2513 static int
2514 wl_iw_get_wpaie(struct net_device *dev,
2515                 struct iw_request_info *info, struct iw_point *iwp, char *extra)
2516 {
2517         WL_TRACE(("%s: SIOCGIWGENIE\n", dev->name));
2518         iwp->length = 64;
2519         dev_wlc_bufvar_get(dev, "wpaie", extra, iwp->length);
2520         return 0;
2521 }
2522
2523 static int
2524 wl_iw_set_encodeext(struct net_device *dev,
2525                     struct iw_request_info *info,
2526                     struct iw_point *dwrq, char *extra)
2527 {
2528         wl_wsec_key_t key;
2529         int error;
2530         struct iw_encode_ext *iwe;
2531
2532         WL_TRACE(("%s: SIOCSIWENCODEEXT\n", dev->name));
2533
2534         CHECK_EXTRA_FOR_NULL(extra);
2535
2536         memset(&key, 0, sizeof(key));
2537         iwe = (struct iw_encode_ext *)extra;
2538
2539         if (dwrq->flags & IW_ENCODE_DISABLED) {
2540
2541         }
2542
2543         key.index = 0;
2544         if (dwrq->flags & IW_ENCODE_INDEX)
2545                 key.index = (dwrq->flags & IW_ENCODE_INDEX) - 1;
2546
2547         key.len = iwe->key_len;
2548
2549         if (!ETHER_ISMULTI(iwe->addr.sa_data))
2550                 bcopy((void *)&iwe->addr.sa_data, (char *)&key.ea,
2551                       ETHER_ADDR_LEN);
2552
2553         if (key.len == 0) {
2554                 if (iwe->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
2555                         WL_WSEC(("Changing the the primary Key to %d\n",
2556                                  key.index));
2557                         key.index = htod32(key.index);
2558                         error = dev_wlc_ioctl(dev, WLC_SET_KEY_PRIMARY,
2559                                               &key.index, sizeof(key.index));
2560                         if (error)
2561                                 return error;
2562                 } else {
2563                         swap_key_from_BE(&key);
2564                         dev_wlc_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
2565                 }
2566         } else {
2567                 if (iwe->key_len > sizeof(key.data))
2568                         return -EINVAL;
2569
2570                 WL_WSEC(("Setting the key index %d\n", key.index));
2571                 if (iwe->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
2572                         WL_WSEC(("key is a Primary Key\n"));
2573                         key.flags = WL_PRIMARY_KEY;
2574                 }
2575
2576                 bcopy((void *)iwe->key, key.data, iwe->key_len);
2577
2578                 if (iwe->alg == IW_ENCODE_ALG_TKIP) {
2579                         u8 keybuf[8];
2580                         bcopy(&key.data[24], keybuf, sizeof(keybuf));
2581                         bcopy(&key.data[16], &key.data[24], sizeof(keybuf));
2582                         bcopy(keybuf, &key.data[16], sizeof(keybuf));
2583                 }
2584
2585                 if (iwe->ext_flags & IW_ENCODE_EXT_RX_SEQ_VALID) {
2586                         unsigned char *ivptr;
2587                         ivptr = (unsigned char *) iwe->rx_seq;
2588                         key.rxiv.hi = (ivptr[5] << 24) | (ivptr[4] << 16) |
2589                             (ivptr[3] << 8) | ivptr[2];
2590                         key.rxiv.lo = (ivptr[1] << 8) | ivptr[0];
2591                         key.iv_initialized = TRUE;
2592                 }
2593
2594                 switch (iwe->alg) {
2595                 case IW_ENCODE_ALG_NONE:
2596                         key.algo = CRYPTO_ALGO_OFF;
2597                         break;
2598                 case IW_ENCODE_ALG_WEP:
2599                         if (iwe->key_len == WEP1_KEY_SIZE)
2600                                 key.algo = CRYPTO_ALGO_WEP1;
2601                         else
2602                                 key.algo = CRYPTO_ALGO_WEP128;
2603                         break;
2604                 case IW_ENCODE_ALG_TKIP:
2605                         key.algo = CRYPTO_ALGO_TKIP;
2606                         break;
2607                 case IW_ENCODE_ALG_CCMP:
2608                         key.algo = CRYPTO_ALGO_AES_CCM;
2609                         break;
2610                 default:
2611                         break;
2612                 }
2613                 swap_key_from_BE(&key);
2614
2615                 dhd_wait_pend8021x(dev);
2616
2617                 error = dev_wlc_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
2618                 if (error)
2619                         return error;
2620         }
2621         return 0;
2622 }
2623
2624 #if WIRELESS_EXT > 17
2625 struct {
2626         pmkid_list_t pmkids;
2627         pmkid_t foo[MAXPMKID - 1];
2628 } pmkid_list;
2629
2630 static int
2631 wl_iw_set_pmksa(struct net_device *dev,
2632                 struct iw_request_info *info,
2633                 struct iw_param *vwrq, char *extra)
2634 {
2635         struct iw_pmksa *iwpmksa;
2636         uint i;
2637         int ret = 0;
2638         char eabuf[ETHER_ADDR_STR_LEN];
2639
2640         WL_WSEC(("%s: SIOCSIWPMKSA\n", dev->name));
2641
2642         CHECK_EXTRA_FOR_NULL(extra);
2643
2644         iwpmksa = (struct iw_pmksa *)extra;
2645         bzero((char *)eabuf, ETHER_ADDR_STR_LEN);
2646
2647         if (iwpmksa->cmd == IW_PMKSA_FLUSH) {
2648                 WL_WSEC(("wl_iw_set_pmksa - IW_PMKSA_FLUSH\n"));
2649                 bzero((char *)&pmkid_list, sizeof(pmkid_list));
2650         }
2651
2652         else if (iwpmksa->cmd == IW_PMKSA_REMOVE) {
2653                 {
2654                         pmkid_list_t pmkid, *pmkidptr;
2655                         uint j;
2656                         pmkidptr = &pmkid;
2657
2658                         bcopy(&iwpmksa->bssid.sa_data[0],
2659                               &pmkidptr->pmkid[0].BSSID, ETHER_ADDR_LEN);
2660                         bcopy(&iwpmksa->pmkid[0], &pmkidptr->pmkid[0].PMKID,
2661                               WPA2_PMKID_LEN);
2662
2663                         WL_WSEC(("wl_iw_set_pmksa:IW_PMKSA_REMOVE:PMKID: %s = ",
2664                         bcm_ether_ntoa(&pmkidptr->pmkid[0].BSSID, eabuf)));
2665                         for (j = 0; j < WPA2_PMKID_LEN; j++)
2666                                 WL_WSEC(("%02x ", pmkidptr->pmkid[0].PMKID[j]));
2667                         WL_WSEC(("\n"));
2668                 }
2669
2670                 for (i = 0; i < pmkid_list.pmkids.npmkid; i++)
2671                         if (!bcmp
2672                             (&iwpmksa->bssid.sa_data[0],
2673                              &pmkid_list.pmkids.pmkid[i].BSSID, ETHER_ADDR_LEN))
2674                                 break;
2675
2676                 if ((pmkid_list.pmkids.npmkid > 0)
2677                     && (i < pmkid_list.pmkids.npmkid)) {
2678                         bzero(&pmkid_list.pmkids.pmkid[i], sizeof(pmkid_t));
2679                         for (; i < (pmkid_list.pmkids.npmkid - 1); i++) {
2680                                 bcopy(&pmkid_list.pmkids.pmkid[i + 1].BSSID,
2681                                       &pmkid_list.pmkids.pmkid[i].BSSID,
2682                                       ETHER_ADDR_LEN);
2683                                 bcopy(&pmkid_list.pmkids.pmkid[i + 1].PMKID,
2684                                       &pmkid_list.pmkids.pmkid[i].PMKID,
2685                                       WPA2_PMKID_LEN);
2686                         }
2687                         pmkid_list.pmkids.npmkid--;
2688                 } else
2689                         ret = -EINVAL;
2690         }
2691
2692         else if (iwpmksa->cmd == IW_PMKSA_ADD) {
2693                 for (i = 0; i < pmkid_list.pmkids.npmkid; i++)
2694                         if (!bcmp
2695                             (&iwpmksa->bssid.sa_data[0],
2696                              &pmkid_list.pmkids.pmkid[i].BSSID, ETHER_ADDR_LEN))
2697                                 break;
2698                 if (i < MAXPMKID) {
2699                         bcopy(&iwpmksa->bssid.sa_data[0],
2700                               &pmkid_list.pmkids.pmkid[i].BSSID,
2701                               ETHER_ADDR_LEN);
2702                         bcopy(&iwpmksa->pmkid[0],
2703                               &pmkid_list.pmkids.pmkid[i].PMKID,
2704                               WPA2_PMKID_LEN);
2705                         if (i == pmkid_list.pmkids.npmkid)
2706                                 pmkid_list.pmkids.npmkid++;
2707                 } else
2708                         ret = -EINVAL;
2709                 {
2710                         uint j;
2711                         uint k;
2712                         k = pmkid_list.pmkids.npmkid;
2713                         WL_WSEC(("wl_iw_set_pmksa,IW_PMKSA_ADD - PMKID: %s = ",
2714                                  bcm_ether_ntoa(&pmkid_list.pmkids.pmkid[k].
2715                                                 BSSID, eabuf)));
2716                         for (j = 0; j < WPA2_PMKID_LEN; j++)
2717                                 WL_WSEC(("%02x ",
2718                                          pmkid_list.pmkids.pmkid[k].PMKID[j]));
2719                         WL_WSEC(("\n"));
2720                 }
2721         }
2722         WL_WSEC(("PRINTING pmkid LIST - No of elements %d\n",
2723                  pmkid_list.pmkids.npmkid));
2724         for (i = 0; i < pmkid_list.pmkids.npmkid; i++) {
2725                 uint j;
2726                 WL_WSEC(("PMKID[%d]: %s = ", i,
2727                          bcm_ether_ntoa(&pmkid_list.pmkids.pmkid[i].BSSID,
2728                                         eabuf)));
2729                 for (j = 0; j < WPA2_PMKID_LEN; j++)
2730                         WL_WSEC(("%02x ", pmkid_list.pmkids.pmkid[i].PMKID[j]));
2731                 WL_WSEC(("\n"));
2732         }
2733         WL_WSEC(("\n"));
2734
2735         if (!ret)
2736                 ret = dev_wlc_bufvar_set(dev, "pmkid_info", (char *)&pmkid_list,
2737                                          sizeof(pmkid_list));
2738         return ret;
2739 }
2740 #endif                          /* WIRELESS_EXT > 17 */
2741
2742 static int
2743 wl_iw_get_encodeext(struct net_device *dev,
2744                     struct iw_request_info *info,
2745                     struct iw_param *vwrq, char *extra)
2746 {
2747         WL_TRACE(("%s: SIOCGIWENCODEEXT\n", dev->name));
2748         return 0;
2749 }
2750
2751 static int
2752 wl_iw_set_wpaauth(struct net_device *dev,
2753                   struct iw_request_info *info,
2754                   struct iw_param *vwrq, char *extra)
2755 {
2756         int error = 0;
2757         int paramid;
2758         int paramval;
2759         int val = 0;
2760         wl_iw_t *iw = *(wl_iw_t **) netdev_priv(dev);
2761
2762         WL_TRACE(("%s: SIOCSIWAUTH\n", dev->name));
2763
2764         paramid = vwrq->flags & IW_AUTH_INDEX;
2765         paramval = vwrq->value;
2766
2767         WL_TRACE(("%s: SIOCSIWAUTH, paramid = 0x%0x, paramval = 0x%0x\n",
2768                   dev->name, paramid, paramval));
2769
2770         switch (paramid) {
2771         case IW_AUTH_WPA_VERSION:
2772                 if (paramval & IW_AUTH_WPA_VERSION_DISABLED)
2773                         val = WPA_AUTH_DISABLED;
2774                 else if (paramval & (IW_AUTH_WPA_VERSION_WPA))
2775                         val = WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED;
2776                 else if (paramval & IW_AUTH_WPA_VERSION_WPA2)
2777                         val = WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED;
2778                 WL_INFORM(("%s: %d: setting wpa_auth to 0x%0x\n", __func__,
2779                            __LINE__, val));
2780                 error = dev_wlc_intvar_set(dev, "wpa_auth", val);
2781                 if (error)
2782                         return error;
2783                 break;
2784         case IW_AUTH_CIPHER_PAIRWISE:
2785         case IW_AUTH_CIPHER_GROUP:
2786                 if (paramval & (IW_AUTH_CIPHER_WEP40 | IW_AUTH_CIPHER_WEP104))
2787                         val = WEP_ENABLED;
2788                 if (paramval & IW_AUTH_CIPHER_TKIP)
2789                         val = TKIP_ENABLED;
2790                 if (paramval & IW_AUTH_CIPHER_CCMP)
2791                         val = AES_ENABLED;
2792
2793                 if (paramid == IW_AUTH_CIPHER_PAIRWISE) {
2794                         iw->pwsec = val;
2795                         val |= iw->gwsec;
2796                 } else {
2797                         iw->gwsec = val;
2798                         val |= iw->pwsec;
2799                 }
2800
2801                 if (iw->privacy_invoked && !val) {
2802                         WL_WSEC(("%s: %s: 'Privacy invoked' TRUE but clearing "
2803                                 "wsec, assuming " "we're a WPS enrollee\n",
2804                                 dev->name, __func__));
2805                         error = dev_wlc_intvar_set(dev, "is_WPS_enrollee",
2806                                                         TRUE);
2807                         if (error) {
2808                                 WL_WSEC(("Failed to set is_WPS_enrollee\n"));
2809                                 return error;
2810                         }
2811                 } else if (val) {
2812                         error = dev_wlc_intvar_set(dev, "is_WPS_enrollee",
2813                                                         FALSE);
2814                         if (error) {
2815                                 WL_WSEC(("Failed to clear is_WPS_enrollee\n"));
2816                                 return error;
2817                         }
2818                 }
2819
2820                 error = dev_wlc_intvar_set(dev, "wsec", val);
2821                 if (error)
2822                         return error;
2823
2824                 break;
2825
2826         case IW_AUTH_KEY_MGMT:
2827                 error = dev_wlc_intvar_get(dev, "wpa_auth", &val);
2828                 if (error)
2829                         return error;
2830
2831                 if (val & (WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED)) {
2832                         if (paramval & IW_AUTH_KEY_MGMT_PSK)
2833                                 val = WPA_AUTH_PSK;
2834                         else
2835                                 val = WPA_AUTH_UNSPECIFIED;
2836                 }
2837                 else if (val & (WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED)) {
2838                         if (paramval & IW_AUTH_KEY_MGMT_PSK)
2839                                 val = WPA2_AUTH_PSK;
2840                         else
2841                                 val = WPA2_AUTH_UNSPECIFIED;
2842                 }
2843                 WL_INFORM(("%s: %d: setting wpa_auth to %d\n", __func__,
2844                            __LINE__, val));
2845                 error = dev_wlc_intvar_set(dev, "wpa_auth", val);
2846                 if (error)
2847                         return error;
2848
2849                 break;
2850         case IW_AUTH_TKIP_COUNTERMEASURES:
2851                 dev_wlc_bufvar_set(dev, "tkip_countermeasures",
2852                                    (char *)&paramval, 1);
2853                 break;
2854
2855         case IW_AUTH_80211_AUTH_ALG:
2856                 WL_INFORM(("Setting the D11auth %d\n", paramval));
2857                 if (paramval == IW_AUTH_ALG_OPEN_SYSTEM)
2858                         val = 0;
2859                 else if (paramval == IW_AUTH_ALG_SHARED_KEY)
2860                         val = 1;
2861                 else if (paramval ==
2862                          (IW_AUTH_ALG_OPEN_SYSTEM | IW_AUTH_ALG_SHARED_KEY))
2863                         val = 2;
2864                 else
2865                         error = 1;
2866                 if (!error) {
2867                         error = dev_wlc_intvar_set(dev, "auth", val);
2868                         if (error)
2869                                 return error;
2870                 }
2871                 break;
2872
2873         case IW_AUTH_WPA_ENABLED:
2874                 if (paramval == 0) {
2875                         iw->pwsec = 0;
2876                         iw->gwsec = 0;
2877                         error = dev_wlc_intvar_get(dev, "wsec", &val);
2878                         if (error)
2879                                 return error;
2880                         if (val & (TKIP_ENABLED | AES_ENABLED)) {
2881                                 val &= ~(TKIP_ENABLED | AES_ENABLED);
2882                                 dev_wlc_intvar_set(dev, "wsec", val);
2883                         }
2884                         val = 0;
2885                         WL_INFORM(("%s: %d: setting wpa_auth to %d\n",
2886                                    __func__, __LINE__, val));
2887                         dev_wlc_intvar_set(dev, "wpa_auth", 0);
2888                         return error;
2889                 }
2890                 break;
2891
2892         case IW_AUTH_DROP_UNENCRYPTED:
2893                 dev_wlc_bufvar_set(dev, "wsec_restrict", (char *)&paramval, 1);
2894                 break;
2895
2896         case IW_AUTH_RX_UNENCRYPTED_EAPOL:
2897                 dev_wlc_bufvar_set(dev, "rx_unencrypted_eapol",
2898                                    (char *)&paramval, 1);
2899                 break;
2900
2901 #if WIRELESS_EXT > 17
2902         case IW_AUTH_ROAMING_CONTROL:
2903                 WL_INFORM(("%s: IW_AUTH_ROAMING_CONTROL\n", __func__));
2904                 break;
2905         case IW_AUTH_PRIVACY_INVOKED:
2906                 {
2907                         int wsec;
2908
2909                         if (paramval == 0) {
2910                                 iw->privacy_invoked = FALSE;
2911                                 error = dev_wlc_intvar_set(dev,
2912                                                 "is_WPS_enrollee", FALSE);
2913                                 if (error) {
2914                                         WL_WSEC(("Failed to clear iovar "
2915                                                 "is_WPS_enrollee\n"));
2916                                         return error;
2917                                 }
2918                         } else {
2919                                 iw->privacy_invoked = TRUE;
2920                                 error = dev_wlc_intvar_get(dev, "wsec", &wsec);
2921                                 if (error)
2922                                         return error;
2923
2924                                 if (!(IW_WSEC_ENABLED(wsec))) {
2925                                         error = dev_wlc_intvar_set(dev,
2926                                                         "is_WPS_enrollee",
2927                                                         TRUE);
2928                                         if (error) {
2929                                                 WL_WSEC(("Failed to set iovar "
2930                                                 "is_WPS_enrollee\n"));
2931                                                 return error;
2932                                         }
2933                                 } else {
2934                                         error = dev_wlc_intvar_set(dev,
2935                                                         "is_WPS_enrollee",
2936                                                         FALSE);
2937                                         if (error) {
2938                                                 WL_WSEC(("Failed to clear "
2939                                                         "is_WPS_enrollee\n"));
2940                                                 return error;
2941                                         }
2942                                 }
2943                         }
2944                         break;
2945                 }
2946 #endif                          /* WIRELESS_EXT > 17 */
2947         default:
2948                 break;
2949         }
2950         return 0;
2951 }
2952
2953 #define VAL_PSK(_val) (((_val) & WPA_AUTH_PSK) || ((_val) & WPA2_AUTH_PSK))
2954
2955 static int
2956 wl_iw_get_wpaauth(struct net_device *dev,
2957                   struct iw_request_info *info,
2958                   struct iw_param *vwrq, char *extra)
2959 {
2960         int error;
2961         int paramid;
2962         int paramval = 0;
2963         int val;
2964         wl_iw_t *iw = *(wl_iw_t **) netdev_priv(dev);
2965
2966         WL_TRACE(("%s: SIOCGIWAUTH\n", dev->name));
2967
2968         paramid = vwrq->flags & IW_AUTH_INDEX;
2969
2970         switch (paramid) {
2971         case IW_AUTH_WPA_VERSION:
2972                 error = dev_wlc_intvar_get(dev, "wpa_auth", &val);
2973                 if (error)
2974                         return error;
2975                 if (val & (WPA_AUTH_NONE | WPA_AUTH_DISABLED))
2976                         paramval = IW_AUTH_WPA_VERSION_DISABLED;
2977                 else if (val & (WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED))
2978                         paramval = IW_AUTH_WPA_VERSION_WPA;
2979                 else if (val & (WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED))
2980                         paramval = IW_AUTH_WPA_VERSION_WPA2;
2981                 break;
2982         case IW_AUTH_CIPHER_PAIRWISE:
2983         case IW_AUTH_CIPHER_GROUP:
2984                 if (paramid == IW_AUTH_CIPHER_PAIRWISE)
2985                         val = iw->pwsec;
2986                 else
2987                         val = iw->gwsec;
2988
2989                 paramval = 0;
2990                 if (val) {
2991                         if (val & WEP_ENABLED)
2992                                 paramval |=
2993                                     (IW_AUTH_CIPHER_WEP40 |
2994                                      IW_AUTH_CIPHER_WEP104);
2995                         if (val & TKIP_ENABLED)
2996                                 paramval |= (IW_AUTH_CIPHER_TKIP);
2997                         if (val & AES_ENABLED)
2998                                 paramval |= (IW_AUTH_CIPHER_CCMP);
2999                 } else
3000                         paramval = IW_AUTH_CIPHER_NONE;
3001                 break;
3002         case IW_AUTH_KEY_MGMT:
3003                 error = dev_wlc_intvar_get(dev, "wpa_auth", &val);
3004                 if (error)
3005                         return error;
3006                 if (VAL_PSK(val))
3007                         paramval = IW_AUTH_KEY_MGMT_PSK;
3008                 else
3009                         paramval = IW_AUTH_KEY_MGMT_802_1X;
3010
3011                 break;
3012         case IW_AUTH_TKIP_COUNTERMEASURES:
3013                 dev_wlc_bufvar_get(dev, "tkip_countermeasures",
3014                                    (char *)&paramval, 1);
3015                 break;
3016
3017         case IW_AUTH_DROP_UNENCRYPTED:
3018                 dev_wlc_bufvar_get(dev, "wsec_restrict", (char *)&paramval, 1);
3019                 break;
3020
3021         case IW_AUTH_RX_UNENCRYPTED_EAPOL:
3022                 dev_wlc_bufvar_get(dev, "rx_unencrypted_eapol",
3023                                    (char *)&paramval, 1);
3024                 break;
3025
3026         case IW_AUTH_80211_AUTH_ALG:
3027                 error = dev_wlc_intvar_get(dev, "auth", &val);
3028                 if (error)
3029                         return error;
3030                 if (!val)
3031                         paramval = IW_AUTH_ALG_OPEN_SYSTEM;
3032                 else
3033                         paramval = IW_AUTH_ALG_SHARED_KEY;
3034                 break;
3035         case IW_AUTH_WPA_ENABLED:
3036                 error = dev_wlc_intvar_get(dev, "wpa_auth", &val);
3037                 if (error)
3038                         return error;
3039                 if (val)
3040                         paramval = TRUE;
3041                 else
3042                         paramval = FALSE;
3043                 break;
3044 #if WIRELESS_EXT > 17
3045         case IW_AUTH_ROAMING_CONTROL:
3046                 WL_ERROR(("%s: IW_AUTH_ROAMING_CONTROL\n", __func__));
3047                 break;
3048         case IW_AUTH_PRIVACY_INVOKED:
3049                 paramval = iw->privacy_invoked;
3050                 break;
3051
3052 #endif
3053         }
3054         vwrq->value = paramval;
3055         return 0;
3056 }
3057 #endif                          /* WIRELESS_EXT > 17 */
3058
3059 static const iw_handler wl_iw_handler[] = {
3060         (iw_handler) wl_iw_config_commit,
3061         (iw_handler) wl_iw_get_name,
3062         (iw_handler) NULL,
3063         (iw_handler) NULL,
3064         (iw_handler) wl_iw_set_freq,
3065         (iw_handler) wl_iw_get_freq,
3066         (iw_handler) wl_iw_set_mode,
3067         (iw_handler) wl_iw_get_mode,
3068         (iw_handler) NULL,
3069         (iw_handler) NULL,
3070         (iw_handler) NULL,
3071         (iw_handler) wl_iw_get_range,
3072         (iw_handler) NULL,
3073         (iw_handler) NULL,
3074         (iw_handler) NULL,
3075         (iw_handler) NULL,
3076         (iw_handler) wl_iw_set_spy,
3077         (iw_handler) wl_iw_get_spy,
3078         (iw_handler) NULL,
3079         (iw_handler) NULL,
3080         (iw_handler) wl_iw_set_wap,
3081         (iw_handler) wl_iw_get_wap,
3082 #if WIRELESS_EXT > 17
3083         (iw_handler) wl_iw_mlme,
3084 #else
3085         (iw_handler) NULL,
3086 #endif
3087 #if defined(WL_IW_USE_ISCAN)
3088         (iw_handler) wl_iw_iscan_get_aplist,
3089 #else
3090         (iw_handler) wl_iw_get_aplist,
3091 #endif
3092 #if WIRELESS_EXT > 13
3093 #if defined(WL_IW_USE_ISCAN)
3094         (iw_handler) wl_iw_iscan_set_scan,
3095         (iw_handler) wl_iw_iscan_get_scan,
3096 #else
3097         (iw_handler) wl_iw_set_scan,
3098         (iw_handler) wl_iw_get_scan,
3099 #endif
3100 #else
3101         (iw_handler) NULL,
3102         (iw_handler) NULL,
3103 #endif                          /* WIRELESS_EXT > 13 */
3104         (iw_handler) wl_iw_set_essid,
3105         (iw_handler) wl_iw_get_essid,
3106         (iw_handler) wl_iw_set_nick,
3107         (iw_handler) wl_iw_get_nick,
3108         (iw_handler) NULL,
3109         (iw_handler) NULL,
3110         (iw_handler) wl_iw_set_rate,
3111         (iw_handler) wl_iw_get_rate,
3112         (iw_handler) wl_iw_set_rts,
3113         (iw_handler) wl_iw_get_rts,
3114         (iw_handler) wl_iw_set_frag,
3115         (iw_handler) wl_iw_get_frag,
3116         (iw_handler) wl_iw_set_txpow,
3117         (iw_handler) wl_iw_get_txpow,
3118 #if WIRELESS_EXT > 10
3119         (iw_handler) wl_iw_set_retry,
3120         (iw_handler) wl_iw_get_retry,
3121 #endif
3122         (iw_handler) wl_iw_set_encode,
3123         (iw_handler) wl_iw_get_encode,
3124         (iw_handler) wl_iw_set_power,
3125         (iw_handler) wl_iw_get_power,
3126 #if WIRELESS_EXT > 17
3127         (iw_handler) NULL,
3128         (iw_handler) NULL,
3129         (iw_handler) wl_iw_set_wpaie,
3130         (iw_handler) wl_iw_get_wpaie,
3131         (iw_handler) wl_iw_set_wpaauth,
3132         (iw_handler) wl_iw_get_wpaauth,
3133         (iw_handler) wl_iw_set_encodeext,
3134         (iw_handler) wl_iw_get_encodeext,
3135         (iw_handler) wl_iw_set_pmksa,
3136 #endif                          /* WIRELESS_EXT > 17 */
3137 };
3138
3139 #if WIRELESS_EXT > 12
3140
3141 const struct iw_handler_def wl_iw_handler_def = {
3142         .num_standard = ARRAY_SIZE(wl_iw_handler),
3143         .standard = (iw_handler *) wl_iw_handler,
3144         .num_private = 0,
3145         .num_private_args = 0,
3146         .private = 0,
3147         .private_args = 0,
3148
3149 #if WIRELESS_EXT >= 19
3150         .get_wireless_stats = dhd_get_wireless_stats,
3151 #endif
3152 };
3153 #endif                          /* WIRELESS_EXT > 12 */
3154
3155 int wl_iw_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
3156 {
3157         struct iwreq *wrq = (struct iwreq *)rq;
3158         struct iw_request_info info;
3159         iw_handler handler;
3160         char *extra = NULL;
3161         int token_size = 1, max_tokens = 0, ret = 0;
3162
3163         WL_TRACE(("\n%s, cmd:%x alled via dhd->do_ioctl()entry point\n",
3164                   __func__, cmd));
3165         if (cmd < SIOCIWFIRST ||
3166                 IW_IOCTL_IDX(cmd) >= ARRAY_SIZE(wl_iw_handler)) {
3167                 WL_ERROR(("%s: error in cmd=%x : out of range\n", __func__,
3168                         cmd));
3169                 return -EOPNOTSUPP;
3170         }
3171
3172         handler = wl_iw_handler[IW_IOCTL_IDX(cmd)];
3173         if (!handler) {
3174                 WL_ERROR(("%s: error in cmd=%x : not supported\n",
3175                         __func__, cmd));
3176                 return -EOPNOTSUPP;
3177         }
3178
3179         switch (cmd) {
3180
3181         case SIOCSIWESSID:
3182         case SIOCGIWESSID:
3183         case SIOCSIWNICKN:
3184         case SIOCGIWNICKN:
3185                 max_tokens = IW_ESSID_MAX_SIZE + 1;
3186                 break;
3187
3188         case SIOCSIWENCODE:
3189         case SIOCGIWENCODE:
3190 #if WIRELESS_EXT > 17
3191         case SIOCSIWENCODEEXT:
3192         case SIOCGIWENCODEEXT:
3193 #endif
3194                 max_tokens = wrq->u.data.length;
3195                 break;
3196
3197         case SIOCGIWRANGE:
3198                 max_tokens = sizeof(struct iw_range) + 500;
3199                 break;
3200
3201         case SIOCGIWAPLIST:
3202                 token_size =
3203                     sizeof(struct sockaddr) + sizeof(struct iw_quality);
3204                 max_tokens = IW_MAX_AP;
3205                 break;
3206
3207 #if WIRELESS_EXT > 13
3208         case SIOCGIWSCAN:
3209 #if defined(WL_IW_USE_ISCAN)
3210                 if (g_iscan)
3211                         max_tokens = wrq->u.data.length;
3212                 else
3213 #endif
3214                         max_tokens = IW_SCAN_MAX_DATA;
3215                 break;
3216 #endif                          /* WIRELESS_EXT > 13 */
3217
3218         case SIOCSIWSPY:
3219                 token_size = sizeof(struct sockaddr);
3220                 max_tokens = IW_MAX_SPY;
3221                 break;
3222
3223         case SIOCGIWSPY:
3224                 token_size =
3225                     sizeof(struct sockaddr) + sizeof(struct iw_quality);
3226                 max_tokens = IW_MAX_SPY;
3227                 break;
3228
3229 #if WIRELESS_EXT > 17
3230         case SIOCSIWPMKSA:
3231         case SIOCSIWGENIE:
3232 #endif
3233         case SIOCSIWPRIV:
3234                 max_tokens = wrq->u.data.length;
3235                 break;
3236         }
3237
3238         if (max_tokens && wrq->u.data.pointer) {
3239                 if (wrq->u.data.length > max_tokens) {
3240                         WL_ERROR(("%s: error in cmd=%x wrq->u.data.length=%d "
3241                         "> max_tokens=%d\n",
3242                         __func__, cmd, wrq->u.data.length, max_tokens));
3243                         return -E2BIG;
3244                 }
3245                 extra = kmalloc(max_tokens * token_size, GFP_KERNEL);
3246                 if (!extra)
3247                         return -ENOMEM;
3248
3249                 if (copy_from_user
3250                     (extra, wrq->u.data.pointer,
3251                      wrq->u.data.length * token_size)) {
3252                         kfree(extra);
3253                         return -EFAULT;
3254                 }
3255         }
3256
3257         info.cmd = cmd;
3258         info.flags = 0;
3259
3260         ret = handler(dev, &info, &wrq->u, extra);
3261
3262         if (extra) {
3263                 if (copy_to_user
3264                     (wrq->u.data.pointer, extra,
3265                      wrq->u.data.length * token_size)) {
3266                         kfree(extra);
3267                         return -EFAULT;
3268                 }
3269
3270                 kfree(extra);
3271         }
3272
3273         return ret;
3274 }
3275
3276 bool
3277 wl_iw_conn_status_str(u32 event_type, u32 status, u32 reason,
3278                       char *stringBuf, uint buflen)
3279 {
3280         typedef struct conn_fail_event_map_t {
3281                 u32 inEvent;
3282                 u32 inStatus;
3283                 u32 inReason;
3284                 const char *outName;
3285                 const char *outCause;
3286         } conn_fail_event_map_t;
3287
3288 #define WL_IW_DONT_CARE 9999
3289         const conn_fail_event_map_t event_map[] = {
3290                 {WLC_E_SET_SSID, WLC_E_STATUS_SUCCESS, WL_IW_DONT_CARE,
3291                  "Conn", "Success"},
3292                 {WLC_E_SET_SSID, WLC_E_STATUS_NO_NETWORKS, WL_IW_DONT_CARE,
3293                  "Conn", "NoNetworks"},
3294                 {WLC_E_SET_SSID, WLC_E_STATUS_FAIL, WL_IW_DONT_CARE,
3295                  "Conn", "ConfigMismatch"},
3296                 {WLC_E_PRUNE, WL_IW_DONT_CARE, WLC_E_PRUNE_ENCR_MISMATCH,
3297                  "Conn", "EncrypMismatch"},
3298                 {WLC_E_PRUNE, WL_IW_DONT_CARE, WLC_E_RSN_MISMATCH,
3299                  "Conn", "RsnMismatch"},
3300                 {WLC_E_AUTH, WLC_E_STATUS_TIMEOUT, WL_IW_DONT_CARE,
3301                  "Conn", "AuthTimeout"},
3302                 {WLC_E_AUTH, WLC_E_STATUS_FAIL, WL_IW_DONT_CARE,
3303                  "Conn", "AuthFail"},
3304                 {WLC_E_AUTH, WLC_E_STATUS_NO_ACK, WL_IW_DONT_CARE,
3305                  "Conn", "AuthNoAck"},
3306                 {WLC_E_REASSOC, WLC_E_STATUS_FAIL, WL_IW_DONT_CARE,
3307                  "Conn", "ReassocFail"},
3308                 {WLC_E_REASSOC, WLC_E_STATUS_TIMEOUT, WL_IW_DONT_CARE,
3309                  "Conn", "ReassocTimeout"},
3310                 {WLC_E_REASSOC, WLC_E_STATUS_ABORT, WL_IW_DONT_CARE,
3311                  "Conn", "ReassocAbort"},
3312                 {WLC_E_PSK_SUP, WLC_SUP_KEYED, WL_IW_DONT_CARE,
3313                  "Sup", "ConnSuccess"},
3314                 {WLC_E_PSK_SUP, WL_IW_DONT_CARE, WL_IW_DONT_CARE,
3315                  "Sup", "WpaHandshakeFail"},
3316                 {WLC_E_DEAUTH_IND, WL_IW_DONT_CARE, WL_IW_DONT_CARE,
3317                  "Conn", "Deauth"},
3318                 {WLC_E_DISASSOC_IND, WL_IW_DONT_CARE, WL_IW_DONT_CARE,
3319                  "Conn", "DisassocInd"},
3320                 {WLC_E_DISASSOC, WL_IW_DONT_CARE, WL_IW_DONT_CARE,
3321                  "Conn", "Disassoc"}
3322         };
3323
3324         const char *name = "";
3325         const char *cause = NULL;
3326         int i;
3327
3328         for (i = 0; i < sizeof(event_map) / sizeof(event_map[0]); i++) {
3329                 const conn_fail_event_map_t *row = &event_map[i];
3330                 if (row->inEvent == event_type &&
3331                     (row->inStatus == status
3332                      || row->inStatus == WL_IW_DONT_CARE)
3333                     && (row->inReason == reason
3334                         || row->inReason == WL_IW_DONT_CARE)) {
3335                         name = row->outName;
3336                         cause = row->outCause;
3337                         break;
3338                 }
3339         }
3340
3341         if (cause) {
3342                 memset(stringBuf, 0, buflen);
3343                 snprintf(stringBuf, buflen, "%s %s %02d %02d",
3344                          name, cause, status, reason);
3345                 WL_INFORM(("Connection status: %s\n", stringBuf));
3346                 return TRUE;
3347         } else {
3348                 return FALSE;
3349         }
3350 }
3351
3352 #if WIRELESS_EXT > 14
3353
3354 static bool
3355 wl_iw_check_conn_fail(wl_event_msg_t *e, char *stringBuf, uint buflen)
3356 {
3357         u32 event = ntoh32(e->event_type);
3358         u32 status = ntoh32(e->status);
3359         u32 reason = ntoh32(e->reason);
3360
3361         if (wl_iw_conn_status_str(event, status, reason, stringBuf, buflen)) {
3362                 return TRUE;
3363         } else
3364                 return FALSE;
3365 }
3366 #endif
3367
3368 #ifndef IW_CUSTOM_MAX
3369 #define IW_CUSTOM_MAX 256
3370 #endif
3371
3372 void wl_iw_event(struct net_device *dev, wl_event_msg_t *e, void *data)
3373 {
3374 #if WIRELESS_EXT > 13
3375         union iwreq_data wrqu;
3376         char extra[IW_CUSTOM_MAX + 1];
3377         int cmd = 0;
3378         u32 event_type = ntoh32(e->event_type);
3379         u16 flags = ntoh16(e->flags);
3380         u32 datalen = ntoh32(e->datalen);
3381         u32 status = ntoh32(e->status);
3382         wl_iw_t *iw;
3383         u32 toto;
3384         memset(&wrqu, 0, sizeof(wrqu));
3385         memset(extra, 0, sizeof(extra));
3386         iw = 0;
3387
3388         if (!dev) {
3389                 WL_ERROR(("%s: dev is null\n", __func__));
3390                 return;
3391         }
3392
3393         iw = *(wl_iw_t **) netdev_priv(dev);
3394
3395         WL_TRACE(("%s: dev=%s event=%d\n", __func__, dev->name, event_type));
3396
3397         switch (event_type) {
3398         case WLC_E_TXFAIL:
3399                 cmd = IWEVTXDROP;
3400                 memcpy(wrqu.addr.sa_data, &e->addr, ETHER_ADDR_LEN);
3401                 wrqu.addr.sa_family = ARPHRD_ETHER;
3402                 break;
3403 #if WIRELESS_EXT > 14
3404         case WLC_E_JOIN:
3405         case WLC_E_ASSOC_IND:
3406         case WLC_E_REASSOC_IND:
3407                 memcpy(wrqu.addr.sa_data, &e->addr, ETHER_ADDR_LEN);
3408                 wrqu.addr.sa_family = ARPHRD_ETHER;
3409                 cmd = IWEVREGISTERED;
3410                 break;
3411         case WLC_E_DEAUTH_IND:
3412         case WLC_E_DISASSOC_IND:
3413                 cmd = SIOCGIWAP;
3414                 bzero(wrqu.addr.sa_data, ETHER_ADDR_LEN);
3415                 wrqu.addr.sa_family = ARPHRD_ETHER;
3416                 bzero(&extra, ETHER_ADDR_LEN);
3417                 break;
3418         case WLC_E_LINK:
3419         case WLC_E_NDIS_LINK:
3420                 cmd = SIOCGIWAP;
3421                 if (!(flags & WLC_EVENT_MSG_LINK)) {
3422                         bzero(wrqu.addr.sa_data, ETHER_ADDR_LEN);
3423                         bzero(&extra, ETHER_ADDR_LEN);
3424                         WAKE_LOCK_TIMEOUT(iw->pub, WAKE_LOCK_LINK_DOWN_TMOUT,
3425                                           20 * HZ);
3426                 } else {
3427                         memcpy(wrqu.addr.sa_data, &e->addr, ETHER_ADDR_LEN);
3428                         WL_TRACE(("Link UP\n"));
3429
3430                 }
3431                 wrqu.addr.sa_family = ARPHRD_ETHER;
3432                 break;
3433         case WLC_E_ACTION_FRAME:
3434                 cmd = IWEVCUSTOM;
3435                 if (datalen + 1 <= sizeof(extra)) {
3436                         wrqu.data.length = datalen + 1;
3437                         extra[0] = WLC_E_ACTION_FRAME;
3438                         memcpy(&extra[1], data, datalen);
3439                         WL_TRACE(("WLC_E_ACTION_FRAME len %d \n",
3440                                   wrqu.data.length));
3441                 }
3442                 break;
3443
3444         case WLC_E_ACTION_FRAME_COMPLETE:
3445                 cmd = IWEVCUSTOM;
3446                 memcpy(&toto, data, 4);
3447                 if (sizeof(status) + 1 <= sizeof(extra)) {
3448                         wrqu.data.length = sizeof(status) + 1;
3449                         extra[0] = WLC_E_ACTION_FRAME_COMPLETE;
3450                         memcpy(&extra[1], &status, sizeof(status));
3451                         printf("wl_iw_event status %d PacketId %d\n", status,
3452                                toto);
3453                         printf("WLC_E_ACTION_FRAME_COMPLETE len %d\n",
3454                                wrqu.data.length);
3455                 }
3456                 break;
3457 #endif                          /* WIRELESS_EXT > 14 */
3458 #if WIRELESS_EXT > 17
3459         case WLC_E_MIC_ERROR:
3460                 {
3461                         struct iw_michaelmicfailure *micerrevt =
3462                             (struct iw_michaelmicfailure *)&extra;
3463                         cmd = IWEVMICHAELMICFAILURE;
3464                         wrqu.data.length = sizeof(struct iw_michaelmicfailure);
3465                         if (flags & WLC_EVENT_MSG_GROUP)
3466                                 micerrevt->flags |= IW_MICFAILURE_GROUP;
3467                         else
3468                                 micerrevt->flags |= IW_MICFAILURE_PAIRWISE;
3469                         memcpy(micerrevt->src_addr.sa_data, &e->addr,
3470                                ETHER_ADDR_LEN);
3471                         micerrevt->src_addr.sa_family = ARPHRD_ETHER;
3472
3473                         break;
3474                 }
3475         case WLC_E_PMKID_CACHE:
3476                 {
3477                         if (data) {
3478                                 struct iw_pmkid_cand *iwpmkidcand =
3479                                     (struct iw_pmkid_cand *)&extra;
3480                                 pmkid_cand_list_t *pmkcandlist;
3481                                 pmkid_cand_t *pmkidcand;
3482                                 int count;
3483
3484                                 cmd = IWEVPMKIDCAND;
3485                                 pmkcandlist = data;
3486                                 count =
3487                                     ntoh32_ua((u8 *) &
3488                                               pmkcandlist->npmkid_cand);
3489                                 ASSERT(count >= 0);
3490                                 wrqu.data.length = sizeof(struct iw_pmkid_cand);
3491                                 pmkidcand = pmkcandlist->pmkid_cand;
3492                                 while (count) {
3493                                         bzero(iwpmkidcand,
3494                                               sizeof(struct iw_pmkid_cand));
3495                                         if (pmkidcand->preauth)
3496                                                 iwpmkidcand->flags |=
3497                                                     IW_PMKID_CAND_PREAUTH;
3498                                         bcopy(&pmkidcand->BSSID,
3499                                               &iwpmkidcand->bssid.sa_data,
3500                                               ETHER_ADDR_LEN);
3501 #ifndef SANDGATE2G
3502                                         wireless_send_event(dev, cmd, &wrqu,
3503                                                             extra);
3504 #endif
3505                                         pmkidcand++;
3506                                         count--;
3507                                 }
3508                         }
3509                         return;
3510                 }
3511 #endif                          /* WIRELESS_EXT > 17 */
3512
3513         case WLC_E_SCAN_COMPLETE:
3514 #if defined(WL_IW_USE_ISCAN)
3515                 if ((g_iscan) && (g_iscan->sysioc_tsk) &&
3516                     (g_iscan->iscan_state != ISCAN_STATE_IDLE)) {
3517                         up(&g_iscan->sysioc_sem);
3518                 } else {
3519                         cmd = SIOCGIWSCAN;
3520                         wrqu.data.length = strlen(extra);
3521                         WL_TRACE(("Event WLC_E_SCAN_COMPLETE from specific "
3522                                 "scan %d\n", g_iscan->iscan_state));
3523                 }
3524 #else
3525                 cmd = SIOCGIWSCAN;
3526                 wrqu.data.length = strlen(extra);
3527                 WL_TRACE(("Event WLC_E_SCAN_COMPLETE\n"));
3528 #endif
3529                 break;
3530
3531         case WLC_E_PFN_NET_FOUND:
3532                 {
3533                         wlc_ssid_t *ssid;
3534                         ssid = (wlc_ssid_t *) data;
3535                         WL_ERROR(("%s Event WLC_E_PFN_NET_FOUND, send %s up : "
3536                                 "find %s len=%d\n", __func__, PNO_EVENT_UP,
3537                                 ssid->SSID, ssid->SSID_len));
3538                         WAKE_LOCK_TIMEOUT(iw->pub, WAKE_LOCK_PNO_FIND_TMOUT,
3539                                           20 * HZ);
3540                         cmd = IWEVCUSTOM;
3541                         memset(&wrqu, 0, sizeof(wrqu));
3542                         strcpy(extra, PNO_EVENT_UP);
3543                         wrqu.data.length = strlen(extra);
3544                 }
3545                 break;
3546
3547         default:
3548                 WL_TRACE(("Unknown Event %d: ignoring\n", event_type));
3549                 break;
3550         }
3551 #ifndef SANDGATE2G
3552         if (cmd) {
3553                 if (cmd == SIOCGIWSCAN)
3554                         wireless_send_event(dev, cmd, &wrqu, NULL);
3555                 else
3556                         wireless_send_event(dev, cmd, &wrqu, extra);
3557         }
3558 #endif
3559
3560 #if WIRELESS_EXT > 14
3561         memset(extra, 0, sizeof(extra));
3562         if (wl_iw_check_conn_fail(e, extra, sizeof(extra))) {
3563                 cmd = IWEVCUSTOM;
3564                 wrqu.data.length = strlen(extra);
3565 #ifndef SANDGATE2G
3566                 wireless_send_event(dev, cmd, &wrqu, extra);
3567 #endif
3568         }
3569 #endif                          /* WIRELESS_EXT > 14 */
3570 #endif                          /* WIRELESS_EXT > 13 */
3571 }
3572
3573 int
3574 wl_iw_get_wireless_stats(struct net_device *dev, struct iw_statistics *wstats)
3575 {
3576         int res = 0;
3577         wl_cnt_t cnt;
3578         int phy_noise;
3579         int rssi;
3580         scb_val_t scb_val;
3581
3582         phy_noise = 0;
3583         res = dev_wlc_ioctl(dev, WLC_GET_PHY_NOISE, &phy_noise,
3584                                 sizeof(phy_noise));
3585         if (res)
3586                 goto done;
3587
3588         phy_noise = dtoh32(phy_noise);
3589         WL_TRACE(("wl_iw_get_wireless_stats phy noise=%d\n", phy_noise));
3590
3591         bzero(&scb_val, sizeof(scb_val_t));
3592         res = dev_wlc_ioctl(dev, WLC_GET_RSSI, &scb_val, sizeof(scb_val_t));
3593         if (res)
3594                 goto done;
3595
3596         rssi = dtoh32(scb_val.val);
3597         WL_TRACE(("wl_iw_get_wireless_stats rssi=%d\n", rssi));
3598         if (rssi <= WL_IW_RSSI_NO_SIGNAL)
3599                 wstats->qual.qual = 0;
3600         else if (rssi <= WL_IW_RSSI_VERY_LOW)
3601                 wstats->qual.qual = 1;
3602         else if (rssi <= WL_IW_RSSI_LOW)
3603                 wstats->qual.qual = 2;
3604         else if (rssi <= WL_IW_RSSI_GOOD)
3605                 wstats->qual.qual = 3;
3606         else if (rssi <= WL_IW_RSSI_VERY_GOOD)
3607                 wstats->qual.qual = 4;
3608         else
3609                 wstats->qual.qual = 5;
3610
3611         wstats->qual.level = 0x100 + rssi;
3612         wstats->qual.noise = 0x100 + phy_noise;
3613 #if WIRELESS_EXT > 18
3614         wstats->qual.updated |= (IW_QUAL_ALL_UPDATED | IW_QUAL_DBM);
3615 #else
3616         wstats->qual.updated |= 7;
3617 #endif
3618
3619 #if WIRELESS_EXT > 11
3620         WL_TRACE(("wl_iw_get_wireless_stats counters=%d\n",
3621                   (int)sizeof(wl_cnt_t)));
3622
3623         memset(&cnt, 0, sizeof(wl_cnt_t));
3624         res =
3625             dev_wlc_bufvar_get(dev, "counters", (char *)&cnt, sizeof(wl_cnt_t));
3626         if (res) {
3627                 WL_ERROR(("wl_iw_get_wireless_stats counters failed error=%d\n",
3628                           res));
3629                 goto done;
3630         }
3631
3632         cnt.version = dtoh16(cnt.version);
3633         if (cnt.version != WL_CNT_T_VERSION) {
3634                 WL_TRACE(("\tIncorrect version of counters struct: expected "
3635                         "%d; got %d\n",
3636                         WL_CNT_T_VERSION, cnt.version));
3637                 goto done;
3638         }
3639
3640         wstats->discard.nwid = 0;
3641         wstats->discard.code = dtoh32(cnt.rxundec);
3642         wstats->discard.fragment = dtoh32(cnt.rxfragerr);
3643         wstats->discard.retries = dtoh32(cnt.txfail);
3644         wstats->discard.misc = dtoh32(cnt.rxrunt) + dtoh32(cnt.rxgiant);
3645         wstats->miss.beacon = 0;
3646
3647         WL_TRACE(("wl_iw_get_wireless_stats counters txframe=%d txbyte=%d\n",
3648                   dtoh32(cnt.txframe), dtoh32(cnt.txbyte)));
3649         WL_TRACE(("wl_iw_get_wireless_stats counters rxfrmtoolong=%d\n",
3650                   dtoh32(cnt.rxfrmtoolong)));
3651         WL_TRACE(("wl_iw_get_wireless_stats counters rxbadplcp=%d\n",
3652                   dtoh32(cnt.rxbadplcp)));
3653         WL_TRACE(("wl_iw_get_wireless_stats counters rxundec=%d\n",
3654                   dtoh32(cnt.rxundec)));
3655         WL_TRACE(("wl_iw_get_wireless_stats counters rxfragerr=%d\n",
3656                   dtoh32(cnt.rxfragerr)));
3657         WL_TRACE(("wl_iw_get_wireless_stats counters txfail=%d\n",
3658                   dtoh32(cnt.txfail)));
3659         WL_TRACE(("wl_iw_get_wireless_stats counters rxrunt=%d\n",
3660                   dtoh32(cnt.rxrunt)));
3661         WL_TRACE(("wl_iw_get_wireless_stats counters rxgiant=%d\n",
3662                   dtoh32(cnt.rxgiant)));
3663 #endif                          /* WIRELESS_EXT > 11 */
3664
3665 done:
3666         return res;
3667 }
3668
3669 int wl_iw_attach(struct net_device *dev, void *dhdp)
3670 {
3671         int params_size;
3672         wl_iw_t *iw;
3673 #if defined(WL_IW_USE_ISCAN)
3674         iscan_info_t *iscan = NULL;
3675
3676         if (!dev)
3677                 return 0;
3678
3679         memset(&g_wl_iw_params, 0, sizeof(wl_iw_extra_params_t));
3680
3681 #ifdef CSCAN
3682         params_size =
3683             (WL_SCAN_PARAMS_FIXED_SIZE + offsetof(wl_iscan_params_t, params)) +
3684             (WL_NUMCHANNELS * sizeof(u16)) +
3685             WL_SCAN_PARAMS_SSID_MAX * sizeof(wlc_ssid_t);
3686 #else
3687         params_size =
3688             (WL_SCAN_PARAMS_FIXED_SIZE + offsetof(wl_iscan_params_t, params));
3689 #endif
3690         iscan = kmalloc(sizeof(iscan_info_t), GFP_KERNEL);
3691
3692         if (!iscan)
3693                 return -ENOMEM;
3694         memset(iscan, 0, sizeof(iscan_info_t));
3695
3696         iscan->iscan_ex_params_p =
3697             (wl_iscan_params_t *) kmalloc(params_size, GFP_KERNEL);
3698         if (!iscan->iscan_ex_params_p)
3699                 return -ENOMEM;
3700         iscan->iscan_ex_param_size = params_size;
3701         iscan->sysioc_tsk = NULL;
3702
3703         g_iscan = iscan;
3704         iscan->dev = dev;
3705         iscan->iscan_state = ISCAN_STATE_IDLE;
3706
3707         iscan->timer_ms = 3000;
3708         init_timer(&iscan->timer);
3709         iscan->timer.data = (unsigned long) iscan;
3710         iscan->timer.function = wl_iw_timerfunc;
3711
3712         sema_init(&iscan->sysioc_sem, 0);
3713         iscan->sysioc_tsk = kthread_run(_iscan_sysioc_thread, iscan,
3714                                         "_iscan_sysioc");
3715         if (IS_ERR(iscan->sysioc_tsk)) {
3716                 iscan->sysioc_tsk = NULL;
3717                 return -ENOMEM;
3718         }
3719 #endif                          /* defined(WL_IW_USE_ISCAN) */
3720
3721         iw = *(wl_iw_t **) netdev_priv(dev);
3722         iw->pub = (dhd_pub_t *) dhdp;
3723         MUTEX_LOCK_INIT(iw->pub);
3724         MUTEX_LOCK_WL_SCAN_SET_INIT();
3725 #ifdef SOFTAP
3726         priv_dev = dev;
3727         MUTEX_LOCK_SOFTAP_SET_INIT(iw->pub);
3728 #endif
3729         g_scan = NULL;
3730
3731         g_scan = (void *)kmalloc(G_SCAN_RESULTS, GFP_KERNEL);
3732         if (!g_scan)
3733                 return -ENOMEM;
3734
3735         memset(g_scan, 0, G_SCAN_RESULTS);
3736         g_scan_specified_ssid = 0;
3737
3738         return 0;
3739 }
3740
3741 void wl_iw_detach(void)
3742 {
3743 #if defined(WL_IW_USE_ISCAN)
3744         iscan_buf_t *buf;
3745         iscan_info_t *iscan = g_iscan;
3746
3747         if (!iscan)
3748                 return;
3749         if (iscan->sysioc_tsk) {
3750                 kthread_stop(iscan->sysioc_tsk);
3751                 iscan->sysioc_tsk = NULL;
3752         }
3753
3754         MUTEX_LOCK_WL_SCAN_SET();
3755         while (iscan->list_hdr) {
3756                 buf = iscan->list_hdr->next;
3757                 kfree(iscan->list_hdr);
3758                 iscan->list_hdr = buf;
3759         }
3760         MUTEX_UNLOCK_WL_SCAN_SET();
3761         kfree(iscan->iscan_ex_params_p);
3762         kfree(iscan);
3763         g_iscan = NULL;
3764 #endif                          /* WL_IW_USE_ISCAN */
3765
3766         kfree(g_scan);
3767
3768         g_scan = NULL;
3769 }